\\n\",\n providers: [PAGINATION_CONTROL_VALUE_ACCESSOR]\n }] }\n];\n/** @nocollapse */\nPaginationComponent.ctorParameters = () => [\n { type: ElementRef },\n { type: PaginationConfig },\n { type: ChangeDetectorRef }\n];\nPaginationComponent.propDecorators = {\n align: [{ type: Input }],\n maxSize: [{ type: Input }],\n boundaryLinks: [{ type: Input }],\n directionLinks: [{ type: Input }],\n firstText: [{ type: Input }],\n previousText: [{ type: Input }],\n nextText: [{ type: Input }],\n lastText: [{ type: Input }],\n rotate: [{ type: Input }],\n pageBtnClass: [{ type: Input }],\n disabled: [{ type: Input }],\n numPages: [{ type: Output }],\n pageChanged: [{ type: Output }],\n itemsPerPage: [{ type: Input }],\n totalItems: [{ type: Input }]\n};\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nclass PaginationModule {\n /**\n * @return {?}\n */\n static forRoot() {\n return { ngModule: PaginationModule, providers: [PaginationConfig] };\n }\n}\nPaginationModule.decorators = [\n { type: NgModule, args: [{\n imports: [CommonModule],\n declarations: [PagerComponent, PaginationComponent],\n exports: [PagerComponent, PaginationComponent]\n },] }\n];\n\nexport { PagerComponent, PaginationComponent, PaginationConfig, PaginationModule, PAGER_CONTROL_VALUE_ACCESSOR as ɵa, PAGINATION_CONTROL_VALUE_ACCESSOR as ɵb };\n//# sourceMappingURL=ngx-bootstrap-pagination.js.map\n","import { CommonModule } from '@angular/common';\r\nimport { NgModule } from '@angular/core';\r\nimport { HttpClientModule } from '@angular/common/http';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { RouterModule } from '@angular/router';\r\n\r\nimport { PageNotFoundComponent } from 'src/app/modules/core/components/page-not-found/page-not-found.component';\r\nimport { SpinnerComponent } from 'src/app/modules/core/components/spinner/spinner.component';\r\nimport { PlantingSitesShellComponent } from './components/planting-sites-shell/planting-sites-shell.component';\r\nimport { FilterListComponent } from './components/planting-sites-shell/filter-list.component';\r\nimport { FilterCheckboxTreeComponent } from './components/filter-checkbox-tree/filter-checkbox-tree.component';\r\nimport { SubFiltersSelectedPipe } from './components/filter-checkbox-tree/sub-filters-selected.pipe';\r\nimport { IntermediateDirective } from './directives/intermediate.directive';\r\nimport { YearPickerComponent } from './components/year-picker/year-picker.component';\r\nimport { PromptUnsubmittedDirective } from './directives/prompt-unsubmitted.directive';\r\nimport { MapPickerComponent } from './components/map-picker/map-picker.component';\r\nimport { AgmCoreModule } from '@agm/core';\r\nimport { MapPickerModalComponent } from './components/map-picker/map-picker-modal.component';\r\nimport { IsInvalidDirective } from './directives/is-invalid.directive';\r\nimport { LatLonToPointPipe } from './components/map-picker/lat-lon-to-point.pipe';\r\nimport { HasDecimalPipe } from './pipes/has-decimal.pipe';\r\nimport { ConfirmDeleteModalComponent } from './components/delete-modal/confirm-delete-modal-component';\r\nimport { AutoCompleteOffDirective } from './directives/auto-complete-off.directive';\r\nimport { AutosizeDirective } from './directives/autosize.directive';\r\nimport { NextPhotoIdPipe } from './pipes/next-photo-id.pipe';\r\nimport { PreviousPhotoIdPipe } from './pipes/previous-photo-id.pipe';\r\nimport { SitesShellFrontendComponent } from './components/planting-sites-shell/sites-shell-frontend/sites-shell-frontend.component';\r\nimport { BackgroundUrlDirective } from './directives/background-url.directive';\r\nimport { HeaderPhotoPipe } from './pipes/header-photo.pipe';\r\nimport { VideoThumbnailPipe } from './pipes/video-thumbnail.pipe';\r\nimport { FilterNoPhotosPipe } from './pipes/filter-no-photos.pipe';\r\nimport { SiteSpeciesPipe } from './pipes/site-species.pipe';\r\nimport { HasSingleDonorPipe } from './pipes/has-single-donor.pipe';\r\nimport { SiteMapIconPipe } from './pipes/site-map-icon.pipe';\r\nimport { CollapseModule } from 'ngx-bootstrap/collapse';\r\nimport { ModalModule } from 'ngx-bootstrap/modal';\r\nimport { NgSelectModule } from '@ng-select/ng-select';\r\nimport { BsDatepickerModule } from 'ngx-bootstrap/datepicker';\r\nimport { PaginationModule } from 'ngx-bootstrap/pagination';\r\nimport { AppHeaderModule } from '@coreui/angular';\r\nimport { TransformEmailPipe } from './pipes/transform-email.pipe';\r\nimport { CustomerTypePipe } from './pipes/customer-type.pipe';\r\nimport { FilterDropDownComponent } from './components/filter-dropdown/filter-dropdown.component';\r\nimport { OnlyVisibleDonorPipe } from './pipes/only-visible-donor.pipe';\r\nimport { HasVisibleDonorPipe } from './pipes/has-visible-donor.pipe';\r\nimport { TotalCertificatesTreePipe } from './pipes/total-certificates-tree.pipe';\r\nimport { UserRolePipe } from './pipes/user-role.pipe';\r\nimport { UserRole } from 'src/app/models/users/user-role';\r\nimport { BsDropdownModule, PopoverModule } from 'ngx-bootstrap';\r\nimport { PopoverComponent } from './components/popover/popover.component';\r\n\r\n@NgModule({\r\n declarations: [\r\n PageNotFoundComponent,\r\n SpinnerComponent,\r\n PlantingSitesShellComponent,\r\n FilterListComponent,\r\n FilterCheckboxTreeComponent,\r\n SubFiltersSelectedPipe,\r\n IntermediateDirective,\r\n YearPickerComponent,\r\n PromptUnsubmittedDirective,\r\n MapPickerComponent,\r\n MapPickerModalComponent,\r\n IsInvalidDirective,\r\n LatLonToPointPipe,\r\n HasDecimalPipe,\r\n ConfirmDeleteModalComponent,\r\n AutoCompleteOffDirective,\r\n AutosizeDirective,\r\n NextPhotoIdPipe,\r\n PreviousPhotoIdPipe,\r\n SitesShellFrontendComponent,\r\n BackgroundUrlDirective,\r\n HeaderPhotoPipe,\r\n VideoThumbnailPipe,\r\n FilterNoPhotosPipe,\r\n OnlyVisibleDonorPipe,\r\n HasVisibleDonorPipe,\r\n SiteSpeciesPipe,\r\n HasSingleDonorPipe,\r\n SiteMapIconPipe,\r\n TransformEmailPipe,\r\n CustomerTypePipe,\r\n FilterDropDownComponent,\r\n TotalCertificatesTreePipe,\r\n UserRolePipe,\r\n PopoverComponent\r\n ],\r\n imports: [\r\n CommonModule,\r\n HttpClientModule,\r\n FormsModule,\r\n RouterModule,\r\n AgmCoreModule,\r\n CollapseModule.forRoot(),\r\n ModalModule.forRoot(),\r\n NgSelectModule,\r\n BsDatepickerModule.forRoot(),\r\n BsDropdownModule.forRoot(),\r\n PaginationModule.forRoot(),\r\n AppHeaderModule,\r\n PopoverModule.forRoot(),\r\n ],\r\n providers: [\r\n\r\n ],\r\n exports: [\r\n CommonModule,\r\n FormsModule,\r\n PageNotFoundComponent,\r\n SpinnerComponent,\r\n PlantingSitesShellComponent,\r\n YearPickerComponent,\r\n PromptUnsubmittedDirective,\r\n MapPickerModalComponent,\r\n MapPickerComponent,\r\n IsInvalidDirective,\r\n LatLonToPointPipe,\r\n HasDecimalPipe,\r\n ConfirmDeleteModalComponent,\r\n AutoCompleteOffDirective,\r\n AutosizeDirective,\r\n PreviousPhotoIdPipe,\r\n NextPhotoIdPipe,\r\n SitesShellFrontendComponent,\r\n BackgroundUrlDirective,\r\n HeaderPhotoPipe,\r\n VideoThumbnailPipe,\r\n FilterNoPhotosPipe,\r\n SiteSpeciesPipe,\r\n HasSingleDonorPipe,\r\n OnlyVisibleDonorPipe,\r\n HasVisibleDonorPipe,\r\n SiteMapIconPipe,\r\n ModalModule,\r\n NgSelectModule,\r\n BsDatepickerModule,\r\n PaginationModule,\r\n AppHeaderModule,\r\n CustomerTypePipe,\r\n FilterDropDownComponent,\r\n TotalCertificatesTreePipe,\r\n UserRolePipe,\r\n PopoverComponent\r\n ]\r\n})\r\nexport class CoreModule { }\r\n","import { isFunction } from './util/isFunction';\nimport { empty as emptyObserver } from './Observer';\nimport { Subscription } from './Subscription';\nimport { rxSubscriber as rxSubscriberSymbol } from '../internal/symbol/rxSubscriber';\nimport { config } from './config';\nimport { hostReportError } from './util/hostReportError';\nexport class Subscriber extends Subscription {\n constructor(destinationOrNext, error, complete) {\n super();\n this.syncErrorValue = null;\n this.syncErrorThrown = false;\n this.syncErrorThrowable = false;\n this.isStopped = false;\n switch (arguments.length) {\n case 0:\n this.destination = emptyObserver;\n break;\n case 1:\n if (!destinationOrNext) {\n this.destination = emptyObserver;\n break;\n }\n if (typeof destinationOrNext === 'object') {\n if (destinationOrNext instanceof Subscriber) {\n this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;\n this.destination = destinationOrNext;\n destinationOrNext.add(this);\n }\n else {\n this.syncErrorThrowable = true;\n this.destination = new SafeSubscriber(this, destinationOrNext);\n }\n break;\n }\n default:\n this.syncErrorThrowable = true;\n this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);\n break;\n }\n }\n [rxSubscriberSymbol]() { return this; }\n static create(next, error, complete) {\n const subscriber = new Subscriber(next, error, complete);\n subscriber.syncErrorThrowable = false;\n return subscriber;\n }\n next(value) {\n if (!this.isStopped) {\n this._next(value);\n }\n }\n error(err) {\n if (!this.isStopped) {\n this.isStopped = true;\n this._error(err);\n }\n }\n complete() {\n if (!this.isStopped) {\n this.isStopped = true;\n this._complete();\n }\n }\n unsubscribe() {\n if (this.closed) {\n return;\n }\n this.isStopped = true;\n super.unsubscribe();\n }\n _next(value) {\n this.destination.next(value);\n }\n _error(err) {\n this.destination.error(err);\n this.unsubscribe();\n }\n _complete() {\n this.destination.complete();\n this.unsubscribe();\n }\n _unsubscribeAndRecycle() {\n const { _parentOrParents } = this;\n this._parentOrParents = null;\n this.unsubscribe();\n this.closed = false;\n this.isStopped = false;\n this._parentOrParents = _parentOrParents;\n return this;\n }\n}\nexport class SafeSubscriber extends Subscriber {\n constructor(_parentSubscriber, observerOrNext, error, complete) {\n super();\n this._parentSubscriber = _parentSubscriber;\n let next;\n let context = this;\n if (isFunction(observerOrNext)) {\n next = observerOrNext;\n }\n else if (observerOrNext) {\n next = observerOrNext.next;\n error = observerOrNext.error;\n complete = observerOrNext.complete;\n if (observerOrNext !== emptyObserver) {\n context = Object.create(observerOrNext);\n if (isFunction(context.unsubscribe)) {\n this.add(context.unsubscribe.bind(context));\n }\n context.unsubscribe = this.unsubscribe.bind(this);\n }\n }\n this._context = context;\n this._next = next;\n this._error = error;\n this._complete = complete;\n }\n next(value) {\n if (!this.isStopped && this._next) {\n const { _parentSubscriber } = this;\n if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n this.__tryOrUnsub(this._next, value);\n }\n else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {\n this.unsubscribe();\n }\n }\n }\n error(err) {\n if (!this.isStopped) {\n const { _parentSubscriber } = this;\n const { useDeprecatedSynchronousErrorHandling } = config;\n if (this._error) {\n if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n this.__tryOrUnsub(this._error, err);\n this.unsubscribe();\n }\n else {\n this.__tryOrSetError(_parentSubscriber, this._error, err);\n this.unsubscribe();\n }\n }\n else if (!_parentSubscriber.syncErrorThrowable) {\n this.unsubscribe();\n if (useDeprecatedSynchronousErrorHandling) {\n throw err;\n }\n hostReportError(err);\n }\n else {\n if (useDeprecatedSynchronousErrorHandling) {\n _parentSubscriber.syncErrorValue = err;\n _parentSubscriber.syncErrorThrown = true;\n }\n else {\n hostReportError(err);\n }\n this.unsubscribe();\n }\n }\n }\n complete() {\n if (!this.isStopped) {\n const { _parentSubscriber } = this;\n if (this._complete) {\n const wrappedComplete = () => this._complete.call(this._context);\n if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n this.__tryOrUnsub(wrappedComplete);\n this.unsubscribe();\n }\n else {\n this.__tryOrSetError(_parentSubscriber, wrappedComplete);\n this.unsubscribe();\n }\n }\n else {\n this.unsubscribe();\n }\n }\n }\n __tryOrUnsub(fn, value) {\n try {\n fn.call(this._context, value);\n }\n catch (err) {\n this.unsubscribe();\n if (config.useDeprecatedSynchronousErrorHandling) {\n throw err;\n }\n else {\n hostReportError(err);\n }\n }\n }\n __tryOrSetError(parent, fn, value) {\n if (!config.useDeprecatedSynchronousErrorHandling) {\n throw new Error('bad call');\n }\n try {\n fn.call(this._context, value);\n }\n catch (err) {\n if (config.useDeprecatedSynchronousErrorHandling) {\n parent.syncErrorValue = err;\n parent.syncErrorThrown = true;\n return true;\n }\n else {\n hostReportError(err);\n return true;\n }\n }\n return false;\n }\n _unsubscribe() {\n const { _parentSubscriber } = this;\n this._context = null;\n this._parentSubscriber = null;\n _parentSubscriber.unsubscribe();\n }\n}\n//# sourceMappingURL=Subscriber.js.map","import { Subscriber } from '../Subscriber';\nexport function canReportError(observer) {\n while (observer) {\n const { closed, destination, isStopped } = observer;\n if (closed || isStopped) {\n return false;\n }\n else if (destination && destination instanceof Subscriber) {\n observer = destination;\n }\n else {\n observer = null;\n }\n }\n return true;\n}\n//# sourceMappingURL=canReportError.js.map","import { multicast } from './multicast';\nimport { refCount } from './refCount';\nimport { Subject } from '../Subject';\nfunction shareSubjectFactory() {\n return new Subject();\n}\nexport function share() {\n return (source) => refCount()(multicast(shareSubjectFactory)(source));\n}\n//# sourceMappingURL=share.js.map","/**\n * @license Angular v8.1.2\n * (c) 2010-2019 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport { Subject, Subscription, Observable, merge as merge$1 } from 'rxjs';\nimport { share } from 'rxjs/operators';\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst ANNOTATIONS = '__annotations__';\nconst PARAMETERS = '__parameters__';\nconst PROP_METADATA = '__prop__metadata__';\n/**\n * @suppress {globalThis}\n */\nfunction makeDecorator(name, props, parentClass, additionalProcessing, typeFn) {\n const metaCtor = makeMetadataCtor(props);\n function DecoratorFactory(...args) {\n if (this instanceof DecoratorFactory) {\n metaCtor.call(this, ...args);\n return this;\n }\n const annotationInstance = new DecoratorFactory(...args);\n return function TypeDecorator(cls) {\n if (typeFn)\n typeFn(cls, ...args);\n // Use of Object.defineProperty is important since it creates non-enumerable property which\n // prevents the property is copied during subclassing.\n const annotations = cls.hasOwnProperty(ANNOTATIONS) ?\n cls[ANNOTATIONS] :\n Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];\n annotations.push(annotationInstance);\n if (additionalProcessing)\n additionalProcessing(cls);\n return cls;\n };\n }\n if (parentClass) {\n DecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n DecoratorFactory.prototype.ngMetadataName = name;\n DecoratorFactory.annotationCls = DecoratorFactory;\n return DecoratorFactory;\n}\nfunction makeMetadataCtor(props) {\n return function ctor(...args) {\n if (props) {\n const values = props(...args);\n for (const propName in values) {\n this[propName] = values[propName];\n }\n }\n };\n}\nfunction makeParamDecorator(name, props, parentClass) {\n const metaCtor = makeMetadataCtor(props);\n function ParamDecoratorFactory(...args) {\n if (this instanceof ParamDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n const annotationInstance = new ParamDecoratorFactory(...args);\n ParamDecorator.annotation = annotationInstance;\n return ParamDecorator;\n function ParamDecorator(cls, unusedKey, index) {\n // Use of Object.defineProperty is important since it creates non-enumerable property which\n // prevents the property is copied during subclassing.\n const parameters = cls.hasOwnProperty(PARAMETERS) ?\n cls[PARAMETERS] :\n Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];\n // there might be gaps if some in between parameters do not have annotations.\n // we pad with nulls.\n while (parameters.length <= index) {\n parameters.push(null);\n }\n (parameters[index] = parameters[index] || []).push(annotationInstance);\n return cls;\n }\n }\n if (parentClass) {\n ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n ParamDecoratorFactory.prototype.ngMetadataName = name;\n ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;\n return ParamDecoratorFactory;\n}\nfunction makePropDecorator(name, props, parentClass, additionalProcessing) {\n const metaCtor = makeMetadataCtor(props);\n function PropDecoratorFactory(...args) {\n if (this instanceof PropDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n const decoratorInstance = new PropDecoratorFactory(...args);\n function PropDecorator(target, name) {\n const constructor = target.constructor;\n // Use of Object.defineProperty is important since it creates non-enumerable property which\n // prevents the property is copied during subclassing.\n const meta = constructor.hasOwnProperty(PROP_METADATA) ?\n constructor[PROP_METADATA] :\n Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];\n meta[name] = meta.hasOwnProperty(name) && meta[name] || [];\n meta[name].unshift(decoratorInstance);\n if (additionalProcessing)\n additionalProcessing(target, name, ...args);\n }\n return PropDecorator;\n }\n if (parentClass) {\n PropDecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n PropDecoratorFactory.prototype.ngMetadataName = name;\n PropDecoratorFactory.annotationCls = PropDecoratorFactory;\n return PropDecoratorFactory;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// WARNING: interface has both a type and a value, skipping emit\nconst ɵ0 = /**\n * @param {?} token\n * @return {?}\n */\n(token) => ({ token });\n/**\n * Inject decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Inject = makeParamDecorator('Inject', (ɵ0));\n// WARNING: interface has both a type and a value, skipping emit\n/**\n * Optional decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Optional = makeParamDecorator('Optional');\n// WARNING: interface has both a type and a value, skipping emit\n/**\n * Self decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Self = makeParamDecorator('Self');\n// WARNING: interface has both a type and a value, skipping emit\n/**\n * SkipSelf decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst SkipSelf = makeParamDecorator('SkipSelf');\n// WARNING: interface has both a type and a value, skipping emit\n/**\n * Host decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Host = makeParamDecorator('Host');\n// WARNING: interface has both a type and a value, skipping emit\nconst ɵ1 = /**\n * @param {?=} attributeName\n * @return {?}\n */\n(attributeName) => ({ attributeName });\n/**\n * Attribute decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Attribute = makeParamDecorator('Attribute', (ɵ1));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Injection flags for DI.\n *\n * @publicApi\n */\nvar InjectFlags;\n(function (InjectFlags) {\n // TODO(alxhub): make this 'const' when ngc no longer writes exports of it into ngfactory files.\n /** Check self and check parent injector if needed */\n InjectFlags[InjectFlags[\"Default\"] = 0] = \"Default\";\n /**\n * Specifies that an injector should retrieve a dependency from any injector until reaching the\n * host element of the current component. (Only used with Element Injector)\n */\n InjectFlags[InjectFlags[\"Host\"] = 1] = \"Host\";\n /** Don't ascend to ancestors of the node requesting injection. */\n InjectFlags[InjectFlags[\"Self\"] = 2] = \"Self\";\n /** Skip the node that is requesting injection. */\n InjectFlags[InjectFlags[\"SkipSelf\"] = 4] = \"SkipSelf\";\n /** Inject `defaultValue` instead if token not found. */\n InjectFlags[InjectFlags[\"Optional\"] = 8] = \"Optional\";\n})(InjectFlags || (InjectFlags = {}));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction getClosureSafeProperty(objWithPropertyToExtract) {\n for (let key in objWithPropertyToExtract) {\n if (objWithPropertyToExtract[key] === getClosureSafeProperty) {\n return key;\n }\n }\n throw Error('Could not find renamed property on target object.');\n}\n/**\n * Sets properties on a target object from a source object, but only if\n * the property doesn't already exist on the target object.\n * @param target The target to set properties on\n * @param source The source of the property keys and values to set\n */\nfunction fillProperties(target, source) {\n for (const key in source) {\n if (source.hasOwnProperty(key) && !target.hasOwnProperty(key)) {\n target[key] = source[key];\n }\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Construct an `InjectableDef` which defines how a token will be constructed by the DI system, and\n * in which injectors (if any) it will be available.\n *\n * This should be assigned to a static `ngInjectableDef` field on a type, which will then be an\n * `InjectableType`.\n *\n * Options:\n * * `providedIn` determines which injectors will include the injectable, by either associating it\n * with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be\n * provided in the `'root'` injector, which will be the application-level injector in most apps.\n * * `factory` gives the zero argument function which will create an instance of the injectable.\n * The factory can call `inject` to access the `Injector` and request injection of dependencies.\n *\n * @codeGenApi\n */\nfunction ɵɵdefineInjectable(opts) {\n return {\n token: opts.token, providedIn: opts.providedIn || null, factory: opts.factory,\n value: undefined,\n };\n}\n/**\n * @deprecated in v8, delete after v10. This API should be used only be generated code, and that\n * code should now use ɵɵdefineInjectable instead.\n * @publicApi\n */\nconst defineInjectable = ɵɵdefineInjectable;\n/**\n * Construct an `InjectorDef` which configures an injector.\n *\n * This should be assigned to a static `ngInjectorDef` field on a type, which will then be an\n * `InjectorType`.\n *\n * Options:\n *\n * * `factory`: an `InjectorType` is an instantiable type, so a zero argument `factory` function to\n * create the type must be provided. If that factory function needs to inject arguments, it can\n * use the `inject` function.\n * * `providers`: an optional array of providers to add to the injector. Each provider must\n * either have a factory or point to a type which has an `ngInjectableDef` static property (the\n * type must be an `InjectableType`).\n * * `imports`: an optional array of imports of other `InjectorType`s or `InjectorTypeWithModule`s\n * whose providers will also be added to the injector. Locally provided types will override\n * providers from imports.\n *\n * @publicApi\n */\nfunction ɵɵdefineInjector(options) {\n return {\n factory: options.factory, providers: options.providers || [], imports: options.imports || [],\n };\n}\n/**\n * Read the `ngInjectableDef` for `type` in a way which is immune to accidentally reading inherited\n * value.\n *\n * @param type A type which may have its own (non-inherited) `ngInjectableDef`.\n */\nfunction getInjectableDef(type) {\n const def = type[NG_INJECTABLE_DEF];\n // The definition read above may come from a base class. `hasOwnProperty` is not sufficient to\n // distinguish this case, as in older browsers (e.g. IE10) static property inheritance is\n // implemented by copying the properties.\n //\n // Instead, the ngInjectableDef's token is compared to the type, and if they don't match then the\n // property was not defined directly on the type itself, and was likely inherited. The definition\n // is only returned if the type matches the def.token.\n return def && def.token === type ? def : null;\n}\n/**\n * Read the `ngInjectableDef` for `type` or read the `ngInjectableDef` from one of its ancestors.\n *\n * @param type A type which may have `ngInjectableDef`, via inheritance.\n *\n * @deprecated Will be removed in v10, where an error will occur in the scenario if we find the\n * `ngInjectableDef` on an ancestor only.\n */\nfunction getInheritedInjectableDef(type) {\n if (type && type[NG_INJECTABLE_DEF]) {\n // TODO(FW-1307): Re-add ngDevMode when closure can handle it\n // ngDevMode &&\n console.warn(`DEPRECATED: DI is instantiating a token \"${type.name}\" that inherits its @Injectable decorator but does not provide one itself.\\n` +\n `This will become an error in v10. Please add @Injectable() to the \"${type.name}\" class.`);\n return type[NG_INJECTABLE_DEF];\n }\n else {\n return null;\n }\n}\n/**\n * Read the `ngInjectorDef` type in a way which is immune to accidentally reading inherited value.\n *\n * @param type type which may have `ngInjectorDef`\n */\nfunction getInjectorDef(type) {\n return type && type.hasOwnProperty(NG_INJECTOR_DEF) ? type[NG_INJECTOR_DEF] : null;\n}\nconst NG_INJECTABLE_DEF = getClosureSafeProperty({ ngInjectableDef: getClosureSafeProperty });\nconst NG_INJECTOR_DEF = getClosureSafeProperty({ ngInjectorDef: getClosureSafeProperty });\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction stringify(token) {\n if (typeof token === 'string') {\n return token;\n }\n if (token instanceof Array) {\n return '[' + token.map(stringify).join(', ') + ']';\n }\n if (token == null) {\n return '' + token;\n }\n if (token.overriddenName) {\n return `${token.overriddenName}`;\n }\n if (token.name) {\n return `${token.name}`;\n }\n const res = token.toString();\n if (res == null) {\n return '' + res;\n }\n const newLineIndex = res.indexOf('\\n');\n return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });\n/**\n * Allows to refer to references which are not yet defined.\n *\n * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of\n * DI is declared, but not yet defined. It is also used when the `token` which we use when creating\n * a query is not yet defined.\n *\n * \\@usageNotes\n * ### Example\n * {\\@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}\n * \\@publicApi\n * @param {?} forwardRefFn\n * @return {?}\n */\nfunction forwardRef(forwardRefFn) {\n ((/** @type {?} */ (forwardRefFn))).__forward_ref__ = forwardRef;\n ((/** @type {?} */ (forwardRefFn))).toString = (/**\n * @return {?}\n */\n function () { return stringify(this()); });\n return ((/** @type {?} */ ((/** @type {?} */ (forwardRefFn)))));\n}\n/**\n * Lazily retrieves the reference value from a forwardRef.\n *\n * Acts as the identity function when given a non-forward-ref value.\n *\n * \\@usageNotes\n * ### Example\n *\n * {\\@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}\n *\n * @see `forwardRef`\n * \\@publicApi\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction resolveForwardRef(type) {\n /** @type {?} */\n const fn = type;\n if (typeof fn === 'function' && fn.hasOwnProperty(__forward_ref__) &&\n fn.__forward_ref__ === forwardRef) {\n return fn();\n }\n else {\n return type;\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst __globalThis = typeof globalThis !== 'undefined' && globalThis;\nconst __window = typeof window !== 'undefined' && window;\nconst __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n self instanceof WorkerGlobalScope && self;\nconst __global = typeof global !== 'undefined' && global;\n// Always use __globalThis if available, which is the spec-defined global variable across all\n// environments, then fallback to __global first, because in Node tests both __global and\n// __window may be defined and _global should be __global in that case.\nconst _global = __globalThis || __global || __window || __self;\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar R3ResolvedDependencyType;\n(function (R3ResolvedDependencyType) {\n R3ResolvedDependencyType[R3ResolvedDependencyType[\"Token\"] = 0] = \"Token\";\n R3ResolvedDependencyType[R3ResolvedDependencyType[\"Attribute\"] = 1] = \"Attribute\";\n})(R3ResolvedDependencyType || (R3ResolvedDependencyType = {}));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction getCompilerFacade() {\n const globalNg = _global['ng'];\n if (!globalNg || !globalNg.ɵcompilerFacade) {\n throw new Error(`Angular JIT compilation failed: '@angular/compiler' not loaded!\\n` +\n ` - JIT compilation is discouraged for production use-cases! Consider AOT mode instead.\\n` +\n ` - Did you bootstrap using '@angular/platform-browser-dynamic' or '@angular/platform-server'?\\n` +\n ` - Alternatively provide the compiler with 'import \"@angular/compiler\";' before bootstrapping.`);\n }\n return globalNg.ɵcompilerFacade;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Creates a token that can be used in a DI Provider.\n *\n * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a\n * runtime representation) such as when injecting an interface, callable type, array or\n * parameterized type.\n *\n * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by\n * the `Injector`. This provides additional level of type safety.\n *\n * ```\n * interface MyInterface {...}\n * var myInterface = injector.get(new InjectionToken('SomeToken'));\n * // myInterface is inferred to be MyInterface.\n * ```\n *\n * When creating an `InjectionToken`, you can optionally specify a factory function which returns\n * (possibly by creating) a default value of the parameterized type `T`. This sets up the\n * `InjectionToken` using this factory as a provider as if it was defined explicitly in the\n * application's root injector. If the factory function, which takes zero arguments, needs to inject\n * dependencies, it can do so using the `inject` function. See below for an example.\n *\n * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which\n * overrides the above behavior and marks the token as belonging to a particular `\\@NgModule`. As\n * mentioned above, `'root'` is the default value for `providedIn`.\n *\n * \\@usageNotes\n * ### Basic Example\n *\n * ### Plain InjectionToken\n *\n * {\\@example core/di/ts/injector_spec.ts region='InjectionToken'}\n *\n * ### Tree-shakable InjectionToken\n *\n * {\\@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}\n *\n *\n * \\@publicApi\n * @template T\n */\nclass InjectionToken {\n /**\n * @param {?} _desc\n * @param {?=} options\n */\n constructor(_desc, options) {\n this._desc = _desc;\n /**\n * \\@internal\n */\n this.ngMetadataName = 'InjectionToken';\n /** @nocollapse */ this.ngInjectableDef = undefined;\n if (typeof options == 'number') {\n // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.\n // __NG_ELEMENT_ID__ is Used by Ivy to determine bloom filter id.\n // We are using it to assign `-1` which is used to identify `Injector`.\n ((/** @type {?} */ (this))).__NG_ELEMENT_ID__ = options;\n }\n else if (options !== undefined) {\n /** @nocollapse */ this.ngInjectableDef = ɵɵdefineInjectable({\n token: this,\n providedIn: options.providedIn || 'root',\n factory: options.factory,\n });\n }\n }\n /**\n * @return {?}\n */\n toString() { return `InjectionToken ${this._desc}`; }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.\n *\n * Requesting this token instead of `Injector` allows `StaticInjector` to be tree-shaken from a\n * project.\n *\n * \\@publicApi\n * @type {?}\n */\nconst INJECTOR = new InjectionToken('INJECTOR', (/** @type {?} */ (-1)));\n/** @type {?} */\nconst _THROW_IF_NOT_FOUND = new Object();\n/** @type {?} */\nconst THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n/** @type {?} */\nconst NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';\n/** @type {?} */\nconst NG_TOKEN_PATH = 'ngTokenPath';\n/** @type {?} */\nconst NEW_LINE = /\\n/gm;\n/** @type {?} */\nconst NO_NEW_LINE = 'ɵ';\n/** @type {?} */\nconst SOURCE = '__source';\nconst ɵ0$1 = getClosureSafeProperty;\n/** @type {?} */\nconst USE_VALUE = getClosureSafeProperty({ provide: String, useValue: ɵ0$1 });\n/**\n * Current injector value used by `inject`.\n * - `undefined`: it is an error to call `inject`\n * - `null`: `inject` can be called but there is no injector (limp-mode).\n * - Injector instance: Use the injector for resolution.\n * @type {?}\n */\nlet _currentInjector = undefined;\n/**\n * @param {?} injector\n * @return {?}\n */\nfunction setCurrentInjector(injector) {\n /** @type {?} */\n const former = _currentInjector;\n _currentInjector = injector;\n return former;\n}\n/**\n * Current implementation of inject.\n *\n * By default, it is `injectInjectorOnly`, which makes it `Injector`-only aware. It can be changed\n * to `directiveInject`, which brings in the `NodeInjector` system of ivy. It is designed this\n * way for two reasons:\n * 1. `Injector` should not depend on ivy logic.\n * 2. To maintain tree shake-ability we don't want to bring in unnecessary code.\n * @type {?}\n */\nlet _injectImplementation;\n/**\n * Sets the current inject implementation.\n * @param {?} impl\n * @return {?}\n */\nfunction setInjectImplementation(impl) {\n /** @type {?} */\n const previous = _injectImplementation;\n _injectImplementation = impl;\n return previous;\n}\n/**\n * @template T\n * @param {?} token\n * @param {?=} flags\n * @return {?}\n */\nfunction injectInjectorOnly(token, flags = InjectFlags.Default) {\n if (_currentInjector === undefined) {\n throw new Error(`inject() must be called from an injection context`);\n }\n else if (_currentInjector === null) {\n return injectRootLimpMode(token, undefined, flags);\n }\n else {\n return _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);\n }\n}\n/**\n * @template T\n * @param {?} token\n * @param {?=} flags\n * @return {?}\n */\nfunction ɵɵinject(token, flags = InjectFlags.Default) {\n return (_injectImplementation || injectInjectorOnly)(token, flags);\n}\n/**\n * Injects a token from the currently active injector.\n *\n * Must be used in the context of a factory function such as one defined for an\n * `InjectionToken`. Throws an error if not called from such a context.\n *\n * Within such a factory function, using this function to request injection of a dependency\n * is faster and more type-safe than providing an additional array of dependencies\n * (as has been common with `useFactory` providers).\n *\n * \\@param token The injection token for the dependency to be injected.\n * \\@param flags Optional flags that control how injection is executed.\n * The flags correspond to injection strategies that can be specified with\n * parameter decorators `\\@Host`, `\\@Self`, `\\@SkipSef`, and `\\@Optional`.\n * \\@return True if injection is successful, null otherwise.\n *\n * \\@usageNotes\n *\n * ### Example\n *\n * {\\@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}\n *\n * \\@publicApi\n * @type {?}\n */\nconst inject = ɵɵinject;\n/**\n * Injects `root` tokens in limp mode.\n *\n * If no injector exists, we can still inject tree-shakable providers which have `providedIn` set to\n * `\"root\"`. This is known as the limp mode injection. In such case the value is stored in the\n * `InjectableDef`.\n * @template T\n * @param {?} token\n * @param {?} notFoundValue\n * @param {?} flags\n * @return {?}\n */\nfunction injectRootLimpMode(token, notFoundValue, flags) {\n /** @type {?} */\n const injectableDef = getInjectableDef(token);\n if (injectableDef && injectableDef.providedIn == 'root') {\n return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() :\n injectableDef.value;\n }\n if (flags & InjectFlags.Optional)\n return null;\n if (notFoundValue !== undefined)\n return notFoundValue;\n throw new Error(`Injector: NOT_FOUND [${stringify(token)}]`);\n}\n/**\n * @param {?} types\n * @return {?}\n */\nfunction injectArgs(types) {\n /** @type {?} */\n const args = [];\n for (let i = 0; i < types.length; i++) {\n /** @type {?} */\n const arg = resolveForwardRef(types[i]);\n if (Array.isArray(arg)) {\n if (arg.length === 0) {\n throw new Error('Arguments array must have arguments.');\n }\n /** @type {?} */\n let type = undefined;\n /** @type {?} */\n let flags = InjectFlags.Default;\n for (let j = 0; j < arg.length; j++) {\n /** @type {?} */\n const meta = arg[j];\n if (meta instanceof Optional || meta.ngMetadataName === 'Optional' || meta === Optional) {\n flags |= InjectFlags.Optional;\n }\n else if (meta instanceof SkipSelf || meta.ngMetadataName === 'SkipSelf' || meta === SkipSelf) {\n flags |= InjectFlags.SkipSelf;\n }\n else if (meta instanceof Self || meta.ngMetadataName === 'Self' || meta === Self) {\n flags |= InjectFlags.Self;\n }\n else if (meta instanceof Inject || meta === Inject) {\n type = meta.token;\n }\n else {\n type = meta;\n }\n }\n args.push(ɵɵinject((/** @type {?} */ (type)), flags));\n }\n else {\n args.push(ɵɵinject(arg));\n }\n }\n return args;\n}\nclass NullInjector {\n /**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\n get(token, notFoundValue = THROW_IF_NOT_FOUND) {\n if (notFoundValue === THROW_IF_NOT_FOUND) {\n // Intentionally left behind: With dev tools open the debugger will stop here. There is no\n // reason why correctly written application should cause this exception.\n // TODO(misko): uncomment the next line once `ngDevMode` works with closure.\n // if(ngDevMode) debugger;\n /** @type {?} */\n const error = new Error(`NullInjectorError: No provider for ${stringify(token)}!`);\n error.name = 'NullInjectorError';\n throw error;\n }\n return notFoundValue;\n }\n}\n/**\n * @param {?} e\n * @param {?} token\n * @param {?} injectorErrorName\n * @param {?} source\n * @return {?}\n */\nfunction catchInjectorError(e, token, injectorErrorName, source) {\n /** @type {?} */\n const tokenPath = e[NG_TEMP_TOKEN_PATH];\n if (token[SOURCE]) {\n tokenPath.unshift(token[SOURCE]);\n }\n e.message = formatError('\\n' + e.message, tokenPath, injectorErrorName, source);\n e[NG_TOKEN_PATH] = tokenPath;\n e[NG_TEMP_TOKEN_PATH] = null;\n throw e;\n}\n/**\n * @param {?} text\n * @param {?} obj\n * @param {?} injectorErrorName\n * @param {?=} source\n * @return {?}\n */\nfunction formatError(text, obj, injectorErrorName, source = null) {\n text = text && text.charAt(0) === '\\n' && text.charAt(1) == NO_NEW_LINE ? text.substr(2) : text;\n /** @type {?} */\n let context = stringify(obj);\n if (obj instanceof Array) {\n context = obj.map(stringify).join(' -> ');\n }\n else if (typeof obj === 'object') {\n /** @type {?} */\n let parts = (/** @type {?} */ ([]));\n for (let key in obj) {\n if (obj.hasOwnProperty(key)) {\n /** @type {?} */\n let value = obj[key];\n parts.push(key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));\n }\n }\n context = `{${parts.join(', ')}}`;\n }\n return `${injectorErrorName}${source ? '(' + source + ')' : ''}[${context}]: ${text.replace(NEW_LINE, '\\n ')}`;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * A mapping of the \\@angular/core API surface used in generated expressions to the actual symbols.\n *\n * This should be kept up to date with the public exports of \\@angular/core.\n * @type {?}\n */\nconst angularCoreDiEnv = {\n 'ɵɵdefineInjectable': ɵɵdefineInjectable,\n 'ɵɵdefineInjector': ɵɵdefineInjector,\n 'ɵɵinject': ɵɵinject,\n 'ɵɵgetFactoryOf': getFactoryOf,\n};\n/**\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getFactoryOf(type) {\n /** @type {?} */\n const typeAny = (/** @type {?} */ (type));\n /** @type {?} */\n const def = getInjectableDef(typeAny) || getInjectorDef(typeAny);\n if (!def || def.factory === undefined) {\n return null;\n }\n return def.factory;\n}\n\n/**\n * @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\n *\n * Represents a type that a Component or other object is instances of.\n *\n * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by\n * the `MyCustomComponent` constructor function.\n *\n * @publicApi\n */\nconst Type = Function;\nfunction isType(v) {\n return typeof v === 'function';\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 * Attention: These regex has to hold even if the code is minified!\n */\nconst DELEGATE_CTOR = /^function\\s+\\S+\\(\\)\\s*{[\\s\\S]+\\.apply\\(this,\\s*arguments\\)/;\nconst INHERITED_CLASS = /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[^{]+{/;\nconst INHERITED_CLASS_WITH_CTOR = /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[^{]+{[\\s\\S]*constructor\\s*\\(/;\nconst INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[^{]+{[\\s\\S]*constructor\\s*\\(\\)\\s*{\\s+super\\(\\.\\.\\.arguments\\)/;\n/**\n * Determine whether a stringified type is a class which delegates its constructor\n * to its parent.\n *\n * This is not trivial since compiled code can actually contain a constructor function\n * even if the original source code did not. For instance, when the child class contains\n * an initialized instance property.\n */\nfunction isDelegateCtor(typeStr) {\n return DELEGATE_CTOR.test(typeStr) || INHERITED_CLASS_WITH_DELEGATE_CTOR.test(typeStr) ||\n (INHERITED_CLASS.test(typeStr) && !INHERITED_CLASS_WITH_CTOR.test(typeStr));\n}\nclass ReflectionCapabilities {\n constructor(reflect) { this._reflect = reflect || _global['Reflect']; }\n isReflectionEnabled() { return true; }\n factory(t) { return (...args) => new t(...args); }\n /** @internal */\n _zipTypesAndAnnotations(paramTypes, paramAnnotations) {\n let result;\n if (typeof paramTypes === 'undefined') {\n result = new Array(paramAnnotations.length);\n }\n else {\n result = new Array(paramTypes.length);\n }\n for (let i = 0; i < result.length; i++) {\n // TS outputs Object for parameters without types, while Traceur omits\n // the annotations. For now we preserve the Traceur behavior to aid\n // migration, but this can be revisited.\n if (typeof paramTypes === 'undefined') {\n result[i] = [];\n }\n else if (paramTypes[i] && paramTypes[i] != Object) {\n result[i] = [paramTypes[i]];\n }\n else {\n result[i] = [];\n }\n if (paramAnnotations && paramAnnotations[i] != null) {\n result[i] = result[i].concat(paramAnnotations[i]);\n }\n }\n return result;\n }\n _ownParameters(type, parentCtor) {\n const typeStr = type.toString();\n // If we have no decorators, we only have function.length as metadata.\n // In that case, to detect whether a child class declared an own constructor or not,\n // we need to look inside of that constructor to check whether it is\n // just calling the parent.\n // This also helps to work around for https://github.com/Microsoft/TypeScript/issues/12439\n // that sets 'design:paramtypes' to []\n // if a class inherits from another class but has no ctor declared itself.\n if (isDelegateCtor(typeStr)) {\n return null;\n }\n // Prefer the direct API.\n if (type.parameters && type.parameters !== parentCtor.parameters) {\n return type.parameters;\n }\n // API of tsickle for lowering decorators to properties on the class.\n const tsickleCtorParams = type.ctorParameters;\n if (tsickleCtorParams && tsickleCtorParams !== parentCtor.ctorParameters) {\n // Newer tsickle uses a function closure\n // Retain the non-function case for compatibility with older tsickle\n const ctorParameters = typeof tsickleCtorParams === 'function' ? tsickleCtorParams() : tsickleCtorParams;\n const paramTypes = ctorParameters.map((ctorParam) => ctorParam && ctorParam.type);\n const paramAnnotations = ctorParameters.map((ctorParam) => ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));\n return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\n }\n // API for metadata created by invoking the decorators.\n const paramAnnotations = type.hasOwnProperty(PARAMETERS) && type[PARAMETERS];\n const paramTypes = this._reflect && this._reflect.getOwnMetadata &&\n this._reflect.getOwnMetadata('design:paramtypes', type);\n if (paramTypes || paramAnnotations) {\n return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\n }\n // If a class has no decorators, at least create metadata\n // based on function.length.\n // Note: We know that this is a real constructor as we checked\n // the content of the constructor above.\n return new Array(type.length).fill(undefined);\n }\n parameters(type) {\n // Note: only report metadata if we have at least one class decorator\n // to stay in sync with the static reflector.\n if (!isType(type)) {\n return [];\n }\n const parentCtor = getParentCtor(type);\n let parameters = this._ownParameters(type, parentCtor);\n if (!parameters && parentCtor !== Object) {\n parameters = this.parameters(parentCtor);\n }\n return parameters || [];\n }\n _ownAnnotations(typeOrFunc, parentCtor) {\n // Prefer the direct API.\n if (typeOrFunc.annotations && typeOrFunc.annotations !== parentCtor.annotations) {\n let annotations = typeOrFunc.annotations;\n if (typeof annotations === 'function' && annotations.annotations) {\n annotations = annotations.annotations;\n }\n return annotations;\n }\n // API of tsickle for lowering decorators to properties on the class.\n if (typeOrFunc.decorators && typeOrFunc.decorators !== parentCtor.decorators) {\n return convertTsickleDecoratorIntoMetadata(typeOrFunc.decorators);\n }\n // API for metadata created by invoking the decorators.\n if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {\n return typeOrFunc[ANNOTATIONS];\n }\n return null;\n }\n annotations(typeOrFunc) {\n if (!isType(typeOrFunc)) {\n return [];\n }\n const parentCtor = getParentCtor(typeOrFunc);\n const ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];\n const parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];\n return parentAnnotations.concat(ownAnnotations);\n }\n _ownPropMetadata(typeOrFunc, parentCtor) {\n // Prefer the direct API.\n if (typeOrFunc.propMetadata &&\n typeOrFunc.propMetadata !== parentCtor.propMetadata) {\n let propMetadata = typeOrFunc.propMetadata;\n if (typeof propMetadata === 'function' && propMetadata.propMetadata) {\n propMetadata = propMetadata.propMetadata;\n }\n return propMetadata;\n }\n // API of tsickle for lowering decorators to properties on the class.\n if (typeOrFunc.propDecorators &&\n typeOrFunc.propDecorators !== parentCtor.propDecorators) {\n const propDecorators = typeOrFunc.propDecorators;\n const propMetadata = {};\n Object.keys(propDecorators).forEach(prop => {\n propMetadata[prop] = convertTsickleDecoratorIntoMetadata(propDecorators[prop]);\n });\n return propMetadata;\n }\n // API for metadata created by invoking the decorators.\n if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {\n return typeOrFunc[PROP_METADATA];\n }\n return null;\n }\n propMetadata(typeOrFunc) {\n if (!isType(typeOrFunc)) {\n return {};\n }\n const parentCtor = getParentCtor(typeOrFunc);\n const propMetadata = {};\n if (parentCtor !== Object) {\n const parentPropMetadata = this.propMetadata(parentCtor);\n Object.keys(parentPropMetadata).forEach((propName) => {\n propMetadata[propName] = parentPropMetadata[propName];\n });\n }\n const ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);\n if (ownPropMetadata) {\n Object.keys(ownPropMetadata).forEach((propName) => {\n const decorators = [];\n if (propMetadata.hasOwnProperty(propName)) {\n decorators.push(...propMetadata[propName]);\n }\n decorators.push(...ownPropMetadata[propName]);\n propMetadata[propName] = decorators;\n });\n }\n return propMetadata;\n }\n ownPropMetadata(typeOrFunc) {\n if (!isType(typeOrFunc)) {\n return {};\n }\n return this._ownPropMetadata(typeOrFunc, getParentCtor(typeOrFunc)) || {};\n }\n hasLifecycleHook(type, lcProperty) {\n return type instanceof Type && lcProperty in type.prototype;\n }\n guards(type) { return {}; }\n getter(name) { return new Function('o', 'return o.' + name + ';'); }\n setter(name) {\n return new Function('o', 'v', 'return o.' + name + ' = v;');\n }\n method(name) {\n const functionBody = `if (!o.${name}) throw new Error('\"${name}\" is undefined');\n return o.${name}.apply(o, args);`;\n return new Function('o', 'args', functionBody);\n }\n // There is not a concept of import uri in Js, but this is useful in developing Dart applications.\n importUri(type) {\n // StaticSymbol\n if (typeof type === 'object' && type['filePath']) {\n return type['filePath'];\n }\n // Runtime type\n return `./${stringify(type)}`;\n }\n resourceUri(type) { return `./${stringify(type)}`; }\n resolveIdentifier(name, moduleUrl, members, runtime) {\n return runtime;\n }\n resolveEnum(enumIdentifier, name) { return enumIdentifier[name]; }\n}\nfunction convertTsickleDecoratorIntoMetadata(decoratorInvocations) {\n if (!decoratorInvocations) {\n return [];\n }\n return decoratorInvocations.map(decoratorInvocation => {\n const decoratorType = decoratorInvocation.type;\n const annotationCls = decoratorType.annotationCls;\n const annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];\n return new annotationCls(...annotationArgs);\n });\n}\nfunction getParentCtor(ctor) {\n const parentProto = ctor.prototype ? Object.getPrototypeOf(ctor.prototype) : null;\n const parentCtor = parentProto ? parentProto.constructor : null;\n // Note: We always use `Object` as the null value\n // to simplify checking later on.\n return parentCtor || Object;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nlet _reflect = null;\n/**\n * @return {?}\n */\nfunction getReflect() {\n return (_reflect = _reflect || new ReflectionCapabilities());\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction reflectDependencies(type) {\n return convertDependencies(getReflect().parameters(type));\n}\n/**\n * @param {?} deps\n * @return {?}\n */\nfunction convertDependencies(deps) {\n /** @type {?} */\n const compiler = getCompilerFacade();\n return deps.map((/**\n * @param {?} dep\n * @return {?}\n */\n dep => reflectDependency(compiler, dep)));\n}\n/**\n * @param {?} compiler\n * @param {?} dep\n * @return {?}\n */\nfunction reflectDependency(compiler, dep) {\n /** @type {?} */\n const meta = {\n token: null,\n host: false,\n optional: false,\n resolved: compiler.R3ResolvedDependencyType.Token,\n self: false,\n skipSelf: false,\n };\n /**\n * @param {?} token\n * @return {?}\n */\n function setTokenAndResolvedType(token) {\n meta.resolved = compiler.R3ResolvedDependencyType.Token;\n meta.token = token;\n }\n if (Array.isArray(dep)) {\n if (dep.length === 0) {\n throw new Error('Dependency array must have arguments.');\n }\n for (let j = 0; j < dep.length; j++) {\n /** @type {?} */\n const param = dep[j];\n if (param === undefined) {\n // param may be undefined if type of dep is not set by ngtsc\n continue;\n }\n else if (param instanceof Optional || param.__proto__.ngMetadataName === 'Optional') {\n meta.optional = true;\n }\n else if (param instanceof SkipSelf || param.__proto__.ngMetadataName === 'SkipSelf') {\n meta.skipSelf = true;\n }\n else if (param instanceof Self || param.__proto__.ngMetadataName === 'Self') {\n meta.self = true;\n }\n else if (param instanceof Host || param.__proto__.ngMetadataName === 'Host') {\n meta.host = true;\n }\n else if (param instanceof Inject) {\n meta.token = param.token;\n }\n else if (param instanceof Attribute) {\n if (param.attributeName === undefined) {\n throw new Error(`Attribute name must be defined.`);\n }\n meta.token = param.attributeName;\n meta.resolved = compiler.R3ResolvedDependencyType.Attribute;\n }\n else {\n setTokenAndResolvedType(param);\n }\n }\n }\n else {\n setTokenAndResolvedType(dep);\n }\n return meta;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Compile an Angular injectable according to its `Injectable` metadata, and patch the resulting\n * `ngInjectableDef` onto the injectable type.\n * @param {?} type\n * @param {?=} srcMeta\n * @return {?}\n */\nfunction compileInjectable(type, srcMeta) {\n /** @type {?} */\n let def = null;\n // if NG_INJECTABLE_DEF is already defined on this class then don't overwrite it\n if (type.hasOwnProperty(NG_INJECTABLE_DEF))\n return;\n Object.defineProperty(type, NG_INJECTABLE_DEF, {\n get: (/**\n * @return {?}\n */\n () => {\n if (def === null) {\n // Allow the compilation of a class with a `@Injectable()` decorator without parameters\n /** @type {?} */\n const meta = srcMeta || { providedIn: null };\n /** @type {?} */\n const hasAProvider = isUseClassProvider(meta) || isUseFactoryProvider(meta) ||\n isUseValueProvider(meta) || isUseExistingProvider(meta);\n /** @type {?} */\n const compilerMeta = {\n name: type.name,\n type: type,\n typeArgumentCount: 0,\n providedIn: meta.providedIn,\n ctorDeps: reflectDependencies(type),\n userDeps: undefined,\n };\n if ((isUseClassProvider(meta) || isUseFactoryProvider(meta)) && meta.deps !== undefined) {\n compilerMeta.userDeps = convertDependencies(meta.deps);\n }\n if (!hasAProvider) {\n // In the case the user specifies a type provider, treat it as {provide: X, useClass: X}.\n // The deps will have been reflected above, causing the factory to create the class by\n // calling\n // its constructor with injected deps.\n compilerMeta.useClass = type;\n }\n else if (isUseClassProvider(meta)) {\n // The user explicitly specified useClass, and may or may not have provided deps.\n compilerMeta.useClass = meta.useClass;\n }\n else if (isUseValueProvider(meta)) {\n // The user explicitly specified useValue.\n compilerMeta.useValue = meta.useValue;\n }\n else if (isUseFactoryProvider(meta)) {\n // The user explicitly specified useFactory.\n compilerMeta.useFactory = meta.useFactory;\n }\n else if (isUseExistingProvider(meta)) {\n // The user explicitly specified useExisting.\n compilerMeta.useExisting = meta.useExisting;\n }\n else {\n // Can't happen - either hasAProvider will be false, or one of the providers will be set.\n throw new Error(`Unreachable state.`);\n }\n def = getCompilerFacade().compileInjectable(angularCoreDiEnv, `ng:///${type.name}/ngInjectableDef.js`, compilerMeta);\n }\n return def;\n }),\n });\n}\nconst ɵ0$2 = getClosureSafeProperty;\n/** @type {?} */\nconst USE_VALUE$1 = getClosureSafeProperty({ provide: String, useValue: ɵ0$2 });\n/**\n * @param {?} meta\n * @return {?}\n */\nfunction isUseClassProvider(meta) {\n return ((/** @type {?} */ (meta))).useClass !== undefined;\n}\n/**\n * @param {?} meta\n * @return {?}\n */\nfunction isUseValueProvider(meta) {\n return USE_VALUE$1 in meta;\n}\n/**\n * @param {?} meta\n * @return {?}\n */\nfunction isUseFactoryProvider(meta) {\n return ((/** @type {?} */ (meta))).useFactory !== undefined;\n}\n/**\n * @param {?} meta\n * @return {?}\n */\nfunction isUseExistingProvider(meta) {\n return ((/** @type {?} */ (meta))).useExisting !== undefined;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nconst ɵ0$3 = getClosureSafeProperty;\n/** @type {?} */\nconst USE_VALUE$2 = getClosureSafeProperty({ provide: String, useValue: ɵ0$3 });\n/** @type {?} */\nconst EMPTY_ARRAY = [];\n/**\n * @param {?} type\n * @param {?=} provider\n * @return {?}\n */\nfunction convertInjectableProviderToFactory(type, provider) {\n if (!provider) {\n /** @type {?} */\n const reflectionCapabilities = new ReflectionCapabilities();\n /** @type {?} */\n const deps = reflectionCapabilities.parameters(type);\n // TODO - convert to flags.\n return (/**\n * @return {?}\n */\n () => new type(...injectArgs((/** @type {?} */ (deps)))));\n }\n if (USE_VALUE$2 in provider) {\n /** @type {?} */\n const valueProvider = ((/** @type {?} */ (provider)));\n return (/**\n * @return {?}\n */\n () => valueProvider.useValue);\n }\n else if (((/** @type {?} */ (provider))).useExisting) {\n /** @type {?} */\n const existingProvider = ((/** @type {?} */ (provider)));\n return (/**\n * @return {?}\n */\n () => ɵɵinject(existingProvider.useExisting));\n }\n else if (((/** @type {?} */ (provider))).useFactory) {\n /** @type {?} */\n const factoryProvider = ((/** @type {?} */ (provider)));\n return (/**\n * @return {?}\n */\n () => factoryProvider.useFactory(...injectArgs(factoryProvider.deps || EMPTY_ARRAY)));\n }\n else if (((/** @type {?} */ (provider))).useClass) {\n /** @type {?} */\n const classProvider = ((/** @type {?} */ (provider)));\n /** @type {?} */\n let deps = ((/** @type {?} */ (provider))).deps;\n if (!deps) {\n /** @type {?} */\n const reflectionCapabilities = new ReflectionCapabilities();\n deps = reflectionCapabilities.parameters(type);\n }\n return (/**\n * @return {?}\n */\n () => new classProvider.useClass(...injectArgs(deps)));\n }\n else {\n /** @type {?} */\n let deps = ((/** @type {?} */ (provider))).deps;\n if (!deps) {\n /** @type {?} */\n const reflectionCapabilities = new ReflectionCapabilities();\n deps = reflectionCapabilities.parameters(type);\n }\n return (/**\n * @return {?}\n */\n () => new type(...injectArgs((/** @type {?} */ (deps)))));\n }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// WARNING: interface has both a type and a value, skipping emit\nconst ɵ0$4 = /**\n * @param {?} type\n * @param {?} meta\n * @return {?}\n */\n(type, meta) => SWITCH_COMPILE_INJECTABLE((/** @type {?} */ (type)), meta);\n/**\n * Injectable decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Injectable = makeDecorator('Injectable', undefined, undefined, undefined, (ɵ0$4));\n/**\n * Supports \\@Injectable() in JIT mode for Render2.\n * @param {?} injectableType\n * @param {?} options\n * @return {?}\n */\nfunction render2CompileInjectable(injectableType, options) {\n if (options && options.providedIn !== undefined && !getInjectableDef(injectableType)) {\n /** @nocollapse */ injectableType.ngInjectableDef = ɵɵdefineInjectable({\n token: injectableType,\n providedIn: options.providedIn,\n factory: convertInjectableProviderToFactory(injectableType, options),\n });\n }\n}\n/** @type {?} */\nconst SWITCH_COMPILE_INJECTABLE__POST_R3__ = compileInjectable;\n/** @type {?} */\nconst SWITCH_COMPILE_INJECTABLE__PRE_R3__ = render2CompileInjectable;\n/** @type {?} */\nconst SWITCH_COMPILE_INJECTABLE = SWITCH_COMPILE_INJECTABLE__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 */\nfunction ngDevModeResetPerfCounters() {\n const locationString = typeof location !== 'undefined' ? location.toString() : '';\n const newCounters = {\n namedConstructors: locationString.indexOf('ngDevMode=namedConstructors') != -1,\n firstTemplatePass: 0,\n tNode: 0,\n tView: 0,\n rendererCreateTextNode: 0,\n rendererSetText: 0,\n rendererCreateElement: 0,\n rendererAddEventListener: 0,\n rendererSetAttribute: 0,\n rendererRemoveAttribute: 0,\n rendererSetProperty: 0,\n rendererSetClassName: 0,\n rendererAddClass: 0,\n rendererRemoveClass: 0,\n rendererSetStyle: 0,\n rendererRemoveStyle: 0,\n rendererDestroy: 0,\n rendererDestroyNode: 0,\n rendererMoveNode: 0,\n rendererRemoveNode: 0,\n rendererAppendChild: 0,\n rendererInsertBefore: 0,\n rendererCreateComment: 0,\n styleMap: 0,\n styleMapCacheMiss: 0,\n classMap: 0,\n classMapCacheMiss: 0,\n stylingProp: 0,\n stylingPropCacheMiss: 0,\n stylingApply: 0,\n stylingApplyCacheMiss: 0,\n };\n // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.\n const allowNgDevModeTrue = locationString.indexOf('ngDevMode=false') === -1;\n _global['ngDevMode'] = allowNgDevModeTrue && newCounters;\n return newCounters;\n}\n/**\n * This checks to see if the `ngDevMode` has been set. If yes,\n * then we honor it, otherwise we default to dev mode with additional checks.\n *\n * The idea is that unless we are doing production build where we explicitly\n * set `ngDevMode == false` we should be helping the developer by providing\n * as much early warning and errors as possible.\n *\n * NOTE: changes to the `ngDevMode` name must be synced with `compiler-cli/src/tooling.ts`.\n */\nif (typeof ngDevMode === 'undefined' || ngDevMode) {\n ngDevModeResetPerfCounters();\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Called when directives inject each other (creating a circular dependency)\n * @param {?} token\n * @return {?}\n */\nfunction throwCyclicDependencyError(token) {\n throw new Error(`Cannot instantiate cyclic dependency! ${token}`);\n}\n/**\n * Called when there are multiple component selectors that match a given node\n * @param {?} tNode\n * @return {?}\n */\nfunction throwMultipleComponentError(tNode) {\n throw new Error(`Multiple components match node with tagname ${tNode.tagName}`);\n}\n/**\n * Throws an ExpressionChangedAfterChecked error if checkNoChanges mode is on.\n * @param {?} creationMode\n * @param {?} oldValue\n * @param {?} currValue\n * @return {?}\n */\nfunction throwErrorIfNoChangesMode(creationMode, oldValue, currValue) {\n /** @type {?} */\n let 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 * @return {?}\n */\nfunction throwMixedMultiProviderError() {\n throw new Error(`Cannot mix multi providers and regular providers`);\n}\n/**\n * @param {?=} ngModuleType\n * @param {?=} providers\n * @param {?=} provider\n * @return {?}\n */\nfunction throwInvalidProviderError(ngModuleType, providers, provider) {\n /** @type {?} */\n let ngModuleDetail = '';\n if (ngModuleType && providers) {\n /** @type {?} */\n const providerDetail = providers.map((/**\n * @param {?} v\n * @return {?}\n */\n v => v == provider ? '?' + provider + '?' : '...'));\n ngModuleDetail =\n ` - only instances of Provider and Type are allowed, got: [${providerDetail.join(', ')}]`;\n }\n throw new Error(`Invalid provider for the NgModule '${stringify(ngModuleType)}'` + ngModuleDetail);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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 * @type {?}\n */\nconst APP_ROOT = new InjectionToken('The presence of this token marks an injector as being the root injector.');\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Marker which indicates that a value has not yet been created from the factory function.\n * @type {?}\n */\nconst 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 * @type {?}\n */\nconst CIRCULAR = {};\n/** @type {?} */\nconst EMPTY_ARRAY$1 = (/** @type {?} */ ([]));\n/**\n * A lazily initialized NullInjector.\n * @type {?}\n */\nlet NULL_INJECTOR = undefined;\n/**\n * @return {?}\n */\nfunction getNullInjector() {\n if (NULL_INJECTOR === undefined) {\n NULL_INJECTOR = new NullInjector();\n }\n return NULL_INJECTOR;\n}\n/**\n * Create a new `Injector` which is configured using a `defType` of `InjectorType`s.\n *\n * \\@publicApi\n * @param {?} defType\n * @param {?=} parent\n * @param {?=} additionalProviders\n * @param {?=} name\n * @return {?}\n */\nfunction createInjector(defType, parent = null, additionalProviders = null, name) {\n parent = parent || getNullInjector();\n return new R3Injector(defType, additionalProviders, parent, name);\n}\nclass R3Injector {\n /**\n * @param {?} def\n * @param {?} additionalProviders\n * @param {?} parent\n * @param {?=} source\n */\n constructor(def, additionalProviders, parent, source = null) {\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 this._destroyed = false;\n // Start off by creating Records for every provider declared in every InjectorType\n // included transitively in `def`.\n /** @type {?} */\n const dedupStack = [];\n deepForEach([def], (/**\n * @param {?} injectorDef\n * @return {?}\n */\n injectorDef => this.processInjectorType(injectorDef, [], dedupStack)));\n additionalProviders && deepForEach(additionalProviders, (/**\n * @param {?} provider\n * @return {?}\n */\n provider => this.processProvider(provider, def, additionalProviders)));\n // Make sure the INJECTOR token provides this injector.\n this.records.set(INJECTOR, 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((/**\n * @param {?} defType\n * @return {?}\n */\n defType => this.get(defType)));\n // Source name, used for debugging\n this.source = source || (typeof def === 'object' ? null : stringify(def));\n }\n /**\n * Flag indicating that this injector was previously destroyed.\n * @return {?}\n */\n get destroyed() { return this._destroyed; }\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 * @return {?}\n */\n destroy() {\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((/**\n * @param {?} service\n * @return {?}\n */\n service => service.ngOnDestroy()));\n }\n finally {\n // Release all references.\n this.records.clear();\n this.onDestroy.clear();\n this.injectorDefTypes.clear();\n }\n }\n /**\n * @template T\n * @param {?} token\n * @param {?=} notFoundValue\n * @param {?=} flags\n * @return {?}\n */\n get(token, notFoundValue = THROW_IF_NOT_FOUND, flags = InjectFlags.Default) {\n this.assertNotDestroyed();\n // Set the injection context.\n /** @type {?} */\n const 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 /** @type {?} */\n let 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 /** @type {?} */\n const 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(injectableDefOrInjectorDefFactory(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 /** @type {?} */\n const nextInjector = !(flags & InjectFlags.Self) ? this.parent : getNullInjector();\n return nextInjector.get(token, flags & InjectFlags.Optional ? null : notFoundValue);\n }\n catch (e) {\n if (e.name === 'NullInjectorError') {\n /** @type {?} */\n const path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];\n path.unshift(stringify(token));\n if (previousInjector) {\n // We still have a parent injector, keep throwing\n throw e;\n }\n else {\n // Format & throw the final error message when we don't have any previous injector\n return catchInjectorError(e, token, 'R3InjectorError', this.source);\n }\n }\n else {\n throw e;\n }\n }\n finally {\n // Lastly, clean up the state by restoring the previous injector.\n setCurrentInjector(previousInjector);\n }\n }\n /**\n * @return {?}\n */\n toString() {\n /** @type {?} */\n const tokens = (/** @type {?} */ ([]));\n /** @type {?} */\n const records = this.records;\n records.forEach((/**\n * @param {?} v\n * @param {?} token\n * @return {?}\n */\n (v, token) => tokens.push(stringify(token))));\n return `R3Injector[${tokens.join(', ')}]`;\n }\n /**\n * @private\n * @return {?}\n */\n assertNotDestroyed() {\n if (this._destroyed) {\n throw new Error('Injector has already been destroyed.');\n }\n }\n /**\n * Add an `InjectorType` or `InjectorTypeWithProviders` and all of its transitive providers\n * to this injector.\n *\n * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,\n * the function will return \"true\" to indicate that the providers of the type definition need\n * to be processed. This allows us to process providers of injector types after all imports of\n * an injector definition are processed. (following View Engine semantics: see FW-1349)\n * @private\n * @param {?} defOrWrappedDef\n * @param {?} parents\n * @param {?} dedupStack\n * @return {?}\n */\n processInjectorType(defOrWrappedDef, parents, dedupStack) {\n defOrWrappedDef = resolveForwardRef(defOrWrappedDef);\n if (!defOrWrappedDef)\n return false;\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 /** @type {?} */\n let def = getInjectorDef(defOrWrappedDef);\n // If that's not present, then attempt to read ngModule from the InjectorDefTypeWithProviders.\n /** @type {?} */\n const ngModule = (def == null) && ((/** @type {?} */ (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 /** @type {?} */\n const defType = (ngModule === undefined) ? ((/** @type {?} */ (defOrWrappedDef))) : ngModule;\n // Check for circular dependencies.\n if (ngDevMode && parents.indexOf(defType) !== -1) {\n /** @type {?} */\n const defName = stringify(defType);\n throw new Error(`Circular dependency in DI detected for type ${defName}. Dependency path: ${parents.map((/**\n * @param {?} defType\n * @return {?}\n */\n defType => stringify(defType))).join(' > ')} > ${defName}.`);\n }\n // Check for multiple imports of the same module\n /** @type {?} */\n const isDuplicate = dedupStack.indexOf(defType) !== -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 false;\n }\n // Track the InjectorType and add a provider for it.\n this.injectorDefTypes.add(defType);\n this.records.set(defType, makeRecord(def.factory, NOT_YET));\n // Add providers in the same way that @NgModule resolution did:\n // First, include providers from any imports.\n if (def.imports != null && !isDuplicate) {\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 /** @type {?} */\n let importTypesWithProviders;\n try {\n deepForEach(def.imports, (/**\n * @param {?} imported\n * @return {?}\n */\n imported => {\n if (this.processInjectorType(imported, parents, dedupStack)) {\n if (importTypesWithProviders === undefined)\n importTypesWithProviders = [];\n // If the processed import is an injector type with providers, we store it in the\n // list of import types with providers, so that we can process those afterwards.\n importTypesWithProviders.push(imported);\n }\n }));\n }\n finally {\n // Remove it from the parents set when finished.\n ngDevMode && parents.pop();\n }\n // Imports which are declared with providers (TypeWithProviders) need to be processed\n // after all imported modules are processed. This is similar to how View Engine\n // processes/merges module imports in the metadata resolver. See: FW-1349.\n if (importTypesWithProviders !== undefined) {\n for (let i = 0; i < importTypesWithProviders.length; i++) {\n const { ngModule, providers } = importTypesWithProviders[i];\n deepForEach((/** @type {?} */ (providers)), (/**\n * @param {?} provider\n * @return {?}\n */\n provider => this.processProvider(provider, ngModule, providers || EMPTY_ARRAY$1)));\n }\n }\n }\n // Next, include providers listed on the definition itself.\n /** @type {?} */\n const defProviders = def.providers;\n if (defProviders != null && !isDuplicate) {\n /** @type {?} */\n const injectorType = (/** @type {?} */ (defOrWrappedDef));\n deepForEach(defProviders, (/**\n * @param {?} provider\n * @return {?}\n */\n provider => this.processProvider(provider, injectorType, defProviders)));\n }\n return (ngModule !== undefined &&\n ((/** @type {?} */ (defOrWrappedDef))).providers !== undefined);\n }\n /**\n * Process a `SingleProvider` and add it.\n * @private\n * @param {?} provider\n * @param {?} ngModuleType\n * @param {?} providers\n * @return {?}\n */\n processProvider(provider, ngModuleType, providers) {\n // Determine the token from the provider. Either it's its own token, or has a {provide: ...}\n // property.\n provider = resolveForwardRef(provider);\n /** @type {?} */\n let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);\n // Construct a `Record` for the provider.\n /** @type {?} */\n const record = providerToRecord(provider, ngModuleType, providers);\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 /** @type {?} */\n let multiRecord = this.records.get(token);\n if (multiRecord) {\n // It has. Throw a nice error if\n if (multiRecord.multi === undefined) {\n throwMixedMultiProviderError();\n }\n }\n else {\n multiRecord = makeRecord(undefined, NOT_YET, true);\n multiRecord.factory = (/**\n * @return {?}\n */\n () => injectArgs((/** @type {?} */ ((/** @type {?} */ (multiRecord)).multi))));\n this.records.set(token, multiRecord);\n }\n token = provider;\n (/** @type {?} */ (multiRecord.multi)).push(provider);\n }\n else {\n /** @type {?} */\n const existing = this.records.get(token);\n if (existing && existing.multi !== undefined) {\n throwMixedMultiProviderError();\n }\n }\n this.records.set(token, record);\n }\n /**\n * @private\n * @template T\n * @param {?} token\n * @param {?} record\n * @return {?}\n */\n hydrate(token, record) {\n if (record.value === CIRCULAR) {\n throwCyclicDependencyError(stringify(token));\n }\n else if (record.value === NOT_YET) {\n record.value = CIRCULAR;\n record.value = (/** @type {?} */ (record.factory))();\n }\n if (typeof record.value === 'object' && record.value && hasOnDestroy(record.value)) {\n this.onDestroy.add(record.value);\n }\n return (/** @type {?} */ (record.value));\n }\n /**\n * @private\n * @param {?} def\n * @return {?}\n */\n injectableDefInScope(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}\n/**\n * @param {?} token\n * @return {?}\n */\nfunction injectableDefOrInjectorDefFactory(token) {\n // Most tokens will have an ngInjectableDef directly on them, which specifies a factory directly.\n /** @type {?} */\n const injectableDef = getInjectableDef(token);\n if (injectableDef !== null) {\n return injectableDef.factory;\n }\n // If the token is an NgModule, it's also injectable but the factory is on its ngInjectorDef.\n /** @type {?} */\n const injectorDef = getInjectorDef(token);\n if (injectorDef !== null) {\n return injectorDef.factory;\n }\n // InjectionTokens should have an ngInjectableDef and thus should be handled above.\n // If it's missing that, it's an error.\n if (token instanceof InjectionToken) {\n throw new Error(`Token ${stringify(token)} is missing an ngInjectableDef definition.`);\n }\n // Undecorated types can sometimes be created if they have no constructor arguments.\n if (token instanceof Function) {\n return getUndecoratedInjectableFactory(token);\n }\n // There was no way to resolve a factory for this token.\n throw new Error('unreachable');\n}\n/**\n * @param {?} token\n * @return {?}\n */\nfunction getUndecoratedInjectableFactory(token) {\n // If the token has parameters then it has dependencies that we cannot resolve implicitly.\n /** @type {?} */\n const paramLength = token.length;\n if (paramLength > 0) {\n /** @type {?} */\n const args = new Array(paramLength).fill('?');\n throw new Error(`Can't resolve all parameters for ${stringify(token)}: (${args.join(', ')}).`);\n }\n // The constructor function appears to have no parameters.\n // This might be because it inherits from a super-class. In which case, use an ngInjectableDef\n // from an ancestor if there is one.\n // Otherwise this really is a simple class with no dependencies, so return a factory that\n // just instantiates the zero-arg constructor.\n /** @type {?} */\n const inheritedInjectableDef = getInheritedInjectableDef(token);\n if (inheritedInjectableDef !== null) {\n return (/**\n * @return {?}\n */\n () => inheritedInjectableDef.factory((/** @type {?} */ (token))));\n }\n else {\n return (/**\n * @return {?}\n */\n () => new ((/** @type {?} */ (token)))());\n }\n}\n/**\n * @param {?} provider\n * @param {?} ngModuleType\n * @param {?} providers\n * @return {?}\n */\nfunction providerToRecord(provider, ngModuleType, providers) {\n /** @type {?} */\n let factory = providerToFactory(provider, ngModuleType, providers);\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 * @param {?=} ngModuleType\n * @param {?=} providers\n * @return {?}\n */\nfunction providerToFactory(provider, ngModuleType, providers) {\n /** @type {?} */\n let factory = undefined;\n if (isTypeProvider(provider)) {\n return injectableDefOrInjectorDefFactory(resolveForwardRef(provider));\n }\n else {\n if (isValueProvider(provider)) {\n factory = (/**\n * @return {?}\n */\n () => resolveForwardRef(provider.useValue));\n }\n else if (isExistingProvider(provider)) {\n factory = (/**\n * @return {?}\n */\n () => ɵɵinject(resolveForwardRef(provider.useExisting)));\n }\n else if (isFactoryProvider(provider)) {\n factory = (/**\n * @return {?}\n */\n () => provider.useFactory(...injectArgs(provider.deps || [])));\n }\n else {\n /** @type {?} */\n const classRef = resolveForwardRef(provider &&\n (((/** @type {?} */ (provider))).useClass || provider.provide));\n if (!classRef) {\n throwInvalidProviderError(ngModuleType, providers, provider);\n }\n if (hasDeps(provider)) {\n factory = (/**\n * @return {?}\n */\n () => new (classRef)(...injectArgs(provider.deps)));\n }\n else {\n return injectableDefOrInjectorDefFactory(classRef);\n }\n }\n }\n return factory;\n}\n/**\n * @template T\n * @param {?} factory\n * @param {?} value\n * @param {?=} multi\n * @return {?}\n */\nfunction makeRecord(factory, value, multi = false) {\n return {\n factory: factory,\n value: value,\n multi: multi ? [] : undefined,\n };\n}\n/**\n * @template T\n * @param {?} input\n * @param {?} fn\n * @return {?}\n */\nfunction deepForEach(input, fn) {\n input.forEach((/**\n * @param {?} value\n * @return {?}\n */\n value => Array.isArray(value) ? deepForEach(value, fn) : fn(value)));\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isValueProvider(value) {\n return value !== null && typeof value == 'object' && USE_VALUE in value;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isExistingProvider(value) {\n return !!(value && ((/** @type {?} */ (value))).useExisting);\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isFactoryProvider(value) {\n return !!(value && ((/** @type {?} */ (value))).useFactory);\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isTypeProvider(value) {\n return typeof value === 'function';\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isClassProvider(value) {\n return !!((/** @type {?} */ (value))).useClass;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction hasDeps(value) {\n return !!((/** @type {?} */ (value))).deps;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction hasOnDestroy(value) {\n return value !== null && typeof value === 'object' &&\n typeof ((/** @type {?} */ (value))).ngOnDestroy === 'function';\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction couldBeInjectableType(value) {\n return (typeof value === 'function') ||\n (typeof value === 'object' && value instanceof InjectionToken);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @param {?} providers\n * @param {?} parent\n * @param {?} name\n * @return {?}\n */\nfunction INJECTOR_IMPL__PRE_R3__(providers, parent, name) {\n return new StaticInjector(providers, parent, name);\n}\n/**\n * @param {?} providers\n * @param {?} parent\n * @param {?} name\n * @return {?}\n */\nfunction INJECTOR_IMPL__POST_R3__(providers, parent, name) {\n return createInjector({ name: name }, parent, providers, name);\n}\n/** @type {?} */\nconst INJECTOR_IMPL = INJECTOR_IMPL__PRE_R3__;\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 * @abstract\n */\nclass Injector {\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 * @param {?} options\n * @param {?=} parent\n * @return {?}\n */\n static create(options, parent) {\n if (Array.isArray(options)) {\n return INJECTOR_IMPL(options, parent, '');\n }\n else {\n return INJECTOR_IMPL(options.providers, options.parent, options.name || '');\n }\n }\n}\nInjector.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;\nInjector.NULL = new NullInjector();\n/** @nocollapse */\n/** @nocollapse */ Injector.ngInjectableDef = ɵɵdefineInjectable({\n token: Injector,\n providedIn: (/** @type {?} */ ('any')),\n factory: (/**\n * @return {?}\n */\n () => ɵɵinject(INJECTOR)),\n});\n/**\n * \\@internal\n * @nocollapse\n */\nInjector.__NG_ELEMENT_ID__ = -1;\n/** @type {?} */\nconst IDENT = (/**\n * @template T\n * @param {?} value\n * @return {?}\n */\nfunction (value) {\n return value;\n});\n/** @type {?} */\nconst EMPTY = (/** @type {?} */ ([]));\n/** @type {?} */\nconst CIRCULAR$1 = IDENT;\n/** @type {?} */\nconst MULTI_PROVIDER_FN = (/**\n * @return {?}\n */\nfunction () {\n return Array.prototype.slice.call(arguments);\n});\n/** @type {?} */\nconst NO_NEW_LINE$1 = 'ɵ';\nclass StaticInjector {\n /**\n * @param {?} providers\n * @param {?=} parent\n * @param {?=} source\n */\n constructor(providers, parent = Injector.NULL, source = null) {\n this.parent = parent;\n this.source = source;\n /** @type {?} */\n const records = this._records = new Map();\n records.set(Injector, (/** @type {?} */ ({ token: Injector, fn: IDENT, deps: EMPTY, value: this, useNew: false })));\n records.set(INJECTOR, (/** @type {?} */ ({ token: INJECTOR, fn: IDENT, deps: EMPTY, value: this, useNew: false })));\n recursivelyProcessProviders(records, providers);\n }\n /**\n * @param {?} token\n * @param {?=} notFoundValue\n * @param {?=} flags\n * @return {?}\n */\n get(token, notFoundValue, flags = InjectFlags.Default) {\n /** @type {?} */\n const record = this._records.get(token);\n try {\n return tryResolveToken(token, record, this._records, this.parent, notFoundValue, flags);\n }\n catch (e) {\n return catchInjectorError(e, token, 'StaticInjectorError', this.source);\n }\n }\n /**\n * @return {?}\n */\n toString() {\n /** @type {?} */\n const tokens = (/** @type {?} */ ([]));\n /** @type {?} */\n const records = this._records;\n records.forEach((/**\n * @param {?} v\n * @param {?} token\n * @return {?}\n */\n (v, token) => tokens.push(stringify(token))));\n return `StaticInjector[${tokens.join(', ')}]`;\n }\n}\n/**\n * @param {?} provider\n * @return {?}\n */\nfunction resolveProvider(provider) {\n /** @type {?} */\n const deps = computeDeps(provider);\n /** @type {?} */\n let fn = IDENT;\n /** @type {?} */\n let value = EMPTY;\n /** @type {?} */\n let useNew = false;\n /** @type {?} */\n let 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 = ((/** @type {?} */ (provider))).useValue;\n }\n else if (((/** @type {?} */ (provider))).useFactory) {\n fn = ((/** @type {?} */ (provider))).useFactory;\n }\n else if (((/** @type {?} */ (provider))).useExisting) ;\n else if (((/** @type {?} */ (provider))).useClass) {\n useNew = true;\n fn = resolveForwardRef(((/** @type {?} */ (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, fn, useNew, value };\n}\n/**\n * @param {?} token\n * @return {?}\n */\nfunction multiProviderMixError(token) {\n return staticError('Cannot mix multi providers and regular providers', token);\n}\n/**\n * @param {?} records\n * @param {?} provider\n * @return {?}\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 (let 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 /** @type {?} */\n let token = resolveForwardRef(provider.provide);\n /** @type {?} */\n const resolvedProvider = resolveProvider(provider);\n if (provider.multi === true) {\n // This is a multi provider.\n /** @type {?} */\n let 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 = (/** @type {?} */ ({\n token: provider.provide,\n deps: [],\n useNew: false,\n fn: MULTI_PROVIDER_FN,\n value: EMPTY\n })));\n }\n // Treat the provider as the token.\n token = provider;\n multiProvider.deps.push({ token, options: 6 /* Default */ });\n }\n /** @type {?} */\n const 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}\n/**\n * @param {?} token\n * @param {?} record\n * @param {?} records\n * @param {?} parent\n * @param {?} notFoundValue\n * @param {?} flags\n * @return {?}\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 /** @type {?} */\n const path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];\n path.unshift(token);\n if (record && record.value == CIRCULAR$1) {\n // Reset the Circular flag.\n record.value = EMPTY;\n }\n throw e;\n }\n}\n/**\n * @param {?} token\n * @param {?} record\n * @param {?} records\n * @param {?} parent\n * @param {?} notFoundValue\n * @param {?} flags\n * @return {?}\n */\nfunction resolveToken(token, record, records, parent, notFoundValue, flags) {\n /** @type {?} */\n let 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$1) {\n throw Error(NO_NEW_LINE$1 + 'Circular dependency');\n }\n else if (value === EMPTY) {\n record.value = CIRCULAR$1;\n /** @type {?} */\n let obj = undefined;\n /** @type {?} */\n let useNew = record.useNew;\n /** @type {?} */\n let fn = record.fn;\n /** @type {?} */\n let depRecords = record.deps;\n /** @type {?} */\n let deps = EMPTY;\n if (depRecords.length) {\n deps = [];\n for (let i = 0; i < depRecords.length; i++) {\n /** @type {?} */\n const depRecord = depRecords[i];\n /** @type {?} */\n const options = depRecord.options;\n /** @type {?} */\n const 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 */) ? Injector.NULL : parent, options & 1 /* Optional */ ? null : Injector.THROW_IF_NOT_FOUND, InjectFlags.Default));\n }\n }\n record.value = value = useNew ? new ((/** @type {?} */ (fn)))(...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}\n/**\n * @param {?} provider\n * @return {?}\n */\nfunction computeDeps(provider) {\n /** @type {?} */\n let deps = EMPTY;\n /** @type {?} */\n const providerDeps = ((/** @type {?} */ (provider))).deps;\n if (providerDeps && providerDeps.length) {\n deps = [];\n for (let i = 0; i < providerDeps.length; i++) {\n /** @type {?} */\n let options = 6 /* Default */;\n /** @type {?} */\n let token = resolveForwardRef(providerDeps[i]);\n if (token instanceof Array) {\n for (let j = 0, annotations = token; j < annotations.length; j++) {\n /** @type {?} */\n const 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 = ((/** @type {?} */ (annotation))).token;\n }\n else {\n token = resolveForwardRef(annotation);\n }\n }\n }\n deps.push({ token, options });\n }\n }\n else if (((/** @type {?} */ (provider))).useExisting) {\n /** @type {?} */\n const token = resolveForwardRef(((/** @type {?} */ (provider))).useExisting);\n deps = [{ 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}\n/**\n * @param {?} text\n * @param {?} obj\n * @return {?}\n */\nfunction staticError(text, obj) {\n return new Error(formatError(text, obj, 'StaticInjectorError'));\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst ERROR_DEBUG_CONTEXT = 'ngDebugContext';\nconst ERROR_ORIGINAL_ERROR = 'ngOriginalError';\nconst ERROR_LOGGER = 'ngErrorLogger';\nfunction wrappedError(message, originalError) {\n const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;\n const error = Error(msg);\n error[ERROR_ORIGINAL_ERROR] = originalError;\n return error;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @param {?} keys\n * @return {?}\n */\nfunction findFirstClosedCycle(keys) {\n /** @type {?} */\n const res = [];\n for (let i = 0; i < keys.length; ++i) {\n if (res.indexOf(keys[i]) > -1) {\n res.push(keys[i]);\n return res;\n }\n res.push(keys[i]);\n }\n return res;\n}\n/**\n * @param {?} keys\n * @return {?}\n */\nfunction constructResolvingPath(keys) {\n if (keys.length > 1) {\n /** @type {?} */\n const reversed = findFirstClosedCycle(keys.slice().reverse());\n /** @type {?} */\n const tokenStrs = reversed.map((/**\n * @param {?} k\n * @return {?}\n */\n k => stringify(k.token)));\n return ' (' + tokenStrs.join(' -> ') + ')';\n }\n return '';\n}\n/**\n * @param {?} injector\n * @param {?} key\n * @param {?} constructResolvingMessage\n * @param {?=} originalError\n * @return {?}\n */\nfunction injectionError(injector, key, constructResolvingMessage, originalError) {\n /** @type {?} */\n const keys = [key];\n /** @type {?} */\n const errMsg = constructResolvingMessage(keys);\n /** @type {?} */\n const error = (/** @type {?} */ ((originalError ? wrappedError(errMsg, originalError) : Error(errMsg))));\n error.addKey = addKey;\n error.keys = keys;\n error.injectors = [injector];\n error.constructResolvingMessage = constructResolvingMessage;\n ((/** @type {?} */ (error)))[ERROR_ORIGINAL_ERROR] = originalError;\n return error;\n}\n/**\n * @this {?}\n * @param {?} injector\n * @param {?} key\n * @return {?}\n */\nfunction addKey(injector, key) {\n this.injectors.push(injector);\n this.keys.push(key);\n // Note: This updated message won't be reflected in the `.stack` property\n this.message = this.constructResolvingMessage(this.keys);\n}\n/**\n * Thrown when trying to retrieve a dependency by key from {\\@link Injector}, but the\n * {\\@link Injector} does not have a {\\@link Provider} for the given key.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * class A {\n * constructor(b:B) {}\n * }\n *\n * expect(() => Injector.resolveAndCreate([A])).toThrowError();\n * ```\n * @param {?} injector\n * @param {?} key\n * @return {?}\n */\nfunction noProviderError(injector, key) {\n return injectionError(injector, key, (/**\n * @param {?} keys\n * @return {?}\n */\n function (keys) {\n /** @type {?} */\n const first = stringify(keys[0].token);\n return `No provider for ${first}!${constructResolvingPath(keys)}`;\n }));\n}\n/**\n * Thrown when dependencies form a cycle.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * var injector = Injector.resolveAndCreate([\n * {provide: \"one\", useFactory: (two) => \"two\", deps: [[new Inject(\"two\")]]},\n * {provide: \"two\", useFactory: (one) => \"one\", deps: [[new Inject(\"one\")]]}\n * ]);\n *\n * expect(() => injector.get(\"one\")).toThrowError();\n * ```\n *\n * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.\n * @param {?} injector\n * @param {?} key\n * @return {?}\n */\nfunction cyclicDependencyError(injector, key) {\n return injectionError(injector, key, (/**\n * @param {?} keys\n * @return {?}\n */\n function (keys) {\n return `Cannot instantiate cyclic dependency!${constructResolvingPath(keys)}`;\n }));\n}\n/**\n * Thrown when a constructing type returns with an Error.\n *\n * The `InstantiationError` class contains the original error plus the dependency graph which caused\n * this object to be instantiated.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * class A {\n * constructor() {\n * throw new Error('message');\n * }\n * }\n *\n * var injector = Injector.resolveAndCreate([A]);\n * try {\n * injector.get(A);\n * } catch (e) {\n * expect(e instanceof InstantiationError).toBe(true);\n * expect(e.originalException.message).toEqual(\"message\");\n * expect(e.originalStack).toBeDefined();\n * }\n * ```\n * @param {?} injector\n * @param {?} originalException\n * @param {?} originalStack\n * @param {?} key\n * @return {?}\n */\nfunction instantiationError(injector, originalException, originalStack, key) {\n return injectionError(injector, key, (/**\n * @param {?} keys\n * @return {?}\n */\n function (keys) {\n /** @type {?} */\n const first = stringify(keys[0].token);\n return `${originalException.message}: Error during instantiation of ${first}!${constructResolvingPath(keys)}.`;\n }), originalException);\n}\n/**\n * Thrown when an object other then {\\@link Provider} (or `Type`) is passed to {\\@link Injector}\n * creation.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * expect(() => Injector.resolveAndCreate([\"not a type\"])).toThrowError();\n * ```\n * @param {?} provider\n * @return {?}\n */\nfunction invalidProviderError(provider) {\n return Error(`Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);\n}\n/**\n * Thrown when the class has no annotation information.\n *\n * Lack of annotation information prevents the {\\@link Injector} from determining which dependencies\n * need to be injected into the constructor.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * class A {\n * constructor(b) {}\n * }\n *\n * expect(() => Injector.resolveAndCreate([A])).toThrowError();\n * ```\n *\n * This error is also thrown when the class not marked with {\\@link Injectable} has parameter types.\n *\n * ```typescript\n * class B {}\n *\n * class A {\n * constructor(b:B) {} // no information about the parameter types of A is available at runtime.\n * }\n *\n * expect(() => Injector.resolveAndCreate([A,B])).toThrowError();\n * ```\n *\n * @param {?} typeOrFunc\n * @param {?} params\n * @return {?}\n */\nfunction noAnnotationError(typeOrFunc, params) {\n /** @type {?} */\n const signature = [];\n for (let i = 0, ii = params.length; i < ii; i++) {\n /** @type {?} */\n const parameter = params[i];\n if (!parameter || parameter.length == 0) {\n signature.push('?');\n }\n else {\n signature.push(parameter.map(stringify).join(' '));\n }\n }\n return Error('Cannot resolve all parameters for \\'' + stringify(typeOrFunc) + '\\'(' +\n signature.join(', ') + '). ' +\n 'Make sure that all the parameters are decorated with Inject or have valid type annotations and that \\'' +\n stringify(typeOrFunc) + '\\' is decorated with Injectable.');\n}\n/**\n * Thrown when getting an object by index.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * class A {}\n *\n * var injector = Injector.resolveAndCreate([A]);\n *\n * expect(() => injector.getAt(100)).toThrowError();\n * ```\n *\n * @param {?} index\n * @return {?}\n */\nfunction outOfBoundsError(index) {\n return Error(`Index ${index} is out-of-bounds.`);\n}\n// TODO: add a working example after alpha38 is released\n/**\n * Thrown when a multi provider and a regular provider are bound to the same token.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * expect(() => Injector.resolveAndCreate([\n * { provide: \"Strings\", useValue: \"string1\", multi: true},\n * { provide: \"Strings\", useValue: \"string2\", multi: false}\n * ])).toThrowError();\n * ```\n * @param {?} provider1\n * @param {?} provider2\n * @return {?}\n */\nfunction mixingMultiProvidersWithRegularProvidersError(provider1, provider2) {\n return Error(`Cannot mix multi providers and regular providers, got: ${provider1} ${provider2}`);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * A unique object used for retrieving items from the {\\@link ReflectiveInjector}.\n *\n * Keys have:\n * - a system-wide unique `id`.\n * - a `token`.\n *\n * `Key` is used internally by {\\@link ReflectiveInjector} because its system-wide unique `id` allows\n * the\n * injector to store created objects in a more efficient way.\n *\n * `Key` should not be created directly. {\\@link ReflectiveInjector} creates keys automatically when\n * resolving\n * providers.\n *\n * @deprecated No replacement\n * \\@publicApi\n */\nclass ReflectiveKey {\n /**\n * Private\n * @param {?} token\n * @param {?} id\n */\n constructor(token, id) {\n this.token = token;\n this.id = id;\n if (!token) {\n throw new Error('Token must be defined!');\n }\n this.displayName = stringify(this.token);\n }\n /**\n * Retrieves a `Key` for a token.\n * @param {?} token\n * @return {?}\n */\n static get(token) {\n return _globalKeyRegistry.get(resolveForwardRef(token));\n }\n /**\n * @return {?} the number of keys registered in the system.\n */\n static get numberOfKeys() { return _globalKeyRegistry.numberOfKeys; }\n}\nclass KeyRegistry {\n constructor() {\n this._allKeys = new Map();\n }\n /**\n * @param {?} token\n * @return {?}\n */\n get(token) {\n if (token instanceof ReflectiveKey)\n return token;\n if (this._allKeys.has(token)) {\n return (/** @type {?} */ (this._allKeys.get(token)));\n }\n /** @type {?} */\n const newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);\n this._allKeys.set(token, newKey);\n return newKey;\n }\n /**\n * @return {?}\n */\n get numberOfKeys() { return this._allKeys.size; }\n}\n/** @type {?} */\nconst _globalKeyRegistry = new KeyRegistry();\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 * Provides access to reflection data about symbols. Used internally by Angular\n * to power dependency injection and compilation.\n */\nclass Reflector {\n constructor(reflectionCapabilities) {\n this.reflectionCapabilities = reflectionCapabilities;\n }\n updateCapabilities(caps) { this.reflectionCapabilities = caps; }\n factory(type) { return this.reflectionCapabilities.factory(type); }\n parameters(typeOrFunc) {\n return this.reflectionCapabilities.parameters(typeOrFunc);\n }\n annotations(typeOrFunc) {\n return this.reflectionCapabilities.annotations(typeOrFunc);\n }\n propMetadata(typeOrFunc) {\n return this.reflectionCapabilities.propMetadata(typeOrFunc);\n }\n hasLifecycleHook(type, lcProperty) {\n return this.reflectionCapabilities.hasLifecycleHook(type, lcProperty);\n }\n getter(name) { return this.reflectionCapabilities.getter(name); }\n setter(name) { return this.reflectionCapabilities.setter(name); }\n method(name) { return this.reflectionCapabilities.method(name); }\n importUri(type) { return this.reflectionCapabilities.importUri(type); }\n resourceUri(type) { return this.reflectionCapabilities.resourceUri(type); }\n resolveIdentifier(name, moduleUrl, members, runtime) {\n return this.reflectionCapabilities.resolveIdentifier(name, moduleUrl, members, runtime);\n }\n resolveEnum(identifier, name) {\n return this.reflectionCapabilities.resolveEnum(identifier, name);\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 * The {@link Reflector} used internally in Angular to access metadata\n * about symbols.\n */\nconst reflector = new Reflector(new ReflectionCapabilities());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * `Dependency` is used by the framework to extend DI.\n * This is internal to Angular and should not be used directly.\n */\nclass ReflectiveDependency {\n /**\n * @param {?} key\n * @param {?} optional\n * @param {?} visibility\n */\n constructor(key, optional, visibility) {\n this.key = key;\n this.optional = optional;\n this.visibility = visibility;\n }\n /**\n * @param {?} key\n * @return {?}\n */\n static fromKey(key) {\n return new ReflectiveDependency(key, false, null);\n }\n}\n/** @type {?} */\nconst _EMPTY_LIST = [];\nclass ResolvedReflectiveProvider_ {\n /**\n * @param {?} key\n * @param {?} resolvedFactories\n * @param {?} multiProvider\n */\n constructor(key, resolvedFactories, multiProvider) {\n this.key = key;\n this.resolvedFactories = resolvedFactories;\n this.multiProvider = multiProvider;\n this.resolvedFactory = this.resolvedFactories[0];\n }\n}\n/**\n * An internal resolved representation of a factory function created by resolving `Provider`.\n * \\@publicApi\n */\nclass ResolvedReflectiveFactory {\n /**\n * @param {?} factory\n * @param {?} dependencies\n */\n constructor(factory, dependencies) {\n this.factory = factory;\n this.dependencies = dependencies;\n }\n}\n/**\n * Resolve a single provider.\n * @param {?} provider\n * @return {?}\n */\nfunction resolveReflectiveFactory(provider) {\n /** @type {?} */\n let factoryFn;\n /** @type {?} */\n let resolvedDeps;\n if (provider.useClass) {\n /** @type {?} */\n const useClass = resolveForwardRef(provider.useClass);\n factoryFn = reflector.factory(useClass);\n resolvedDeps = _dependenciesFor(useClass);\n }\n else if (provider.useExisting) {\n factoryFn = (/**\n * @param {?} aliasInstance\n * @return {?}\n */\n (aliasInstance) => aliasInstance);\n resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];\n }\n else if (provider.useFactory) {\n factoryFn = provider.useFactory;\n resolvedDeps = constructDependencies(provider.useFactory, provider.deps);\n }\n else {\n factoryFn = (/**\n * @return {?}\n */\n () => provider.useValue);\n resolvedDeps = _EMPTY_LIST;\n }\n return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);\n}\n/**\n * Converts the `Provider` into `ResolvedProvider`.\n *\n * `Injector` internally only uses `ResolvedProvider`, `Provider` contains convenience provider\n * syntax.\n * @param {?} provider\n * @return {?}\n */\nfunction resolveReflectiveProvider(provider) {\n return new ResolvedReflectiveProvider_(ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)], provider.multi || false);\n}\n/**\n * Resolve a list of Providers.\n * @param {?} providers\n * @return {?}\n */\nfunction resolveReflectiveProviders(providers) {\n /** @type {?} */\n const normalized = _normalizeProviders(providers, []);\n /** @type {?} */\n const resolved = normalized.map(resolveReflectiveProvider);\n /** @type {?} */\n const resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());\n return Array.from(resolvedProviderMap.values());\n}\n/**\n * Merges a list of ResolvedProviders into a list where each key is contained exactly once and\n * multi providers have been merged.\n * @param {?} providers\n * @param {?} normalizedProvidersMap\n * @return {?}\n */\nfunction mergeResolvedReflectiveProviders(providers, normalizedProvidersMap) {\n for (let i = 0; i < providers.length; i++) {\n /** @type {?} */\n const provider = providers[i];\n /** @type {?} */\n const existing = normalizedProvidersMap.get(provider.key.id);\n if (existing) {\n if (provider.multiProvider !== existing.multiProvider) {\n throw mixingMultiProvidersWithRegularProvidersError(existing, provider);\n }\n if (provider.multiProvider) {\n for (let j = 0; j < provider.resolvedFactories.length; j++) {\n existing.resolvedFactories.push(provider.resolvedFactories[j]);\n }\n }\n else {\n normalizedProvidersMap.set(provider.key.id, provider);\n }\n }\n else {\n /** @type {?} */\n let resolvedProvider;\n if (provider.multiProvider) {\n resolvedProvider = new ResolvedReflectiveProvider_(provider.key, provider.resolvedFactories.slice(), provider.multiProvider);\n }\n else {\n resolvedProvider = provider;\n }\n normalizedProvidersMap.set(provider.key.id, resolvedProvider);\n }\n }\n return normalizedProvidersMap;\n}\n/**\n * @param {?} providers\n * @param {?} res\n * @return {?}\n */\nfunction _normalizeProviders(providers, res) {\n providers.forEach((/**\n * @param {?} b\n * @return {?}\n */\n b => {\n if (b instanceof Type) {\n res.push({ provide: b, useClass: b });\n }\n else if (b && typeof b == 'object' && ((/** @type {?} */ (b))).provide !== undefined) {\n res.push((/** @type {?} */ (b)));\n }\n else if (b instanceof Array) {\n _normalizeProviders(b, res);\n }\n else {\n throw invalidProviderError(b);\n }\n }));\n return res;\n}\n/**\n * @param {?} typeOrFunc\n * @param {?=} dependencies\n * @return {?}\n */\nfunction constructDependencies(typeOrFunc, dependencies) {\n if (!dependencies) {\n return _dependenciesFor(typeOrFunc);\n }\n else {\n /** @type {?} */\n const params = dependencies.map((/**\n * @param {?} t\n * @return {?}\n */\n t => [t]));\n return dependencies.map((/**\n * @param {?} t\n * @return {?}\n */\n t => _extractToken(typeOrFunc, t, params)));\n }\n}\n/**\n * @param {?} typeOrFunc\n * @return {?}\n */\nfunction _dependenciesFor(typeOrFunc) {\n /** @type {?} */\n const params = reflector.parameters(typeOrFunc);\n if (!params)\n return [];\n if (params.some((/**\n * @param {?} p\n * @return {?}\n */\n p => p == null))) {\n throw noAnnotationError(typeOrFunc, params);\n }\n return params.map((/**\n * @param {?} p\n * @return {?}\n */\n p => _extractToken(typeOrFunc, p, params)));\n}\n/**\n * @param {?} typeOrFunc\n * @param {?} metadata\n * @param {?} params\n * @return {?}\n */\nfunction _extractToken(typeOrFunc, metadata, params) {\n /** @type {?} */\n let token = null;\n /** @type {?} */\n let optional = false;\n if (!Array.isArray(metadata)) {\n if (metadata instanceof Inject) {\n return _createDependency(metadata.token, optional, null);\n }\n else {\n return _createDependency(metadata, optional, null);\n }\n }\n /** @type {?} */\n let visibility = null;\n for (let i = 0; i < metadata.length; ++i) {\n /** @type {?} */\n const paramMetadata = metadata[i];\n if (paramMetadata instanceof Type) {\n token = paramMetadata;\n }\n else if (paramMetadata instanceof Inject) {\n token = paramMetadata.token;\n }\n else if (paramMetadata instanceof Optional) {\n optional = true;\n }\n else if (paramMetadata instanceof Self || paramMetadata instanceof SkipSelf) {\n visibility = paramMetadata;\n }\n else if (paramMetadata instanceof InjectionToken) {\n token = paramMetadata;\n }\n }\n token = resolveForwardRef(token);\n if (token != null) {\n return _createDependency(token, optional, visibility);\n }\n else {\n throw noAnnotationError(typeOrFunc, params);\n }\n}\n/**\n * @param {?} token\n * @param {?} optional\n * @param {?} visibility\n * @return {?}\n */\nfunction _createDependency(token, optional, visibility) {\n return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n// Threshold for the dynamic version\n/** @type {?} */\nconst UNDEFINED = new Object();\n/**\n * A ReflectiveDependency injection container used for instantiating objects and resolving\n * dependencies.\n *\n * An `Injector` is a replacement for a `new` operator, which can automatically resolve the\n * constructor dependencies.\n *\n * In typical use, application code asks for the dependencies in the constructor and they are\n * resolved by the `Injector`.\n *\n * \\@usageNotes\n * ### Example\n *\n * The following example creates an `Injector` configured to create `Engine` and `Car`.\n *\n * ```typescript\n * \\@Injectable()\n * class Engine {\n * }\n *\n * \\@Injectable()\n * class Car {\n * constructor(public engine:Engine) {}\n * }\n *\n * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);\n * var car = injector.get(Car);\n * expect(car instanceof Car).toBe(true);\n * expect(car.engine instanceof Engine).toBe(true);\n * ```\n *\n * Notice, we don't use the `new` operator because we explicitly want to have the `Injector`\n * resolve all of the object's dependencies automatically.\n *\n * @deprecated from v5 - slow and brings in a lot of code, Use `Injector.create` instead.\n * \\@publicApi\n * @abstract\n */\nclass ReflectiveInjector {\n /**\n * Turns an array of provider definitions into an array of resolved providers.\n *\n * A resolution is a process of flattening multiple nested arrays and converting individual\n * providers into an array of `ResolvedReflectiveProvider`s.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * \\@Injectable()\n * class Engine {\n * }\n * /\n * class Car {\n * constructor(public engine:Engine) {}\n * }\n *\n * var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);\n *\n * expect(providers.length).toEqual(2);\n *\n * expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);\n * expect(providers[0].key.displayName).toBe(\"Car\");\n * expect(providers[0].dependencies.length).toEqual(1);\n * expect(providers[0].factory).toBeDefined();\n *\n * expect(providers[1].key.displayName).toBe(\"Engine\");\n * });\n * ```\n *\n * @param {?} providers\n * @return {?}\n */\n static resolve(providers) {\n return resolveReflectiveProviders(providers);\n }\n /**\n * Resolves an array of providers and creates an injector from those providers.\n *\n * The passed-in providers can be an array of `Type`, `Provider`,\n * or a recursive array of more providers.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * \\@Injectable()\n * class Engine {\n * }\n * /\n * class Car {\n * constructor(public engine:Engine) {}\n * }\n *\n * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);\n * expect(injector.get(Car) instanceof Car).toBe(true);\n * ```\n * @param {?} providers\n * @param {?=} parent\n * @return {?}\n */\n static resolveAndCreate(providers, parent) {\n /** @type {?} */\n const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);\n return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);\n }\n /**\n * Creates an injector from previously resolved providers.\n *\n * This API is the recommended way to construct injectors in performance-sensitive parts.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```typescript\n * \\@Injectable()\n * class Engine {\n * }\n * /\n * class Car {\n * constructor(public engine:Engine) {}\n * }\n *\n * var providers = ReflectiveInjector.resolve([Car, Engine]);\n * var injector = ReflectiveInjector.fromResolvedProviders(providers);\n * expect(injector.get(Car) instanceof Car).toBe(true);\n * ```\n * @param {?} providers\n * @param {?=} parent\n * @return {?}\n */\n static fromResolvedProviders(providers, parent) {\n return new ReflectiveInjector_(providers, parent);\n }\n}\nclass ReflectiveInjector_ {\n /**\n * Private\n * @param {?} _providers\n * @param {?=} _parent\n */\n constructor(_providers, _parent) {\n /**\n * \\@internal\n */\n this._constructionCounter = 0;\n this._providers = _providers;\n this.parent = _parent || null;\n /** @type {?} */\n const len = _providers.length;\n this.keyIds = new Array(len);\n this.objs = new Array(len);\n for (let i = 0; i < len; i++) {\n this.keyIds[i] = _providers[i].key.id;\n this.objs[i] = UNDEFINED;\n }\n }\n /**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\n get(token, notFoundValue = THROW_IF_NOT_FOUND) {\n return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);\n }\n /**\n * @param {?} providers\n * @return {?}\n */\n resolveAndCreateChild(providers) {\n /** @type {?} */\n const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);\n return this.createChildFromResolved(ResolvedReflectiveProviders);\n }\n /**\n * @param {?} providers\n * @return {?}\n */\n createChildFromResolved(providers) {\n /** @type {?} */\n const inj = new ReflectiveInjector_(providers);\n ((/** @type {?} */ (inj))).parent = this;\n return inj;\n }\n /**\n * @param {?} provider\n * @return {?}\n */\n resolveAndInstantiate(provider) {\n return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);\n }\n /**\n * @param {?} provider\n * @return {?}\n */\n instantiateResolved(provider) {\n return this._instantiateProvider(provider);\n }\n /**\n * @param {?} index\n * @return {?}\n */\n getProviderAtIndex(index) {\n if (index < 0 || index >= this._providers.length) {\n throw outOfBoundsError(index);\n }\n return this._providers[index];\n }\n /**\n * \\@internal\n * @param {?} provider\n * @return {?}\n */\n _new(provider) {\n if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {\n throw cyclicDependencyError(this, provider.key);\n }\n return this._instantiateProvider(provider);\n }\n /**\n * @private\n * @return {?}\n */\n _getMaxNumberOfObjects() { return this.objs.length; }\n /**\n * @private\n * @param {?} provider\n * @return {?}\n */\n _instantiateProvider(provider) {\n if (provider.multiProvider) {\n /** @type {?} */\n const res = new Array(provider.resolvedFactories.length);\n for (let i = 0; i < provider.resolvedFactories.length; ++i) {\n res[i] = this._instantiate(provider, provider.resolvedFactories[i]);\n }\n return res;\n }\n else {\n return this._instantiate(provider, provider.resolvedFactories[0]);\n }\n }\n /**\n * @private\n * @param {?} provider\n * @param {?} ResolvedReflectiveFactory\n * @return {?}\n */\n _instantiate(provider, ResolvedReflectiveFactory) {\n /** @type {?} */\n const factory = ResolvedReflectiveFactory.factory;\n /** @type {?} */\n let deps;\n try {\n deps =\n ResolvedReflectiveFactory.dependencies.map((/**\n * @param {?} dep\n * @return {?}\n */\n dep => this._getByReflectiveDependency(dep)));\n }\n catch (e) {\n if (e.addKey) {\n e.addKey(this, provider.key);\n }\n throw e;\n }\n /** @type {?} */\n let obj;\n try {\n obj = factory(...deps);\n }\n catch (e) {\n throw instantiationError(this, e, e.stack, provider.key);\n }\n return obj;\n }\n /**\n * @private\n * @param {?} dep\n * @return {?}\n */\n _getByReflectiveDependency(dep) {\n return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);\n }\n /**\n * @private\n * @param {?} key\n * @param {?} visibility\n * @param {?} notFoundValue\n * @return {?}\n */\n _getByKey(key, visibility, notFoundValue) {\n if (key === ReflectiveInjector_.INJECTOR_KEY) {\n return this;\n }\n if (visibility instanceof Self) {\n return this._getByKeySelf(key, notFoundValue);\n }\n else {\n return this._getByKeyDefault(key, notFoundValue, visibility);\n }\n }\n /**\n * @private\n * @param {?} keyId\n * @return {?}\n */\n _getObjByKeyId(keyId) {\n for (let i = 0; i < this.keyIds.length; i++) {\n if (this.keyIds[i] === keyId) {\n if (this.objs[i] === UNDEFINED) {\n this.objs[i] = this._new(this._providers[i]);\n }\n return this.objs[i];\n }\n }\n return UNDEFINED;\n }\n /**\n * \\@internal\n * @param {?} key\n * @param {?} notFoundValue\n * @return {?}\n */\n _throwOrNull(key, notFoundValue) {\n if (notFoundValue !== THROW_IF_NOT_FOUND) {\n return notFoundValue;\n }\n else {\n throw noProviderError(this, key);\n }\n }\n /**\n * \\@internal\n * @param {?} key\n * @param {?} notFoundValue\n * @return {?}\n */\n _getByKeySelf(key, notFoundValue) {\n /** @type {?} */\n const obj = this._getObjByKeyId(key.id);\n return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);\n }\n /**\n * \\@internal\n * @param {?} key\n * @param {?} notFoundValue\n * @param {?} visibility\n * @return {?}\n */\n _getByKeyDefault(key, notFoundValue, visibility) {\n /** @type {?} */\n let inj;\n if (visibility instanceof SkipSelf) {\n inj = this.parent;\n }\n else {\n inj = this;\n }\n while (inj instanceof ReflectiveInjector_) {\n /** @type {?} */\n const inj_ = (/** @type {?} */ (inj));\n /** @type {?} */\n const obj = inj_._getObjByKeyId(key.id);\n if (obj !== UNDEFINED)\n return obj;\n inj = inj_.parent;\n }\n if (inj !== null) {\n return inj.get(key.token, notFoundValue);\n }\n else {\n return this._throwOrNull(key, notFoundValue);\n }\n }\n /**\n * @return {?}\n */\n get displayName() {\n /** @type {?} */\n const providers = _mapProviders(this, (/**\n * @param {?} b\n * @return {?}\n */\n (b) => ' \"' + b.key.displayName + '\" '))\n .join(', ');\n return `ReflectiveInjector(providers: [${providers}])`;\n }\n /**\n * @return {?}\n */\n toString() { return this.displayName; }\n}\nReflectiveInjector_.INJECTOR_KEY = ReflectiveKey.get(Injector);\n/**\n * @param {?} injector\n * @param {?} fn\n * @return {?}\n */\nfunction _mapProviders(injector, fn) {\n /** @type {?} */\n const res = new Array(injector._providers.length);\n for (let i = 0; i < injector._providers.length; ++i) {\n res[i] = fn(injector.getProviderAtIndex(i));\n }\n return res;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * A DI token that you can use to create a virtual [provider](guide/glossary#provider)\n * that will populate the `entryComponents` field of components and NgModules\n * based on its `useValue` property value.\n * All components that are referenced in the `useValue` value (either directly\n * or in a nested array or map) are added to the `entryComponents` property.\n *\n * \\@usageNotes\n *\n * The following example shows how the router can populate the `entryComponents`\n * field of an NgModule based on a router configuration that 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 * @type {?}\n */\nconst ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryComponents');\n// WARNING: interface has both a type and a value, skipping emit\n/**\n * Base class for query metadata.\n *\n * @see `ContentChildren`.\n * @see `ContentChild`.\n * @see `ViewChildren`.\n * @see `ViewChild`.\n *\n * \\@publicApi\n * @abstract\n */\nclass Query {\n}\nconst ɵ0$5 = /**\n * @param {?=} selector\n * @param {?=} data\n * @return {?}\n */\n(selector, data = {}) => (Object.assign({ selector, first: false, isViewQuery: false, descendants: false }, data));\n/**\n * ContentChildren decorator and metadata.\n *\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst ContentChildren = makePropDecorator('ContentChildren', (ɵ0$5), Query);\nconst ɵ1$1 = /**\n * @param {?=} selector\n * @param {?=} data\n * @return {?}\n */\n(selector, data = {}) => (Object.assign({ selector, first: true, isViewQuery: false, descendants: true }, data));\n/**\n * ContentChild decorator and metadata.\n *\n *\n * \\@Annotation\n *\n * \\@publicApi\n * @type {?}\n */\nconst ContentChild = makePropDecorator('ContentChild', (ɵ1$1), Query);\nconst ɵ2 = /**\n * @param {?=} selector\n * @param {?=} data\n * @return {?}\n */\n(selector, data = {}) => (Object.assign({ selector, first: false, isViewQuery: true, descendants: true }, data));\n/**\n * ViewChildren decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst ViewChildren = makePropDecorator('ViewChildren', (ɵ2), Query);\nconst ɵ3 = /**\n * @param {?} selector\n * @param {?} data\n * @return {?}\n */\n(selector, data) => (Object.assign({ selector, first: true, isViewQuery: true, descendants: true }, data));\n/**\n * ViewChild decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst ViewChild = makePropDecorator('ViewChild', (ɵ3), Query);\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @enum {number} */\nconst ChangeDetectionStrategy = {\n /**\n * Use the `CheckOnce` strategy, meaning that automatic change detection is deactivated\n * until reactivated by setting the strategy to `Default` (`CheckAlways`).\n * Change detection can still be explicitly invoked.\n * This strategy applies to all child directives and cannot be overridden.\n */\n OnPush: 0,\n /**\n * Use the default `CheckAlways` strategy, in which change detection is automatic until\n * explicitly deactivated.\n */\n Default: 1,\n};\nChangeDetectionStrategy[ChangeDetectionStrategy.OnPush] = 'OnPush';\nChangeDetectionStrategy[ChangeDetectionStrategy.Default] = 'Default';\n/** @enum {number} */\nconst ChangeDetectorStatus = {\n /**\n * A state in which, after calling `detectChanges()`, the change detector\n * state becomes `Checked`, and must be explicitly invoked or reactivated.\n */\n CheckOnce: 0,\n /**\n * A state in which change detection is skipped until the change detector mode\n * becomes `CheckOnce`.\n */\n Checked: 1,\n /**\n * A state in which change detection continues automatically until explicitly\n * deactivated.\n */\n CheckAlways: 2,\n /**\n * A state in which a change detector sub tree is not a part of the main tree and\n * should be skipped.\n */\n Detached: 3,\n /**\n * Indicates that the change detector encountered an error checking a binding\n * or calling a directive lifecycle method and is now in an inconsistent state. Change\n * detectors in this state do not detect changes.\n */\n Errored: 4,\n /**\n * Indicates that the change detector has been destroyed.\n */\n Destroyed: 5,\n};\nChangeDetectorStatus[ChangeDetectorStatus.CheckOnce] = 'CheckOnce';\nChangeDetectorStatus[ChangeDetectorStatus.Checked] = 'Checked';\nChangeDetectorStatus[ChangeDetectorStatus.CheckAlways] = 'CheckAlways';\nChangeDetectorStatus[ChangeDetectorStatus.Detached] = 'Detached';\nChangeDetectorStatus[ChangeDetectorStatus.Errored] = 'Errored';\nChangeDetectorStatus[ChangeDetectorStatus.Destroyed] = 'Destroyed';\n/**\n * Reports whether a given strategy is currently the default for change detection.\n * @see `ChangeDetectorStatus` / `ChangeDetectorRef`\n * @param {?} changeDetectionStrategy The strategy to check.\n * @return {?} True if the given strategy is the current default, false otherwise.\n */\nfunction isDefaultChangeDetectionStrategy(changeDetectionStrategy) {\n return changeDetectionStrategy == null ||\n changeDetectionStrategy === ChangeDetectionStrategy.Default;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * 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 MyComponent{\n * }\n *\n * // Calling `renderComponent` will fail because `renderComponent` is a synchronous process\n * // and `MyComponent`'s `\\@Component.templateUrl` needs to be resolved asynchronously.\n *\n * // Calling `resolveComponentResources()` will resolve `\\@Component.templateUrl` into\n * // `\\@Component.template`, which allows `renderComponent` to proceed in a synchronous manner.\n *\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 `template` 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 for returning a `Promise` to the\n * contents of the resolved URL. Browser's `fetch()` method is a good default implementation.\n * @return {?}\n */\nfunction resolveComponentResources(resourceResolver) {\n // Store all promises which are fetching the resources.\n /** @type {?} */\n const componentResolved = [];\n // Cache so that we don't fetch the same resource more than once.\n /** @type {?} */\n const urlMap = new Map();\n /**\n * @param {?} url\n * @return {?}\n */\n function cachedResourceResolve(url) {\n /** @type {?} */\n let promise = urlMap.get(url);\n if (!promise) {\n /** @type {?} */\n const resp = resourceResolver(url);\n urlMap.set(url, promise = resp.then(unwrapResponse));\n }\n return promise;\n }\n componentResourceResolutionQueue.forEach((/**\n * @param {?} component\n * @param {?} type\n * @return {?}\n */\n (component, type) => {\n /** @type {?} */\n const promises = [];\n if (component.templateUrl) {\n promises.push(cachedResourceResolve(component.templateUrl).then((/**\n * @param {?} template\n * @return {?}\n */\n (template) => {\n component.template = template;\n })));\n }\n /** @type {?} */\n const styleUrls = component.styleUrls;\n /** @type {?} */\n const styles = component.styles || (component.styles = []);\n /** @type {?} */\n const styleOffset = component.styles.length;\n styleUrls && styleUrls.forEach((/**\n * @param {?} styleUrl\n * @param {?} index\n * @return {?}\n */\n (styleUrl, index) => {\n styles.push(''); // pre-allocate array.\n promises.push(cachedResourceResolve(styleUrl).then((/**\n * @param {?} style\n * @return {?}\n */\n (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 /** @type {?} */\n const fullyResolved = Promise.all(promises).then((/**\n * @return {?}\n */\n () => componentDefResolved(type)));\n componentResolved.push(fullyResolved);\n }));\n clearResolutionOfComponentResourcesQueue();\n return Promise.all(componentResolved).then((/**\n * @return {?}\n */\n () => undefined));\n}\n/** @type {?} */\nlet componentResourceResolutionQueue = new Map();\n// Track when existing ngComponentDef for a Type is waiting on resources.\n/** @type {?} */\nconst componentDefPendingResolution = new Set();\n/**\n * @param {?} type\n * @param {?} metadata\n * @return {?}\n */\nfunction maybeQueueResolutionOfComponentResources(type, metadata) {\n if (componentNeedsResolution(metadata)) {\n componentResourceResolutionQueue.set(type, metadata);\n componentDefPendingResolution.add(type);\n }\n}\n/**\n * @param {?} component\n * @return {?}\n */\nfunction componentNeedsResolution(component) {\n return !!((component.templateUrl && !component.hasOwnProperty('template')) ||\n component.styleUrls && component.styleUrls.length);\n}\n/**\n * @return {?}\n */\nfunction clearResolutionOfComponentResourcesQueue() {\n /** @type {?} */\n const old = componentResourceResolutionQueue;\n componentResourceResolutionQueue = new Map();\n return old;\n}\n/**\n * @return {?}\n */\nfunction isComponentResourceResolutionQueueEmpty() {\n return componentResourceResolutionQueue.size === 0;\n}\n/**\n * @param {?} response\n * @return {?}\n */\nfunction unwrapResponse(response) {\n return typeof response == 'string' ? response : response.text();\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction componentDefResolved(type) {\n componentDefPendingResolution.delete(type);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @enum {number} */\nconst ViewEncapsulation = {\n /**\n * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host\n * Element and pre-processing the style rules provided via {@link Component#styles styles} or\n * {@link Component#styleUrls styleUrls}, and adding the new Host Element attribute to all\n * selectors.\n *\n * This is the default option.\n */\n Emulated: 0,\n /**\n * @deprecated v6.1.0 - use {ViewEncapsulation.ShadowDom} instead.\n * Use the native encapsulation mechanism of the renderer.\n *\n * For the DOM this means using the deprecated [Shadow DOM\n * v0](https://w3c.github.io/webcomponents/spec/shadow/) and\n * creating a ShadowRoot for Component's Host Element.\n */\n Native: 1,\n /**\n * Don't provide any template or style encapsulation.\n */\n None: 2,\n /**\n * Use Shadow DOM to encapsulate styles.\n *\n * For the DOM this means using modern [Shadow\n * DOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n * creating a ShadowRoot for Component's Host Element.\n */\n ShadowDom: 3,\n};\nViewEncapsulation[ViewEncapsulation.Emulated] = 'Emulated';\nViewEncapsulation[ViewEncapsulation.Native] = 'Native';\nViewEncapsulation[ViewEncapsulation.None] = 'None';\nViewEncapsulation[ViewEncapsulation.ShadowDom] = 'ShadowDom';\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Convince closure compiler that the wrapped function has no side-effects.\n *\n * Closure compiler always assumes that `toString` has no side-effects. We use this quirk to\n * allow us to execute a function but have closure compiler mark the call as no-side-effects.\n * It is important that the return value for the `noSideEffects` function be assigned\n * to something which is retained otherwise the call to `noSideEffects` will be removed by closure\n * compiler.\n */\nfunction noSideEffects(fn) {\n return '' + { toString: fn };\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * This file contains reuseable \"empty\" symbols that can be used as default return values\n * in different parts of the rendering code. Because the same symbols are returned, this\n * allows for identity checks against these values to be consistently used by the framework\n * code.\n * @type {?}\n */\nconst EMPTY_OBJ = {};\n/** @type {?} */\nconst EMPTY_ARRAY$2 = [];\n// freezing the values prevents any code from accidentally inserting new values in\nif (typeof ngDevMode !== 'undefined' && ngDevMode) {\n // These property accesses can be ignored because ngDevMode will be set to false\n // when optimizing code and the whole if statement will be dropped.\n // tslint:disable-next-line:no-toplevel-property-access\n Object.freeze(EMPTY_OBJ);\n // tslint:disable-next-line:no-toplevel-property-access\n Object.freeze(EMPTY_ARRAY$2);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst NG_COMPONENT_DEF = getClosureSafeProperty({ ngComponentDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_DIRECTIVE_DEF = getClosureSafeProperty({ ngDirectiveDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_PIPE_DEF = getClosureSafeProperty({ ngPipeDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_MODULE_DEF = getClosureSafeProperty({ ngModuleDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_LOCALE_ID_DEF = getClosureSafeProperty({ ngLocaleIdDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_BASE_DEF = getClosureSafeProperty({ ngBaseDef: getClosureSafeProperty });\n// TODO(misko): This is wrong. The NG_ELEMENT_ID should never be minified.\n/**\n * If a directive is diPublic, bloomAdd sets a property on the type with this constant as\n * the key and the directive's unique ID as the value. This allows us to map directives to their\n * bloom filter bit for DI.\n * @type {?}\n */\nconst NG_ELEMENT_ID = getClosureSafeProperty({ __NG_ELEMENT_ID__: getClosureSafeProperty });\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nlet _renderCompCount = 0;\n/**\n * Create a component definition object.\n *\n *\n * # Example\n * ```\n * class MyDirective {\n * // Generated by Angular Template Compiler\n * // [Symbol] syntax will not be supported by TypeScript until v2.7\n * static ngComponentDef = defineComponent({\n * ...\n * });\n * }\n * ```\n * \\@codeGenApi\n * @template T\n * @param {?} componentDefinition\n * @return {?}\n */\nfunction ɵɵdefineComponent(componentDefinition) {\n /** @type {?} */\n const type = componentDefinition.type;\n /** @type {?} */\n const typePrototype = type.prototype;\n /** @type {?} */\n const declaredInputs = (/** @type {?} */ ({}));\n /** @type {?} */\n const def = {\n type: type,\n providersResolver: null,\n consts: componentDefinition.consts,\n vars: componentDefinition.vars,\n factory: componentDefinition.factory,\n template: componentDefinition.template || (/** @type {?} */ (null)),\n ngContentSelectors: componentDefinition.ngContentSelectors,\n hostBindings: componentDefinition.hostBindings || null,\n contentQueries: componentDefinition.contentQueries || null,\n declaredInputs: declaredInputs,\n inputs: (/** @type {?} */ (null)),\n // assigned in noSideEffects\n outputs: (/** @type {?} */ (null)),\n // assigned in noSideEffects\n exportAs: componentDefinition.exportAs || null,\n onChanges: null,\n onInit: typePrototype.ngOnInit || null,\n doCheck: typePrototype.ngDoCheck || null,\n afterContentInit: typePrototype.ngAfterContentInit || null,\n afterContentChecked: typePrototype.ngAfterContentChecked || null,\n afterViewInit: typePrototype.ngAfterViewInit || null,\n afterViewChecked: typePrototype.ngAfterViewChecked || null,\n onDestroy: typePrototype.ngOnDestroy || null,\n onPush: componentDefinition.changeDetection === ChangeDetectionStrategy.OnPush,\n directiveDefs: (/** @type {?} */ (null)),\n // assigned in noSideEffects\n pipeDefs: (/** @type {?} */ (null)),\n // assigned in noSideEffects\n selectors: componentDefinition.selectors,\n viewQuery: componentDefinition.viewQuery || null,\n features: 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$2,\n _: (/** @type {?} */ (null)),\n setInput: null,\n schemas: componentDefinition.schemas || null,\n tView: null,\n };\n def._ = (/** @type {?} */ (noSideEffects((/**\n * @return {?}\n */\n () => {\n /** @type {?} */\n const directiveTypes = (/** @type {?} */ (componentDefinition.directives));\n /** @type {?} */\n const feature = componentDefinition.features;\n /** @type {?} */\n const pipeTypes = (/** @type {?} */ (componentDefinition.pipes));\n def.id += _renderCompCount++;\n def.inputs = invertObject(componentDefinition.inputs, declaredInputs),\n def.outputs = invertObject(componentDefinition.outputs),\n feature && feature.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n (fn) => fn(def)));\n def.directiveDefs = directiveTypes ?\n (/**\n * @return {?}\n */\n () => (typeof directiveTypes === 'function' ? directiveTypes() : directiveTypes)\n .map(extractDirectiveDef)) :\n null;\n def.pipeDefs = pipeTypes ?\n (/**\n * @return {?}\n */\n () => (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef)) :\n null;\n // Add ngInjectableDef so components are reachable through the module injector by default\n // (unless it has already been set by the @Injectable decorator). This is mostly to\n // support injecting components in tests. In real application code, components should\n // be retrieved through the node injector, so this isn't a problem.\n if (!type.hasOwnProperty(NG_INJECTABLE_DEF)) {\n ((/** @type {?} */ (type)))[NG_INJECTABLE_DEF] =\n ɵɵdefineInjectable({ token: type, factory: (/** @type {?} */ (componentDefinition.factory)) });\n }\n }))));\n return (/** @type {?} */ (def));\n}\n/**\n * \\@codeGenApi\n * @param {?} type\n * @param {?} directives\n * @param {?} pipes\n * @return {?}\n */\nfunction ɵɵsetComponentScope(type, directives, pipes) {\n /** @type {?} */\n const def = ((/** @type {?} */ (type.ngComponentDef)));\n def.directiveDefs = (/**\n * @return {?}\n */\n () => directives.map(extractDirectiveDef));\n def.pipeDefs = (/**\n * @return {?}\n */\n () => pipes.map(extractPipeDef));\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction extractDirectiveDef(type) {\n /** @type {?} */\n const def = getComponentDef(type) || getDirectiveDef(type);\n if (ngDevMode && !def) {\n throw new Error(`'${type.name}' is neither 'ComponentType' or 'DirectiveType'.`);\n }\n return (/** @type {?} */ (def));\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction extractPipeDef(type) {\n /** @type {?} */\n const def = getPipeDef(type);\n if (ngDevMode && !def) {\n throw new Error(`'${type.name}' is not a 'PipeType'.`);\n }\n return (/** @type {?} */ (def));\n}\n/**\n * \\@codeGenApi\n * @template T\n * @param {?} def\n * @return {?}\n */\nfunction ɵɵdefineNgModule(def) {\n /** @type {?} */\n const res = {\n type: def.type,\n bootstrap: def.bootstrap || EMPTY_ARRAY$2,\n declarations: def.declarations || EMPTY_ARRAY$2,\n imports: def.imports || EMPTY_ARRAY$2,\n exports: def.exports || EMPTY_ARRAY$2,\n transitiveCompileScopes: null,\n schemas: def.schemas || null,\n id: def.id || null,\n };\n return (/** @type {?} */ (res));\n}\n/**\n * Adds the module metadata that is necessary to compute the module's transitive scope to an\n * existing module definition.\n *\n * Scope metadata of modules is not used in production builds, so calls to this function can be\n * marked pure to tree-shake it from the bundle, allowing for all referenced declarations\n * to become eligible for tree-shaking as well.\n *\n * \\@codeGenApi\n * @param {?} type\n * @param {?} scope\n * @return {?}\n */\nfunction ɵɵsetNgModuleScope(type, scope) {\n return (/** @type {?} */ (noSideEffects((/**\n * @return {?}\n */\n () => {\n /** @type {?} */\n /** @nocollapse */ const ngModuleDef = getNgModuleDef(type, true);\n ngModuleDef.declarations = scope.declarations || EMPTY_ARRAY$2;\n ngModuleDef.imports = scope.imports || EMPTY_ARRAY$2;\n ngModuleDef.exports = scope.exports || EMPTY_ARRAY$2;\n }))));\n}\n/**\n * Inverts an inputs or outputs lookup such that the keys, which were the\n * minified keys, are part of the values, and the values are parsed so that\n * the publicName of the property is the new key\n *\n * e.g. for\n *\n * ```\n * class Comp {\n * \\@Input()\n * propName1: string;\n *\n * \\@Input('publicName2')\n * declaredPropName2: number;\n * }\n * ```\n *\n * will be serialized as\n *\n * ```\n * {\n * propName1: 'propName1',\n * declaredPropName2: ['publicName2', 'declaredPropName2'],\n * }\n * ```\n *\n * which is than translated by the minifier as:\n *\n * ```\n * {\n * minifiedPropName1: 'propName1',\n * minifiedPropName2: ['publicName2', 'declaredPropName2'],\n * }\n * ```\n *\n * becomes: (public name => minifiedName)\n *\n * ```\n * {\n * 'propName1': 'minifiedPropName1',\n * 'publicName2': 'minifiedPropName2',\n * }\n * ```\n *\n * Optionally the function can take `secondary` which will result in: (public name => declared name)\n *\n * ```\n * {\n * 'propName1': 'propName1',\n * 'publicName2': 'declaredPropName2',\n * }\n * ```\n *\n * @template T\n * @param {?=} obj\n * @param {?=} secondary\n * @return {?}\n */\nfunction invertObject(obj, secondary) {\n if (obj == null)\n return (/** @type {?} */ (EMPTY_OBJ));\n /** @type {?} */\n const newLookup = {};\n for (const minifiedKey in obj) {\n if (obj.hasOwnProperty(minifiedKey)) {\n /** @type {?} */\n let publicName = (/** @type {?} */ (obj[minifiedKey]));\n /** @type {?} */\n let declaredName = publicName;\n if (Array.isArray(publicName)) {\n declaredName = publicName[1];\n publicName = publicName[0];\n }\n newLookup[publicName] = minifiedKey;\n if (secondary) {\n (secondary[publicName] = (/** @type {?} */ (declaredName)));\n }\n }\n }\n return newLookup;\n}\n/**\n * Create a base definition\n *\n * # Example\n * ```ts\n * class ShouldBeInherited {\n * static ngBaseDef = ɵɵdefineBase({\n * ...\n * })\n * }\n * ```\n *\n * \\@codeGenApi\n * @template T\n * @param {?} baseDefinition The base definition parameters\n *\n * @return {?}\n */\nfunction ɵɵdefineBase(baseDefinition) {\n /** @type {?} */\n const declaredInputs = (/** @type {?} */ ({}));\n return {\n inputs: invertObject((/** @type {?} */ (baseDefinition.inputs)), declaredInputs),\n declaredInputs: declaredInputs,\n outputs: invertObject((/** @type {?} */ (baseDefinition.outputs))),\n viewQuery: baseDefinition.viewQuery || null,\n contentQueries: baseDefinition.contentQueries || null,\n hostBindings: baseDefinition.hostBindings || null\n };\n}\n/**\n * Create a directive definition object.\n *\n * # Example\n * ```ts\n * class MyDirective {\n * // Generated by Angular Template Compiler\n * // [Symbol] syntax will not be supported by TypeScript until v2.7\n * static ngDirectiveDef = ɵɵdefineDirective({\n * ...\n * });\n * }\n * ```\n *\n * \\@codeGenApi\n * @type {?}\n */\nconst ɵɵdefineDirective = (/** @type {?} */ ((/** @type {?} */ (ɵɵdefineComponent))));\n/**\n * Create a pipe definition object.\n *\n * # Example\n * ```\n * class MyPipe implements PipeTransform {\n * // Generated by Angular Template Compiler\n * static ngPipeDef = definePipe({\n * ...\n * });\n * }\n * ```\n * \\@codeGenApi\n * @template T\n * @param {?} pipeDef Pipe definition generated by the compiler\n *\n * @return {?}\n */\nfunction ɵɵdefinePipe(pipeDef) {\n return (/** @type {?} */ (((/** @type {?} */ ({\n name: pipeDef.name,\n factory: pipeDef.factory,\n pure: pipeDef.pure !== false,\n onDestroy: pipeDef.type.prototype.ngOnDestroy || null\n })))));\n}\n/**\n * The following getter methods retrieve the definition form the type. Currently the retrieval\n * honors inheritance, but in the future we may change the rule to require that definitions are\n * explicit. This would require some sort of migration strategy.\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getComponentDef(type) {\n return ((/** @type {?} */ (type)))[NG_COMPONENT_DEF] || null;\n}\n/**\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getDirectiveDef(type) {\n return ((/** @type {?} */ (type)))[NG_DIRECTIVE_DEF] || null;\n}\n/**\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getPipeDef(type) {\n return ((/** @type {?} */ (type)))[NG_PIPE_DEF] || null;\n}\n/**\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getBaseDef(type) {\n return ((/** @type {?} */ (type)))[NG_BASE_DEF] || null;\n}\n/**\n * @template T\n * @param {?} type\n * @param {?=} throwNotFound\n * @return {?}\n */\nfunction getNgModuleDef(type, throwNotFound) {\n /** @type {?} */\n /** @nocollapse */ const ngModuleDef = ((/** @type {?} */ (type)))[NG_MODULE_DEF] || null;\n if (!ngModuleDef && throwNotFound === true) {\n throw new Error(`Type ${stringify(type)} does not have 'ngModuleDef' property.`);\n }\n return ngModuleDef;\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction getNgLocaleIdDef(type) {\n return ((/** @type {?} */ (type)))[NG_LOCALE_ID_DEF] || null;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Returns whether the values are different from a change detection stand point.\n *\n * Constraints are relaxed in checkNoChanges mode. See `devModeEqual` for details.\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction isDifferent(a, b) {\n // NaN is the only value that is not equal to itself so the first\n // test checks if both a and b are not NaN\n return !(a !== a && b !== b) && a !== b;\n}\n/**\n * Used for stringify render output in Ivy.\n * Important! This function is very performance-sensitive and we should\n * be extra careful not to introduce megamorphic reads in it.\n * @param {?} value\n * @return {?}\n */\nfunction renderStringify(value) {\n if (typeof value === 'string')\n return value;\n if (value == null)\n return '';\n return '' + value;\n}\n/**\n * Used to stringify a value so that it can be displayed in an error message.\n * Important! This function contains a megamorphic read and should only be\n * used for error messages.\n * @param {?} value\n * @return {?}\n */\nfunction stringifyForError(value) {\n if (typeof value === 'function')\n return value.name || value.toString();\n if (typeof value === 'object' && value != null && typeof value.type === 'function') {\n return value.type.name || value.type.toString();\n }\n return renderStringify(value);\n}\nconst ɵ0$6 = /**\n * @return {?}\n */\n() => (typeof requestAnimationFrame !== 'undefined' && requestAnimationFrame || // browser only\n setTimeout // everything else\n).bind(_global);\n/** @type {?} */\nconst defaultScheduler = ((ɵ0$6))();\n/**\n *\n * \\@codeGenApi\n * @param {?} element\n * @return {?}\n */\nfunction ɵɵresolveWindow(element) {\n return { name: 'window', target: element.ownerDocument.defaultView };\n}\n/**\n *\n * \\@codeGenApi\n * @param {?} element\n * @return {?}\n */\nfunction ɵɵresolveDocument(element) {\n return { name: 'document', target: element.ownerDocument };\n}\n/**\n *\n * \\@codeGenApi\n * @param {?} element\n * @return {?}\n */\nfunction ɵɵresolveBody(element) {\n return { name: 'body', target: element.ownerDocument.body };\n}\n/**\n * The special delimiter we use to separate property names, prefixes, and suffixes\n * in property binding metadata. See storeBindingMetadata().\n *\n * We intentionally use the Unicode \"REPLACEMENT CHARACTER\" (U+FFFD) as a delimiter\n * because it is a very uncommon character that is unlikely to be part of a user's\n * property names or interpolation strings. If it is in fact used in a property\n * binding, DebugElement.properties will not return the correct value for that\n * binding. However, there should be no runtime effect for real applications.\n *\n * This character is typically rendered as a question mark inside of a diamond.\n * See https://en.wikipedia.org/wiki/Specials_(Unicode_block)\n *\n * @type {?}\n */\nconst INTERPOLATION_DELIMITER = `�`;\n/**\n * Determines whether or not the given string is a property metadata string.\n * See storeBindingMetadata().\n * @param {?} str\n * @return {?}\n */\nfunction isPropMetadataString(str) {\n return str.indexOf(INTERPOLATION_DELIMITER) >= 0;\n}\n/**\n * Unwrap a value which might be behind a closure (for forward declaration reasons).\n * @template T\n * @param {?} value\n * @return {?}\n */\nfunction maybeUnwrapFn(value) {\n if (value instanceof Function) {\n return value();\n }\n else {\n return value;\n }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Below are constants for LView indices to help us look up LView members\n// without having to remember the specific indices.\n// Uglify will inline these when minifying so there shouldn't be a cost.\n/** @type {?} */\nconst HOST = 0;\n/** @type {?} */\nconst TVIEW = 1;\n/** @type {?} */\nconst FLAGS = 2;\n/** @type {?} */\nconst PARENT = 3;\n/** @type {?} */\nconst NEXT = 4;\n/** @type {?} */\nconst QUERIES = 5;\n/** @type {?} */\nconst T_HOST = 6;\n/** @type {?} */\nconst BINDING_INDEX = 7;\n/** @type {?} */\nconst CLEANUP = 8;\n/** @type {?} */\nconst CONTEXT = 9;\n/** @type {?} */\nconst INJECTOR$1 = 10;\n/** @type {?} */\nconst RENDERER_FACTORY = 11;\n/** @type {?} */\nconst RENDERER = 12;\n/** @type {?} */\nconst SANITIZER = 13;\n/** @type {?} */\nconst CHILD_HEAD = 14;\n/** @type {?} */\nconst CHILD_TAIL = 15;\n/** @type {?} */\nconst CONTENT_QUERIES = 16;\n/** @type {?} */\nconst DECLARATION_VIEW = 17;\n/** @type {?} */\nconst PREORDER_HOOK_FLAGS = 18;\n/**\n * Size of LView's header. Necessary to adjust for it when setting slots.\n * @type {?}\n */\nconst HEADER_OFFSET = 20;\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 assertNotSame(actual, expected, msg) {\n if (actual === expected) {\n throwError(msg);\n }\n}\nfunction assertLessThan(actual, expected, msg) {\n if (actual >= expected) {\n throwError(msg);\n }\n}\nfunction assertGreaterThan(actual, expected, msg) {\n if (actual <= expected) {\n throwError(msg);\n }\n}\nfunction assertDefined(actual, msg) {\n if (actual == null) {\n throwError(msg);\n }\n}\nfunction throwError(msg) {\n // tslint:disable-next-line\n debugger; // Left intentionally for better debugger experience.\n throw new Error(`ASSERTION ERROR: ${msg}`);\n}\nfunction assertDomNode(node) {\n // If we're in a worker, `Node` will not be defined.\n assertEqual((typeof Node !== 'undefined' && node instanceof Node) ||\n (typeof node === 'object' && node.constructor.name === 'WebWorkerRenderNode'), true, `The provided value must be an instance of a DOM Node but got ${stringify(node)}`);\n}\nfunction assertDataInRange(arr, index) {\n const maxLen = arr ? arr.length : 0;\n assertLessThan(index, maxLen, `Index expected to be less than ${maxLen} but got ${index}`);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Special location which allows easy identification of type. If we have an array which was\n * retrieved from the `LView` and that array has `true` at `TYPE` location, we know it is\n * `LContainer`.\n * @type {?}\n */\nconst TYPE = 1;\n/**\n * Below are constants for LContainer indices to help us look up LContainer members\n * without having to remember the specific indices.\n * Uglify will inline these when minifying so there shouldn't be a cost.\n * @type {?}\n */\nconst ACTIVE_INDEX = 2;\n// PARENT, NEXT, QUERIES and T_HOST are indices 3, 4, 5 and 6.\n// As we already have these constants in LView, we don't need to re-create them.\n/** @type {?} */\nconst NATIVE = 7;\n/** @type {?} */\nconst VIEW_REFS = 8;\n/**\n * Size of LContainer's header. Represents the index after which all views in the\n * container will be inserted. We need to keep a record of current views so we know\n * which views are already in the DOM (and don't need to be re-added) and so we can\n * remove views from the DOM when they are no longer required.\n * @type {?}\n */\nconst CONTAINER_HEADER_OFFSET = 9;\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This property will be monkey-patched on elements, components and directives\n * @type {?}\n */\nconst MONKEY_PATCH_KEY_NAME = '__ngContext__';\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`,\n * `StylingContext`) in same location in `LView`. This is because we don't want to pre-allocate\n * space for it because the storage is sparse. This file contains utilities for dealing with such\n * data types.\n *\n * How do we know what is stored at a given location in `LView`.\n * - `Array.isArray(value) === false` => `RNode` (The normal storage value)\n * - `Array.isArray(value) === true` => then the `value[0]` represents the wrapped value.\n * - `typeof value[TYPE] === 'object'` => `LView`\n * - This happens when we have a component at a given location\n * - `typeof value[TYPE] === 'number'` => `StylingContext`\n * - This happens when we have style/class binding at a given location.\n * - `typeof value[TYPE] === true` => `LContainer`\n * - This happens when we have `LContainer` binding at a given location.\n *\n *\n * NOTE: it is assumed that `Array.isArray` and `typeof` operations are very efficient.\n */\n/**\n * Returns `RNode`.\n * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`, `StylingContext`\n * @return {?}\n */\nfunction unwrapRNode(value) {\n while (Array.isArray(value)) {\n value = (/** @type {?} */ (value[HOST]));\n }\n return (/** @type {?} */ (value));\n}\n/**\n * True if `value` is `LView`.\n * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`, `StylingContext`\n * @return {?}\n */\nfunction isLView(value) {\n return Array.isArray(value) && typeof value[TYPE] === 'object';\n}\n/**\n * True if `value` is `LContainer`.\n * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`, `StylingContext`\n * @return {?}\n */\nfunction isLContainer(value) {\n return Array.isArray(value) && value[TYPE] === true;\n}\n/**\n * True if `value` is `StylingContext`.\n * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`, `StylingContext`\n * @return {?}\n */\nfunction isStylingContext(value) {\n return Array.isArray(value) && typeof value[TYPE] === 'number';\n}\n/**\n * Retrieves an element value from the provided `viewData`, by unwrapping\n * from any containers, component views, or style contexts.\n * @param {?} index\n * @param {?} lView\n * @return {?}\n */\nfunction getNativeByIndex(index, lView) {\n return unwrapRNode(lView[index + HEADER_OFFSET]);\n}\n/**\n * @param {?} tNode\n * @param {?} hostView\n * @return {?}\n */\nfunction getNativeByTNode(tNode, hostView) {\n return unwrapRNode(hostView[tNode.index]);\n}\n/**\n * A helper function that returns `true` if a given `TNode` has any matching directives.\n * @param {?} tNode\n * @return {?}\n */\nfunction hasDirectives(tNode) {\n return tNode.directiveEnd > tNode.directiveStart;\n}\n/**\n * @param {?} index\n * @param {?} view\n * @return {?}\n */\nfunction getTNode(index, view) {\n ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');\n ngDevMode && assertLessThan(index, view[TVIEW].data.length, 'wrong index for TNode');\n return (/** @type {?} */ (view[TVIEW].data[index + HEADER_OFFSET]));\n}\n/**\n * Retrieves a value from any `LView` or `TData`.\n * @template T\n * @param {?} view\n * @param {?} index\n * @return {?}\n */\nfunction loadInternal(view, index) {\n ngDevMode && assertDataInRange(view, index + HEADER_OFFSET);\n return view[index + HEADER_OFFSET];\n}\n/**\n * @param {?} nodeIndex\n * @param {?} hostView\n * @return {?}\n */\nfunction getComponentViewByIndex(nodeIndex, hostView) {\n // Could be an LView or an LContainer. If LContainer, unwrap to find LView.\n /** @type {?} */\n const slotValue = hostView[nodeIndex];\n /** @type {?} */\n const lView = isLView(slotValue) ? slotValue : slotValue[HOST];\n return lView;\n}\n/**\n * @param {?} tNode\n * @return {?}\n */\nfunction isContentQueryHost(tNode) {\n return (tNode.flags & 4 /* hasContentQuery */) !== 0;\n}\n/**\n * @param {?} tNode\n * @return {?}\n */\nfunction isComponent(tNode) {\n return (tNode.flags & 1 /* isComponent */) === 1 /* isComponent */;\n}\n/**\n * @template T\n * @param {?} def\n * @return {?}\n */\nfunction isComponentDef(def) {\n return ((/** @type {?} */ (def))).template !== null;\n}\n/**\n * @param {?} target\n * @return {?}\n */\nfunction isRootView(target) {\n return (target[FLAGS] & 512 /* IsRoot */) !== 0;\n}\n/**\n * Returns the monkey-patch value data present on the target (which could be\n * a component, directive or a DOM node).\n * @param {?} target\n * @return {?}\n */\nfunction readPatchedData(target) {\n ngDevMode && assertDefined(target, 'Target expected');\n return target[MONKEY_PATCH_KEY_NAME];\n}\n/**\n * @param {?} target\n * @return {?}\n */\nfunction readPatchedLView(target) {\n /** @type {?} */\n const value = readPatchedData(target);\n if (value) {\n return Array.isArray(value) ? value : ((/** @type {?} */ (value))).lView;\n }\n return null;\n}\n/**\n * Returns a boolean for whether the view is attached to the change detection tree.\n *\n * Note: This determines whether a view should be checked, not whether it's inserted\n * into a container. For that, you'll want `viewAttachedToContainer` below.\n * @param {?} view\n * @return {?}\n */\nfunction viewAttachedToChangeDetector(view) {\n return (view[FLAGS] & 128 /* Attached */) === 128 /* Attached */;\n}\n/**\n * Returns a boolean for whether the view is attached to a container.\n * @param {?} view\n * @return {?}\n */\nfunction viewAttachedToContainer(view) {\n return isLContainer(view[PARENT]);\n}\n/**\n * Resets the pre-order hook flags of the view.\n * @param {?} lView the LView on which the flags are reset\n * @return {?}\n */\nfunction resetPreOrderHookFlags(lView) {\n lView[PREORDER_HOOK_FLAGS] = 0;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @param {?} actual\n * @param {?=} msg\n * @return {?}\n */\nfunction assertComponentType(actual, msg = 'Type passed in is not ComponentType, it does not have \\'ngComponentDef\\' property.') {\n if (!getComponentDef(actual)) {\n throwError(msg);\n }\n}\n/**\n * @param {?} actual\n * @param {?=} msg\n * @return {?}\n */\nfunction assertNgModuleType(actual, msg = 'Type passed in is not NgModuleType, it does not have \\'ngModuleDef\\' property.') {\n if (!getNgModuleDef(actual)) {\n throwError(msg);\n }\n}\n/**\n * @param {?} isParent\n * @return {?}\n */\nfunction assertPreviousIsParent(isParent) {\n assertEqual(isParent, true, 'previousOrParentTNode should be a parent');\n}\n/**\n * @param {?} tNode\n * @return {?}\n */\nfunction assertHasParent(tNode) {\n assertDefined(tNode, 'previousOrParentTNode should exist!');\n assertDefined((/** @type {?} */ (tNode)).parent, 'previousOrParentTNode should have a parent');\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction assertLContainerOrUndefined(value) {\n value && assertEqual(isLContainer(value), true, 'Expecting LContainer or undefined or null');\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction assertLContainer(value) {\n assertDefined(value, 'LContainer must be defined');\n assertEqual(isLContainer(value), true, 'Expecting LContainer');\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction assertLViewOrUndefined(value) {\n value && assertEqual(isLView(value), true, 'Expecting LView or undefined or null');\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction assertLView(value) {\n assertDefined(value, 'LView must be defined');\n assertEqual(isLView(value), true, 'Expecting LView');\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Adds all directive lifecycle hooks from the given `DirectiveDef` to the given `TView`.\n *\n * Must be run *only* on the first template pass.\n *\n * Sets up the pre-order hooks on the provided `tView`,\n * see {\\@link HookData} for details about the data structure.\n *\n * @param {?} directiveIndex The index of the directive in LView\n * @param {?} directiveDef The definition containing the hooks to setup in tView\n * @param {?} tView The current TView\n * @param {?} nodeIndex The index of the node to which the directive is attached\n * @param {?} initialPreOrderHooksLength the number of pre-order hooks already registered before the\n * current process, used to know if the node index has to be added to the array. If it is -1,\n * the node index is never added.\n * @param {?} initialPreOrderCheckHooksLength same as previous for pre-order check hooks\n * @return {?}\n */\nfunction registerPreOrderHooks(directiveIndex, directiveDef, tView, nodeIndex, initialPreOrderHooksLength, initialPreOrderCheckHooksLength) {\n ngDevMode &&\n assertEqual(tView.firstTemplatePass, true, 'Should only be called on first template pass');\n const { onChanges, onInit, doCheck } = directiveDef;\n if (initialPreOrderHooksLength >= 0 &&\n (!tView.preOrderHooks || initialPreOrderHooksLength === tView.preOrderHooks.length) &&\n (onChanges || onInit || doCheck)) {\n (tView.preOrderHooks || (tView.preOrderHooks = [])).push(nodeIndex);\n }\n if (initialPreOrderCheckHooksLength >= 0 &&\n (!tView.preOrderCheckHooks ||\n initialPreOrderCheckHooksLength === tView.preOrderCheckHooks.length) &&\n (onChanges || doCheck)) {\n (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(nodeIndex);\n }\n if (onChanges) {\n (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, onChanges);\n (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, onChanges);\n }\n if (onInit) {\n (tView.preOrderHooks || (tView.preOrderHooks = [])).push(-directiveIndex, onInit);\n }\n if (doCheck) {\n (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, doCheck);\n (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, doCheck);\n }\n}\n/**\n *\n * Loops through the directives on the provided `tNode` and queues hooks to be\n * run that are not initialization hooks.\n *\n * Should be executed during `elementEnd()` and similar to\n * preserve hook execution order. Content, view, and destroy hooks for projected\n * components and directives must be called *before* their hosts.\n *\n * Sets up the content, view, and destroy hooks on the provided `tView`,\n * see {\\@link HookData} for details about the data structure.\n *\n * NOTE: This does not set up `onChanges`, `onInit` or `doCheck`, those are set up\n * separately at `elementStart`.\n *\n * @param {?} tView The current TView\n * @param {?} tNode The TNode whose directives are to be searched for hooks to queue\n * @return {?}\n */\nfunction registerPostOrderHooks(tView, tNode) {\n if (tView.firstTemplatePass) {\n // It's necessary to loop through the directives at elementEnd() (rather than processing in\n // directiveCreate) so we can preserve the current hook order. Content, view, and destroy\n // hooks for projected components and directives must be called *before* their hosts.\n for (let i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {\n /** @type {?} */\n const directiveDef = (/** @type {?} */ (tView.data[i]));\n if (directiveDef.afterContentInit) {\n (tView.contentHooks || (tView.contentHooks = [])).push(-i, directiveDef.afterContentInit);\n }\n if (directiveDef.afterContentChecked) {\n (tView.contentHooks || (tView.contentHooks = [])).push(i, directiveDef.afterContentChecked);\n (tView.contentCheckHooks || (tView.contentCheckHooks = [])).push(i, directiveDef.afterContentChecked);\n }\n if (directiveDef.afterViewInit) {\n (tView.viewHooks || (tView.viewHooks = [])).push(-i, directiveDef.afterViewInit);\n }\n if (directiveDef.afterViewChecked) {\n (tView.viewHooks || (tView.viewHooks = [])).push(i, directiveDef.afterViewChecked);\n (tView.viewCheckHooks || (tView.viewCheckHooks = [])).push(i, directiveDef.afterViewChecked);\n }\n if (directiveDef.onDestroy != null) {\n (tView.destroyHooks || (tView.destroyHooks = [])).push(i, directiveDef.onDestroy);\n }\n }\n }\n}\n/**\n * Executing hooks requires complex logic as we need to deal with 2 constraints.\n *\n * 1. Init hooks (ngOnInit, ngAfterContentInit, ngAfterViewInit) must all be executed once and only\n * once, across many change detection cycles. This must be true even if some hooks throw, or if\n * some recursively trigger a change detection cycle.\n * To solve that, it is required to track the state of the execution of these init hooks.\n * This is done by storing and maintaining flags in the view: the {@link InitPhaseState},\n * and the index within that phase. They can be seen as a cursor in the following structure:\n * [[onInit1, onInit2], [afterContentInit1], [afterViewInit1, afterViewInit2, afterViewInit3]]\n * They are are stored as flags in LView[FLAGS].\n *\n * 2. Pre-order hooks can be executed in batches, because of the select instruction.\n * To be able to pause and resume their execution, we also need some state about the hook's array\n * that is being processed:\n * - the index of the next hook to be executed\n * - the number of init hooks already found in the processed part of the array\n * They are are stored as flags in LView[PREORDER_HOOK_FLAGS].\n */\n/**\n * Executes necessary hooks at the start of executing a template.\n *\n * Executes hooks that are to be run during the initialization of a directive such\n * as `onChanges`, `onInit`, and `doCheck`.\n *\n * @param {?} currentView\n * @param {?} tView Static data for the view containing the hooks to be executed\n * @param {?} checkNoChangesMode Whether or not we're in checkNoChanges mode.\n * @param {?} currentNodeIndex\n * @return {?}\n */\nfunction executePreOrderHooks(currentView, tView, checkNoChangesMode, currentNodeIndex) {\n if (!checkNoChangesMode) {\n executeHooks(currentView, tView.preOrderHooks, tView.preOrderCheckHooks, checkNoChangesMode, 0 /* OnInitHooksToBeRun */, currentNodeIndex !== undefined ? currentNodeIndex : null);\n }\n}\n/**\n * Executes hooks against the given `LView` based off of whether or not\n * This is the first pass.\n *\n * @param {?} currentView The view instance data to run the hooks against\n * @param {?} firstPassHooks An array of hooks to run if we're in the first view pass\n * @param {?} checkHooks An Array of hooks to run if we're not in the first view pass.\n * @param {?} checkNoChangesMode Whether or not we're in no changes mode.\n * @param {?} initPhaseState the current state of the init phase\n * @param {?} currentNodeIndex 3 cases depending the the value:\n * - undefined: all hooks from the array should be executed (post-order case)\n * - null: execute hooks only from the saved index until the end of the array (pre-order case, when\n * flushing the remaining hooks)\n * - number: execute hooks only from the saved index until that node index exclusive (pre-order\n * case, when executing select(number))\n * @return {?}\n */\nfunction executeHooks(currentView, firstPassHooks, checkHooks, checkNoChangesMode, initPhaseState, currentNodeIndex) {\n if (checkNoChangesMode)\n return;\n /** @type {?} */\n const hooksToCall = (currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhaseState ?\n firstPassHooks :\n checkHooks;\n if (hooksToCall) {\n callHooks(currentView, hooksToCall, initPhaseState, currentNodeIndex);\n }\n // The init phase state must be always checked here as it may have been recursively updated\n if (currentNodeIndex == null &&\n (currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhaseState &&\n initPhaseState !== 3 /* InitPhaseCompleted */) {\n currentView[FLAGS] &= 1023 /* IndexWithinInitPhaseReset */;\n currentView[FLAGS] += 1 /* InitPhaseStateIncrementer */;\n }\n}\n/**\n * Calls lifecycle hooks with their contexts, skipping init hooks if it's not\n * the first LView pass\n *\n * @param {?} currentView The current view\n * @param {?} arr The array in which the hooks are found\n * @param {?} initPhase\n * @param {?} currentNodeIndex 3 cases depending the the value:\n * - undefined: all hooks from the array should be executed (post-order case)\n * - null: execute hooks only from the saved index until the end of the array (pre-order case, when\n * flushing the remaining hooks)\n * - number: execute hooks only from the saved index until that node index exclusive (pre-order\n * case, when executing select(number))\n * @return {?}\n */\nfunction callHooks(currentView, arr, initPhase, currentNodeIndex) {\n /** @type {?} */\n const startIndex = currentNodeIndex !== undefined ?\n (currentView[PREORDER_HOOK_FLAGS] & 65535 /* IndexOfTheNextPreOrderHookMaskMask */) :\n 0;\n /** @type {?} */\n const nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;\n /** @type {?} */\n let lastNodeIndexFound = 0;\n for (let i = startIndex; i < arr.length; i++) {\n /** @type {?} */\n const hook = (/** @type {?} */ (arr[i + 1]));\n if (typeof hook === 'number') {\n lastNodeIndexFound = (/** @type {?} */ (arr[i]));\n if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {\n break;\n }\n }\n else {\n /** @type {?} */\n const isInitHook = arr[i] < 0;\n if (isInitHook)\n currentView[PREORDER_HOOK_FLAGS] += 65536 /* NumberOfInitHooksCalledIncrementer */;\n if (lastNodeIndexFound < nodeIndexLimit || nodeIndexLimit == -1) {\n callHook(currentView, initPhase, arr, i);\n currentView[PREORDER_HOOK_FLAGS] =\n (currentView[PREORDER_HOOK_FLAGS] & 4294901760 /* NumberOfInitHooksCalledMask */) + i +\n 2;\n }\n i++;\n }\n }\n}\n/**\n * Execute one hook against the current `LView`.\n *\n * @param {?} currentView The current view\n * @param {?} initPhase\n * @param {?} arr The array in which the hooks are found\n * @param {?} i The current index within the hook data array\n * @return {?}\n */\nfunction callHook(currentView, initPhase, arr, i) {\n /** @type {?} */\n const isInitHook = arr[i] < 0;\n /** @type {?} */\n const hook = (/** @type {?} */ (arr[i + 1]));\n /** @type {?} */\n const directiveIndex = isInitHook ? -arr[i] : (/** @type {?} */ (arr[i]));\n /** @type {?} */\n const directive = currentView[directiveIndex];\n if (isInitHook) {\n /** @type {?} */\n const indexWithintInitPhase = currentView[FLAGS] >> 10 /* IndexWithinInitPhaseShift */;\n // The init phase state must be always checked here as it may have been recursively\n // updated\n if (indexWithintInitPhase <\n (currentView[PREORDER_HOOK_FLAGS] >> 16 /* NumberOfInitHooksCalledShift */) &&\n (currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhase) {\n currentView[FLAGS] += 1024 /* IndexWithinInitPhaseIncrementer */;\n hook.call(directive);\n }\n }\n else {\n hook.call(directive);\n }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nlet stylingContext = null;\n/**\n * Gets the most recent styling context value.\n *\n * Note that only one styling context is stored at a given time.\n * @return {?}\n */\nfunction getCachedStylingContext() {\n return stylingContext;\n}\n/**\n * Sets the most recent styling context value.\n *\n * Note that only one styling context is stored at a given time.\n *\n * @param {?} context The styling context value that will be stored\n * @return {?}\n */\nfunction setCachedStylingContext(context) {\n stylingContext = context;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Store the element depth count. This is used to identify the root elements of the template\n * so that we can than attach `LView` to only those elements.\n * @type {?}\n */\nlet elementDepthCount;\n/**\n * @return {?}\n */\nfunction getElementDepthCount() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return elementDepthCount;\n}\n/**\n * @return {?}\n */\nfunction increaseElementDepthCount() {\n elementDepthCount++;\n}\n/**\n * @return {?}\n */\nfunction decreaseElementDepthCount() {\n elementDepthCount--;\n}\n/** @type {?} */\nlet currentDirectiveDef = null;\n/**\n * @return {?}\n */\nfunction getCurrentDirectiveDef() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return currentDirectiveDef;\n}\n/**\n * @param {?} def\n * @return {?}\n */\nfunction setCurrentDirectiveDef(def) {\n currentDirectiveDef = def;\n}\n/**\n * Stores whether directives should be matched to elements.\n *\n * When template contains `ngNonBindable` than we need to prevent the runtime form matching\n * directives on children of that element.\n *\n * Example:\n * ```\n * \n * Should match component / directive.\n * \n *
\n * \n * Should not match component / directive because we are in ngNonBindable.\n * \n *
\n * ```\n * @type {?}\n */\nlet bindingsEnabled;\n/**\n * @return {?}\n */\nfunction getBindingsEnabled() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return bindingsEnabled;\n}\n/**\n * Enables directive matching on elements.\n *\n * * Example:\n * ```\n * \n * Should match component / directive.\n * \n *
\n * \n * \n * Should not match component / directive because we are in ngNonBindable.\n * \n * \n *
\n * \n * \n * Should not match component / directive because we are in ngNonBindable.\n * \n * \n *
\n * ```\n *\n * \\@codeGenApi\n * @return {?}\n */\nfunction ɵɵdisableBindings() {\n bindingsEnabled = false;\n}\n/**\n * @return {?}\n */\nfunction getLView() {\n return lView;\n}\n/**\n * Used as the starting directive id value.\n *\n * All subsequent directives are incremented from this value onwards.\n * The reason why this value is `1` instead of `0` is because the `0`\n * value is reserved for the template.\n * @type {?}\n */\nconst MIN_DIRECTIVE_ID = 1;\n/** @type {?} */\nlet activeDirectiveId = MIN_DIRECTIVE_ID;\n/**\n * Position depth (with respect from leaf to root) in a directive sub-class inheritance chain.\n * @type {?}\n */\nlet activeDirectiveSuperClassDepthPosition = 0;\n/**\n * Total count of how many directives are a part of an inheritance chain.\n *\n * When directives are sub-classed (extended) from one to another, Angular\n * needs to keep track of exactly how many were encountered so it can accurately\n * generate the next directive id (once the next directive id is visited).\n * Normally the next directive id just a single incremented value from the\n * previous one, however, if the previous directive is a part of an inheritance\n * chain (a series of sub-classed directives) then the incremented value must\n * also take into account the total amount of sub-classed values.\n *\n * Note that this value resets back to zero once the next directive is\n * visited (when `incrementActiveDirectiveId` or `setActiveHostElement`\n * is called).\n * @type {?}\n */\nlet activeDirectiveSuperClassHeight = 0;\n/**\n * Sets the active directive host element and resets the directive id value\n * (when the provided elementIndex value has changed).\n *\n * @param {?=} elementIndex the element index value for the host element where\n * the directive/component instance lives\n * @return {?}\n */\nfunction setActiveHostElement(elementIndex = null) {\n if (_selectedIndex !== elementIndex) {\n setSelectedIndex(elementIndex == null ? -1 : elementIndex);\n activeDirectiveId = elementIndex == null ? 0 : MIN_DIRECTIVE_ID;\n activeDirectiveSuperClassDepthPosition = 0;\n activeDirectiveSuperClassHeight = 0;\n }\n}\n/**\n * Returns the current id value of the current directive.\n *\n * For example we have an element that has two directives on it:\n * \n *\n * dirOne->hostBindings() (id == 1)\n * dirTwo->hostBindings() (id == 2)\n *\n * Note that this is only active when `hostBinding` functions are being processed.\n *\n * Note that directive id values are specific to an element (this means that\n * the same id value could be present on another element with a completely\n * different set of directives).\n * @return {?}\n */\nfunction getActiveDirectiveId() {\n return activeDirectiveId;\n}\n/**\n * Increments the current directive id value.\n *\n * For example we have an element that has two directives on it:\n * \n *\n * dirOne->hostBindings() (index = 1)\n * // increment\n * dirTwo->hostBindings() (index = 2)\n *\n * Depending on whether or not a previous directive had any inherited\n * directives present, that value will be incremented in addition\n * to the id jumping up by one.\n *\n * Note that this is only active when `hostBinding` functions are being processed.\n *\n * Note that directive id values are specific to an element (this means that\n * the same id value could be present on another element with a completely\n * different set of directives).\n * @return {?}\n */\nfunction incrementActiveDirectiveId() {\n activeDirectiveId += 1 + activeDirectiveSuperClassHeight;\n // because we are dealing with a new directive this\n // means we have exited out of the inheritance chain\n activeDirectiveSuperClassDepthPosition = 0;\n activeDirectiveSuperClassHeight = 0;\n}\n/**\n * Set the current super class (reverse inheritance) position depth for a directive.\n *\n * For example we have two directives: Child and Other (but Child is a sub-class of Parent)\n * \n *\n * // increment\n * parentInstance->hostBindings() (depth = 1)\n * // decrement\n * childInstance->hostBindings() (depth = 0)\n * otherInstance->hostBindings() (depth = 0 b/c it's a different directive)\n *\n * Note that this is only active when `hostBinding` functions are being processed.\n * @param {?} delta\n * @return {?}\n */\nfunction adjustActiveDirectiveSuperClassDepthPosition(delta) {\n activeDirectiveSuperClassDepthPosition += delta;\n // we keep track of the height value so that when the next directive is visited\n // then Angular knows to generate a new directive id value which has taken into\n // account how many sub-class directives were a part of the previous directive.\n activeDirectiveSuperClassHeight =\n Math.max(activeDirectiveSuperClassHeight, activeDirectiveSuperClassDepthPosition);\n}\n/**\n * Returns he current depth of the super/sub class inheritance chain.\n *\n * This will return how many inherited directive/component classes\n * exist in the current chain.\n *\n * ```typescript\n * \\@Directive({ selector: '[super-dir]' })\n * class SuperDir {}\n * / selector: '[sub-dir]' })\n * class SubDir extends SuperDir {}\n *\n * // if `
` is used then the super class height is `1`\n * // if `
` is used then the super class height is `0`\n * ```\n * @return {?}\n */\nfunction getActiveDirectiveSuperClassHeight() {\n return activeDirectiveSuperClassHeight;\n}\n/**\n * Returns the current super class (reverse inheritance) depth for a directive.\n *\n * This is designed to help instruction code distinguish different hostBindings\n * calls from each other when a directive has extended from another directive.\n * Normally using the directive id value is enough, but with the case\n * of parent/sub-class directive inheritance more information is required.\n *\n * Note that this is only active when `hostBinding` functions are being processed.\n * @return {?}\n */\nfunction getActiveDirectiveSuperClassDepth() {\n return activeDirectiveSuperClassDepthPosition;\n}\n/**\n * Restores `contextViewData` to the given OpaqueViewState instance.\n *\n * Used in conjunction with the getCurrentView() instruction to save a snapshot\n * of the current view and restore it when listeners are invoked. This allows\n * walking the declaration view tree in listeners to get vars from parent views.\n *\n * \\@codeGenApi\n * @param {?} viewToRestore The OpaqueViewState instance to restore.\n *\n * @return {?}\n */\nfunction ɵɵrestoreView(viewToRestore) {\n contextLView = (/** @type {?} */ ((/** @type {?} */ (viewToRestore))));\n}\n/**\n * Used to set the parent property when nodes are created and track query results.\n * @type {?}\n */\nlet previousOrParentTNode;\n/**\n * @return {?}\n */\nfunction getPreviousOrParentTNode() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return previousOrParentTNode;\n}\n/**\n * @param {?} tNode\n * @param {?} _isParent\n * @return {?}\n */\nfunction setPreviousOrParentTNode(tNode, _isParent) {\n previousOrParentTNode = tNode;\n isParent = _isParent;\n}\n/**\n * @param {?} tNode\n * @param {?} view\n * @return {?}\n */\nfunction setTNodeAndViewData(tNode, view) {\n ngDevMode && assertLViewOrUndefined(view);\n previousOrParentTNode = tNode;\n lView = view;\n}\n/**\n * If `isParent` is:\n * - `true`: then `previousOrParentTNode` points to a parent node.\n * - `false`: then `previousOrParentTNode` points to previous node (sibling).\n * @type {?}\n */\nlet isParent;\n/**\n * @return {?}\n */\nfunction getIsParent() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return isParent;\n}\n/**\n * @return {?}\n */\nfunction setIsNotParent() {\n isParent = false;\n}\n/**\n * @return {?}\n */\nfunction setIsParent() {\n isParent = true;\n}\n/**\n * Checks whether a given view is in creation mode\n * @param {?=} view\n * @return {?}\n */\nfunction isCreationMode(view = lView) {\n return (view[FLAGS] & 4 /* CreationMode */) === 4 /* CreationMode */;\n}\n/**\n * State of the current view being processed.\n *\n * An array of nodes (text, element, container, etc), pipes, their bindings, and\n * any local variables that need to be stored between invocations.\n * @type {?}\n */\nlet lView;\n/**\n * The last viewData retrieved by nextContext().\n * Allows building nextContext() and reference() calls.\n *\n * e.g. const inner = x().$implicit; const outer = x().$implicit;\n * @type {?}\n */\nlet contextLView = (/** @type {?} */ (null));\n/**\n * @return {?}\n */\nfunction getContextLView() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return contextLView;\n}\n/**\n * In this mode, any changes in bindings will throw an ExpressionChangedAfterChecked error.\n *\n * Necessary to support ChangeDetectorRef.checkNoChanges().\n * @type {?}\n */\nlet checkNoChangesMode = false;\n/**\n * @return {?}\n */\nfunction getCheckNoChangesMode() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return checkNoChangesMode;\n}\n/**\n * @param {?} mode\n * @return {?}\n */\nfunction setCheckNoChangesMode(mode) {\n checkNoChangesMode = mode;\n}\n/**\n * The root index from which pure function instructions should calculate their binding\n * indices. In component views, this is TView.bindingStartIndex. In a host binding\n * context, this is the TView.expandoStartIndex + any dirs/hostVars before the given dir.\n * @type {?}\n */\nlet bindingRootIndex = -1;\n// top level variables should not be exported for performance reasons (PERF_NOTES.md)\n/**\n * @return {?}\n */\nfunction getBindingRoot() {\n return bindingRootIndex;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction setBindingRoot(value) {\n bindingRootIndex = value;\n}\n/**\n * Current index of a View or Content Query which needs to be processed next.\n * We iterate over the list of Queries and increment current query index at every step.\n * @type {?}\n */\nlet currentQueryIndex = 0;\n/**\n * @return {?}\n */\nfunction getCurrentQueryIndex() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return currentQueryIndex;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction setCurrentQueryIndex(value) {\n currentQueryIndex = value;\n}\n/**\n * Swap the current state with a new state.\n *\n * For performance reasons we store the state in the top level of the module.\n * This way we minimize the number of properties to read. Whenever a new view\n * is entered we have to store the state for later, and when the view is\n * exited the state has to be restored\n *\n * @param {?} newView New state to become active\n * @param {?} hostTNode\n * @return {?} the previous state;\n */\nfunction enterView(newView, hostTNode) {\n ngDevMode && assertLViewOrUndefined(newView);\n /** @type {?} */\n const oldView = lView;\n if (newView) {\n /** @type {?} */\n const tView = newView[TVIEW];\n bindingRootIndex = tView.bindingStartIndex;\n }\n previousOrParentTNode = (/** @type {?} */ (hostTNode));\n isParent = true;\n lView = contextLView = newView;\n return oldView;\n}\n/**\n * @template T\n * @param {?=} level\n * @return {?}\n */\nfunction nextContextImpl(level = 1) {\n contextLView = walkUpViews(level, (/** @type {?} */ (contextLView)));\n return (/** @type {?} */ (contextLView[CONTEXT]));\n}\n/**\n * @param {?} nestingLevel\n * @param {?} currentView\n * @return {?}\n */\nfunction walkUpViews(nestingLevel, currentView) {\n while (nestingLevel > 0) {\n ngDevMode && assertDefined(currentView[DECLARATION_VIEW], 'Declaration view should be defined if nesting level is greater than 0.');\n currentView = (/** @type {?} */ (currentView[DECLARATION_VIEW]));\n nestingLevel--;\n }\n return currentView;\n}\n/**\n * Resets the application state.\n * @return {?}\n */\nfunction resetComponentState() {\n isParent = false;\n previousOrParentTNode = (/** @type {?} */ (null));\n elementDepthCount = 0;\n bindingsEnabled = true;\n}\n/**\n * Used in lieu of enterView to make it clear when we are exiting a child view. This makes\n * the direction of traversal (up or down the view tree) a bit clearer.\n *\n * @param {?} newView New state to become active\n * @param {?} safeToRunHooks Whether the runtime is in a state where running lifecycle hooks is valid.\n * This is not always the case (for example, the application may have crashed and `leaveView` is\n * being executed while unwinding the call stack).\n * @return {?}\n */\nfunction leaveView(newView, safeToRunHooks) {\n /** @type {?} */\n const tView = lView[TVIEW];\n if (isCreationMode(lView)) {\n lView[FLAGS] &= ~4 /* CreationMode */;\n }\n else {\n try {\n resetPreOrderHookFlags(lView);\n safeToRunHooks && executeHooks(lView, tView.viewHooks, tView.viewCheckHooks, checkNoChangesMode, 2 /* AfterViewInitHooksToBeRun */, undefined);\n }\n finally {\n // Views are clean and in update mode after being checked, so these bits are cleared\n lView[FLAGS] &= ~(64 /* Dirty */ | 8 /* FirstLViewPass */);\n lView[BINDING_INDEX] = tView.bindingStartIndex;\n }\n }\n setCachedStylingContext(null);\n enterView(newView, null);\n}\n/** @type {?} */\nlet _selectedIndex = -1;\n/**\n * Gets the most recent index passed to {\\@link select}\n *\n * Used with {\\@link property} instruction (and more in the future) to identify the index in the\n * current `LView` to act on.\n * @return {?}\n */\nfunction getSelectedIndex() {\n return _selectedIndex;\n}\n/**\n * Sets the most recent index passed to {\\@link select}\n *\n * Used with {\\@link property} instruction (and more in the future) to identify the index in the\n * current `LView` to act on.\n * @param {?} index\n * @return {?}\n */\nfunction setSelectedIndex(index) {\n _selectedIndex = index;\n // remove the styling context from the cache\n // because we are now on a different element\n setCachedStylingContext(null);\n}\n/** @type {?} */\nlet _currentNamespace = null;\n/**\n * Sets the namespace used to create elements to `'http://www.w3.org/2000/svg'` in global state.\n *\n * \\@codeGenApi\n * @return {?}\n */\nfunction ɵɵnamespaceSVG() {\n _currentNamespace = 'http://www.w3.org/2000/svg';\n}\n/**\n * Sets the namespace used to create elements to `'http://www.w3.org/1998/MathML/'` in global state.\n *\n * \\@codeGenApi\n * @return {?}\n */\nfunction ɵɵnamespaceMathML() {\n _currentNamespace = 'http://www.w3.org/1998/MathML/';\n}\n/**\n * Sets the namespace used to create elements no `null`, which forces element creation to use\n * `createElement` rather than `createElementNS`.\n *\n * \\@codeGenApi\n * @return {?}\n */\nfunction ɵɵnamespaceHTML() {\n _currentNamespace = null;\n}\n/**\n * @return {?}\n */\nfunction getNamespace() {\n return _currentNamespace;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @type {?} */\nconst BRAND = '__SANITIZER_TRUSTED_BRAND__';\n/**\n * @param {?} value\n * @param {?} type\n * @return {?}\n */\nfunction allowSanitizationBypass(value, type) {\n return (value instanceof String && ((/** @type {?} */ (value)))[BRAND] === type);\n}\n/**\n * Mark `html` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link htmlSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedHtml `html` string which needs to be implicitly trusted.\n * @return {?} a `html` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustHtml(trustedHtml) {\n return bypassSanitizationTrustString(trustedHtml, \"Html\" /* Html */);\n}\n/**\n * Mark `style` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link styleSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedStyle `style` string which needs to be implicitly trusted.\n * @return {?} a `style` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustStyle(trustedStyle) {\n return bypassSanitizationTrustString(trustedStyle, \"Style\" /* Style */);\n}\n/**\n * Mark `script` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link scriptSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedScript `script` string which needs to be implicitly trusted.\n * @return {?} a `script` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustScript(trustedScript) {\n return bypassSanitizationTrustString(trustedScript, \"Script\" /* Script */);\n}\n/**\n * Mark `url` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link urlSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedUrl `url` string which needs to be implicitly trusted.\n * @return {?} a `url` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustUrl(trustedUrl) {\n return bypassSanitizationTrustString(trustedUrl, \"Url\" /* Url */);\n}\n/**\n * Mark `url` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link resourceUrlSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedResourceUrl `url` string which needs to be implicitly trusted.\n * @return {?} a `url` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustResourceUrl(trustedResourceUrl) {\n return bypassSanitizationTrustString(trustedResourceUrl, \"ResourceUrl\" /* ResourceUrl */);\n}\n/**\n * @param {?} trustedString\n * @param {?} mode\n * @return {?}\n */\nfunction bypassSanitizationTrustString(trustedString, mode) {\n /** @type {?} */\n const trusted = (/** @type {?} */ (new String(trustedString)));\n trusted[BRAND] = mode;\n return trusted;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This file is used to control if the default rendering pipeline should be `ViewEngine` or `Ivy`.\n *\n * For more information on how to run and debug tests with either Ivy or View Engine (legacy),\n * please see [BAZEL.md](./docs/BAZEL.md).\n */\nlet _devMode = true;\nlet _runModeLocked = false;\n/**\n * Returns whether Angular is in development mode. After called once,\n * the value is locked and won't change any more.\n *\n * By default, this is true, unless a user calls `enableProdMode` before calling this.\n *\n * @publicApi\n */\nfunction isDevMode() {\n _runModeLocked = true;\n return _devMode;\n}\n/**\n * Disable Angular's development mode, which turns off assertions and other\n * checks within the framework.\n *\n * One important assertion this disables verifies that a change detection pass\n * does not result in additional changes to any bindings (also known as\n * unidirectional data flow).\n *\n * @publicApi\n */\nfunction enableProdMode() {\n if (_runModeLocked) {\n throw new Error('Cannot enable prod mode after platform setup.');\n }\n _devMode = false;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This helper class is used to get hold of an inert tree of DOM elements containing dirty HTML\n * that needs sanitizing.\n * Depending upon browser support we must use one of three strategies for doing this.\n * Support: Safari 10.x -> XHR strategy\n * Support: Firefox -> DomParser strategy\n * Default: InertDocument strategy\n */\nclass InertBodyHelper {\n /**\n * @param {?} defaultDoc\n */\n constructor(defaultDoc) {\n this.defaultDoc = defaultDoc;\n this.inertDocument = this.defaultDoc.implementation.createHTMLDocument('sanitization-inert');\n this.inertBodyElement = this.inertDocument.body;\n if (this.inertBodyElement == null) {\n // usually there should be only one body element in the document, but IE doesn't have any, so\n // we need to create one.\n /** @type {?} */\n const inertHtml = this.inertDocument.createElement('html');\n this.inertDocument.appendChild(inertHtml);\n this.inertBodyElement = this.inertDocument.createElement('body');\n inertHtml.appendChild(this.inertBodyElement);\n }\n this.inertBodyElement.innerHTML = '';\n if (this.inertBodyElement.querySelector && !this.inertBodyElement.querySelector('svg')) {\n // We just hit the Safari 10.1 bug - which allows JS to run inside the SVG G element\n // so use the XHR strategy.\n this.getInertBodyElement = this.getInertBodyElement_XHR;\n return;\n }\n this.inertBodyElement.innerHTML =\n '