{"ast":null,"code":"import { __decorate, __param, __awaiter } from 'tslib';\nimport { HostListener, Injector, ElementRef, Directive, Inject, NgZone, ɵɵdefineInjectable, ɵɵinject, Injectable, Optional, ChangeDetectorRef, Component, ChangeDetectionStrategy, InjectionToken, ApplicationRef, EventEmitter, ViewContainerRef, ComponentFactoryResolver, Attribute, SkipSelf, Output, ViewChild, ContentChild, TemplateRef, IterableDiffers, APP_INITIALIZER, NgModule } from '@angular/core';\nimport { NgControl, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { DOCUMENT, Location, LocationStrategy, CommonModule } from '@angular/common';\nimport { NavigationStart, UrlSerializer, Router, PRIMARY_OUTLET, ActivatedRoute, ChildrenOutletContexts, RouterLink } from '@angular/router';\nimport { isPlatform, getPlatforms, LIFECYCLE_WILL_ENTER, LIFECYCLE_DID_ENTER, LIFECYCLE_WILL_LEAVE, LIFECYCLE_DID_LEAVE, LIFECYCLE_WILL_UNLOAD, componentOnReady, actionSheetController, alertController, loadingController, menuController, pickerController, modalController, popoverController, toastController, createAnimation, getTimeGivenProgression, createGesture, setupConfig } from '@ionic/core';\nimport * as ɵngcc0 from '@angular/core';\nimport * as ɵngcc1 from '@angular/common';\nimport * as ɵngcc2 from '@angular/router';\nconst _c0 = [\"*\"];\nconst _c1 = [\"outlet\"];\nconst _c2 = [[[\"\", \"slot\", \"top\"]], \"*\"];\nconst _c3 = [\"[slot=top]\", \"*\"];\nexport { IonicSafeString, IonicSlides, IonicSwiper, createAnimation, getPlatforms, iosTransitionAnimation, isPlatform, mdTransitionAnimation } from '@ionic/core';\nimport { Subject, fromEvent, BehaviorSubject } from 'rxjs';\nimport { filter, switchMap, distinctUntilChanged } from 'rxjs/operators';\nimport { applyPolyfills, defineCustomElements } from '@ionic/core/loader';\nconst raf = h => {\n if (typeof __zone_symbol__requestAnimationFrame === 'function') {\n return __zone_symbol__requestAnimationFrame(h);\n }\n if (typeof requestAnimationFrame === 'function') {\n return requestAnimationFrame(h);\n }\n return setTimeout(h);\n};\nclass ValueAccessor {\n constructor(injector, el) {\n this.injector = injector;\n this.el = el;\n this.onChange = () => {};\n this.onTouched = () => {};\n }\n writeValue(value) {\n /**\n * TODO for Ionic 6:\n * Change `value == null ? '' : value;`\n * to `value`. This was a fix for IE9, but IE9\n * is no longer supported; however, this change\n * is potentially a breaking change\n */\n this.el.nativeElement.value = this.lastValue = value == null ? '' : value;\n setIonicClasses(this.el);\n }\n handleChangeEvent(el, value) {\n if (el === this.el.nativeElement) {\n if (value !== this.lastValue) {\n this.lastValue = value;\n this.onChange(value);\n }\n setIonicClasses(this.el);\n }\n }\n _handleBlurEvent(el) {\n if (el === this.el.nativeElement) {\n this.onTouched();\n setIonicClasses(this.el);\n }\n }\n registerOnChange(fn) {\n this.onChange = fn;\n }\n registerOnTouched(fn) {\n this.onTouched = fn;\n }\n setDisabledState(isDisabled) {\n this.el.nativeElement.disabled = isDisabled;\n }\n ngOnDestroy() {\n if (this.statusChanges) {\n this.statusChanges.unsubscribe();\n }\n }\n ngAfterViewInit() {\n let ngControl;\n try {\n ngControl = this.injector.get(NgControl);\n } catch ( /* No FormControl or ngModel binding */_a) {/* No FormControl or ngModel binding */}\n if (!ngControl) {\n return;\n }\n // Listen for changes in validity, disabled, or pending states\n if (ngControl.statusChanges) {\n this.statusChanges = ngControl.statusChanges.subscribe(() => setIonicClasses(this.el));\n }\n /**\n * TODO Remove this in favor of https://github.com/angular/angular/issues/10887\n * whenever it is implemented. Currently, Ionic's form status classes\n * do not react to changes when developers manually call\n * Angular form control methods such as markAsTouched.\n * This results in Ionic's form status classes being out\n * of sync with the ng form status classes.\n * This patches the methods to manually sync\n * the classes until this feature is implemented in Angular.\n */\n const formControl = ngControl.control;\n if (formControl) {\n const methodsToPatch = ['markAsTouched', 'markAllAsTouched', 'markAsUntouched', 'markAsDirty', 'markAsPristine'];\n methodsToPatch.forEach(method => {\n if (formControl[method]) {\n const oldFn = formControl[method].bind(formControl);\n formControl[method] = (...params) => {\n oldFn(...params);\n setIonicClasses(this.el);\n };\n }\n });\n }\n }\n}\nValueAccessor.ɵfac = function ValueAccessor_Factory(t) {\n ɵngcc0.ɵɵinvalidFactory();\n};\nValueAccessor.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: ValueAccessor,\n hostBindings: function ValueAccessor_HostBindings(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"ionBlur\", function ValueAccessor_ionBlur_HostBindingHandler($event) {\n return ctx._handleBlurEvent($event.target);\n });\n }\n }\n});\n__decorate([HostListener('ionBlur', ['$event.target'])], ValueAccessor.prototype, \"_handleBlurEvent\", null);\nconst setIonicClasses = element => {\n raf(() => {\n const input = element.nativeElement;\n const classes = getClasses(input);\n setClasses(input, classes);\n const item = input.closest('ion-item');\n if (item) {\n setClasses(item, classes);\n }\n });\n};\nconst getClasses = element => {\n const classList = element.classList;\n const classes = [];\n for (let i = 0; i < classList.length; i++) {\n const item = classList.item(i);\n if (item !== null && startsWith(item, 'ng-')) {\n classes.push(`ion-${item.substr(3)}`);\n }\n }\n return classes;\n};\nconst ɵ0 = getClasses;\nconst setClasses = (element, classes) => {\n const classList = element.classList;\n ['ion-valid', 'ion-invalid', 'ion-touched', 'ion-untouched', 'ion-dirty', 'ion-pristine'].forEach(c => classList.remove(c));\n classes.forEach(c => classList.add(c));\n};\nconst ɵ1 = setClasses;\nconst startsWith = (input, search) => {\n return input.substr(0, search.length) === search;\n};\nconst ɵ2 = startsWith;\nvar BooleanValueAccessor_1;\nlet BooleanValueAccessor = BooleanValueAccessor_1 = class BooleanValueAccessor extends ValueAccessor {\n constructor(injector, el) {\n super(injector, el);\n }\n writeValue(value) {\n this.el.nativeElement.checked = this.lastValue = value == null ? false : value;\n setIonicClasses(this.el);\n }\n _handleIonChange(el) {\n this.handleChangeEvent(el, el.checked);\n }\n};\nBooleanValueAccessor.ɵfac = function BooleanValueAccessor_Factory(t) {\n return new (t || BooleanValueAccessor)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef));\n};\nBooleanValueAccessor.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: BooleanValueAccessor,\n selectors: [[\"ion-checkbox\"], [\"ion-toggle\"]],\n hostBindings: function BooleanValueAccessor_HostBindings(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"ionChange\", function BooleanValueAccessor_ionChange_HostBindingHandler($event) {\n return ctx._handleIonChange($event.target);\n });\n }\n },\n features: [ɵngcc0.ɵɵProvidersFeature([{\n provide: NG_VALUE_ACCESSOR,\n useExisting: BooleanValueAccessor_1,\n multi: true\n }]), ɵngcc0.ɵɵInheritDefinitionFeature]\n});\nBooleanValueAccessor.ctorParameters = () => [{\n type: Injector\n}, {\n type: ElementRef\n}];\n__decorate([HostListener('ionChange', ['$event.target'])], BooleanValueAccessor.prototype, \"_handleIonChange\", null);\nvar NumericValueAccessor_1;\nlet NumericValueAccessor = NumericValueAccessor_1 = class NumericValueAccessor extends ValueAccessor {\n constructor(injector, el) {\n super(injector, el);\n }\n _handleIonChange(el) {\n this.handleChangeEvent(el, el.value);\n }\n registerOnChange(fn) {\n super.registerOnChange(value => {\n fn(value === '' ? null : parseFloat(value));\n });\n }\n};\nNumericValueAccessor.ɵfac = function NumericValueAccessor_Factory(t) {\n return new (t || NumericValueAccessor)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef));\n};\nNumericValueAccessor.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: NumericValueAccessor,\n selectors: [[\"ion-input\", \"type\", \"number\"]],\n hostBindings: function NumericValueAccessor_HostBindings(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"ionChange\", function NumericValueAccessor_ionChange_HostBindingHandler($event) {\n return ctx._handleIonChange($event.target);\n });\n }\n },\n features: [ɵngcc0.ɵɵProvidersFeature([{\n provide: NG_VALUE_ACCESSOR,\n useExisting: NumericValueAccessor_1,\n multi: true\n }]), ɵngcc0.ɵɵInheritDefinitionFeature]\n});\nNumericValueAccessor.ctorParameters = () => [{\n type: Injector\n}, {\n type: ElementRef\n}];\n__decorate([HostListener('ionChange', ['$event.target'])], NumericValueAccessor.prototype, \"_handleIonChange\", null);\nvar RadioValueAccessor_1;\nlet RadioValueAccessor = RadioValueAccessor_1 = class RadioValueAccessor extends ValueAccessor {\n constructor(injector, el) {\n super(injector, el);\n }\n _handleIonSelect(el) {\n this.handleChangeEvent(el, el.checked);\n }\n};\nRadioValueAccessor.ɵfac = function RadioValueAccessor_Factory(t) {\n return new (t || RadioValueAccessor)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef));\n};\nRadioValueAccessor.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: RadioValueAccessor,\n selectors: [[\"ion-radio\"]],\n hostBindings: function RadioValueAccessor_HostBindings(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"ionSelect\", function RadioValueAccessor_ionSelect_HostBindingHandler($event) {\n return ctx._handleIonSelect($event.target);\n });\n }\n },\n features: [ɵngcc0.ɵɵProvidersFeature([{\n provide: NG_VALUE_ACCESSOR,\n useExisting: RadioValueAccessor_1,\n multi: true\n }]), ɵngcc0.ɵɵInheritDefinitionFeature]\n});\nRadioValueAccessor.ctorParameters = () => [{\n type: Injector\n}, {\n type: ElementRef\n}];\n__decorate([HostListener('ionSelect', ['$event.target'])], RadioValueAccessor.prototype, \"_handleIonSelect\", null);\nvar SelectValueAccessor_1;\nlet SelectValueAccessor = SelectValueAccessor_1 = class SelectValueAccessor extends ValueAccessor {\n constructor(injector, el) {\n super(injector, el);\n }\n _handleChangeEvent(el) {\n this.handleChangeEvent(el, el.value);\n }\n};\nSelectValueAccessor.ɵfac = function SelectValueAccessor_Factory(t) {\n return new (t || SelectValueAccessor)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef));\n};\nSelectValueAccessor.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: SelectValueAccessor,\n selectors: [[\"ion-range\"], [\"ion-select\"], [\"ion-radio-group\"], [\"ion-segment\"], [\"ion-datetime\"]],\n hostBindings: function SelectValueAccessor_HostBindings(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"ionChange\", function SelectValueAccessor_ionChange_HostBindingHandler($event) {\n return ctx._handleChangeEvent($event.target);\n });\n }\n },\n features: [ɵngcc0.ɵɵProvidersFeature([{\n provide: NG_VALUE_ACCESSOR,\n useExisting: SelectValueAccessor_1,\n multi: true\n }]), ɵngcc0.ɵɵInheritDefinitionFeature]\n});\nSelectValueAccessor.ctorParameters = () => [{\n type: Injector\n}, {\n type: ElementRef\n}];\n__decorate([HostListener('ionChange', ['$event.target'])], SelectValueAccessor.prototype, \"_handleChangeEvent\", null);\nvar TextValueAccessor_1;\nlet TextValueAccessor = TextValueAccessor_1 = class TextValueAccessor extends ValueAccessor {\n constructor(injector, el) {\n super(injector, el);\n }\n _handleInputEvent(el) {\n this.handleChangeEvent(el, el.value);\n }\n};\nTextValueAccessor.ɵfac = function TextValueAccessor_Factory(t) {\n return new (t || TextValueAccessor)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef));\n};\nTextValueAccessor.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: TextValueAccessor,\n selectors: [[\"ion-input\", 3, \"type\", \"number\"], [\"ion-textarea\"], [\"ion-searchbar\"]],\n hostBindings: function TextValueAccessor_HostBindings(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"ionChange\", function TextValueAccessor_ionChange_HostBindingHandler($event) {\n return ctx._handleInputEvent($event.target);\n });\n }\n },\n features: [ɵngcc0.ɵɵProvidersFeature([{\n provide: NG_VALUE_ACCESSOR,\n useExisting: TextValueAccessor_1,\n multi: true\n }]), ɵngcc0.ɵɵInheritDefinitionFeature]\n});\nTextValueAccessor.ctorParameters = () => [{\n type: Injector\n}, {\n type: ElementRef\n}];\n__decorate([HostListener('ionChange', ['$event.target'])], TextValueAccessor.prototype, \"_handleInputEvent\", null);\nlet Platform = class Platform {\n constructor(doc, zone) {\n this.doc = doc;\n /**\n * @hidden\n */\n this.backButton = new Subject();\n /**\n * The keyboardDidShow event emits when the\n * on-screen keyboard is presented.\n */\n this.keyboardDidShow = new Subject();\n /**\n * The keyboardDidHide event emits when the\n * on-screen keyboard is hidden.\n */\n this.keyboardDidHide = new Subject();\n /**\n * The pause event emits when the native platform puts the application\n * into the background, typically when the user switches to a different\n * application. This event would emit when a Cordova app is put into\n * the background, however, it would not fire on a standard web browser.\n */\n this.pause = new Subject();\n /**\n * The resume event emits when the native platform pulls the application\n * out from the background. This event would emit when a Cordova app comes\n * out from the background, however, it would not fire on a standard web browser.\n */\n this.resume = new Subject();\n /**\n * The resize event emits when the browser window has changed dimensions. This\n * could be from a browser window being physically resized, or from a device\n * changing orientation.\n */\n this.resize = new Subject();\n zone.run(() => {\n this.win = doc.defaultView;\n this.backButton.subscribeWithPriority = function (priority, callback) {\n return this.subscribe(ev => {\n return ev.register(priority, processNextHandler => zone.run(() => callback(processNextHandler)));\n });\n };\n proxyEvent(this.pause, doc, 'pause');\n proxyEvent(this.resume, doc, 'resume');\n proxyEvent(this.backButton, doc, 'ionBackButton');\n proxyEvent(this.resize, this.win, 'resize');\n proxyEvent(this.keyboardDidShow, this.win, 'ionKeyboardDidShow');\n proxyEvent(this.keyboardDidHide, this.win, 'ionKeyboardDidHide');\n let readyResolve;\n this._readyPromise = new Promise(res => {\n readyResolve = res;\n });\n if (this.win && this.win['cordova']) {\n doc.addEventListener('deviceready', () => {\n readyResolve('cordova');\n }, {\n once: true\n });\n } else {\n readyResolve('dom');\n }\n });\n }\n /**\n * @returns returns true/false based on platform.\n * @description\n * Depending on the platform the user is on, `is(platformName)` will\n * return `true` or `false`. Note that the same app can return `true`\n * for more than one platform name. For example, an app running from\n * an iPad would return `true` for the platform names: `mobile`,\n * `ios`, `ipad`, and `tablet`. Additionally, if the app was running\n * from Cordova then `cordova` would be true, and if it was running\n * from a web browser on the iPad then `mobileweb` would be `true`.\n *\n * ```\n * import { Platform } from 'ionic-angular';\n *\n * @Component({...})\n * export MyPage {\n * constructor(public platform: Platform) {\n * if (this.platform.is('ios')) {\n * // This will only print when on iOS\n * console.log('I am an iOS device!');\n * }\n * }\n * }\n * ```\n *\n * | Platform Name | Description |\n * |-----------------|------------------------------------|\n * | android | on a device running Android. |\n * | capacitor | on a device running Capacitor. |\n * | cordova | on a device running Cordova. |\n * | ios | on a device running iOS. |\n * | ipad | on an iPad device. |\n * | iphone | on an iPhone device. |\n * | phablet | on a phablet device. |\n * | tablet | on a tablet device. |\n * | electron | in Electron on a desktop device. |\n * | pwa | as a PWA app. |\n * | mobile | on a mobile device. |\n * | mobileweb | on a mobile device in a browser. |\n * | desktop | on a desktop device. |\n * | hybrid | is a cordova or capacitor app. |\n *\n */\n is(platformName) {\n return isPlatform(this.win, platformName);\n }\n /**\n * @returns the array of platforms\n * @description\n * Depending on what device you are on, `platforms` can return multiple values.\n * Each possible value is a hierarchy of platforms. For example, on an iPhone,\n * it would return `mobile`, `ios`, and `iphone`.\n *\n * ```\n * import { Platform } from 'ionic-angular';\n *\n * @Component({...})\n * export MyPage {\n * constructor(public platform: Platform) {\n * // This will print an array of the current platforms\n * console.log(this.platform.platforms());\n * }\n * }\n * ```\n */\n platforms() {\n return getPlatforms(this.win);\n }\n /**\n * Returns a promise when the platform is ready and native functionality\n * can be called. If the app is running from within a web browser, then\n * the promise will resolve when the DOM is ready. When the app is running\n * from an application engine such as Cordova, then the promise will\n * resolve when Cordova triggers the `deviceready` event.\n *\n * The resolved value is the `readySource`, which states which platform\n * ready was used. For example, when Cordova is ready, the resolved ready\n * source is `cordova`. The default ready source value will be `dom`. The\n * `readySource` is useful if different logic should run depending on the\n * platform the app is running from. For example, only Cordova can execute\n * the status bar plugin, so the web should not run status bar plugin logic.\n *\n * ```\n * import { Component } from '@angular/core';\n * import { Platform } from 'ionic-angular';\n *\n * @Component({...})\n * export MyApp {\n * constructor(public platform: Platform) {\n * this.platform.ready().then((readySource) => {\n * console.log('Platform ready from', readySource);\n * // Platform now ready, execute any required native code\n * });\n * }\n * }\n * ```\n */\n ready() {\n return this._readyPromise;\n }\n /**\n * Returns if this app is using right-to-left language direction or not.\n * We recommend the app's `index.html` file already has the correct `dir`\n * attribute value set, such as `` or ``.\n * [W3C: Structural markup and right-to-left text in HTML](http://www.w3.org/International/questions/qa-html-dir)\n */\n get isRTL() {\n return this.doc.dir === 'rtl';\n }\n /**\n * Get the query string parameter\n */\n getQueryParam(key) {\n return readQueryParam(this.win.location.href, key);\n }\n /**\n * Returns `true` if the app is in landscape mode.\n */\n isLandscape() {\n return !this.isPortrait();\n }\n /**\n * Returns `true` if the app is in portrait mode.\n */\n isPortrait() {\n return this.win.matchMedia && this.win.matchMedia('(orientation: portrait)').matches;\n }\n testUserAgent(expression) {\n const nav = this.win.navigator;\n return !!(nav && nav.userAgent && nav.userAgent.indexOf(expression) >= 0);\n }\n /**\n * Get the current url.\n */\n url() {\n return this.win.location.href;\n }\n /**\n * Gets the width of the platform's viewport using `window.innerWidth`.\n */\n width() {\n return this.win.innerWidth;\n }\n /**\n * Gets the height of the platform's viewport using `window.innerHeight`.\n */\n height() {\n return this.win.innerHeight;\n }\n};\nPlatform.ɵfac = function Platform_Factory(t) {\n return new (t || Platform)(ɵngcc0.ɵɵinject(DOCUMENT), ɵngcc0.ɵɵinject(ɵngcc0.NgZone));\n};\nPlatform.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: Platform,\n factory: function (t) {\n return Platform.ɵfac(t);\n },\n providedIn: 'root'\n});\nPlatform.ctorParameters = () => [{\n type: undefined,\n decorators: [{\n type: Inject,\n args: [DOCUMENT]\n }]\n}, {\n type: NgZone\n}];\nPlatform.ngInjectableDef = ɵɵdefineInjectable({\n factory: function Platform_Factory() {\n return new Platform(ɵɵinject(DOCUMENT), ɵɵinject(NgZone));\n },\n token: Platform,\n providedIn: \"root\"\n});\nPlatform = __decorate([__param(0, Inject(DOCUMENT))], Platform);\nconst readQueryParam = (url, key) => {\n key = key.replace(/[\\[]/, '\\\\[').replace(/[\\]]/, '\\\\]');\n const regex = new RegExp('[\\\\?&]' + key + '=([^]*)');\n const results = regex.exec(url);\n return results ? decodeURIComponent(results[1].replace(/\\+/g, ' ')) : null;\n};\nconst ɵ0$1 = readQueryParam;\nconst proxyEvent = (emitter, el, eventName) => {\n if (el) {\n el.addEventListener(eventName, ev => {\n // ?? cordova might emit \"null\" events\n emitter.next(ev != null ? ev.detail : undefined);\n });\n }\n};\nconst ɵ1$1 = proxyEvent;\nlet NavController = class NavController {\n constructor(platform, location, serializer, router) {\n this.location = location;\n this.serializer = serializer;\n this.router = router;\n this.direction = DEFAULT_DIRECTION;\n this.animated = DEFAULT_ANIMATED;\n this.guessDirection = 'forward';\n this.lastNavId = -1;\n // Subscribe to router events to detect direction\n if (router) {\n router.events.subscribe(ev => {\n if (ev instanceof NavigationStart) {\n const id = ev.restoredState ? ev.restoredState.navigationId : ev.id;\n this.guessDirection = id < this.lastNavId ? 'back' : 'forward';\n this.guessAnimation = !ev.restoredState ? this.guessDirection : undefined;\n this.lastNavId = this.guessDirection === 'forward' ? ev.id : id;\n }\n });\n }\n // Subscribe to backButton events\n platform.backButton.subscribeWithPriority(0, processNextHandler => {\n this.pop();\n processNextHandler();\n });\n }\n /**\n * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,\n * it's equivalent to calling `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition.\n *\n * Going **forward** means that a new page is going to be pushed to the stack of the outlet (ion-router-outlet),\n * and that it will show a \"forward\" animation by default.\n *\n * Navigating forward can also be triggered in a declarative manner by using the `[routerDirection]` directive:\n *\n * ```html\n * Link\n * ```\n */\n navigateForward(url, options = {}) {\n this.setDirection('forward', options.animated, options.animationDirection, options.animation);\n return this.navigate(url, options);\n }\n /**\n * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,\n * it's equivalent to calling:\n *\n * ```ts\n * this.navController.setDirection('back');\n * this.router.navigateByUrl(path);\n * ```\n *\n * Going **back** means that all the pages in the stack until the navigated page is found will be popped,\n * and that it will show a \"back\" animation by default.\n *\n * Navigating back can also be triggered in a declarative manner by using the `[routerDirection]` directive:\n *\n * ```html\n * Link\n * ```\n */\n navigateBack(url, options = {}) {\n this.setDirection('back', options.animated, options.animationDirection, options.animation);\n return this.navigate(url, options);\n }\n /**\n * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,\n * it's equivalent to calling:\n *\n * ```ts\n * this.navController.setDirection('root');\n * this.router.navigateByUrl(path);\n * ```\n *\n * Going **root** means that all existing pages in the stack will be removed,\n * and the navigated page will become the single page in the stack.\n *\n * Navigating root can also be triggered in a declarative manner by using the `[routerDirection]` directive:\n *\n * ```html\n * Link\n * ```\n */\n navigateRoot(url, options = {}) {\n this.setDirection('root', options.animated, options.animationDirection, options.animation);\n return this.navigate(url, options);\n }\n /**\n * Same as [Location](https://angular.io/api/common/Location)'s back() method.\n * It will use the standard `window.history.back()` under the hood, but featuring a `back` animation\n * by default.\n */\n back(options = {\n animated: true,\n animationDirection: 'back'\n }) {\n this.setDirection('back', options.animated, options.animationDirection, options.animation);\n return this.location.back();\n }\n /**\n * This methods goes back in the context of Ionic's stack navigation.\n *\n * It recursively finds the top active `ion-router-outlet` and calls `pop()`.\n * This is the recommended way to go back when you are using `ion-router-outlet`.\n */\n pop() {\n return __awaiter(this, void 0, void 0, function* () {\n let outlet = this.topOutlet;\n while (outlet) {\n if (yield outlet.pop()) {\n break;\n } else {\n outlet = outlet.parentOutlet;\n }\n }\n });\n }\n /**\n * This methods specifies the direction of the next navigation performed by the Angular router.\n *\n * `setDirection()` does not trigger any transition, it just sets some flags to be consumed by `ion-router-outlet`.\n *\n * It's recommended to use `navigateForward()`, `navigateBack()` and `navigateRoot()` instead of `setDirection()`.\n */\n setDirection(direction, animated, animationDirection, animationBuilder) {\n this.direction = direction;\n this.animated = getAnimation(direction, animated, animationDirection);\n this.animationBuilder = animationBuilder;\n }\n /**\n * @internal\n */\n setTopOutlet(outlet) {\n this.topOutlet = outlet;\n }\n /**\n * @internal\n */\n consumeTransition() {\n let direction = 'root';\n let animation;\n const animationBuilder = this.animationBuilder;\n if (this.direction === 'auto') {\n direction = this.guessDirection;\n animation = this.guessAnimation;\n } else {\n animation = this.animated;\n direction = this.direction;\n }\n this.direction = DEFAULT_DIRECTION;\n this.animated = DEFAULT_ANIMATED;\n this.animationBuilder = undefined;\n return {\n direction,\n animation,\n animationBuilder\n };\n }\n navigate(url, options) {\n if (Array.isArray(url)) {\n return this.router.navigate(url, options);\n } else {\n /**\n * navigateByUrl ignores any properties that\n * would change the url, so things like queryParams\n * would be ignored unless we create a url tree\n * More Info: https://github.com/angular/angular/issues/18798\n */\n const urlTree = this.serializer.parse(url.toString());\n if (options.queryParams !== undefined) {\n urlTree.queryParams = Object.assign({}, options.queryParams);\n }\n if (options.fragment !== undefined) {\n urlTree.fragment = options.fragment;\n }\n /**\n * `navigateByUrl` will still apply `NavigationExtras` properties\n * that do not modify the url, such as `replaceUrl` which is why\n * `options` is passed in here.\n */\n return this.router.navigateByUrl(urlTree, options);\n }\n }\n};\nNavController.ɵfac = function NavController_Factory(t) {\n return new (t || NavController)(ɵngcc0.ɵɵinject(Platform), ɵngcc0.ɵɵinject(ɵngcc1.Location), ɵngcc0.ɵɵinject(ɵngcc2.UrlSerializer), ɵngcc0.ɵɵinject(ɵngcc2.Router, 8));\n};\nNavController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: NavController,\n factory: function (t) {\n return NavController.ɵfac(t);\n },\n providedIn: 'root'\n});\nNavController.ctorParameters = () => [{\n type: Platform\n}, {\n type: Location\n}, {\n type: UrlSerializer\n}, {\n type: Router,\n decorators: [{\n type: Optional\n }]\n}];\nNavController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function NavController_Factory() {\n return new NavController(ɵɵinject(Platform), ɵɵinject(Location), ɵɵinject(UrlSerializer), ɵɵinject(Router, 8));\n },\n token: NavController,\n providedIn: \"root\"\n});\nNavController = __decorate([__param(3, Optional())], NavController);\nconst getAnimation = (direction, animated, animationDirection) => {\n if (animated === false) {\n return undefined;\n }\n if (animationDirection !== undefined) {\n return animationDirection;\n }\n if (direction === 'forward' || direction === 'back') {\n return direction;\n } else if (direction === 'root' && animated === true) {\n return 'forward';\n }\n return undefined;\n};\nconst ɵ0$2 = getAnimation;\nconst DEFAULT_DIRECTION = 'auto';\nconst DEFAULT_ANIMATED = undefined;\n\n/* eslint-disable */\nconst proxyInputs = (Cmp, inputs) => {\n const Prototype = Cmp.prototype;\n inputs.forEach(item => {\n Object.defineProperty(Prototype, item, {\n get() {\n return this.el[item];\n },\n set(val) {\n this.z.runOutsideAngular(() => this.el[item] = val);\n }\n });\n });\n};\nconst proxyMethods = (Cmp, methods) => {\n const Prototype = Cmp.prototype;\n methods.forEach(methodName => {\n Prototype[methodName] = function () {\n const args = arguments;\n return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args));\n };\n });\n};\nconst proxyOutputs = (instance, el, events) => {\n events.forEach(eventName => instance[eventName] = fromEvent(el, eventName));\n};\nfunction ProxyCmp(opts) {\n const decorator = function (cls) {\n if (opts.inputs) {\n proxyInputs(cls, opts.inputs);\n }\n if (opts.methods) {\n proxyMethods(cls, opts.methods);\n }\n return cls;\n };\n return decorator;\n}\nlet IonApp = class IonApp {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonApp.ɵfac = function IonApp_Factory(t) {\n return new (t || IonApp)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonApp.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonApp,\n selectors: [[\"ion-app\"]],\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonApp_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonApp.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nlet IonAvatar = class IonAvatar {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonAvatar.ɵfac = function IonAvatar_Factory(t) {\n return new (t || IonAvatar)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonAvatar.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonAvatar,\n selectors: [[\"ion-avatar\"]],\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonAvatar_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonAvatar.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nlet IonBackButton = class IonBackButton {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonBackButton.ɵfac = function IonBackButton_Factory(t) {\n return new (t || IonBackButton)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonBackButton.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonBackButton,\n selectors: [[\"ion-back-button\"]],\n inputs: {\n color: \"color\",\n defaultHref: \"defaultHref\",\n disabled: \"disabled\",\n icon: \"icon\",\n mode: \"mode\",\n routerAnimation: \"routerAnimation\",\n text: \"text\",\n type: \"type\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonBackButton_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonBackButton.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonBackButton = __decorate([ProxyCmp({\n inputs: [\"color\", \"defaultHref\", \"disabled\", \"icon\", \"mode\", \"routerAnimation\", \"text\", \"type\"]\n})], IonBackButton);\nlet IonBackdrop = class IonBackdrop {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionBackdropTap\"]);\n }\n};\nIonBackdrop.ɵfac = function IonBackdrop_Factory(t) {\n return new (t || IonBackdrop)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonBackdrop.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonBackdrop,\n selectors: [[\"ion-backdrop\"]],\n inputs: {\n stopPropagation: \"stopPropagation\",\n tappable: \"tappable\",\n visible: \"visible\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonBackdrop_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonBackdrop.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonBackdrop = __decorate([ProxyCmp({\n inputs: [\"stopPropagation\", \"tappable\", \"visible\"]\n})], IonBackdrop);\nlet IonBadge = class IonBadge {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonBadge.ɵfac = function IonBadge_Factory(t) {\n return new (t || IonBadge)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonBadge.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonBadge,\n selectors: [[\"ion-badge\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonBadge_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonBadge.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonBadge = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\"]\n})], IonBadge);\nlet IonButton = class IonButton {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionFocus\", \"ionBlur\"]);\n }\n};\nIonButton.ɵfac = function IonButton_Factory(t) {\n return new (t || IonButton)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonButton.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonButton,\n selectors: [[\"ion-button\"]],\n inputs: {\n buttonType: \"buttonType\",\n color: \"color\",\n disabled: \"disabled\",\n download: \"download\",\n expand: \"expand\",\n fill: \"fill\",\n href: \"href\",\n mode: \"mode\",\n rel: \"rel\",\n routerAnimation: \"routerAnimation\",\n routerDirection: \"routerDirection\",\n shape: \"shape\",\n size: \"size\",\n strong: \"strong\",\n target: \"target\",\n type: \"type\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonButton_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonButton.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonButton = __decorate([ProxyCmp({\n inputs: [\"buttonType\", \"color\", \"disabled\", \"download\", \"expand\", \"fill\", \"href\", \"mode\", \"rel\", \"routerAnimation\", \"routerDirection\", \"shape\", \"size\", \"strong\", \"target\", \"type\"]\n})], IonButton);\nlet IonButtons = class IonButtons {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonButtons.ɵfac = function IonButtons_Factory(t) {\n return new (t || IonButtons)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonButtons.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonButtons,\n selectors: [[\"ion-buttons\"]],\n inputs: {\n collapse: \"collapse\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonButtons_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonButtons.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonButtons = __decorate([ProxyCmp({\n inputs: [\"collapse\"]\n})], IonButtons);\nlet IonCard = class IonCard {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonCard.ɵfac = function IonCard_Factory(t) {\n return new (t || IonCard)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonCard.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonCard,\n selectors: [[\"ion-card\"]],\n inputs: {\n button: \"button\",\n color: \"color\",\n disabled: \"disabled\",\n download: \"download\",\n href: \"href\",\n mode: \"mode\",\n rel: \"rel\",\n routerAnimation: \"routerAnimation\",\n routerDirection: \"routerDirection\",\n target: \"target\",\n type: \"type\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonCard_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonCard.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonCard = __decorate([ProxyCmp({\n inputs: [\"button\", \"color\", \"disabled\", \"download\", \"href\", \"mode\", \"rel\", \"routerAnimation\", \"routerDirection\", \"target\", \"type\"]\n})], IonCard);\nlet IonCardContent = class IonCardContent {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonCardContent.ɵfac = function IonCardContent_Factory(t) {\n return new (t || IonCardContent)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonCardContent.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonCardContent,\n selectors: [[\"ion-card-content\"]],\n inputs: {\n mode: \"mode\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonCardContent_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonCardContent.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonCardContent = __decorate([ProxyCmp({\n inputs: [\"mode\"]\n})], IonCardContent);\nlet IonCardHeader = class IonCardHeader {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonCardHeader.ɵfac = function IonCardHeader_Factory(t) {\n return new (t || IonCardHeader)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonCardHeader.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonCardHeader,\n selectors: [[\"ion-card-header\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\",\n translucent: \"translucent\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonCardHeader_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonCardHeader.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonCardHeader = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\", \"translucent\"]\n})], IonCardHeader);\nlet IonCardSubtitle = class IonCardSubtitle {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonCardSubtitle.ɵfac = function IonCardSubtitle_Factory(t) {\n return new (t || IonCardSubtitle)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonCardSubtitle.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonCardSubtitle,\n selectors: [[\"ion-card-subtitle\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonCardSubtitle_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonCardSubtitle.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonCardSubtitle = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\"]\n})], IonCardSubtitle);\nlet IonCardTitle = class IonCardTitle {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonCardTitle.ɵfac = function IonCardTitle_Factory(t) {\n return new (t || IonCardTitle)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonCardTitle.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonCardTitle,\n selectors: [[\"ion-card-title\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonCardTitle_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonCardTitle.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonCardTitle = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\"]\n})], IonCardTitle);\nlet IonCheckbox = class IonCheckbox {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionChange\", \"ionFocus\", \"ionBlur\"]);\n }\n};\nIonCheckbox.ɵfac = function IonCheckbox_Factory(t) {\n return new (t || IonCheckbox)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonCheckbox.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonCheckbox,\n selectors: [[\"ion-checkbox\"]],\n inputs: {\n checked: \"checked\",\n color: \"color\",\n disabled: \"disabled\",\n indeterminate: \"indeterminate\",\n mode: \"mode\",\n name: \"name\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonCheckbox_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonCheckbox.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonCheckbox = __decorate([ProxyCmp({\n inputs: [\"checked\", \"color\", \"disabled\", \"indeterminate\", \"mode\", \"name\", \"value\"]\n})], IonCheckbox);\nlet IonChip = class IonChip {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonChip.ɵfac = function IonChip_Factory(t) {\n return new (t || IonChip)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonChip.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonChip,\n selectors: [[\"ion-chip\"]],\n inputs: {\n color: \"color\",\n disabled: \"disabled\",\n mode: \"mode\",\n outline: \"outline\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonChip_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonChip.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonChip = __decorate([ProxyCmp({\n inputs: [\"color\", \"disabled\", \"mode\", \"outline\"]\n})], IonChip);\nlet IonCol = class IonCol {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonCol.ɵfac = function IonCol_Factory(t) {\n return new (t || IonCol)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonCol.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonCol,\n selectors: [[\"ion-col\"]],\n inputs: {\n offset: \"offset\",\n offsetLg: \"offsetLg\",\n offsetMd: \"offsetMd\",\n offsetSm: \"offsetSm\",\n offsetXl: \"offsetXl\",\n offsetXs: \"offsetXs\",\n pull: \"pull\",\n pullLg: \"pullLg\",\n pullMd: \"pullMd\",\n pullSm: \"pullSm\",\n pullXl: \"pullXl\",\n pullXs: \"pullXs\",\n push: \"push\",\n pushLg: \"pushLg\",\n pushMd: \"pushMd\",\n pushSm: \"pushSm\",\n pushXl: \"pushXl\",\n pushXs: \"pushXs\",\n size: \"size\",\n sizeLg: \"sizeLg\",\n sizeMd: \"sizeMd\",\n sizeSm: \"sizeSm\",\n sizeXl: \"sizeXl\",\n sizeXs: \"sizeXs\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonCol_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonCol.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonCol = __decorate([ProxyCmp({\n inputs: [\"offset\", \"offsetLg\", \"offsetMd\", \"offsetSm\", \"offsetXl\", \"offsetXs\", \"pull\", \"pullLg\", \"pullMd\", \"pullSm\", \"pullXl\", \"pullXs\", \"push\", \"pushLg\", \"pushMd\", \"pushSm\", \"pushXl\", \"pushXs\", \"size\", \"sizeLg\", \"sizeMd\", \"sizeSm\", \"sizeXl\", \"sizeXs\"]\n})], IonCol);\nlet IonContent = class IonContent {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionScrollStart\", \"ionScroll\", \"ionScrollEnd\"]);\n }\n};\nIonContent.ɵfac = function IonContent_Factory(t) {\n return new (t || IonContent)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonContent.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonContent,\n selectors: [[\"ion-content\"]],\n inputs: {\n color: \"color\",\n forceOverscroll: \"forceOverscroll\",\n fullscreen: \"fullscreen\",\n scrollEvents: \"scrollEvents\",\n scrollX: \"scrollX\",\n scrollY: \"scrollY\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonContent_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonContent.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonContent = __decorate([ProxyCmp({\n inputs: [\"color\", \"forceOverscroll\", \"fullscreen\", \"scrollEvents\", \"scrollX\", \"scrollY\"],\n \"methods\": [\"getScrollElement\", \"scrollToTop\", \"scrollToBottom\", \"scrollByPoint\", \"scrollToPoint\"]\n})], IonContent);\nlet IonDatetime = class IonDatetime {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionCancel\", \"ionChange\", \"ionFocus\", \"ionBlur\"]);\n }\n};\nIonDatetime.ɵfac = function IonDatetime_Factory(t) {\n return new (t || IonDatetime)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonDatetime.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonDatetime,\n selectors: [[\"ion-datetime\"]],\n inputs: {\n cancelText: \"cancelText\",\n dayNames: \"dayNames\",\n dayShortNames: \"dayShortNames\",\n dayValues: \"dayValues\",\n disabled: \"disabled\",\n displayFormat: \"displayFormat\",\n displayTimezone: \"displayTimezone\",\n doneText: \"doneText\",\n hourValues: \"hourValues\",\n max: \"max\",\n min: \"min\",\n minuteValues: \"minuteValues\",\n mode: \"mode\",\n monthNames: \"monthNames\",\n monthShortNames: \"monthShortNames\",\n monthValues: \"monthValues\",\n name: \"name\",\n pickerFormat: \"pickerFormat\",\n pickerOptions: \"pickerOptions\",\n placeholder: \"placeholder\",\n readonly: \"readonly\",\n value: \"value\",\n yearValues: \"yearValues\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonDatetime_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonDatetime.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonDatetime = __decorate([ProxyCmp({\n inputs: [\"cancelText\", \"dayNames\", \"dayShortNames\", \"dayValues\", \"disabled\", \"displayFormat\", \"displayTimezone\", \"doneText\", \"hourValues\", \"max\", \"min\", \"minuteValues\", \"mode\", \"monthNames\", \"monthShortNames\", \"monthValues\", \"name\", \"pickerFormat\", \"pickerOptions\", \"placeholder\", \"readonly\", \"value\", \"yearValues\"],\n \"methods\": [\"open\"]\n})], IonDatetime);\nlet IonFab = class IonFab {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonFab.ɵfac = function IonFab_Factory(t) {\n return new (t || IonFab)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonFab.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonFab,\n selectors: [[\"ion-fab\"]],\n inputs: {\n activated: \"activated\",\n edge: \"edge\",\n horizontal: \"horizontal\",\n vertical: \"vertical\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonFab_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonFab.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonFab = __decorate([ProxyCmp({\n inputs: [\"activated\", \"edge\", \"horizontal\", \"vertical\"],\n \"methods\": [\"close\"]\n})], IonFab);\nlet IonFabButton = class IonFabButton {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionFocus\", \"ionBlur\"]);\n }\n};\nIonFabButton.ɵfac = function IonFabButton_Factory(t) {\n return new (t || IonFabButton)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonFabButton.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonFabButton,\n selectors: [[\"ion-fab-button\"]],\n inputs: {\n activated: \"activated\",\n closeIcon: \"closeIcon\",\n color: \"color\",\n disabled: \"disabled\",\n download: \"download\",\n href: \"href\",\n mode: \"mode\",\n rel: \"rel\",\n routerAnimation: \"routerAnimation\",\n routerDirection: \"routerDirection\",\n show: \"show\",\n size: \"size\",\n target: \"target\",\n translucent: \"translucent\",\n type: \"type\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonFabButton_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonFabButton.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonFabButton = __decorate([ProxyCmp({\n inputs: [\"activated\", \"closeIcon\", \"color\", \"disabled\", \"download\", \"href\", \"mode\", \"rel\", \"routerAnimation\", \"routerDirection\", \"show\", \"size\", \"target\", \"translucent\", \"type\"]\n})], IonFabButton);\nlet IonFabList = class IonFabList {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonFabList.ɵfac = function IonFabList_Factory(t) {\n return new (t || IonFabList)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonFabList.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonFabList,\n selectors: [[\"ion-fab-list\"]],\n inputs: {\n activated: \"activated\",\n side: \"side\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonFabList_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonFabList.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonFabList = __decorate([ProxyCmp({\n inputs: [\"activated\", \"side\"]\n})], IonFabList);\nlet IonFooter = class IonFooter {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonFooter.ɵfac = function IonFooter_Factory(t) {\n return new (t || IonFooter)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonFooter.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonFooter,\n selectors: [[\"ion-footer\"]],\n inputs: {\n mode: \"mode\",\n translucent: \"translucent\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonFooter_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonFooter.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonFooter = __decorate([ProxyCmp({\n inputs: [\"mode\", \"translucent\"]\n})], IonFooter);\nlet IonGrid = class IonGrid {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonGrid.ɵfac = function IonGrid_Factory(t) {\n return new (t || IonGrid)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonGrid.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonGrid,\n selectors: [[\"ion-grid\"]],\n inputs: {\n fixed: \"fixed\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonGrid_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonGrid.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonGrid = __decorate([ProxyCmp({\n inputs: [\"fixed\"]\n})], IonGrid);\nlet IonHeader = class IonHeader {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonHeader.ɵfac = function IonHeader_Factory(t) {\n return new (t || IonHeader)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonHeader.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonHeader,\n selectors: [[\"ion-header\"]],\n inputs: {\n collapse: \"collapse\",\n mode: \"mode\",\n translucent: \"translucent\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonHeader_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonHeader.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonHeader = __decorate([ProxyCmp({\n inputs: [\"collapse\", \"mode\", \"translucent\"]\n})], IonHeader);\nlet IonIcon = class IonIcon {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonIcon.ɵfac = function IonIcon_Factory(t) {\n return new (t || IonIcon)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonIcon.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonIcon,\n selectors: [[\"ion-icon\"]],\n inputs: {\n ariaHidden: \"ariaHidden\",\n ariaLabel: \"ariaLabel\",\n color: \"color\",\n flipRtl: \"flipRtl\",\n icon: \"icon\",\n ios: \"ios\",\n lazy: \"lazy\",\n md: \"md\",\n mode: \"mode\",\n name: \"name\",\n sanitize: \"sanitize\",\n size: \"size\",\n src: \"src\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonIcon_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonIcon.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonIcon = __decorate([ProxyCmp({\n inputs: [\"ariaHidden\", \"ariaLabel\", \"color\", \"flipRtl\", \"icon\", \"ios\", \"lazy\", \"md\", \"mode\", \"name\", \"sanitize\", \"size\", \"src\"]\n})], IonIcon);\nlet IonImg = class IonImg {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionImgWillLoad\", \"ionImgDidLoad\", \"ionError\"]);\n }\n};\nIonImg.ɵfac = function IonImg_Factory(t) {\n return new (t || IonImg)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonImg.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonImg,\n selectors: [[\"ion-img\"]],\n inputs: {\n alt: \"alt\",\n src: \"src\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonImg_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonImg.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonImg = __decorate([ProxyCmp({\n inputs: [\"alt\", \"src\"]\n})], IonImg);\nlet IonInfiniteScroll = class IonInfiniteScroll {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionInfinite\"]);\n }\n};\nIonInfiniteScroll.ɵfac = function IonInfiniteScroll_Factory(t) {\n return new (t || IonInfiniteScroll)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonInfiniteScroll.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonInfiniteScroll,\n selectors: [[\"ion-infinite-scroll\"]],\n inputs: {\n disabled: \"disabled\",\n position: \"position\",\n threshold: \"threshold\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonInfiniteScroll_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonInfiniteScroll.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonInfiniteScroll = __decorate([ProxyCmp({\n inputs: [\"disabled\", \"position\", \"threshold\"],\n \"methods\": [\"complete\"]\n})], IonInfiniteScroll);\nlet IonInfiniteScrollContent = class IonInfiniteScrollContent {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonInfiniteScrollContent.ɵfac = function IonInfiniteScrollContent_Factory(t) {\n return new (t || IonInfiniteScrollContent)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonInfiniteScrollContent.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonInfiniteScrollContent,\n selectors: [[\"ion-infinite-scroll-content\"]],\n inputs: {\n loadingSpinner: \"loadingSpinner\",\n loadingText: \"loadingText\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonInfiniteScrollContent_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonInfiniteScrollContent.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonInfiniteScrollContent = __decorate([ProxyCmp({\n inputs: [\"loadingSpinner\", \"loadingText\"]\n})], IonInfiniteScrollContent);\nlet IonInput = class IonInput {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionInput\", \"ionChange\", \"ionBlur\", \"ionFocus\"]);\n }\n};\nIonInput.ɵfac = function IonInput_Factory(t) {\n return new (t || IonInput)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonInput.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonInput,\n selectors: [[\"ion-input\"]],\n inputs: {\n accept: \"accept\",\n autocapitalize: \"autocapitalize\",\n autocomplete: \"autocomplete\",\n autocorrect: \"autocorrect\",\n autofocus: \"autofocus\",\n clearInput: \"clearInput\",\n clearOnEdit: \"clearOnEdit\",\n color: \"color\",\n debounce: \"debounce\",\n disabled: \"disabled\",\n enterkeyhint: \"enterkeyhint\",\n inputmode: \"inputmode\",\n max: \"max\",\n maxlength: \"maxlength\",\n min: \"min\",\n minlength: \"minlength\",\n mode: \"mode\",\n multiple: \"multiple\",\n name: \"name\",\n pattern: \"pattern\",\n placeholder: \"placeholder\",\n readonly: \"readonly\",\n required: \"required\",\n size: \"size\",\n spellcheck: \"spellcheck\",\n step: \"step\",\n type: \"type\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonInput_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonInput.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonInput = __decorate([ProxyCmp({\n inputs: [\"accept\", \"autocapitalize\", \"autocomplete\", \"autocorrect\", \"autofocus\", \"clearInput\", \"clearOnEdit\", \"color\", \"debounce\", \"disabled\", \"enterkeyhint\", \"inputmode\", \"max\", \"maxlength\", \"min\", \"minlength\", \"mode\", \"multiple\", \"name\", \"pattern\", \"placeholder\", \"readonly\", \"required\", \"size\", \"spellcheck\", \"step\", \"type\", \"value\"],\n \"methods\": [\"setFocus\", \"getInputElement\"]\n})], IonInput);\nlet IonItem = class IonItem {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonItem.ɵfac = function IonItem_Factory(t) {\n return new (t || IonItem)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonItem.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonItem,\n selectors: [[\"ion-item\"]],\n inputs: {\n button: \"button\",\n color: \"color\",\n detail: \"detail\",\n detailIcon: \"detailIcon\",\n disabled: \"disabled\",\n download: \"download\",\n href: \"href\",\n lines: \"lines\",\n mode: \"mode\",\n rel: \"rel\",\n routerAnimation: \"routerAnimation\",\n routerDirection: \"routerDirection\",\n target: \"target\",\n type: \"type\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonItem_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonItem.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonItem = __decorate([ProxyCmp({\n inputs: [\"button\", \"color\", \"detail\", \"detailIcon\", \"disabled\", \"download\", \"href\", \"lines\", \"mode\", \"rel\", \"routerAnimation\", \"routerDirection\", \"target\", \"type\"]\n})], IonItem);\nlet IonItemDivider = class IonItemDivider {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonItemDivider.ɵfac = function IonItemDivider_Factory(t) {\n return new (t || IonItemDivider)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonItemDivider.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonItemDivider,\n selectors: [[\"ion-item-divider\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\",\n sticky: \"sticky\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonItemDivider_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonItemDivider.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonItemDivider = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\", \"sticky\"]\n})], IonItemDivider);\nlet IonItemGroup = class IonItemGroup {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonItemGroup.ɵfac = function IonItemGroup_Factory(t) {\n return new (t || IonItemGroup)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonItemGroup.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonItemGroup,\n selectors: [[\"ion-item-group\"]],\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonItemGroup_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonItemGroup.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nlet IonItemOption = class IonItemOption {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonItemOption.ɵfac = function IonItemOption_Factory(t) {\n return new (t || IonItemOption)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonItemOption.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonItemOption,\n selectors: [[\"ion-item-option\"]],\n inputs: {\n color: \"color\",\n disabled: \"disabled\",\n download: \"download\",\n expandable: \"expandable\",\n href: \"href\",\n mode: \"mode\",\n rel: \"rel\",\n target: \"target\",\n type: \"type\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonItemOption_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonItemOption.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonItemOption = __decorate([ProxyCmp({\n inputs: [\"color\", \"disabled\", \"download\", \"expandable\", \"href\", \"mode\", \"rel\", \"target\", \"type\"]\n})], IonItemOption);\nlet IonItemOptions = class IonItemOptions {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionSwipe\"]);\n }\n};\nIonItemOptions.ɵfac = function IonItemOptions_Factory(t) {\n return new (t || IonItemOptions)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonItemOptions.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonItemOptions,\n selectors: [[\"ion-item-options\"]],\n inputs: {\n side: \"side\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonItemOptions_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonItemOptions.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonItemOptions = __decorate([ProxyCmp({\n inputs: [\"side\"]\n})], IonItemOptions);\nlet IonItemSliding = class IonItemSliding {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionDrag\"]);\n }\n};\nIonItemSliding.ɵfac = function IonItemSliding_Factory(t) {\n return new (t || IonItemSliding)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonItemSliding.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonItemSliding,\n selectors: [[\"ion-item-sliding\"]],\n inputs: {\n disabled: \"disabled\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonItemSliding_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonItemSliding.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonItemSliding = __decorate([ProxyCmp({\n inputs: [\"disabled\"],\n \"methods\": [\"getOpenAmount\", \"getSlidingRatio\", \"open\", \"close\", \"closeOpened\"]\n})], IonItemSliding);\nlet IonLabel = class IonLabel {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonLabel.ɵfac = function IonLabel_Factory(t) {\n return new (t || IonLabel)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonLabel.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonLabel,\n selectors: [[\"ion-label\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\",\n position: \"position\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonLabel_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonLabel.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonLabel = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\", \"position\"]\n})], IonLabel);\nlet IonList = class IonList {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonList.ɵfac = function IonList_Factory(t) {\n return new (t || IonList)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonList.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonList,\n selectors: [[\"ion-list\"]],\n inputs: {\n inset: \"inset\",\n lines: \"lines\",\n mode: \"mode\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonList_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonList.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonList = __decorate([ProxyCmp({\n inputs: [\"inset\", \"lines\", \"mode\"],\n \"methods\": [\"closeSlidingItems\"]\n})], IonList);\nlet IonListHeader = class IonListHeader {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonListHeader.ɵfac = function IonListHeader_Factory(t) {\n return new (t || IonListHeader)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonListHeader.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonListHeader,\n selectors: [[\"ion-list-header\"]],\n inputs: {\n color: \"color\",\n lines: \"lines\",\n mode: \"mode\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonListHeader_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonListHeader.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonListHeader = __decorate([ProxyCmp({\n inputs: [\"color\", \"lines\", \"mode\"]\n})], IonListHeader);\nlet IonMenu = class IonMenu {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionWillOpen\", \"ionWillClose\", \"ionDidOpen\", \"ionDidClose\"]);\n }\n};\nIonMenu.ɵfac = function IonMenu_Factory(t) {\n return new (t || IonMenu)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonMenu.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonMenu,\n selectors: [[\"ion-menu\"]],\n inputs: {\n contentId: \"contentId\",\n disabled: \"disabled\",\n maxEdgeStart: \"maxEdgeStart\",\n menuId: \"menuId\",\n side: \"side\",\n swipeGesture: \"swipeGesture\",\n type: \"type\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonMenu_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonMenu.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonMenu = __decorate([ProxyCmp({\n inputs: [\"contentId\", \"disabled\", \"maxEdgeStart\", \"menuId\", \"side\", \"swipeGesture\", \"type\"],\n \"methods\": [\"isOpen\", \"isActive\", \"open\", \"close\", \"toggle\", \"setOpen\"]\n})], IonMenu);\nlet IonMenuButton = class IonMenuButton {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonMenuButton.ɵfac = function IonMenuButton_Factory(t) {\n return new (t || IonMenuButton)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonMenuButton.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonMenuButton,\n selectors: [[\"ion-menu-button\"]],\n inputs: {\n autoHide: \"autoHide\",\n color: \"color\",\n disabled: \"disabled\",\n menu: \"menu\",\n mode: \"mode\",\n type: \"type\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonMenuButton_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonMenuButton.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonMenuButton = __decorate([ProxyCmp({\n inputs: [\"autoHide\", \"color\", \"disabled\", \"menu\", \"mode\", \"type\"]\n})], IonMenuButton);\nlet IonMenuToggle = class IonMenuToggle {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonMenuToggle.ɵfac = function IonMenuToggle_Factory(t) {\n return new (t || IonMenuToggle)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonMenuToggle.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonMenuToggle,\n selectors: [[\"ion-menu-toggle\"]],\n inputs: {\n autoHide: \"autoHide\",\n menu: \"menu\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonMenuToggle_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonMenuToggle.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonMenuToggle = __decorate([ProxyCmp({\n inputs: [\"autoHide\", \"menu\"]\n})], IonMenuToggle);\nlet IonNav = class IonNav {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionNavWillChange\", \"ionNavDidChange\"]);\n }\n};\nIonNav.ɵfac = function IonNav_Factory(t) {\n return new (t || IonNav)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonNav.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonNav,\n selectors: [[\"ion-nav\"]],\n inputs: {\n animated: \"animated\",\n animation: \"animation\",\n root: \"root\",\n rootParams: \"rootParams\",\n swipeGesture: \"swipeGesture\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonNav_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonNav.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonNav = __decorate([ProxyCmp({\n inputs: [\"animated\", \"animation\", \"root\", \"rootParams\", \"swipeGesture\"],\n \"methods\": [\"push\", \"insert\", \"insertPages\", \"pop\", \"popTo\", \"popToRoot\", \"removeIndex\", \"setRoot\", \"setPages\", \"getActive\", \"getByIndex\", \"canGoBack\", \"getPrevious\"]\n})], IonNav);\nlet IonNavLink = class IonNavLink {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonNavLink.ɵfac = function IonNavLink_Factory(t) {\n return new (t || IonNavLink)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonNavLink.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonNavLink,\n selectors: [[\"ion-nav-link\"]],\n inputs: {\n component: \"component\",\n componentProps: \"componentProps\",\n routerAnimation: \"routerAnimation\",\n routerDirection: \"routerDirection\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonNavLink_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonNavLink.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonNavLink = __decorate([ProxyCmp({\n inputs: [\"component\", \"componentProps\", \"routerAnimation\", \"routerDirection\"]\n})], IonNavLink);\nlet IonNote = class IonNote {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonNote.ɵfac = function IonNote_Factory(t) {\n return new (t || IonNote)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonNote.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonNote,\n selectors: [[\"ion-note\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonNote_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonNote.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonNote = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\"]\n})], IonNote);\nlet IonProgressBar = class IonProgressBar {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonProgressBar.ɵfac = function IonProgressBar_Factory(t) {\n return new (t || IonProgressBar)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonProgressBar.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonProgressBar,\n selectors: [[\"ion-progress-bar\"]],\n inputs: {\n buffer: \"buffer\",\n color: \"color\",\n mode: \"mode\",\n reversed: \"reversed\",\n type: \"type\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonProgressBar_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonProgressBar.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonProgressBar = __decorate([ProxyCmp({\n inputs: [\"buffer\", \"color\", \"mode\", \"reversed\", \"type\", \"value\"]\n})], IonProgressBar);\nlet IonRadio = class IonRadio {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionFocus\", \"ionBlur\"]);\n }\n};\nIonRadio.ɵfac = function IonRadio_Factory(t) {\n return new (t || IonRadio)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonRadio.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonRadio,\n selectors: [[\"ion-radio\"]],\n inputs: {\n color: \"color\",\n disabled: \"disabled\",\n mode: \"mode\",\n name: \"name\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonRadio_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonRadio.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonRadio = __decorate([ProxyCmp({\n inputs: [\"color\", \"disabled\", \"mode\", \"name\", \"value\"]\n})], IonRadio);\nlet IonRadioGroup = class IonRadioGroup {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionChange\"]);\n }\n};\nIonRadioGroup.ɵfac = function IonRadioGroup_Factory(t) {\n return new (t || IonRadioGroup)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonRadioGroup.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonRadioGroup,\n selectors: [[\"ion-radio-group\"]],\n inputs: {\n allowEmptySelection: \"allowEmptySelection\",\n name: \"name\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonRadioGroup_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonRadioGroup.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonRadioGroup = __decorate([ProxyCmp({\n inputs: [\"allowEmptySelection\", \"name\", \"value\"]\n})], IonRadioGroup);\nlet IonRange = class IonRange {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionChange\", \"ionFocus\", \"ionBlur\"]);\n }\n};\nIonRange.ɵfac = function IonRange_Factory(t) {\n return new (t || IonRange)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonRange.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonRange,\n selectors: [[\"ion-range\"]],\n inputs: {\n color: \"color\",\n debounce: \"debounce\",\n disabled: \"disabled\",\n dualKnobs: \"dualKnobs\",\n max: \"max\",\n min: \"min\",\n mode: \"mode\",\n name: \"name\",\n pin: \"pin\",\n snaps: \"snaps\",\n step: \"step\",\n ticks: \"ticks\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonRange_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonRange.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonRange = __decorate([ProxyCmp({\n inputs: [\"color\", \"debounce\", \"disabled\", \"dualKnobs\", \"max\", \"min\", \"mode\", \"name\", \"pin\", \"snaps\", \"step\", \"ticks\", \"value\"]\n})], IonRange);\nlet IonRefresher = class IonRefresher {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionRefresh\", \"ionPull\", \"ionStart\"]);\n }\n};\nIonRefresher.ɵfac = function IonRefresher_Factory(t) {\n return new (t || IonRefresher)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonRefresher.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonRefresher,\n selectors: [[\"ion-refresher\"]],\n inputs: {\n closeDuration: \"closeDuration\",\n disabled: \"disabled\",\n pullFactor: \"pullFactor\",\n pullMax: \"pullMax\",\n pullMin: \"pullMin\",\n snapbackDuration: \"snapbackDuration\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonRefresher_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonRefresher.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonRefresher = __decorate([ProxyCmp({\n inputs: [\"closeDuration\", \"disabled\", \"pullFactor\", \"pullMax\", \"pullMin\", \"snapbackDuration\"],\n \"methods\": [\"complete\", \"cancel\", \"getProgress\"]\n})], IonRefresher);\nlet IonRefresherContent = class IonRefresherContent {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonRefresherContent.ɵfac = function IonRefresherContent_Factory(t) {\n return new (t || IonRefresherContent)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonRefresherContent.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonRefresherContent,\n selectors: [[\"ion-refresher-content\"]],\n inputs: {\n pullingIcon: \"pullingIcon\",\n pullingText: \"pullingText\",\n refreshingSpinner: \"refreshingSpinner\",\n refreshingText: \"refreshingText\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonRefresherContent_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonRefresherContent.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonRefresherContent = __decorate([ProxyCmp({\n inputs: [\"pullingIcon\", \"pullingText\", \"refreshingSpinner\", \"refreshingText\"]\n})], IonRefresherContent);\nlet IonReorder = class IonReorder {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonReorder.ɵfac = function IonReorder_Factory(t) {\n return new (t || IonReorder)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonReorder.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonReorder,\n selectors: [[\"ion-reorder\"]],\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonReorder_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonReorder.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nlet IonReorderGroup = class IonReorderGroup {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionItemReorder\"]);\n }\n};\nIonReorderGroup.ɵfac = function IonReorderGroup_Factory(t) {\n return new (t || IonReorderGroup)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonReorderGroup.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonReorderGroup,\n selectors: [[\"ion-reorder-group\"]],\n inputs: {\n disabled: \"disabled\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonReorderGroup_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonReorderGroup.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonReorderGroup = __decorate([ProxyCmp({\n inputs: [\"disabled\"],\n \"methods\": [\"complete\"]\n})], IonReorderGroup);\nlet IonRippleEffect = class IonRippleEffect {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonRippleEffect.ɵfac = function IonRippleEffect_Factory(t) {\n return new (t || IonRippleEffect)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonRippleEffect.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonRippleEffect,\n selectors: [[\"ion-ripple-effect\"]],\n inputs: {\n type: \"type\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonRippleEffect_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonRippleEffect.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonRippleEffect = __decorate([ProxyCmp({\n inputs: [\"type\"],\n \"methods\": [\"addRipple\"]\n})], IonRippleEffect);\nlet IonRow = class IonRow {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonRow.ɵfac = function IonRow_Factory(t) {\n return new (t || IonRow)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonRow.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonRow,\n selectors: [[\"ion-row\"]],\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonRow_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonRow.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nlet IonSearchbar = class IonSearchbar {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionInput\", \"ionChange\", \"ionCancel\", \"ionClear\", \"ionBlur\", \"ionFocus\"]);\n }\n};\nIonSearchbar.ɵfac = function IonSearchbar_Factory(t) {\n return new (t || IonSearchbar)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSearchbar.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSearchbar,\n selectors: [[\"ion-searchbar\"]],\n inputs: {\n animated: \"animated\",\n autocomplete: \"autocomplete\",\n autocorrect: \"autocorrect\",\n cancelButtonIcon: \"cancelButtonIcon\",\n cancelButtonText: \"cancelButtonText\",\n clearIcon: \"clearIcon\",\n color: \"color\",\n debounce: \"debounce\",\n disabled: \"disabled\",\n enterkeyhint: \"enterkeyhint\",\n inputmode: \"inputmode\",\n mode: \"mode\",\n placeholder: \"placeholder\",\n searchIcon: \"searchIcon\",\n showCancelButton: \"showCancelButton\",\n showClearButton: \"showClearButton\",\n spellcheck: \"spellcheck\",\n type: \"type\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSearchbar_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSearchbar.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonSearchbar = __decorate([ProxyCmp({\n inputs: [\"animated\", \"autocomplete\", \"autocorrect\", \"cancelButtonIcon\", \"cancelButtonText\", \"clearIcon\", \"color\", \"debounce\", \"disabled\", \"enterkeyhint\", \"inputmode\", \"mode\", \"placeholder\", \"searchIcon\", \"showCancelButton\", \"showClearButton\", \"spellcheck\", \"type\", \"value\"],\n \"methods\": [\"setFocus\", \"getInputElement\"]\n})], IonSearchbar);\nlet IonSegment = class IonSegment {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionChange\"]);\n }\n};\nIonSegment.ɵfac = function IonSegment_Factory(t) {\n return new (t || IonSegment)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSegment.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSegment,\n selectors: [[\"ion-segment\"]],\n inputs: {\n color: \"color\",\n disabled: \"disabled\",\n mode: \"mode\",\n scrollable: \"scrollable\",\n swipeGesture: \"swipeGesture\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSegment_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSegment.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonSegment = __decorate([ProxyCmp({\n inputs: [\"color\", \"disabled\", \"mode\", \"scrollable\", \"swipeGesture\", \"value\"]\n})], IonSegment);\nlet IonSegmentButton = class IonSegmentButton {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonSegmentButton.ɵfac = function IonSegmentButton_Factory(t) {\n return new (t || IonSegmentButton)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSegmentButton.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSegmentButton,\n selectors: [[\"ion-segment-button\"]],\n inputs: {\n disabled: \"disabled\",\n layout: \"layout\",\n mode: \"mode\",\n type: \"type\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSegmentButton_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSegmentButton.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonSegmentButton = __decorate([ProxyCmp({\n inputs: [\"disabled\", \"layout\", \"mode\", \"type\", \"value\"]\n})], IonSegmentButton);\nlet IonSelect = class IonSelect {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionChange\", \"ionCancel\", \"ionFocus\", \"ionBlur\"]);\n }\n};\nIonSelect.ɵfac = function IonSelect_Factory(t) {\n return new (t || IonSelect)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSelect.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSelect,\n selectors: [[\"ion-select\"]],\n inputs: {\n cancelText: \"cancelText\",\n compareWith: \"compareWith\",\n disabled: \"disabled\",\n interface: \"interface\",\n interfaceOptions: \"interfaceOptions\",\n mode: \"mode\",\n multiple: \"multiple\",\n name: \"name\",\n okText: \"okText\",\n placeholder: \"placeholder\",\n selectedText: \"selectedText\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSelect_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSelect.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonSelect = __decorate([ProxyCmp({\n inputs: [\"cancelText\", \"compareWith\", \"disabled\", \"interface\", \"interfaceOptions\", \"mode\", \"multiple\", \"name\", \"okText\", \"placeholder\", \"selectedText\", \"value\"],\n \"methods\": [\"open\"]\n})], IonSelect);\nlet IonSelectOption = class IonSelectOption {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonSelectOption.ɵfac = function IonSelectOption_Factory(t) {\n return new (t || IonSelectOption)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSelectOption.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSelectOption,\n selectors: [[\"ion-select-option\"]],\n inputs: {\n disabled: \"disabled\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSelectOption_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSelectOption.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonSelectOption = __decorate([ProxyCmp({\n inputs: [\"disabled\", \"value\"]\n})], IonSelectOption);\nlet IonSkeletonText = class IonSkeletonText {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonSkeletonText.ɵfac = function IonSkeletonText_Factory(t) {\n return new (t || IonSkeletonText)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSkeletonText.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSkeletonText,\n selectors: [[\"ion-skeleton-text\"]],\n inputs: {\n animated: \"animated\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSkeletonText_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSkeletonText.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonSkeletonText = __decorate([ProxyCmp({\n inputs: [\"animated\"]\n})], IonSkeletonText);\nlet IonSlide = class IonSlide {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonSlide.ɵfac = function IonSlide_Factory(t) {\n return new (t || IonSlide)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSlide.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSlide,\n selectors: [[\"ion-slide\"]],\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSlide_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSlide.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nlet IonSlides = class IonSlides {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionSlidesDidLoad\", \"ionSlideTap\", \"ionSlideDoubleTap\", \"ionSlideWillChange\", \"ionSlideDidChange\", \"ionSlideNextStart\", \"ionSlidePrevStart\", \"ionSlideNextEnd\", \"ionSlidePrevEnd\", \"ionSlideTransitionStart\", \"ionSlideTransitionEnd\", \"ionSlideDrag\", \"ionSlideReachStart\", \"ionSlideReachEnd\", \"ionSlideTouchStart\", \"ionSlideTouchEnd\"]);\n }\n};\nIonSlides.ɵfac = function IonSlides_Factory(t) {\n return new (t || IonSlides)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSlides.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSlides,\n selectors: [[\"ion-slides\"]],\n inputs: {\n mode: \"mode\",\n options: \"options\",\n pager: \"pager\",\n scrollbar: \"scrollbar\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSlides_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSlides.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonSlides = __decorate([ProxyCmp({\n inputs: [\"mode\", \"options\", \"pager\", \"scrollbar\"],\n \"methods\": [\"update\", \"updateAutoHeight\", \"slideTo\", \"slideNext\", \"slidePrev\", \"getActiveIndex\", \"getPreviousIndex\", \"length\", \"isEnd\", \"isBeginning\", \"startAutoplay\", \"stopAutoplay\", \"lockSwipeToNext\", \"lockSwipeToPrev\", \"lockSwipes\", \"getSwiper\"]\n})], IonSlides);\nlet IonSpinner = class IonSpinner {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonSpinner.ɵfac = function IonSpinner_Factory(t) {\n return new (t || IonSpinner)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSpinner.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSpinner,\n selectors: [[\"ion-spinner\"]],\n inputs: {\n color: \"color\",\n duration: \"duration\",\n name: \"name\",\n paused: \"paused\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSpinner_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSpinner.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonSpinner = __decorate([ProxyCmp({\n inputs: [\"color\", \"duration\", \"name\", \"paused\"]\n})], IonSpinner);\nlet IonSplitPane = class IonSplitPane {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionSplitPaneVisible\"]);\n }\n};\nIonSplitPane.ɵfac = function IonSplitPane_Factory(t) {\n return new (t || IonSplitPane)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonSplitPane.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonSplitPane,\n selectors: [[\"ion-split-pane\"]],\n inputs: {\n contentId: \"contentId\",\n disabled: \"disabled\",\n when: \"when\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonSplitPane_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonSplitPane.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonSplitPane = __decorate([ProxyCmp({\n inputs: [\"contentId\", \"disabled\", \"when\"]\n})], IonSplitPane);\nlet IonTabBar = class IonTabBar {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonTabBar.ɵfac = function IonTabBar_Factory(t) {\n return new (t || IonTabBar)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonTabBar.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonTabBar,\n selectors: [[\"ion-tab-bar\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\",\n selectedTab: \"selectedTab\",\n translucent: \"translucent\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonTabBar_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonTabBar.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonTabBar = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\", \"selectedTab\", \"translucent\"]\n})], IonTabBar);\nlet IonTabButton = class IonTabButton {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonTabButton.ɵfac = function IonTabButton_Factory(t) {\n return new (t || IonTabButton)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonTabButton.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonTabButton,\n selectors: [[\"ion-tab-button\"]],\n inputs: {\n disabled: \"disabled\",\n download: \"download\",\n href: \"href\",\n layout: \"layout\",\n mode: \"mode\",\n rel: \"rel\",\n selected: \"selected\",\n tab: \"tab\",\n target: \"target\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonTabButton_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonTabButton.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonTabButton = __decorate([ProxyCmp({\n inputs: [\"disabled\", \"download\", \"href\", \"layout\", \"mode\", \"rel\", \"selected\", \"tab\", \"target\"]\n})], IonTabButton);\nlet IonText = class IonText {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonText.ɵfac = function IonText_Factory(t) {\n return new (t || IonText)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonText.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonText,\n selectors: [[\"ion-text\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonText_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonText.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonText = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\"]\n})], IonText);\nlet IonTextarea = class IonTextarea {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionChange\", \"ionInput\", \"ionBlur\", \"ionFocus\"]);\n }\n};\nIonTextarea.ɵfac = function IonTextarea_Factory(t) {\n return new (t || IonTextarea)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonTextarea.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonTextarea,\n selectors: [[\"ion-textarea\"]],\n inputs: {\n autoGrow: \"autoGrow\",\n autocapitalize: \"autocapitalize\",\n autofocus: \"autofocus\",\n clearOnEdit: \"clearOnEdit\",\n color: \"color\",\n cols: \"cols\",\n debounce: \"debounce\",\n disabled: \"disabled\",\n enterkeyhint: \"enterkeyhint\",\n inputmode: \"inputmode\",\n maxlength: \"maxlength\",\n minlength: \"minlength\",\n mode: \"mode\",\n name: \"name\",\n placeholder: \"placeholder\",\n readonly: \"readonly\",\n required: \"required\",\n rows: \"rows\",\n spellcheck: \"spellcheck\",\n value: \"value\",\n wrap: \"wrap\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonTextarea_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonTextarea.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonTextarea = __decorate([ProxyCmp({\n inputs: [\"autoGrow\", \"autocapitalize\", \"autofocus\", \"clearOnEdit\", \"color\", \"cols\", \"debounce\", \"disabled\", \"enterkeyhint\", \"inputmode\", \"maxlength\", \"minlength\", \"mode\", \"name\", \"placeholder\", \"readonly\", \"required\", \"rows\", \"spellcheck\", \"value\", \"wrap\"],\n \"methods\": [\"setFocus\", \"getInputElement\"]\n})], IonTextarea);\nlet IonThumbnail = class IonThumbnail {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonThumbnail.ɵfac = function IonThumbnail_Factory(t) {\n return new (t || IonThumbnail)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonThumbnail.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonThumbnail,\n selectors: [[\"ion-thumbnail\"]],\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonThumbnail_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonThumbnail.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nlet IonTitle = class IonTitle {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonTitle.ɵfac = function IonTitle_Factory(t) {\n return new (t || IonTitle)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonTitle.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonTitle,\n selectors: [[\"ion-title\"]],\n inputs: {\n color: \"color\",\n size: \"size\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonTitle_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonTitle.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonTitle = __decorate([ProxyCmp({\n inputs: [\"color\", \"size\"]\n})], IonTitle);\nlet IonToggle = class IonToggle {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n proxyOutputs(this, this.el, [\"ionChange\", \"ionFocus\", \"ionBlur\"]);\n }\n};\nIonToggle.ɵfac = function IonToggle_Factory(t) {\n return new (t || IonToggle)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonToggle.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonToggle,\n selectors: [[\"ion-toggle\"]],\n inputs: {\n checked: \"checked\",\n color: \"color\",\n disabled: \"disabled\",\n mode: \"mode\",\n name: \"name\",\n value: \"value\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonToggle_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonToggle.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonToggle = __decorate([ProxyCmp({\n inputs: [\"checked\", \"color\", \"disabled\", \"mode\", \"name\", \"value\"]\n})], IonToggle);\nlet IonToolbar = class IonToolbar {\n constructor(c, r, z) {\n this.z = z;\n c.detach();\n this.el = r.nativeElement;\n }\n};\nIonToolbar.ɵfac = function IonToolbar_Factory(t) {\n return new (t || IonToolbar)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone));\n};\nIonToolbar.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonToolbar,\n selectors: [[\"ion-toolbar\"]],\n inputs: {\n color: \"color\",\n mode: \"mode\"\n },\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonToolbar_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonToolbar.ctorParameters = () => [{\n type: ChangeDetectorRef\n}, {\n type: ElementRef\n}, {\n type: NgZone\n}];\nIonToolbar = __decorate([ProxyCmp({\n inputs: [\"color\", \"mode\"]\n})], IonToolbar);\nlet Config = class Config {\n get(key, fallback) {\n const c = getConfig();\n if (c) {\n return c.get(key, fallback);\n }\n return null;\n }\n getBoolean(key, fallback) {\n const c = getConfig();\n if (c) {\n return c.getBoolean(key, fallback);\n }\n return false;\n }\n getNumber(key, fallback) {\n const c = getConfig();\n if (c) {\n return c.getNumber(key, fallback);\n }\n return 0;\n }\n set(key, value) {\n console.warn(`[DEPRECATION][Config]: The Config.set() method is deprecated and will be removed in Ionic Framework 6.0. Please see https://ionicframework.com/docs/angular/config for alternatives.`);\n const c = getConfig();\n if (c) {\n c.set(key, value);\n }\n }\n};\nConfig.ɵfac = function Config_Factory(t) {\n return new (t || Config)();\n};\nConfig.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: Config,\n factory: function (t) {\n return Config.ɵfac(t);\n },\n providedIn: 'root'\n});\nConfig.ngInjectableDef = ɵɵdefineInjectable({\n factory: function Config_Factory() {\n return new Config();\n },\n token: Config,\n providedIn: \"root\"\n});\nconst ConfigToken = new InjectionToken('USERCONFIG');\nconst getConfig = () => {\n if (typeof window !== 'undefined') {\n const Ionic = window.Ionic;\n if (Ionic && Ionic.config) {\n return Ionic.config;\n }\n }\n return null;\n};\nconst ɵ0$3 = getConfig;\n\n/**\n * @description\n * NavParams are an object that exists on a page and can contain data for that particular view.\n * Similar to how data was pass to a view in V1 with `$stateParams`, NavParams offer a much more flexible\n * option with a simple `get` method.\n *\n * @usage\n * ```ts\n * import { NavParams } from '@ionic/angular';\n *\n * export class MyClass{\n *\n * constructor(navParams: NavParams){\n * // userParams is an object we have in our nav-parameters\n * navParams.get('userParams');\n * }\n *\n * }\n * ```\n */\nclass NavParams {\n constructor(data = {}) {\n this.data = data;\n }\n /**\n * Get the value of a nav-parameter for the current view\n *\n * ```ts\n * import { NavParams } from 'ionic-angular';\n *\n * export class MyClass{\n * constructor(public navParams: NavParams){\n * // userParams is an object we have in our nav-parameters\n * this.navParams.get('userParams');\n * }\n * }\n * ```\n *\n * @param param Which param you want to look up\n */\n get(param) {\n return this.data[param];\n }\n}\nlet AngularDelegate = class AngularDelegate {\n constructor(zone, appRef) {\n this.zone = zone;\n this.appRef = appRef;\n }\n create(resolver, injector, location) {\n return new AngularFrameworkDelegate(resolver, injector, location, this.appRef, this.zone);\n }\n};\nAngularDelegate.ɵfac = function AngularDelegate_Factory(t) {\n return new (t || AngularDelegate)(ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(ɵngcc0.ApplicationRef));\n};\nAngularDelegate.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: AngularDelegate,\n factory: function (t) {\n return AngularDelegate.ɵfac(t);\n }\n});\nAngularDelegate.ctorParameters = () => [{\n type: NgZone\n}, {\n type: ApplicationRef\n}];\nclass AngularFrameworkDelegate {\n constructor(resolver, injector, location, appRef, zone) {\n this.resolver = resolver;\n this.injector = injector;\n this.location = location;\n this.appRef = appRef;\n this.zone = zone;\n this.elRefMap = new WeakMap();\n this.elEventsMap = new WeakMap();\n }\n attachViewToDom(container, component, params, cssClasses) {\n return this.zone.run(() => {\n return new Promise(resolve => {\n const el = attachView(this.zone, this.resolver, this.injector, this.location, this.appRef, this.elRefMap, this.elEventsMap, container, component, params, cssClasses);\n resolve(el);\n });\n });\n }\n removeViewFromDom(_container, component) {\n return this.zone.run(() => {\n return new Promise(resolve => {\n const componentRef = this.elRefMap.get(component);\n if (componentRef) {\n componentRef.destroy();\n this.elRefMap.delete(component);\n const unbindEvents = this.elEventsMap.get(component);\n if (unbindEvents) {\n unbindEvents();\n this.elEventsMap.delete(component);\n }\n }\n resolve();\n });\n });\n }\n}\nconst attachView = (zone, resolver, injector, location, appRef, elRefMap, elEventsMap, container, component, params, cssClasses) => {\n const factory = resolver.resolveComponentFactory(component);\n const childInjector = Injector.create({\n providers: getProviders(params),\n parent: injector\n });\n const componentRef = location ? location.createComponent(factory, location.length, childInjector) : factory.create(childInjector);\n const instance = componentRef.instance;\n const hostElement = componentRef.location.nativeElement;\n if (params) {\n Object.assign(instance, params);\n }\n if (cssClasses) {\n for (const clazz of cssClasses) {\n hostElement.classList.add(clazz);\n }\n }\n const unbindEvents = bindLifecycleEvents(zone, instance, hostElement);\n container.appendChild(hostElement);\n if (!location) {\n appRef.attachView(componentRef.hostView);\n }\n componentRef.changeDetectorRef.reattach();\n elRefMap.set(hostElement, componentRef);\n elEventsMap.set(hostElement, unbindEvents);\n return hostElement;\n};\nconst LIFECYCLES = [LIFECYCLE_WILL_ENTER, LIFECYCLE_DID_ENTER, LIFECYCLE_WILL_LEAVE, LIFECYCLE_DID_LEAVE, LIFECYCLE_WILL_UNLOAD];\nconst bindLifecycleEvents = (zone, instance, element) => {\n return zone.run(() => {\n const unregisters = LIFECYCLES.filter(eventName => typeof instance[eventName] === 'function').map(eventName => {\n const handler = ev => instance[eventName](ev.detail);\n element.addEventListener(eventName, handler);\n return () => element.removeEventListener(eventName, handler);\n });\n return () => unregisters.forEach(fn => fn());\n });\n};\nconst NavParamsToken = new InjectionToken('NavParamsToken');\nconst getProviders = params => {\n return [{\n provide: NavParamsToken,\n useValue: params\n }, {\n provide: NavParams,\n useFactory: provideNavParamsInjectable,\n deps: [NavParamsToken]\n }];\n};\nconst ɵ0$4 = getProviders;\nconst provideNavParamsInjectable = params => {\n return new NavParams(params);\n};\nconst ɵ1$2 = provideNavParamsInjectable;\nconst insertView = (views, view, direction) => {\n if (direction === 'root') {\n return setRoot(views, view);\n } else if (direction === 'forward') {\n return setForward(views, view);\n } else {\n return setBack(views, view);\n }\n};\nconst setRoot = (views, view) => {\n views = views.filter(v => v.stackId !== view.stackId);\n views.push(view);\n return views;\n};\nconst ɵ0$5 = setRoot;\nconst setForward = (views, view) => {\n const index = views.indexOf(view);\n if (index >= 0) {\n views = views.filter(v => v.stackId !== view.stackId || v.id <= view.id);\n } else {\n views.push(view);\n }\n return views;\n};\nconst ɵ1$3 = setForward;\nconst setBack = (views, view) => {\n const index = views.indexOf(view);\n if (index >= 0) {\n return views.filter(v => v.stackId !== view.stackId || v.id <= view.id);\n } else {\n return setRoot(views, view);\n }\n};\nconst ɵ2$1 = setBack;\nconst getUrl = (router, activatedRoute) => {\n const urlTree = router.createUrlTree(['.'], {\n relativeTo: activatedRoute\n });\n return router.serializeUrl(urlTree);\n};\nconst isTabSwitch = (enteringView, leavingView) => {\n if (!leavingView) {\n return true;\n }\n return enteringView.stackId !== leavingView.stackId;\n};\nconst computeStackId = (prefixUrl, url) => {\n if (!prefixUrl) {\n return undefined;\n }\n const segments = toSegments(url);\n for (let i = 0; i < segments.length; i++) {\n if (i >= prefixUrl.length) {\n return segments[i];\n }\n if (segments[i] !== prefixUrl[i]) {\n return undefined;\n }\n }\n return undefined;\n};\nconst toSegments = path => {\n return path.split('/').map(s => s.trim()).filter(s => s !== '');\n};\nconst destroyView = view => {\n if (view) {\n // TODO lifecycle event\n view.ref.destroy();\n view.unlistenEvents();\n }\n};\nclass StackController {\n constructor(tabsPrefix, containerEl, router, navCtrl, zone, location) {\n this.containerEl = containerEl;\n this.router = router;\n this.navCtrl = navCtrl;\n this.zone = zone;\n this.location = location;\n this.views = [];\n this.skipTransition = false;\n this.nextId = 0;\n this.tabsPrefix = tabsPrefix !== undefined ? toSegments(tabsPrefix) : undefined;\n }\n createView(ref, activatedRoute) {\n const url = getUrl(this.router, activatedRoute);\n const element = ref && ref.location && ref.location.nativeElement;\n const unlistenEvents = bindLifecycleEvents(this.zone, ref.instance, element);\n return {\n id: this.nextId++,\n stackId: computeStackId(this.tabsPrefix, url),\n unlistenEvents,\n element,\n ref,\n url\n };\n }\n getExistingView(activatedRoute) {\n const activatedUrlKey = getUrl(this.router, activatedRoute);\n const view = this.views.find(vw => vw.url === activatedUrlKey);\n if (view) {\n view.ref.changeDetectorRef.reattach();\n }\n return view;\n }\n setActive(enteringView) {\n const consumeResult = this.navCtrl.consumeTransition();\n let {\n direction,\n animation,\n animationBuilder\n } = consumeResult;\n const leavingView = this.activeView;\n const tabSwitch = isTabSwitch(enteringView, leavingView);\n if (tabSwitch) {\n direction = 'back';\n animation = undefined;\n }\n const viewsSnapshot = this.views.slice();\n let currentNavigation;\n const router = this.router;\n // Angular >= 7.2.0\n if (router.getCurrentNavigation) {\n currentNavigation = router.getCurrentNavigation();\n // Angular < 7.2.0\n } else if (router.navigations && router.navigations.value) {\n currentNavigation = router.navigations.value;\n }\n /**\n * If the navigation action\n * sets `replaceUrl: true`\n * then we need to make sure\n * we remove the last item\n * from our views stack\n */\n if (currentNavigation && currentNavigation.extras && currentNavigation.extras.replaceUrl) {\n if (this.views.length > 0) {\n this.views.splice(-1, 1);\n }\n }\n const reused = this.views.includes(enteringView);\n const views = this.insertView(enteringView, direction);\n // Trigger change detection before transition starts\n // This will call ngOnInit() the first time too, just after the view\n // was attached to the dom, but BEFORE the transition starts\n if (!reused) {\n enteringView.ref.changeDetectorRef.detectChanges();\n }\n /**\n * If we are going back from a page that\n * was presented using a custom animation\n * we should default to using that\n * unless the developer explicitly\n * provided another animation.\n */\n const customAnimation = enteringView.animationBuilder;\n if (animationBuilder === undefined && direction === 'back' && !tabSwitch && customAnimation !== undefined) {\n animationBuilder = customAnimation;\n }\n /**\n * Save any custom animation so that navigating\n * back will use this custom animation by default.\n */\n if (leavingView) {\n leavingView.animationBuilder = animationBuilder;\n }\n // Wait until previous transitions finish\n return this.zone.runOutsideAngular(() => {\n return this.wait(() => {\n // disconnect leaving page from change detection to\n // reduce jank during the page transition\n if (leavingView) {\n leavingView.ref.changeDetectorRef.detach();\n }\n // In case the enteringView is the same as the leavingPage we need to reattach()\n enteringView.ref.changeDetectorRef.reattach();\n return this.transition(enteringView, leavingView, animation, this.canGoBack(1), false, animationBuilder).then(() => cleanupAsync(enteringView, views, viewsSnapshot, this.location)).then(() => ({\n enteringView,\n direction,\n animation,\n tabSwitch\n }));\n });\n });\n }\n canGoBack(deep, stackId = this.getActiveStackId()) {\n return this.getStack(stackId).length > deep;\n }\n pop(deep, stackId = this.getActiveStackId()) {\n return this.zone.run(() => {\n const views = this.getStack(stackId);\n if (views.length <= deep) {\n return Promise.resolve(false);\n }\n const view = views[views.length - deep - 1];\n let url = view.url;\n const viewSavedData = view.savedData;\n if (viewSavedData) {\n const primaryOutlet = viewSavedData.get('primary');\n if (primaryOutlet && primaryOutlet.route && primaryOutlet.route._routerState && primaryOutlet.route._routerState.snapshot && primaryOutlet.route._routerState.snapshot.url) {\n url = primaryOutlet.route._routerState.snapshot.url;\n }\n }\n const {\n animationBuilder\n } = this.navCtrl.consumeTransition();\n return this.navCtrl.navigateBack(url, Object.assign({}, view.savedExtras, {\n animation: animationBuilder\n })).then(() => true);\n });\n }\n startBackTransition() {\n const leavingView = this.activeView;\n if (leavingView) {\n const views = this.getStack(leavingView.stackId);\n const enteringView = views[views.length - 2];\n const customAnimation = enteringView.animationBuilder;\n return this.wait(() => {\n return this.transition(enteringView,\n // entering view\n leavingView,\n // leaving view\n 'back', this.canGoBack(2), true, customAnimation);\n });\n }\n return Promise.resolve();\n }\n endBackTransition(shouldComplete) {\n if (shouldComplete) {\n this.skipTransition = true;\n this.pop(1);\n } else if (this.activeView) {\n cleanup(this.activeView, this.views, this.views, this.location);\n }\n }\n getLastUrl(stackId) {\n const views = this.getStack(stackId);\n return views.length > 0 ? views[views.length - 1] : undefined;\n }\n /**\n * @internal\n */\n getRootUrl(stackId) {\n const views = this.getStack(stackId);\n return views.length > 0 ? views[0] : undefined;\n }\n getActiveStackId() {\n return this.activeView ? this.activeView.stackId : undefined;\n }\n hasRunningTask() {\n return this.runningTask !== undefined;\n }\n destroy() {\n this.containerEl = undefined;\n this.views.forEach(destroyView);\n this.activeView = undefined;\n this.views = [];\n }\n getStack(stackId) {\n return this.views.filter(v => v.stackId === stackId);\n }\n insertView(enteringView, direction) {\n this.activeView = enteringView;\n this.views = insertView(this.views, enteringView, direction);\n return this.views.slice();\n }\n transition(enteringView, leavingView, direction, showGoBack, progressAnimation, animationBuilder) {\n if (this.skipTransition) {\n this.skipTransition = false;\n return Promise.resolve(false);\n }\n if (leavingView === enteringView) {\n return Promise.resolve(false);\n }\n const enteringEl = enteringView ? enteringView.element : undefined;\n const leavingEl = leavingView ? leavingView.element : undefined;\n const containerEl = this.containerEl;\n if (enteringEl && enteringEl !== leavingEl) {\n enteringEl.classList.add('ion-page');\n enteringEl.classList.add('ion-page-invisible');\n if (enteringEl.parentElement !== containerEl) {\n containerEl.appendChild(enteringEl);\n }\n if (containerEl.commit) {\n return containerEl.commit(enteringEl, leavingEl, {\n deepWait: true,\n duration: direction === undefined ? 0 : undefined,\n direction,\n showGoBack,\n progressAnimation,\n animationBuilder\n });\n }\n }\n return Promise.resolve(false);\n }\n wait(task) {\n return __awaiter(this, void 0, void 0, function* () {\n if (this.runningTask !== undefined) {\n yield this.runningTask;\n this.runningTask = undefined;\n }\n const promise = this.runningTask = task();\n promise.finally(() => this.runningTask = undefined);\n return promise;\n });\n }\n}\nconst cleanupAsync = (activeRoute, views, viewsSnapshot, location) => {\n if (typeof requestAnimationFrame === 'function') {\n return new Promise(resolve => {\n requestAnimationFrame(() => {\n cleanup(activeRoute, views, viewsSnapshot, location);\n resolve();\n });\n });\n }\n return Promise.resolve();\n};\nconst ɵ0$6 = cleanupAsync;\nconst cleanup = (activeRoute, views, viewsSnapshot, location) => {\n viewsSnapshot.filter(view => !views.includes(view)).forEach(destroyView);\n views.forEach(view => {\n /**\n * In the event that a user navigated multiple\n * times in rapid succession, we want to make sure\n * we don't pre-emptively detach a view while\n * it is in mid-transition.\n *\n * In this instance we also do not care about query\n * params or fragments as it will be the same view regardless\n */\n const locationWithoutParams = location.path().split('?')[0];\n const locationWithoutFragment = locationWithoutParams.split('#')[0];\n if (view !== activeRoute && view.url !== locationWithoutFragment) {\n const element = view.element;\n element.setAttribute('aria-hidden', 'true');\n element.classList.add('ion-page-hidden');\n view.ref.changeDetectorRef.detach();\n }\n });\n};\nconst ɵ1$4 = cleanup;\nlet IonRouterOutlet = class IonRouterOutlet {\n constructor(parentContexts, location, resolver, name, tabs, config, navCtrl, commonLocation, elementRef, router, zone, activatedRoute, parentOutlet) {\n this.parentContexts = parentContexts;\n this.location = location;\n this.resolver = resolver;\n this.config = config;\n this.navCtrl = navCtrl;\n this.parentOutlet = parentOutlet;\n this.activated = null;\n this.activatedView = null;\n this._activatedRoute = null;\n // Maintain map of activated route proxies for each component instance\n this.proxyMap = new WeakMap();\n // Keep the latest activated route in a subject for the proxy routes to switch map to\n this.currentActivatedRoute$ = new BehaviorSubject(null);\n this.stackEvents = new EventEmitter();\n this.activateEvents = new EventEmitter();\n this.deactivateEvents = new EventEmitter();\n this.nativeEl = elementRef.nativeElement;\n this.name = name || PRIMARY_OUTLET;\n this.tabsPrefix = tabs === 'true' ? getUrl(router, activatedRoute) : undefined;\n this.stackCtrl = new StackController(this.tabsPrefix, this.nativeEl, router, navCtrl, zone, commonLocation);\n parentContexts.onChildOutletCreated(this.name, this);\n }\n set animation(animation) {\n this.nativeEl.animation = animation;\n }\n set animated(animated) {\n this.nativeEl.animated = animated;\n }\n set swipeGesture(swipe) {\n this._swipeGesture = swipe;\n this.nativeEl.swipeHandler = swipe ? {\n canStart: () => this.stackCtrl.canGoBack(1) && !this.stackCtrl.hasRunningTask(),\n onStart: () => this.stackCtrl.startBackTransition(),\n onEnd: shouldContinue => this.stackCtrl.endBackTransition(shouldContinue)\n } : undefined;\n }\n ngOnDestroy() {\n this.stackCtrl.destroy();\n }\n getContext() {\n return this.parentContexts.getContext(this.name);\n }\n ngOnInit() {\n if (!this.activated) {\n // If the outlet was not instantiated at the time the route got activated we need to populate\n // the outlet when it is initialized (ie inside a NgIf)\n const context = this.getContext();\n if (context && context.route) {\n this.activateWith(context.route, context.resolver || null);\n }\n }\n new Promise(resolve => componentOnReady(this.nativeEl, resolve)).then(() => {\n if (this._swipeGesture === undefined) {\n this.swipeGesture = this.config.getBoolean('swipeBackEnabled', this.nativeEl.mode === 'ios');\n }\n });\n }\n get isActivated() {\n return !!this.activated;\n }\n get component() {\n if (!this.activated) {\n throw new Error('Outlet is not activated');\n }\n return this.activated.instance;\n }\n get activatedRoute() {\n if (!this.activated) {\n throw new Error('Outlet is not activated');\n }\n return this._activatedRoute;\n }\n get activatedRouteData() {\n if (this._activatedRoute) {\n return this._activatedRoute.snapshot.data;\n }\n return {};\n }\n /**\n * Called when the `RouteReuseStrategy` instructs to detach the subtree\n */\n detach() {\n throw new Error('incompatible reuse strategy');\n }\n /**\n * Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree\n */\n attach(_ref, _activatedRoute) {\n throw new Error('incompatible reuse strategy');\n }\n deactivate() {\n if (this.activated) {\n if (this.activatedView) {\n const context = this.getContext();\n this.activatedView.savedData = new Map(context.children['contexts']);\n /**\n * Angular v11.2.10 introduced a change\n * where this route context is cleared out when\n * a router-outlet is deactivated, However,\n * we need this route information in order to\n * return a user back to the correct tab when\n * leaving and then going back to the tab context.\n */\n const primaryOutlet = this.activatedView.savedData.get('primary');\n if (primaryOutlet && context.route) {\n primaryOutlet.route = Object.assign({}, context.route);\n }\n /**\n * Ensure we are saving the NavigationExtras\n * data otherwise it will be lost\n */\n this.activatedView.savedExtras = {};\n if (context.route) {\n const contextSnapshot = context.route.snapshot;\n this.activatedView.savedExtras.queryParams = contextSnapshot.queryParams;\n this.activatedView.savedExtras.fragment = contextSnapshot.fragment;\n }\n }\n const c = this.component;\n this.activatedView = null;\n this.activated = null;\n this._activatedRoute = null;\n this.deactivateEvents.emit(c);\n }\n }\n activateWith(activatedRoute, resolver) {\n if (this.isActivated) {\n throw new Error('Cannot activate an already activated outlet');\n }\n this._activatedRoute = activatedRoute;\n let cmpRef;\n let enteringView = this.stackCtrl.getExistingView(activatedRoute);\n if (enteringView) {\n cmpRef = this.activated = enteringView.ref;\n const saved = enteringView.savedData;\n if (saved) {\n // self-restore\n const context = this.getContext();\n context.children['contexts'] = saved;\n }\n // Updated activated route proxy for this component\n this.updateActivatedRouteProxy(cmpRef.instance, activatedRoute);\n } else {\n const snapshot = activatedRoute._futureSnapshot;\n const component = snapshot.routeConfig.component;\n resolver = resolver || this.resolver;\n const factory = resolver.resolveComponentFactory(component);\n const childContexts = this.parentContexts.getOrCreateContext(this.name).children;\n // We create an activated route proxy object that will maintain future updates for this component\n // over its lifecycle in the stack.\n const component$ = new BehaviorSubject(null);\n const activatedRouteProxy = this.createActivatedRouteProxy(component$, activatedRoute);\n const injector = new OutletInjector(activatedRouteProxy, childContexts, this.location.injector);\n cmpRef = this.activated = this.location.createComponent(factory, this.location.length, injector);\n // Once the component is created we can push it to our local subject supplied to the proxy\n component$.next(cmpRef.instance);\n // Calling `markForCheck` to make sure we will run the change detection when the\n // `RouterOutlet` is inside a `ChangeDetectionStrategy.OnPush` component.\n enteringView = this.stackCtrl.createView(this.activated, activatedRoute);\n // Store references to the proxy by component\n this.proxyMap.set(cmpRef.instance, activatedRouteProxy);\n this.currentActivatedRoute$.next({\n component: cmpRef.instance,\n activatedRoute\n });\n }\n this.activatedView = enteringView;\n this.stackCtrl.setActive(enteringView).then(data => {\n this.navCtrl.setTopOutlet(this);\n this.activateEvents.emit(cmpRef.instance);\n this.stackEvents.emit(data);\n });\n }\n /**\n * Returns `true` if there are pages in the stack to go back.\n */\n canGoBack(deep = 1, stackId) {\n return this.stackCtrl.canGoBack(deep, stackId);\n }\n /**\n * Resolves to `true` if it the outlet was able to sucessfully pop the last N pages.\n */\n pop(deep = 1, stackId) {\n return this.stackCtrl.pop(deep, stackId);\n }\n /**\n * Returns the URL of the active page of each stack.\n */\n getLastUrl(stackId) {\n const active = this.stackCtrl.getLastUrl(stackId);\n return active ? active.url : undefined;\n }\n /**\n * Returns the RouteView of the active page of each stack.\n * @internal\n */\n getLastRouteView(stackId) {\n return this.stackCtrl.getLastUrl(stackId);\n }\n /**\n * Returns the root view in the tab stack.\n * @internal\n */\n getRootView(stackId) {\n return this.stackCtrl.getRootUrl(stackId);\n }\n /**\n * Returns the active stack ID. In the context of ion-tabs, it means the active tab.\n */\n getActiveStackId() {\n return this.stackCtrl.getActiveStackId();\n }\n /**\n * Since the activated route can change over the life time of a component in an ion router outlet, we create\n * a proxy so that we can update the values over time as a user navigates back to components already in the stack.\n */\n createActivatedRouteProxy(component$, activatedRoute) {\n const proxy = new ActivatedRoute();\n proxy._futureSnapshot = activatedRoute._futureSnapshot;\n proxy._routerState = activatedRoute._routerState;\n proxy.snapshot = activatedRoute.snapshot;\n proxy.outlet = activatedRoute.outlet;\n proxy.component = activatedRoute.component;\n // Setup wrappers for the observables so consumers don't have to worry about switching to new observables as the state updates\n proxy._paramMap = this.proxyObservable(component$, 'paramMap');\n proxy._queryParamMap = this.proxyObservable(component$, 'queryParamMap');\n proxy.url = this.proxyObservable(component$, 'url');\n proxy.params = this.proxyObservable(component$, 'params');\n proxy.queryParams = this.proxyObservable(component$, 'queryParams');\n proxy.fragment = this.proxyObservable(component$, 'fragment');\n proxy.data = this.proxyObservable(component$, 'data');\n return proxy;\n }\n /**\n * Create a wrapped observable that will switch to the latest activated route matched by the given component\n */\n proxyObservable(component$, path) {\n return component$.pipe(\n // First wait until the component instance is pushed\n filter(component => !!component), switchMap(component => this.currentActivatedRoute$.pipe(filter(current => current !== null && current.component === component), switchMap(current => current && current.activatedRoute[path]), distinctUntilChanged())));\n }\n /**\n * Updates the activated route proxy for the given component to the new incoming router state\n */\n updateActivatedRouteProxy(component, activatedRoute) {\n const proxy = this.proxyMap.get(component);\n if (!proxy) {\n throw new Error(`Could not find activated route proxy for view`);\n }\n proxy._futureSnapshot = activatedRoute._futureSnapshot;\n proxy._routerState = activatedRoute._routerState;\n proxy.snapshot = activatedRoute.snapshot;\n proxy.outlet = activatedRoute.outlet;\n proxy.component = activatedRoute.component;\n this.currentActivatedRoute$.next({\n component,\n activatedRoute\n });\n }\n};\nIonRouterOutlet.ɵfac = function IonRouterOutlet_Factory(t) {\n return new (t || IonRouterOutlet)(ɵngcc0.ɵɵdirectiveInject(ɵngcc2.ChildrenOutletContexts), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵinjectAttribute('name'), ɵngcc0.ɵɵinjectAttribute('tabs'), ɵngcc0.ɵɵdirectiveInject(Config), ɵngcc0.ɵɵdirectiveInject(NavController), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Location), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.Router), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.ActivatedRoute), ɵngcc0.ɵɵdirectiveInject(IonRouterOutlet, 12));\n};\nIonRouterOutlet.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: IonRouterOutlet,\n selectors: [[\"ion-router-outlet\"]],\n inputs: {\n animated: \"animated\",\n animation: \"animation\",\n swipeGesture: \"swipeGesture\"\n },\n outputs: {\n stackEvents: \"stackEvents\",\n activateEvents: \"activate\",\n deactivateEvents: \"deactivate\"\n },\n exportAs: [\"outlet\"]\n});\nIonRouterOutlet.ctorParameters = () => [{\n type: ChildrenOutletContexts\n}, {\n type: ViewContainerRef\n}, {\n type: ComponentFactoryResolver\n}, {\n type: String,\n decorators: [{\n type: Attribute,\n args: ['name']\n }]\n}, {\n type: String,\n decorators: [{\n type: Optional\n }, {\n type: Attribute,\n args: ['tabs']\n }]\n}, {\n type: Config\n}, {\n type: NavController\n}, {\n type: Location\n}, {\n type: ElementRef\n}, {\n type: Router\n}, {\n type: NgZone\n}, {\n type: ActivatedRoute\n}, {\n type: IonRouterOutlet,\n decorators: [{\n type: SkipSelf\n }, {\n type: Optional\n }]\n}];\n__decorate([Output()], IonRouterOutlet.prototype, \"stackEvents\", void 0);\n__decorate([Output('activate')], IonRouterOutlet.prototype, \"activateEvents\", void 0);\n__decorate([Output('deactivate')], IonRouterOutlet.prototype, \"deactivateEvents\", void 0);\nIonRouterOutlet = __decorate([__param(3, Attribute('name')), __param(4, Optional()), __param(4, Attribute('tabs')), __param(12, SkipSelf()), __param(12, Optional())], IonRouterOutlet);\nclass OutletInjector {\n constructor(route, childContexts, parent) {\n this.route = route;\n this.childContexts = childContexts;\n this.parent = parent;\n }\n get(token, notFoundValue) {\n if (token === ActivatedRoute) {\n return this.route;\n }\n if (token === ChildrenOutletContexts) {\n return this.childContexts;\n }\n // tslint:disable-next-line\n return this.parent.get(token, notFoundValue);\n }\n}\nlet IonTabs = class IonTabs {\n constructor(navCtrl) {\n this.navCtrl = navCtrl;\n this.ionTabsWillChange = new EventEmitter();\n this.ionTabsDidChange = new EventEmitter();\n }\n /**\n * @internal\n */\n onPageSelected(detail) {\n const stackId = detail.enteringView.stackId;\n if (detail.tabSwitch && stackId !== undefined) {\n if (this.tabBar) {\n this.tabBar.selectedTab = stackId;\n }\n this.ionTabsWillChange.emit({\n tab: stackId\n });\n this.ionTabsDidChange.emit({\n tab: stackId\n });\n }\n }\n /**\n * When a tab button is clicked, there are several scenarios:\n * 1. If the selected tab is currently active (the tab button has been clicked\n * again), then it should go to the root view for that tab.\n *\n * a. Get the saved root view from the router outlet. If the saved root view\n * matches the tabRootUrl, set the route view to this view including the\n * navigation extras.\n * b. If the saved root view from the router outlet does\n * not match, navigate to the tabRootUrl. No navigation extras are\n * included.\n *\n * 2. If the current tab tab is not currently selected, get the last route\n * view from the router outlet.\n *\n * a. If the last route view exists, navigate to that view including any\n * navigation extras\n * b. If the last route view doesn't exist, then navigate\n * to the default tabRootUrl\n */\n select(tabOrEvent) {\n const isTabString = typeof tabOrEvent === 'string';\n const tab = isTabString ? tabOrEvent : tabOrEvent.detail.tab;\n const alreadySelected = this.outlet.getActiveStackId() === tab;\n const tabRootUrl = `${this.outlet.tabsPrefix}/${tab}`;\n /**\n * If this is a nested tab, prevent the event\n * from bubbling otherwise the outer tabs\n * will respond to this event too, causing\n * the app to get directed to the wrong place.\n */\n if (!isTabString) {\n tabOrEvent.stopPropagation();\n }\n if (alreadySelected) {\n const activeStackId = this.outlet.getActiveStackId();\n const activeView = this.outlet.getLastRouteView(activeStackId);\n // If on root tab, do not navigate to root tab again\n if (activeView.url === tabRootUrl) {\n return;\n }\n const rootView = this.outlet.getRootView(tab);\n const navigationExtras = rootView && tabRootUrl === rootView.url && rootView.savedExtras;\n return this.navCtrl.navigateRoot(tabRootUrl, Object.assign({}, navigationExtras, {\n animated: true,\n animationDirection: 'back'\n }));\n } else {\n const lastRoute = this.outlet.getLastRouteView(tab);\n /**\n * If there is a lastRoute, goto that, otherwise goto the fallback url of the\n * selected tab\n */\n const url = lastRoute && lastRoute.url || tabRootUrl;\n const navigationExtras = lastRoute && lastRoute.savedExtras;\n return this.navCtrl.navigateRoot(url, Object.assign({}, navigationExtras, {\n animated: true,\n animationDirection: 'back'\n }));\n }\n }\n getSelected() {\n return this.outlet.getActiveStackId();\n }\n};\nIonTabs.ɵfac = function IonTabs_Factory(t) {\n return new (t || IonTabs)(ɵngcc0.ɵɵdirectiveInject(NavController));\n};\nIonTabs.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonTabs,\n selectors: [[\"ion-tabs\"]],\n contentQueries: function IonTabs_ContentQueries(rf, ctx, dirIndex) {\n if (rf & 1) {\n ɵngcc0.ɵɵcontentQuery(dirIndex, IonTabBar, 5);\n }\n if (rf & 2) {\n let _t;\n ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.tabBar = _t.first);\n }\n },\n viewQuery: function IonTabs_Query(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵviewQuery(_c1, 5, IonRouterOutlet);\n }\n if (rf & 2) {\n let _t;\n ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.outlet = _t.first);\n }\n },\n hostBindings: function IonTabs_HostBindings(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"ionTabButtonClick\", function IonTabs_ionTabButtonClick_HostBindingHandler($event) {\n return ctx.select($event);\n });\n }\n },\n outputs: {\n ionTabsWillChange: \"ionTabsWillChange\",\n ionTabsDidChange: \"ionTabsDidChange\"\n },\n ngContentSelectors: _c3,\n decls: 5,\n vars: 0,\n consts: [[1, \"tabs-inner\"], [\"tabs\", \"true\", 3, \"stackEvents\"], [\"outlet\", \"\"]],\n template: function IonTabs_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef(_c2);\n ɵngcc0.ɵɵprojection(0);\n ɵngcc0.ɵɵelementStart(1, \"div\", 0)(2, \"ion-router-outlet\", 1, 2);\n ɵngcc0.ɵɵlistener(\"stackEvents\", function IonTabs_Template_ion_router_outlet_stackEvents_2_listener($event) {\n return ctx.onPageSelected($event);\n });\n ɵngcc0.ɵɵelementEnd()();\n ɵngcc0.ɵɵprojection(4, 1);\n }\n },\n dependencies: [IonRouterOutlet],\n styles: [\"[_nghost-%COMP%] {\\n display: flex;\\n position: absolute;\\n top: 0;\\n left: 0;\\n right: 0;\\n bottom: 0;\\n\\n flex-direction: column;\\n\\n width: 100%;\\n height: 100%;\\n\\n contain: layout size style;\\n z-index: $z-index-page-container;\\n }\\n .tabs-inner[_ngcontent-%COMP%] {\\n position: relative;\\n\\n flex: 1;\\n\\n contain: layout size style;\\n }\"]\n});\nIonTabs.ctorParameters = () => [{\n type: NavController\n}];\n__decorate([ViewChild('outlet', {\n read: IonRouterOutlet,\n static: false\n})], IonTabs.prototype, \"outlet\", void 0);\n__decorate([ContentChild(IonTabBar, {\n static: false\n})], IonTabs.prototype, \"tabBar\", void 0);\n__decorate([Output()], IonTabs.prototype, \"ionTabsWillChange\", void 0);\n__decorate([Output()], IonTabs.prototype, \"ionTabsDidChange\", void 0);\n__decorate([HostListener('ionTabButtonClick', ['$event'])], IonTabs.prototype, \"select\", null);\nlet IonBackButtonDelegate = class IonBackButtonDelegate {\n constructor(routerOutlet, navCtrl, config) {\n this.routerOutlet = routerOutlet;\n this.navCtrl = navCtrl;\n this.config = config;\n }\n /**\n * @internal\n */\n onClick(ev) {\n const defaultHref = this.defaultHref || this.config.get('backButtonDefaultHref');\n if (this.routerOutlet && this.routerOutlet.canGoBack()) {\n this.navCtrl.setDirection('back', undefined, undefined, this.routerAnimation);\n this.routerOutlet.pop();\n ev.preventDefault();\n } else if (defaultHref != null) {\n this.navCtrl.navigateBack(defaultHref, {\n animation: this.routerAnimation\n });\n ev.preventDefault();\n }\n }\n};\nIonBackButtonDelegate.ɵfac = function IonBackButtonDelegate_Factory(t) {\n return new (t || IonBackButtonDelegate)(ɵngcc0.ɵɵdirectiveInject(IonRouterOutlet, 8), ɵngcc0.ɵɵdirectiveInject(NavController), ɵngcc0.ɵɵdirectiveInject(Config));\n};\nIonBackButtonDelegate.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: IonBackButtonDelegate,\n selectors: [[\"ion-back-button\"]],\n hostBindings: function IonBackButtonDelegate_HostBindings(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"click\", function IonBackButtonDelegate_click_HostBindingHandler($event) {\n return ctx.onClick($event);\n });\n }\n },\n inputs: {\n defaultHref: \"defaultHref\",\n routerAnimation: \"routerAnimation\"\n }\n});\nIonBackButtonDelegate.ctorParameters = () => [{\n type: IonRouterOutlet,\n decorators: [{\n type: Optional\n }]\n}, {\n type: NavController\n}, {\n type: Config\n}];\n__decorate([HostListener('click', ['$event'])], IonBackButtonDelegate.prototype, \"onClick\", null);\nIonBackButtonDelegate = __decorate([__param(0, Optional())], IonBackButtonDelegate);\nlet NavDelegate = class NavDelegate {\n constructor(ref, resolver, injector, angularDelegate, location) {\n this.el = ref.nativeElement;\n ref.nativeElement.delegate = angularDelegate.create(resolver, injector, location);\n proxyOutputs(this, this.el, ['ionNavDidChange', 'ionNavWillChange']);\n }\n};\nNavDelegate.ɵfac = function NavDelegate_Factory(t) {\n return new (t || NavDelegate)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Injector), ɵngcc0.ɵɵdirectiveInject(AngularDelegate), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef));\n};\nNavDelegate.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: NavDelegate,\n selectors: [[\"ion-nav\"]]\n});\nNavDelegate.ctorParameters = () => [{\n type: ElementRef\n}, {\n type: ComponentFactoryResolver\n}, {\n type: Injector\n}, {\n type: AngularDelegate\n}, {\n type: ViewContainerRef\n}];\nNavDelegate = __decorate([ProxyCmp({\n inputs: ['animated', 'animation', 'root', 'rootParams', 'swipeGesture'],\n methods: ['push', 'insert', 'insertPages', 'pop', 'popTo', 'popToRoot', 'removeIndex', 'setRoot', 'setPages', 'getActive', 'getByIndex', 'canGoBack', 'getPrevious']\n})], NavDelegate);\nlet RouterLinkDelegate = class RouterLinkDelegate {\n constructor(locationStrategy, navCtrl, elementRef, router, routerLink) {\n this.locationStrategy = locationStrategy;\n this.navCtrl = navCtrl;\n this.elementRef = elementRef;\n this.router = router;\n this.routerLink = routerLink;\n this.routerDirection = 'forward';\n }\n ngOnInit() {\n this.updateTargetUrlAndHref();\n }\n ngOnChanges() {\n this.updateTargetUrlAndHref();\n }\n ngOnDestroy() {\n if (this.subscription) {\n this.subscription.unsubscribe();\n }\n }\n updateTargetUrlAndHref() {\n if (this.routerLink) {\n const href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.routerLink.urlTree));\n this.elementRef.nativeElement.href = href;\n }\n }\n /**\n * @internal\n */\n onClick(ev) {\n this.navCtrl.setDirection(this.routerDirection, undefined, undefined, this.routerAnimation);\n ev.preventDefault();\n }\n};\nRouterLinkDelegate.ɵfac = function RouterLinkDelegate_Factory(t) {\n return new (t || RouterLinkDelegate)(ɵngcc0.ɵɵdirectiveInject(ɵngcc1.LocationStrategy), ɵngcc0.ɵɵdirectiveInject(NavController), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.Router), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.RouterLink, 8));\n};\nRouterLinkDelegate.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: RouterLinkDelegate,\n selectors: [[\"\", \"routerLink\", \"\"]],\n hostBindings: function RouterLinkDelegate_HostBindings(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵlistener(\"click\", function RouterLinkDelegate_click_HostBindingHandler($event) {\n return ctx.onClick($event);\n });\n }\n },\n inputs: {\n routerDirection: \"routerDirection\",\n routerAnimation: \"routerAnimation\"\n },\n features: [ɵngcc0.ɵɵNgOnChangesFeature]\n});\nRouterLinkDelegate.ctorParameters = () => [{\n type: LocationStrategy\n}, {\n type: NavController\n}, {\n type: ElementRef\n}, {\n type: Router\n}, {\n type: RouterLink,\n decorators: [{\n type: Optional\n }]\n}];\n__decorate([HostListener('click', ['$event'])], RouterLinkDelegate.prototype, \"onClick\", null);\nRouterLinkDelegate = __decorate([__param(4, Optional())], RouterLinkDelegate);\n\n/**\n * @hidden\n */\nlet VirtualFooter = class VirtualFooter {\n constructor(templateRef) {\n this.templateRef = templateRef;\n }\n};\nVirtualFooter.ɵfac = function VirtualFooter_Factory(t) {\n return new (t || VirtualFooter)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef));\n};\nVirtualFooter.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: VirtualFooter,\n selectors: [[\"\", \"virtualFooter\", \"\"]]\n});\nVirtualFooter.ctorParameters = () => [{\n type: TemplateRef\n}];\n\n/**\n * @hidden\n */\nlet VirtualHeader = class VirtualHeader {\n constructor(templateRef) {\n this.templateRef = templateRef;\n }\n};\nVirtualHeader.ɵfac = function VirtualHeader_Factory(t) {\n return new (t || VirtualHeader)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef));\n};\nVirtualHeader.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: VirtualHeader,\n selectors: [[\"\", \"virtualHeader\", \"\"]]\n});\nVirtualHeader.ctorParameters = () => [{\n type: TemplateRef\n}];\n\n/**\n * @hidden\n */\nlet VirtualItem = class VirtualItem {\n constructor(templateRef, viewContainer) {\n this.templateRef = templateRef;\n this.viewContainer = viewContainer;\n }\n};\nVirtualItem.ɵfac = function VirtualItem_Factory(t) {\n return new (t || VirtualItem)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef));\n};\nVirtualItem.ɵdir = /*@__PURE__*/ɵngcc0.ɵɵdefineDirective({\n type: VirtualItem,\n selectors: [[\"\", \"virtualItem\", \"\"]]\n});\nVirtualItem.ctorParameters = () => [{\n type: TemplateRef\n}, {\n type: ViewContainerRef\n}];\nlet IonVirtualScroll = class IonVirtualScroll {\n constructor(z, iterableDiffers, elementRef) {\n this.z = z;\n this.iterableDiffers = iterableDiffers;\n this.refMap = new WeakMap();\n this.el = elementRef.nativeElement;\n this.el.nodeRender = this.nodeRender.bind(this);\n }\n ngOnChanges(changes) {\n if (this.trackBy && 'items' in changes) {\n // React on virtualScroll changes only once all inputs have been initialized\n const value = changes['items'].currentValue;\n if (this.differ === undefined && value != null) {\n try {\n this.differ = this.iterableDiffers.find(value).create(this.trackBy);\n } catch (e) {\n throw new Error(`Cannot find a differ supporting object '${value}'. VirtualScroll only supports binding to Iterables such as Arrays.`);\n }\n }\n }\n }\n ngDoCheck() {\n // and if there actually are changes\n const changes = this.differ !== undefined && this.items ? this.differ.diff(this.items) : null;\n if (changes === null) {\n return;\n }\n // TODO: optimize\n this.checkRange(0);\n }\n nodeRender(el, cell, index) {\n return this.z.run(() => {\n let node;\n if (!el) {\n node = this.itmTmp.viewContainer.createEmbeddedView(this.getComponent(cell.type), {\n $implicit: cell.value,\n index\n }, index);\n el = getElement(node);\n this.refMap.set(el, node);\n } else {\n node = this.refMap.get(el);\n const ctx = node.context;\n ctx.$implicit = cell.value;\n ctx.index = cell.index;\n }\n // run sync change detections\n node.detectChanges();\n return el;\n });\n }\n getComponent(type) {\n switch (type) {\n case 'item':\n return this.itmTmp.templateRef;\n case 'header':\n return this.hdrTmp.templateRef;\n case 'footer':\n return this.ftrTmp.templateRef;\n }\n throw new Error('template for virtual item was not provided');\n }\n};\nIonVirtualScroll.ɵfac = function IonVirtualScroll_Factory(t) {\n return new (t || IonVirtualScroll)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.IterableDiffers), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef));\n};\nIonVirtualScroll.ɵcmp = /*@__PURE__*/ɵngcc0.ɵɵdefineComponent({\n type: IonVirtualScroll,\n selectors: [[\"ion-virtual-scroll\"]],\n contentQueries: function IonVirtualScroll_ContentQueries(rf, ctx, dirIndex) {\n if (rf & 1) {\n ɵngcc0.ɵɵcontentQuery(dirIndex, VirtualItem, 5);\n ɵngcc0.ɵɵcontentQuery(dirIndex, VirtualHeader, 5);\n ɵngcc0.ɵɵcontentQuery(dirIndex, VirtualFooter, 5);\n }\n if (rf & 2) {\n let _t;\n ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.itmTmp = _t.first);\n ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.hdrTmp = _t.first);\n ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.ftrTmp = _t.first);\n }\n },\n inputs: {\n approxItemHeight: \"approxItemHeight\",\n approxHeaderHeight: \"approxHeaderHeight\",\n approxFooterHeight: \"approxFooterHeight\",\n headerFn: \"headerFn\",\n footerFn: \"footerFn\",\n items: \"items\",\n itemHeight: \"itemHeight\",\n headerHeight: \"headerHeight\",\n footerHeight: \"footerHeight\",\n trackBy: \"trackBy\"\n },\n features: [ɵngcc0.ɵɵNgOnChangesFeature],\n ngContentSelectors: _c0,\n decls: 1,\n vars: 0,\n template: function IonVirtualScroll_Template(rf, ctx) {\n if (rf & 1) {\n ɵngcc0.ɵɵprojectionDef();\n ɵngcc0.ɵɵprojection(0);\n }\n },\n encapsulation: 2,\n changeDetection: 0\n});\nIonVirtualScroll.ctorParameters = () => [{\n type: NgZone\n}, {\n type: IterableDiffers\n}, {\n type: ElementRef\n}];\n__decorate([ContentChild(VirtualItem, {\n static: false\n})], IonVirtualScroll.prototype, \"itmTmp\", void 0);\n__decorate([ContentChild(VirtualHeader, {\n static: false\n})], IonVirtualScroll.prototype, \"hdrTmp\", void 0);\n__decorate([ContentChild(VirtualFooter, {\n static: false\n})], IonVirtualScroll.prototype, \"ftrTmp\", void 0);\nIonVirtualScroll = __decorate([ProxyCmp({\n inputs: ['approxItemHeight', 'approxHeaderHeight', 'approxFooterHeight', 'headerFn', 'footerFn', 'items', 'itemHeight', 'headerHeight', 'footerHeight'],\n methods: ['checkEnd', 'checkRange', 'positionForItem']\n})], IonVirtualScroll);\nconst getElement = view => {\n const rootNodes = view.rootNodes;\n for (let i = 0; i < rootNodes.length; i++) {\n if (rootNodes[i].nodeType === 1) {\n return rootNodes[i];\n }\n }\n throw new Error('virtual element was not created');\n};\nconst ɵ0$7 = getElement;\nclass OverlayBaseController {\n constructor(ctrl) {\n this.ctrl = ctrl;\n }\n /**\n * Creates a new overlay\n */\n create(opts) {\n // TODO: next major release opts is not optional\n return this.ctrl.create(opts || {});\n }\n /**\n * When `id` is not provided, it dismisses the top overlay.\n */\n dismiss(data, role, id) {\n return this.ctrl.dismiss(data, role, id);\n }\n /**\n * Returns the top overlay.\n */\n getTop() {\n return this.ctrl.getTop();\n }\n}\nlet ActionSheetController = class ActionSheetController extends OverlayBaseController {\n constructor() {\n super(actionSheetController);\n }\n};\nActionSheetController.ɵfac = function ActionSheetController_Factory(t) {\n return new (t || ActionSheetController)();\n};\nActionSheetController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: ActionSheetController,\n factory: function (t) {\n return ActionSheetController.ɵfac(t);\n },\n providedIn: 'root'\n});\nActionSheetController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function ActionSheetController_Factory() {\n return new ActionSheetController();\n },\n token: ActionSheetController,\n providedIn: \"root\"\n});\nlet AlertController = class AlertController extends OverlayBaseController {\n constructor() {\n super(alertController);\n }\n};\nAlertController.ɵfac = function AlertController_Factory(t) {\n return new (t || AlertController)();\n};\nAlertController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: AlertController,\n factory: function (t) {\n return AlertController.ɵfac(t);\n },\n providedIn: 'root'\n});\nAlertController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function AlertController_Factory() {\n return new AlertController();\n },\n token: AlertController,\n providedIn: \"root\"\n});\nlet LoadingController = class LoadingController extends OverlayBaseController {\n constructor() {\n super(loadingController);\n }\n};\nLoadingController.ɵfac = function LoadingController_Factory(t) {\n return new (t || LoadingController)();\n};\nLoadingController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: LoadingController,\n factory: function (t) {\n return LoadingController.ɵfac(t);\n },\n providedIn: 'root'\n});\nLoadingController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function LoadingController_Factory() {\n return new LoadingController();\n },\n token: LoadingController,\n providedIn: \"root\"\n});\nlet MenuController = class MenuController {\n /**\n * Programmatically open the Menu.\n * @param [menuId] Optionally get the menu by its id, or side.\n * @return returns a promise when the menu is fully opened\n */\n open(menuId) {\n return menuController.open(menuId);\n }\n /**\n * Programmatically close the Menu. If no `menuId` is given as the first\n * argument then it'll close any menu which is open. If a `menuId`\n * is given then it'll close that exact menu.\n * @param [menuId] Optionally get the menu by its id, or side.\n * @return returns a promise when the menu is fully closed\n */\n close(menuId) {\n return menuController.close(menuId);\n }\n /**\n * Toggle the menu. If it's closed, it will open, and if opened, it\n * will close.\n * @param [menuId] Optionally get the menu by its id, or side.\n * @return returns a promise when the menu has been toggled\n */\n toggle(menuId) {\n return menuController.toggle(menuId);\n }\n /**\n * Used to enable or disable a menu. For example, there could be multiple\n * left menus, but only one of them should be able to be opened at the same\n * time. If there are multiple menus on the same side, then enabling one menu\n * will also automatically disable all the others that are on the same side.\n * @param [menuId] Optionally get the menu by its id, or side.\n * @return Returns the instance of the menu, which is useful for chaining.\n */\n enable(shouldEnable, menuId) {\n return menuController.enable(shouldEnable, menuId);\n }\n /**\n * Used to enable or disable the ability to swipe open the menu.\n * @param shouldEnable True if it should be swipe-able, false if not.\n * @param [menuId] Optionally get the menu by its id, or side.\n * @return Returns the instance of the menu, which is useful for chaining.\n */\n swipeGesture(shouldEnable, menuId) {\n return menuController.swipeGesture(shouldEnable, menuId);\n }\n /**\n * @param [menuId] Optionally get the menu by its id, or side.\n * @return Returns true if the specified menu is currently open, otherwise false.\n * If the menuId is not specified, it returns true if ANY menu is currenly open.\n */\n isOpen(menuId) {\n return menuController.isOpen(menuId);\n }\n /**\n * @param [menuId] Optionally get the menu by its id, or side.\n * @return Returns true if the menu is currently enabled, otherwise false.\n */\n isEnabled(menuId) {\n return menuController.isEnabled(menuId);\n }\n /**\n * Used to get a menu instance. If a `menuId` is not provided then it'll\n * return the first menu found. If a `menuId` is `left` or `right`, then\n * it'll return the enabled menu on that side. Otherwise, if a `menuId` is\n * provided, then it'll try to find the menu using the menu's `id`\n * property. If a menu is not found then it'll return `null`.\n * @param [menuId] Optionally get the menu by its id, or side.\n * @return Returns the instance of the menu if found, otherwise `null`.\n */\n get(menuId) {\n return menuController.get(menuId);\n }\n /**\n * @return Returns the instance of the menu already opened, otherwise `null`.\n */\n getOpen() {\n return menuController.getOpen();\n }\n /**\n * @return Returns an array of all menu instances.\n */\n getMenus() {\n return menuController.getMenus();\n }\n};\nMenuController.ɵfac = function MenuController_Factory(t) {\n return new (t || MenuController)();\n};\nMenuController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: MenuController,\n factory: function (t) {\n return MenuController.ɵfac(t);\n },\n providedIn: 'root'\n});\nMenuController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function MenuController_Factory() {\n return new MenuController();\n },\n token: MenuController,\n providedIn: \"root\"\n});\nlet PickerController = class PickerController extends OverlayBaseController {\n constructor() {\n super(pickerController);\n }\n};\nPickerController.ɵfac = function PickerController_Factory(t) {\n return new (t || PickerController)();\n};\nPickerController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: PickerController,\n factory: function (t) {\n return PickerController.ɵfac(t);\n },\n providedIn: 'root'\n});\nPickerController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function PickerController_Factory() {\n return new PickerController();\n },\n token: PickerController,\n providedIn: \"root\"\n});\nlet ModalController = class ModalController extends OverlayBaseController {\n constructor(angularDelegate, resolver, injector) {\n super(modalController);\n this.angularDelegate = angularDelegate;\n this.resolver = resolver;\n this.injector = injector;\n }\n create(opts) {\n return super.create(Object.assign({}, opts, {\n delegate: this.angularDelegate.create(this.resolver, this.injector)\n }));\n }\n};\nModalController.ɵfac = function ModalController_Factory(t) {\n return new (t || ModalController)(ɵngcc0.ɵɵinject(AngularDelegate), ɵngcc0.ɵɵinject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵinject(ɵngcc0.Injector));\n};\nModalController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: ModalController,\n factory: function (t) {\n return ModalController.ɵfac(t);\n }\n});\nModalController.ctorParameters = () => [{\n type: AngularDelegate\n}, {\n type: ComponentFactoryResolver\n}, {\n type: Injector\n}];\nlet PopoverController = class PopoverController extends OverlayBaseController {\n constructor(angularDelegate, resolver, injector) {\n super(popoverController);\n this.angularDelegate = angularDelegate;\n this.resolver = resolver;\n this.injector = injector;\n }\n create(opts) {\n return super.create(Object.assign({}, opts, {\n delegate: this.angularDelegate.create(this.resolver, this.injector)\n }));\n }\n};\nPopoverController.ɵfac = function PopoverController_Factory(t) {\n return new (t || PopoverController)(ɵngcc0.ɵɵinject(AngularDelegate), ɵngcc0.ɵɵinject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵinject(ɵngcc0.Injector));\n};\nPopoverController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: PopoverController,\n factory: function (t) {\n return PopoverController.ɵfac(t);\n }\n});\nPopoverController.ctorParameters = () => [{\n type: AngularDelegate\n}, {\n type: ComponentFactoryResolver\n}, {\n type: Injector\n}];\nlet ToastController = class ToastController extends OverlayBaseController {\n constructor() {\n super(toastController);\n }\n};\nToastController.ɵfac = function ToastController_Factory(t) {\n return new (t || ToastController)();\n};\nToastController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: ToastController,\n factory: function (t) {\n return ToastController.ɵfac(t);\n },\n providedIn: 'root'\n});\nToastController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function ToastController_Factory() {\n return new ToastController();\n },\n token: ToastController,\n providedIn: \"root\"\n});\nlet DomController = class DomController {\n /**\n * Schedules a task to run during the READ phase of the next frame.\n * This task should only read the DOM, but never modify it.\n */\n read(cb) {\n getQueue().read(cb);\n }\n /**\n * Schedules a task to run during the WRITE phase of the next frame.\n * This task should write the DOM, but never READ it.\n */\n write(cb) {\n getQueue().write(cb);\n }\n};\nDomController.ɵfac = function DomController_Factory(t) {\n return new (t || DomController)();\n};\nDomController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: DomController,\n factory: function (t) {\n return DomController.ɵfac(t);\n },\n providedIn: 'root'\n});\nDomController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function DomController_Factory() {\n return new DomController();\n },\n token: DomController,\n providedIn: \"root\"\n});\nconst getQueue = () => {\n const win = typeof window !== 'undefined' ? window : null;\n if (win != null) {\n const Ionic = win.Ionic;\n if (Ionic && Ionic.queue) {\n return Ionic.queue;\n }\n return {\n read: cb => win.requestAnimationFrame(cb),\n write: cb => win.requestAnimationFrame(cb)\n };\n }\n return {\n read: cb => cb(),\n write: cb => cb()\n };\n};\nconst ɵ0$8 = getQueue;\nlet AnimationController = class AnimationController {\n /**\n * Create a new animation\n */\n create(animationId) {\n return createAnimation(animationId);\n }\n /**\n * EXPERIMENTAL\n *\n * Given a progression and a cubic bezier function,\n * this utility returns the time value(s) at which the\n * cubic bezier reaches the given time progression.\n *\n * If the cubic bezier never reaches the progression\n * the result will be an empty array.\n *\n * This is most useful for switching between easing curves\n * when doing a gesture animation (i.e. going from linear easing\n * during a drag, to another easing when `progressEnd` is called)\n */\n easingTime(p0, p1, p2, p3, progression) {\n return getTimeGivenProgression(p0, p1, p2, p3, progression);\n }\n};\nAnimationController.ɵfac = function AnimationController_Factory(t) {\n return new (t || AnimationController)();\n};\nAnimationController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: AnimationController,\n factory: function (t) {\n return AnimationController.ɵfac(t);\n },\n providedIn: 'root'\n});\nAnimationController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function AnimationController_Factory() {\n return new AnimationController();\n },\n token: AnimationController,\n providedIn: \"root\"\n});\nlet GestureController = class GestureController {\n constructor(zone) {\n this.zone = zone;\n }\n /**\n * Create a new gesture\n */\n create(opts, runInsideAngularZone = false) {\n if (runInsideAngularZone) {\n Object.getOwnPropertyNames(opts).forEach(key => {\n if (typeof opts[key] === 'function') {\n const fn = opts[key];\n opts[key] = (...props) => this.zone.run(() => fn(...props));\n }\n });\n }\n return createGesture(opts);\n }\n};\nGestureController.ɵfac = function GestureController_Factory(t) {\n return new (t || GestureController)(ɵngcc0.ɵɵinject(ɵngcc0.NgZone));\n};\nGestureController.ɵprov = /*@__PURE__*/ɵngcc0.ɵɵdefineInjectable({\n token: GestureController,\n factory: function (t) {\n return GestureController.ɵfac(t);\n },\n providedIn: 'root'\n});\nGestureController.ctorParameters = () => [{\n type: NgZone\n}];\nGestureController.ngInjectableDef = ɵɵdefineInjectable({\n factory: function GestureController_Factory() {\n return new GestureController(ɵɵinject(NgZone));\n },\n token: GestureController,\n providedIn: \"root\"\n});\nclass IonicRouteStrategy {\n shouldDetach(_route) {\n return false;\n }\n shouldAttach(_route) {\n return false;\n }\n store(_route, _detachedTree) {\n return;\n }\n retrieve(_route) {\n return null;\n }\n shouldReuseRoute(future, curr) {\n if (future.routeConfig !== curr.routeConfig) {\n return false;\n }\n // checking router params\n const futureParams = future.params;\n const currentParams = curr.params;\n const keysA = Object.keys(futureParams);\n const keysB = Object.keys(currentParams);\n if (keysA.length !== keysB.length) {\n return false;\n }\n // Test for A's keys different from B.\n for (const key of keysA) {\n if (currentParams[key] !== futureParams[key]) {\n return false;\n }\n }\n return true;\n }\n}\nconst appInitialize = (config, doc, zone) => {\n return () => {\n const win = doc.defaultView;\n if (win && typeof window !== 'undefined') {\n setupConfig(Object.assign({}, config, {\n _zoneGate: h => zone.run(h)\n }));\n const aelFn = '__zone_symbol__addEventListener' in doc.body ? '__zone_symbol__addEventListener' : 'addEventListener';\n return applyPolyfills().then(() => {\n return defineCustomElements(win, {\n exclude: ['ion-tabs', 'ion-tab'],\n syncQueue: true,\n raf,\n jmp: h => zone.runOutsideAngular(h),\n ael(elm, eventName, cb, opts) {\n elm[aelFn](eventName, cb, opts);\n },\n rel(elm, eventName, cb, opts) {\n elm.removeEventListener(eventName, cb, opts);\n }\n });\n });\n }\n };\n};\nvar IonicModule_1;\nconst DECLARATIONS = [\n// proxies\nIonApp, IonAvatar, IonBackButton, IonBackdrop, IonBadge, IonButton, IonButtons, IonCard, IonCardContent, IonCardHeader, IonCardSubtitle, IonCardTitle, IonCheckbox, IonChip, IonCol, IonContent, IonDatetime, IonFab, IonFabButton, IonFabList, IonFooter, IonGrid, IonHeader, IonIcon, IonImg, IonInfiniteScroll, IonInfiniteScrollContent, IonInput, IonItem, IonItemDivider, IonItemGroup, IonItemOption, IonItemOptions, IonItemSliding, IonLabel, IonList, IonListHeader, IonMenu, IonMenuButton, IonMenuToggle, IonNav, IonNavLink, IonNote, IonProgressBar, IonRadio, IonRadioGroup, IonRange, IonRefresher, IonRefresherContent, IonReorder, IonReorderGroup, IonRippleEffect, IonRow, IonSearchbar, IonSegment, IonSegmentButton, IonSelect, IonSelectOption, IonSkeletonText, IonSlide, IonSlides, IonSpinner, IonSplitPane, IonTabBar, IonTabButton, IonText, IonTextarea, IonThumbnail, IonToggle, IonToolbar, IonTitle, IonTabs,\n// ngModel accessors\nBooleanValueAccessor, NumericValueAccessor, RadioValueAccessor, SelectValueAccessor, TextValueAccessor,\n// navigation\nIonRouterOutlet, IonBackButtonDelegate, NavDelegate, RouterLinkDelegate,\n// virtual scroll\nVirtualFooter, VirtualHeader, VirtualItem, IonVirtualScroll];\nlet IonicModule = IonicModule_1 = class IonicModule {\n static forRoot(config) {\n return {\n ngModule: IonicModule_1,\n providers: [{\n provide: ConfigToken,\n useValue: config\n }, {\n provide: APP_INITIALIZER,\n useFactory: appInitialize,\n multi: true,\n deps: [ConfigToken, DOCUMENT, NgZone]\n }]\n };\n }\n};\nIonicModule.ɵfac = function IonicModule_Factory(t) {\n return new (t || IonicModule)();\n};\nIonicModule.ɵmod = /*@__PURE__*/ɵngcc0.ɵɵdefineNgModule({\n type: IonicModule\n});\nIonicModule.ɵinj = /*@__PURE__*/ɵngcc0.ɵɵdefineInjector({\n providers: [AngularDelegate, ModalController, PopoverController],\n imports: [CommonModule]\n});\n(function () {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(BooleanValueAccessor, [{\n type: Directive,\n args: [{\n /* tslint:disable-next-line:directive-selector */\n selector: 'ion-checkbox,ion-toggle',\n providers: [{\n provide: NG_VALUE_ACCESSOR,\n useExisting: BooleanValueAccessor_1,\n multi: true\n }]\n }]\n }], function () {\n return [{\n type: ɵngcc0.Injector\n }, {\n type: ɵngcc0.ElementRef\n }];\n }, {\n _handleIonChange: [{\n type: HostListener,\n args: ['ionChange', ['$event.target']]\n }]\n });\n})();\n(function () {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(NumericValueAccessor, [{\n type: Directive,\n args: [{\n /* tslint:disable-next-line:directive-selector */\n selector: 'ion-input[type=number]',\n providers: [{\n provide: NG_VALUE_ACCESSOR,\n useExisting: NumericValueAccessor_1,\n multi: true\n }]\n }]\n }], function () {\n return [{\n type: ɵngcc0.Injector\n }, {\n type: ɵngcc0.ElementRef\n }];\n }, {\n _handleIonChange: [{\n type: HostListener,\n args: ['ionChange', ['$event.target']]\n }]\n });\n})();\n(function () {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(RadioValueAccessor, [{\n type: Directive,\n args: [{\n /* tslint:disable-next-line:directive-selector */\n selector: 'ion-radio',\n providers: [{\n provide: NG_VALUE_ACCESSOR,\n useExisting: RadioValueAccessor_1,\n multi: true\n }]\n }]\n }], function () {\n return [{\n type: ɵngcc0.Injector\n }, {\n type: ɵngcc0.ElementRef\n }];\n }, {\n _handleIonSelect: [{\n type: HostListener,\n args: ['ionSelect', ['$event.target']]\n }]\n });\n})();\n(function () {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(SelectValueAccessor, [{\n type: Directive,\n args: [{\n /* tslint:disable-next-line:directive-selector */\n selector: 'ion-range, ion-select, ion-radio-group, ion-segment, ion-datetime',\n providers: [{\n provide: NG_VALUE_ACCESSOR,\n useExisting: SelectValueAccessor_1,\n multi: true\n }]\n }]\n }], function () {\n return [{\n type: ɵngcc0.Injector\n }, {\n type: ɵngcc0.ElementRef\n }];\n }, {\n _handleChangeEvent: [{\n type: HostListener,\n args: ['ionChange', ['$event.target']]\n }]\n });\n})();\n(function () {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(TextValueAccessor, [{\n type: Directive,\n args: [{\n /* tslint:disable-next-line:directive-selector */\n selector: 'ion-input:not([type=number]),ion-textarea,ion-searchbar',\n providers: [{\n provide: NG_VALUE_ACCESSOR,\n useExisting: TextValueAccessor_1,\n multi: true\n }]\n }]\n }], function () {\n return [{\n type: ɵngcc0.Injector\n }, {\n type: ɵngcc0.ElementRef\n }];\n }, {\n _handleInputEvent: [{\n type: HostListener,\n args: ['ionChange', ['$event.target']]\n }]\n });\n})();\n(function () {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(Platform, [{\n type: Injectable,\n args: [{\n providedIn: 'root'\n }]\n }], function () {\n return [{\n type: undefined,\n decorators: [{\n type: Inject,\n args: [DOCUMENT]\n }]\n }, {\n type: ɵngcc0.NgZone\n }];\n }, null);\n})();\n(function () {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(NavController, [{\n type: Injectable,\n args: [{\n providedIn: 'root'\n }]\n }], function () {\n return [{\n type: Platform\n }, {\n type: ɵngcc1.Location\n }, {\n type: ɵngcc2.UrlSerializer\n }, {\n type: ɵngcc2.Router,\n decorators: [{\n type: Optional\n }]\n }];\n }, null);\n})();\n(function () {\n (typeof ngDevMode === \"undefined\" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(IonApp, [{\n type: Component,\n args: [{\n selector: \"ion-app\",\n changeDetection: ChangeDetectionStrategy.OnPush,\n template: \"