@ionic/angular 7.3.4-dev.11699470772.1dad7e66 → 7.3.4-dev.11699991837.1bc64f72

package/esm2020/providers/loading-controller.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { loadingController } from '@ionic/core';
+import { OverlayBaseController } from '../util/overlay';
+import * as i0 from "@angular/core";
+export class LoadingController extends OverlayBaseController {
+    constructor() {
+        super(loadingController);
+    }
+}
+/** @nocollapse */ LoadingController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LoadingController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ LoadingController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LoadingController, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LoadingController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGluZy1jb250cm9sbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9sb2FkaW5nLWNvbnRyb2xsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQWtCLGlCQUFpQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRWhFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDOztBQUt4RCxNQUFNLE9BQU8saUJBQWtCLFNBQVEscUJBQTREO0lBQ2pHO1FBQ0UsS0FBSyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDM0IsQ0FBQzs7a0lBSFUsaUJBQWlCO3NJQUFqQixpQkFBaUIsY0FGaEIsTUFBTTs0RkFFUCxpQkFBaUI7a0JBSDdCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTG9hZGluZ09wdGlvbnMsIGxvYWRpbmdDb250cm9sbGVyIH0gZnJvbSAnQGlvbmljL2NvcmUnO1xuXG5pbXBvcnQgeyBPdmVybGF5QmFzZUNvbnRyb2xsZXIgfSBmcm9tICcuLi91dGlsL292ZXJsYXknO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgTG9hZGluZ0NvbnRyb2xsZXIgZXh0ZW5kcyBPdmVybGF5QmFzZUNvbnRyb2xsZXI8TG9hZGluZ09wdGlvbnMsIEhUTUxJb25Mb2FkaW5nRWxlbWVudD4ge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcihsb2FkaW5nQ29udHJvbGxlcik7XG4gIH1cbn1cbiJdfQ==

package/esm2020/providers/menu-controller.mjs

@@ -0,0 +1,100 @@
+import { Injectable } from '@angular/core';
+import { menuController } from '@ionic/core';
+import * as i0 from "@angular/core";
+export class MenuController {
+    /**
+     * Programmatically open the Menu.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return returns a promise when the menu is fully opened
+     */
+    open(menuId) {
+        return menuController.open(menuId);
+    }
+    /**
+     * Programmatically close the Menu. If no `menuId` is given as the first
+     * argument then it'll close any menu which is open. If a `menuId`
+     * is given then it'll close that exact menu.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return returns a promise when the menu is fully closed
+     */
+    close(menuId) {
+        return menuController.close(menuId);
+    }
+    /**
+     * Toggle the menu. If it's closed, it will open, and if opened, it
+     * will close.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return returns a promise when the menu has been toggled
+     */
+    toggle(menuId) {
+        return menuController.toggle(menuId);
+    }
+    /**
+     * Used to enable or disable a menu. For example, there could be multiple
+     * left menus, but only one of them should be able to be opened at the same
+     * time. If there are multiple menus on the same side, then enabling one menu
+     * will also automatically disable all the others that are on the same side.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns the instance of the menu, which is useful for chaining.
+     */
+    enable(shouldEnable, menuId) {
+        return menuController.enable(shouldEnable, menuId);
+    }
+    /**
+     * Used to enable or disable the ability to swipe open the menu.
+     * @param shouldEnable  True if it should be swipe-able, false if not.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns the instance of the menu, which is useful for chaining.
+     */
+    swipeGesture(shouldEnable, menuId) {
+        return menuController.swipeGesture(shouldEnable, menuId);
+    }
+    /**
+     * @param [menuId] Optionally get the menu by its id, or side.
+     * @return Returns true if the specified menu is currently open, otherwise false.
+     * If the menuId is not specified, it returns true if ANY menu is currenly open.
+     */
+    isOpen(menuId) {
+        return menuController.isOpen(menuId);
+    }
+    /**
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns true if the menu is currently enabled, otherwise false.
+     */
+    isEnabled(menuId) {
+        return menuController.isEnabled(menuId);
+    }
+    /**
+     * Used to get a menu instance. If a `menuId` is not provided then it'll
+     * return the first menu found. If a `menuId` is `left` or `right`, then
+     * it'll return the enabled menu on that side. Otherwise, if a `menuId` is
+     * provided, then it'll try to find the menu using the menu's `id`
+     * property. If a menu is not found then it'll return `null`.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns the instance of the menu if found, otherwise `null`.
+     */
+    get(menuId) {
+        return menuController.get(menuId);
+    }
+    /**
+     * @return Returns the instance of the menu already opened, otherwise `null`.
+     */
+    getOpen() {
+        return menuController.getOpen();
+    }
+    /**
+     * @return Returns an array of all menu instances.
+     */
+    getMenus() {
+        return menuController.getMenus();
+    }
+}
+/** @nocollapse */ MenuController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ MenuController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuController, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1jb250cm9sbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9tZW51LWNvbnRyb2xsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sYUFBYSxDQUFDOztBQUs3QyxNQUFNLE9BQU8sY0FBYztJQUN6Qjs7OztPQUlHO0lBQ0gsSUFBSSxDQUFDLE1BQWU7UUFDbEIsT0FBTyxjQUFjLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSCxLQUFLLENBQUMsTUFBZTtRQUNuQixPQUFPLGNBQWMsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDdEMsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsTUFBTSxDQUFDLE1BQWU7UUFDcEIsT0FBTyxjQUFjLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsTUFBTSxDQUFDLFlBQXFCLEVBQUUsTUFBZTtRQUMzQyxPQUFPLGNBQWMsQ0FBQyxNQUFNLENBQUMsWUFBWSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ3JELENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILFlBQVksQ0FBQyxZQUFxQixFQUFFLE1BQWU7UUFDakQsT0FBTyxjQUFjLENBQUMsWUFBWSxDQUFDLFlBQVksRUFBRSxNQUFNLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILE1BQU0sQ0FBQyxNQUFlO1FBQ3BCLE9BQU8sY0FBYyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUN2QyxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsU0FBUyxDQUFDLE1BQWU7UUFDdkIsT0FBTyxjQUFjLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRDs7Ozs7Ozs7T0FRRztJQUNILEdBQUcsQ0FBQyxNQUFlO1FBQ2pCLE9BQU8sY0FBYyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxPQUFPO1FBQ0wsT0FBTyxjQUFjLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDbEMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsUUFBUTtRQUNOLE9BQU8sY0FBYyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ25DLENBQUM7OytIQS9GVSxjQUFjO21JQUFkLGNBQWMsY0FGYixNQUFNOzRGQUVQLGNBQWM7a0JBSDFCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgbWVudUNvbnRyb2xsZXIgfSBmcm9tICdAaW9uaWMvY29yZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBNZW51Q29udHJvbGxlciB7XG4gIC8qKlxuICAgKiBQcm9ncmFtbWF0aWNhbGx5IG9wZW4gdGhlIE1lbnUuXG4gICAqIEBwYXJhbSBbbWVudUlkXSAgT3B0aW9uYWxseSBnZXQgdGhlIG1lbnUgYnkgaXRzIGlkLCBvciBzaWRlLlxuICAgKiBAcmV0dXJuIHJldHVybnMgYSBwcm9taXNlIHdoZW4gdGhlIG1lbnUgaXMgZnVsbHkgb3BlbmVkXG4gICAqL1xuICBvcGVuKG1lbnVJZD86IHN0cmluZyk6IFByb21pc2U8Ym9vbGVhbj4ge1xuICAgIHJldHVybiBtZW51Q29udHJvbGxlci5vcGVuKG1lbnVJZCk7XG4gIH1cblxuICAvKipcbiAgICogUHJvZ3JhbW1hdGljYWxseSBjbG9zZSB0aGUgTWVudS4gSWYgbm8gYG1lbnVJZGAgaXMgZ2l2ZW4gYXMgdGhlIGZpcnN0XG4gICAqIGFyZ3VtZW50IHRoZW4gaXQnbGwgY2xvc2UgYW55IG1lbnUgd2hpY2ggaXMgb3Blbi4gSWYgYSBgbWVudUlkYFxuICAgKiBpcyBnaXZlbiB0aGVuIGl0J2xsIGNsb3NlIHRoYXQgZXhhY3QgbWVudS5cbiAgICogQHBhcmFtIFttZW51SWRdICBPcHRpb25hbGx5IGdldCB0aGUgbWVudSBieSBpdHMgaWQsIG9yIHNpZGUuXG4gICAqIEByZXR1cm4gcmV0dXJucyBhIHByb21pc2Ugd2hlbiB0aGUgbWVudSBpcyBmdWxseSBjbG9zZWRcbiAgICovXG4gIGNsb3NlKG1lbnVJZD86IHN0cmluZyk6IFByb21pc2U8Ym9vbGVhbj4ge1xuICAgIHJldHVybiBtZW51Q29udHJvbGxlci5jbG9zZShtZW51SWQpO1xuICB9XG5cbiAgLyoqXG4gICAqIFRvZ2dsZSB0aGUgbWVudS4gSWYgaXQncyBjbG9zZWQsIGl0IHdpbGwgb3BlbiwgYW5kIGlmIG9wZW5lZCwgaXRcbiAgICogd2lsbCBjbG9zZS5cbiAgICogQHBhcmFtIFttZW51SWRdICBPcHRpb25hbGx5IGdldCB0aGUgbWVudSBieSBpdHMgaWQsIG9yIHNpZGUuXG4gICAqIEByZXR1cm4gcmV0dXJucyBhIHByb21pc2Ugd2hlbiB0aGUgbWVudSBoYXMgYmVlbiB0b2dnbGVkXG4gICAqL1xuICB0b2dnbGUobWVudUlkPzogc3RyaW5nKTogUHJvbWlzZTxib29sZWFuPiB7XG4gICAgcmV0dXJuIG1lbnVDb250cm9sbGVyLnRvZ2dsZShtZW51SWQpO1xuICB9XG5cbiAgLyoqXG4gICAqIFVzZWQgdG8gZW5hYmxlIG9yIGRpc2FibGUgYSBtZW51LiBGb3IgZXhhbXBsZSwgdGhlcmUgY291bGQgYmUgbXVsdGlwbGVcbiAgICogbGVmdCBtZW51cywgYnV0IG9ubHkgb25lIG9mIHRoZW0gc2hvdWxkIGJlIGFibGUgdG8gYmUgb3BlbmVkIGF0IHRoZSBzYW1lXG4gICAqIHRpbWUuIElmIHRoZXJlIGFyZSBtdWx0aXBsZSBtZW51cyBvbiB0aGUgc2FtZSBzaWRlLCB0aGVuIGVuYWJsaW5nIG9uZSBtZW51XG4gICAqIHdpbGwgYWxzbyBhdXRvbWF0aWNhbGx5IGRpc2FibGUgYWxsIHRoZSBvdGhlcnMgdGhhdCBhcmUgb24gdGhlIHNhbWUgc2lkZS5cbiAgICogQHBhcmFtIFttZW51SWRdICBPcHRpb25hbGx5IGdldCB0aGUgbWVudSBieSBpdHMgaWQsIG9yIHNpZGUuXG4gICAqIEByZXR1cm4gUmV0dXJucyB0aGUgaW5zdGFuY2Ugb2YgdGhlIG1lbnUsIHdoaWNoIGlzIHVzZWZ1bCBmb3IgY2hhaW5pbmcuXG4gICAqL1xuICBlbmFibGUoc2hvdWxkRW5hYmxlOiBib29sZWFuLCBtZW51SWQ/OiBzdHJpbmcpOiBQcm9taXNlPEhUTUxJb25NZW51RWxlbWVudCB8IHVuZGVmaW5lZD4ge1xuICAgIHJldHVybiBtZW51Q29udHJvbGxlci5lbmFibGUoc2hvdWxkRW5hYmxlLCBtZW51SWQpO1xuICB9XG5cbiAgLyoqXG4gICAqIFVzZWQgdG8gZW5hYmxlIG9yIGRpc2FibGUgdGhlIGFiaWxpdHkgdG8gc3dpcGUgb3BlbiB0aGUgbWVudS5cbiAgICogQHBhcmFtIHNob3VsZEVuYWJsZSAgVHJ1ZSBpZiBpdCBzaG91bGQgYmUgc3dpcGUtYWJsZSwgZmFsc2UgaWYgbm90LlxuICAgKiBAcGFyYW0gW21lbnVJZF0gIE9wdGlvbmFsbHkgZ2V0IHRoZSBtZW51IGJ5IGl0cyBpZCwgb3Igc2lkZS5cbiAgICogQHJldHVybiBSZXR1cm5zIHRoZSBpbnN0YW5jZSBvZiB0aGUgbWVudSwgd2hpY2ggaXMgdXNlZnVsIGZvciBjaGFpbmluZy5cbiAgICovXG4gIHN3aXBlR2VzdHVyZShzaG91bGRFbmFibGU6IGJvb2xlYW4sIG1lbnVJZD86IHN0cmluZyk6IFByb21pc2U8SFRNTElvbk1lbnVFbGVtZW50IHwgdW5kZWZpbmVkPiB7XG4gICAgcmV0dXJuIG1lbnVDb250cm9sbGVyLnN3aXBlR2VzdHVyZShzaG91bGRFbmFibGUsIG1lbnVJZCk7XG4gIH1cblxuICAvKipcbiAgICogQHBhcmFtIFttZW51SWRdIE9wdGlvbmFsbHkgZ2V0IHRoZSBtZW51IGJ5IGl0cyBpZCwgb3Igc2lkZS5cbiAgICogQHJldHVybiBSZXR1cm5zIHRydWUgaWYgdGhlIHNwZWNpZmllZCBtZW51IGlzIGN1cnJlbnRseSBvcGVuLCBvdGhlcndpc2UgZmFsc2UuXG4gICAqIElmIHRoZSBtZW51SWQgaXMgbm90IHNwZWNpZmllZCwgaXQgcmV0dXJucyB0cnVlIGlmIEFOWSBtZW51IGlzIGN1cnJlbmx5IG9wZW4uXG4gICAqL1xuICBpc09wZW4obWVudUlkPzogc3RyaW5nKTogUHJvbWlzZTxib29sZWFuPiB7XG4gICAgcmV0dXJuIG1lbnVDb250cm9sbGVyLmlzT3BlbihtZW51SWQpO1xuICB9XG5cbiAgLyoqXG4gICAqIEBwYXJhbSBbbWVudUlkXSAgT3B0aW9uYWxseSBnZXQgdGhlIG1lbnUgYnkgaXRzIGlkLCBvciBzaWRlLlxuICAgKiBAcmV0dXJuIFJldHVybnMgdHJ1ZSBpZiB0aGUgbWVudSBpcyBjdXJyZW50bHkgZW5hYmxlZCwgb3RoZXJ3aXNlIGZhbHNlLlxuICAgKi9cbiAgaXNFbmFibGVkKG1lbnVJZD86IHN0cmluZyk6IFByb21pc2U8Ym9vbGVhbj4ge1xuICAgIHJldHVybiBtZW51Q29udHJvbGxlci5pc0VuYWJsZWQobWVudUlkKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBVc2VkIHRvIGdldCBhIG1lbnUgaW5zdGFuY2UuIElmIGEgYG1lbnVJZGAgaXMgbm90IHByb3ZpZGVkIHRoZW4gaXQnbGxcbiAgICogcmV0dXJuIHRoZSBmaXJzdCBtZW51IGZvdW5kLiBJZiBhIGBtZW51SWRgIGlzIGBsZWZ0YCBvciBgcmlnaHRgLCB0aGVuXG4gICAqIGl0J2xsIHJldHVybiB0aGUgZW5hYmxlZCBtZW51IG9uIHRoYXQgc2lkZS4gT3RoZXJ3aXNlLCBpZiBhIGBtZW51SWRgIGlzXG4gICAqIHByb3ZpZGVkLCB0aGVuIGl0J2xsIHRyeSB0byBmaW5kIHRoZSBtZW51IHVzaW5nIHRoZSBtZW51J3MgYGlkYFxuICAgKiBwcm9wZXJ0eS4gSWYgYSBtZW51IGlzIG5vdCBmb3VuZCB0aGVuIGl0J2xsIHJldHVybiBgbnVsbGAuXG4gICAqIEBwYXJhbSBbbWVudUlkXSAgT3B0aW9uYWxseSBnZXQgdGhlIG1lbnUgYnkgaXRzIGlkLCBvciBzaWRlLlxuICAgKiBAcmV0dXJuIFJldHVybnMgdGhlIGluc3RhbmNlIG9mIHRoZSBtZW51IGlmIGZvdW5kLCBvdGhlcndpc2UgYG51bGxgLlxuICAgKi9cbiAgZ2V0KG1lbnVJZD86IHN0cmluZyk6IFByb21pc2U8SFRNTElvbk1lbnVFbGVtZW50IHwgdW5kZWZpbmVkPiB7XG4gICAgcmV0dXJuIG1lbnVDb250cm9sbGVyLmdldChtZW51SWQpO1xuICB9XG5cbiAgLyoqXG4gICAqIEByZXR1cm4gUmV0dXJucyB0aGUgaW5zdGFuY2Ugb2YgdGhlIG1lbnUgYWxyZWFkeSBvcGVuZWQsIG90aGVyd2lzZSBgbnVsbGAuXG4gICAqL1xuICBnZXRPcGVuKCk6IFByb21pc2U8SFRNTElvbk1lbnVFbGVtZW50IHwgdW5kZWZpbmVkPiB7XG4gICAgcmV0dXJuIG1lbnVDb250cm9sbGVyLmdldE9wZW4oKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBAcmV0dXJuIFJldHVybnMgYW4gYXJyYXkgb2YgYWxsIG1lbnUgaW5zdGFuY2VzLlxuICAgKi9cbiAgZ2V0TWVudXMoKTogUHJvbWlzZTxIVE1MSW9uTWVudUVsZW1lbnRbXT4ge1xuICAgIHJldHVybiBtZW51Q29udHJvbGxlci5nZXRNZW51cygpO1xuICB9XG59XG4iXX0=

package/esm2020/providers/modal-controller.mjs

@@ -0,0 +1,25 @@
+import { Injector, Injectable, EnvironmentInjector, inject } from '@angular/core';
+import { modalController } from '@ionic/core';
+import { OverlayBaseController } from '../util/overlay';
+import { AngularDelegate } from './angular-delegate';
+import * as i0 from "@angular/core";
+export class ModalController extends OverlayBaseController {
+    constructor() {
+        super(modalController);
+        this.angularDelegate = inject(AngularDelegate);
+        this.injector = inject(Injector);
+        this.environmentInjector = inject(EnvironmentInjector);
+    }
+    create(opts) {
+        return super.create({
+            ...opts,
+            delegate: this.angularDelegate.create(this.environmentInjector, this.injector, 'modal'),
+        });
+    }
+}
+/** @nocollapse */ ModalController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ModalController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ ModalController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ModalController });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ModalController, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/nav-controller.mjs

@@ -0,0 +1,221 @@
+import { Injectable, Optional } from '@angular/core';
+import { NavigationStart } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "./platform";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/router";
+export class NavController {
+    constructor(platform, location, serializer, router) {
+        this.location = location;
+        this.serializer = serializer;
+        this.router = router;
+        this.direction = DEFAULT_DIRECTION;
+        this.animated = DEFAULT_ANIMATED;
+        this.guessDirection = 'forward';
+        this.lastNavId = -1;
+        // Subscribe to router events to detect direction
+        if (router) {
+            router.events.subscribe((ev) => {
+                if (ev instanceof NavigationStart) {
+                    const id = ev.restoredState ? ev.restoredState.navigationId : ev.id;
+                    this.guessDirection = id < this.lastNavId ? 'back' : 'forward';
+                    this.guessAnimation = !ev.restoredState ? this.guessDirection : undefined;
+                    this.lastNavId = this.guessDirection === 'forward' ? ev.id : id;
+                }
+            });
+        }
+        // Subscribe to backButton events
+        platform.backButton.subscribeWithPriority(0, (processNextHandler) => {
+            this.pop();
+            processNextHandler();
+        });
+    }
+    /**
+     * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
+     * it's equivalent to calling `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition.
+     *
+     * Going **forward** means that a new page is going to be pushed to the stack of the outlet (ion-router-outlet),
+     * and that it will show a "forward" animation by default.
+     *
+     * Navigating forward can also be triggered in a declarative manner by using the `[routerDirection]` directive:
+     *
+     * ```html
+     * <a routerLink="/path/to/page" routerDirection="forward">Link</a>
+     * ```
+     */
+    navigateForward(url, options = {}) {
+        this.setDirection('forward', options.animated, options.animationDirection, options.animation);
+        return this.navigate(url, options);
+    }
+    /**
+     * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
+     * it's equivalent to calling:
+     *
+     * ```ts
+     * this.navController.setDirection('back');
+     * this.router.navigateByUrl(path);
+     * ```
+     *
+     * Going **back** means that all the pages in the stack until the navigated page is found will be popped,
+     * and that it will show a "back" animation by default.
+     *
+     * Navigating back can also be triggered in a declarative manner by using the `[routerDirection]` directive:
+     *
+     * ```html
+     * <a routerLink="/path/to/page" routerDirection="back">Link</a>
+     * ```
+     */
+    navigateBack(url, options = {}) {
+        this.setDirection('back', options.animated, options.animationDirection, options.animation);
+        return this.navigate(url, options);
+    }
+    /**
+     * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
+     * it's equivalent to calling:
+     *
+     * ```ts
+     * this.navController.setDirection('root');
+     * this.router.navigateByUrl(path);
+     * ```
+     *
+     * Going **root** means that all existing pages in the stack will be removed,
+     * and the navigated page will become the single page in the stack.
+     *
+     * Navigating root can also be triggered in a declarative manner by using the `[routerDirection]` directive:
+     *
+     * ```html
+     * <a routerLink="/path/to/page" routerDirection="root">Link</a>
+     * ```
+     */
+    navigateRoot(url, options = {}) {
+        this.setDirection('root', options.animated, options.animationDirection, options.animation);
+        return this.navigate(url, options);
+    }
+    /**
+     * Same as [Location](https://angular.io/api/common/Location)'s back() method.
+     * It will use the standard `window.history.back()` under the hood, but featuring a `back` animation
+     * by default.
+     */
+    back(options = { animated: true, animationDirection: 'back' }) {
+        this.setDirection('back', options.animated, options.animationDirection, options.animation);
+        return this.location.back();
+    }
+    /**
+     * This methods goes back in the context of Ionic's stack navigation.
+     *
+     * It recursively finds the top active `ion-router-outlet` and calls `pop()`.
+     * This is the recommended way to go back when you are using `ion-router-outlet`.
+     *
+     * Resolves to `true` if it was able to pop.
+     */
+    async pop() {
+        let outlet = this.topOutlet;
+        while (outlet) {
+            if (await outlet.pop()) {
+                return true;
+            }
+            else {
+                outlet = outlet.parentOutlet;
+            }
+        }
+        return false;
+    }
+    /**
+     * This methods specifies the direction of the next navigation performed by the Angular router.
+     *
+     * `setDirection()` does not trigger any transition, it just sets some flags to be consumed by `ion-router-outlet`.
+     *
+     * It's recommended to use `navigateForward()`, `navigateBack()` and `navigateRoot()` instead of `setDirection()`.
+     */
+    setDirection(direction, animated, animationDirection, animationBuilder) {
+        this.direction = direction;
+        this.animated = getAnimation(direction, animated, animationDirection);
+        this.animationBuilder = animationBuilder;
+    }
+    /**
+     * @internal
+     */
+    setTopOutlet(outlet) {
+        this.topOutlet = outlet;
+    }
+    /**
+     * @internal
+     */
+    consumeTransition() {
+        let direction = 'root';
+        let animation;
+        const animationBuilder = this.animationBuilder;
+        if (this.direction === 'auto') {
+            direction = this.guessDirection;
+            animation = this.guessAnimation;
+        }
+        else {
+            animation = this.animated;
+            direction = this.direction;
+        }
+        this.direction = DEFAULT_DIRECTION;
+        this.animated = DEFAULT_ANIMATED;
+        this.animationBuilder = undefined;
+        return {
+            direction,
+            animation,
+            animationBuilder,
+        };
+    }
+    navigate(url, options) {
+        if (Array.isArray(url)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return this.router.navigate(url, options);
+        }
+        else {
+            /**
+             * navigateByUrl ignores any properties that
+             * would change the url, so things like queryParams
+             * would be ignored unless we create a url tree
+             * More Info: https://github.com/angular/angular/issues/18798
+             */
+            const urlTree = this.serializer.parse(url.toString());
+            if (options.queryParams !== undefined) {
+                urlTree.queryParams = { ...options.queryParams };
+            }
+            if (options.fragment !== undefined) {
+                urlTree.fragment = options.fragment;
+            }
+            /**
+             * `navigateByUrl` will still apply `NavigationExtras` properties
+             * that do not modify the url, such as `replaceUrl` which is why
+             * `options` is passed in here.
+             */
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return this.router.navigateByUrl(urlTree, options);
+        }
+    }
+}
+/** @nocollapse */ NavController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: NavController, deps: [{ token: i1.Platform }, { token: i2.Location }, { token: i3.UrlSerializer }, { token: i3.Router, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ NavController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: NavController, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: NavController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i2.Location }, { type: i3.UrlSerializer }, { type: i3.Router, decorators: [{
+                    type: Optional
+                }] }]; } });
+const getAnimation = (direction, animated, animationDirection) => {
+    if (animated === false) {
+        return undefined;
+    }
+    if (animationDirection !== undefined) {
+        return animationDirection;
+    }
+    if (direction === 'forward' || direction === 'back') {
+        return direction;
+    }
+    else if (direction === 'root' && animated === true) {
+        return 'forward';
+    }
+    return undefined;
+};
+const DEFAULT_DIRECTION = 'auto';
+const DEFAULT_ANIMATED = undefined;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-controller.js","sourceRoot":"","sources":["../../../src/providers/nav-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable, Optional } from '@angular/core';\nimport { NavigationExtras, Router, UrlSerializer, UrlTree, NavigationStart } from '@angular/router';\nimport { AnimationBuilder, NavDirection, RouterDirection } from '@ionic/core';\n\nimport { IonRouterOutlet } from '../directives/navigation/ion-router-outlet';\n\nimport { Platform } from './platform';\n\nexport interface AnimationOptions {\n  animated?: boolean;\n  animation?: AnimationBuilder;\n  animationDirection?: 'forward' | 'back';\n}\n\nexport interface NavigationOptions extends NavigationExtras, AnimationOptions {}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class NavController {\n  private topOutlet?: IonRouterOutlet;\n  private direction: 'forward' | 'back' | 'root' | 'auto' = DEFAULT_DIRECTION;\n  private animated?: NavDirection = DEFAULT_ANIMATED;\n  private animationBuilder?: AnimationBuilder;\n  private guessDirection: RouterDirection = 'forward';\n  private guessAnimation?: NavDirection;\n  private lastNavId = -1;\n\n  constructor(\n    platform: Platform,\n    private location: Location,\n    private serializer: UrlSerializer,\n    @Optional() private router?: Router\n  ) {\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\n    // Subscribe to backButton events\n    platform.backButton.subscribeWithPriority(0, (processNextHandler) => {\n      this.pop();\n      processNextHandler();\n    });\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   * <a routerLink=\"/path/to/page\" routerDirection=\"forward\">Link</a>\n   * ```\n   */\n  navigateForward(url: string | UrlTree | any[], options: NavigationOptions = {}): Promise<boolean> {\n    this.setDirection('forward', options.animated, options.animationDirection, options.animation);\n    return this.navigate(url, options);\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:\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   * <a routerLink=\"/path/to/page\" routerDirection=\"back\">Link</a>\n   * ```\n   */\n  navigateBack(url: string | UrlTree | any[], options: NavigationOptions = {}): Promise<boolean> {\n    this.setDirection('back', options.animated, options.animationDirection, options.animation);\n    return this.navigate(url, options);\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:\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   * <a routerLink=\"/path/to/page\" routerDirection=\"root\">Link</a>\n   * ```\n   */\n  navigateRoot(url: string | UrlTree | any[], options: NavigationOptions = {}): Promise<boolean> {\n    this.setDirection('root', options.animated, options.animationDirection, options.animation);\n    return this.navigate(url, options);\n  }\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: AnimationOptions = { animated: true, animationDirection: 'back' }): void {\n    this.setDirection('back', options.animated, options.animationDirection, options.animation);\n    return this.location.back();\n  }\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   * Resolves to `true` if it was able to pop.\n   */\n  async pop(): Promise<boolean> {\n    let outlet = this.topOutlet;\n\n    while (outlet) {\n      if (await outlet.pop()) {\n        return true;\n      } else {\n        outlet = outlet.parentOutlet;\n      }\n    }\n\n    return false;\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(\n    direction: RouterDirection,\n    animated?: boolean,\n    animationDirection?: 'forward' | 'back',\n    animationBuilder?: AnimationBuilder\n  ): void {\n    this.direction = direction;\n    this.animated = getAnimation(direction, animated, animationDirection);\n    this.animationBuilder = animationBuilder;\n  }\n\n  /**\n   * @internal\n   */\n  setTopOutlet(outlet: IonRouterOutlet): void {\n    this.topOutlet = outlet;\n  }\n\n  /**\n   * @internal\n   */\n  consumeTransition(): {\n    direction: RouterDirection;\n    animation: NavDirection | undefined;\n    animationBuilder: AnimationBuilder | undefined;\n  } {\n    let direction: RouterDirection = 'root';\n    let animation: NavDirection | undefined;\n    const animationBuilder = this.animationBuilder;\n\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\n    return {\n      direction,\n      animation,\n      animationBuilder,\n    };\n  }\n\n  private navigate(url: string | UrlTree | any[], options: NavigationOptions) {\n    if (Array.isArray(url)) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\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\n      if (options.queryParams !== undefined) {\n        urlTree.queryParams = { ...options.queryParams };\n      }\n\n      if (options.fragment !== undefined) {\n        urlTree.fragment = options.fragment;\n      }\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      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      return this.router!.navigateByUrl(urlTree, options);\n    }\n  }\n}\n\nconst getAnimation = (\n  direction: RouterDirection,\n  animated: boolean | undefined,\n  animationDirection: 'forward' | 'back' | undefined\n): NavDirection | undefined => {\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};\n\nconst DEFAULT_DIRECTION = 'auto';\nconst DEFAULT_ANIMATED = undefined;\n"]}

package/esm2020/providers/picker-controller.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { pickerController } from '@ionic/core';
+import { OverlayBaseController } from '../util/overlay';
+import * as i0 from "@angular/core";
+export class PickerController extends OverlayBaseController {
+    constructor() {
+        super(pickerController);
+    }
+}
+/** @nocollapse */ PickerController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: PickerController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ PickerController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: PickerController, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: PickerController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlja2VyLWNvbnRyb2xsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3BpY2tlci1jb250cm9sbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFpQixnQkFBZ0IsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUU5RCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQzs7QUFLeEQsTUFBTSxPQUFPLGdCQUFpQixTQUFRLHFCQUEwRDtJQUM5RjtRQUNFLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQzFCLENBQUM7O2lJQUhVLGdCQUFnQjtxSUFBaEIsZ0JBQWdCLGNBRmYsTUFBTTs0RkFFUCxnQkFBZ0I7a0JBSDVCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUGlja2VyT3B0aW9ucywgcGlja2VyQ29udHJvbGxlciB9IGZyb20gJ0Bpb25pYy9jb3JlJztcblxuaW1wb3J0IHsgT3ZlcmxheUJhc2VDb250cm9sbGVyIH0gZnJvbSAnLi4vdXRpbC9vdmVybGF5JztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIFBpY2tlckNvbnRyb2xsZXIgZXh0ZW5kcyBPdmVybGF5QmFzZUNvbnRyb2xsZXI8UGlja2VyT3B0aW9ucywgSFRNTElvblBpY2tlckVsZW1lbnQ+IHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIocGlja2VyQ29udHJvbGxlcik7XG4gIH1cbn1cbiJdfQ==