@pod-os/elements 0.6.1-bea440b.0 → 0.7.1-2196a40.0

package/dist/cjs/{overlays-49fe9ba7.js → overlays-65c716aa.js}

@@ -1,9 +1,12 @@
 'use strict';
 
-const ionicGlobal = require('./ionic-global-56e10eb5.js');
-const hardwareBackButton = require('./hardware-back-button-01027575.js');
-const helpers = require('./helpers-398ced09.js');
+const ionicGlobal = require('./ionic-global-f2d95fd3.js');
+const hardwareBackButton = require('./hardware-back-button-25372ec7.js');
+const helpers = require('./helpers-cb08f5ae.js');
 
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
 let lastId = 0;
 const activeAnimations = new WeakMap();
 const createController = (tagName) => {
@@ -16,15 +19,13 @@ const createController = (tagName) => {
     },
     async getTop() {
       return getOverlay(document, tagName);
-    }
+    },
   };
 };
 const alertController = /*@__PURE__*/ createController('ion-alert');
 const actionSheetController = /*@__PURE__*/ createController('ion-action-sheet');
-const pickerController = /*@__PURE__*/ createController('ion-picker');
 const popoverController = /*@__PURE__*/ createController('ion-popover');
 const prepareOverlay = (el) => {
-  /* tslint:disable-next-line */
   if (typeof document !== 'undefined') {
     connectListeners(document);
   }
@@ -35,45 +36,58 @@ const prepareOverlay = (el) => {
   }
 };
 const createOverlay = (tagName, opts) => {
-  /* tslint:disable-next-line */
-  if (typeof customElements !== 'undefined') {
-    return customElements.whenDefined(tagName).then(() => {
+  if (typeof window !== 'undefined' && typeof window.customElements !== 'undefined') {
+    return window.customElements.whenDefined(tagName).then(() => {
       const element = document.createElement(tagName);
       element.classList.add('overlay-hidden');
-      // convert the passed in overlay options into props
-      // that get passed down into the new overlay
-      Object.assign(element, opts);
+      /**
+       * Convert the passed in overlay options into props
+       * that get passed down into the new overlay.
+       */
+      Object.assign(element, Object.assign(Object.assign({}, opts), { hasController: true }));
       // append the overlay element to the document body
       getAppRoot(document).appendChild(element);
-      return new Promise(resolve => helpers.componentOnReady(element, resolve));
+      return new Promise((resolve) => helpers.componentOnReady(element, resolve));
     });
   }
   return Promise.resolve();
 };
-const focusableQueryString = '[tabindex]:not([tabindex^="-"]), input:not([type=hidden]):not([tabindex^="-"]), textarea:not([tabindex^="-"]), button:not([tabindex^="-"]), select:not([tabindex^="-"]), .ion-focusable:not([tabindex^="-"])';
-const innerFocusableQueryString = 'input:not([type=hidden]), textarea, button, select';
+/**
+ * This query string selects elements that
+ * are eligible to receive focus. We select
+ * interactive elements that meet the following
+ * criteria:
+ * 1. Element does not have a negative tabindex
+ * 2. Element does not have `hidden`
+ * 3. Element does not have `disabled` for non-Ionic components.
+ * 4. Element does not have `disabled` or `disabled="true"` for Ionic components.
+ * Note: We need this distinction because `disabled="false"` is
+ * valid usage for the disabled property on ion-button.
+ */
+const focusableQueryString = '[tabindex]:not([tabindex^="-"]):not([hidden]):not([disabled]), input:not([type=hidden]):not([tabindex^="-"]):not([hidden]):not([disabled]), textarea:not([tabindex^="-"]):not([hidden]):not([disabled]), button:not([tabindex^="-"]):not([hidden]):not([disabled]), select:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable[disabled="false"]:not([tabindex^="-"]):not([hidden])';
 const focusFirstDescendant = (ref, overlay) => {
   let firstInput = ref.querySelector(focusableQueryString);
-  const shadowRoot = firstInput && firstInput.shadowRoot;
+  const shadowRoot = firstInput === null || firstInput === void 0 ? void 0 : firstInput.shadowRoot;
   if (shadowRoot) {
     // If there are no inner focusable elements, just focus the host element.
-    firstInput = shadowRoot.querySelector(innerFocusableQueryString) || firstInput;
+    firstInput = shadowRoot.querySelector(focusableQueryString) || firstInput;
   }
   if (firstInput) {
-    firstInput.focus();
+    helpers.focusElement(firstInput);
   }
   else {
     // Focus overlay instead of letting focus escape
     overlay.focus();
   }
 };
+const isOverlayHidden = (overlay) => overlay.classList.contains('overlay-hidden');
 const focusLastDescendant = (ref, overlay) => {
   const inputs = Array.from(ref.querySelectorAll(focusableQueryString));
   let lastInput = inputs.length > 0 ? inputs[inputs.length - 1] : null;
-  const shadowRoot = lastInput && lastInput.shadowRoot;
+  const shadowRoot = lastInput === null || lastInput === void 0 ? void 0 : lastInput.shadowRoot;
   if (shadowRoot) {
     // If there are no inner focusable elements, just focus the host element.
-    lastInput = shadowRoot.querySelector(innerFocusableQueryString) || lastInput;
+    lastInput = shadowRoot.querySelector(focusableQueryString) || lastInput;
   }
   if (lastInput) {
     lastInput.focus();
@@ -91,53 +105,116 @@ const focusLastDescendant = (ref, overlay) => {
  * Should NOT include: Toast
  */
 const trapKeyboardFocus = (ev, doc) => {
-  const lastOverlay = getOverlay(doc);
+  const lastOverlay = getOverlay(doc, 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-picker,ion-popover');
   const target = ev.target;
-  // If no active overlay, ignore this event
+  /**
+   * If no active overlay, ignore this event.
+   *
+   * If this component uses the shadow dom,
+   * this global listener is pointless
+   * since it will not catch the focus
+   * traps as they are inside the shadow root.
+   * We need to add a listener to the shadow root
+   * itself to ensure the focus trap works.
+   */
   if (!lastOverlay || !target) {
     return;
   }
   /**
-   * If we are focusing the overlay, clear
-   * the last focused element so that hitting
-   * tab activates the first focusable element
-   * in the overlay wrapper.
+   * If the ion-disable-focus-trap class
+   * is present on an overlay, then this component
+   * instance has opted out of focus trapping.
+   * An example of this is when the sheet modal
+   * has a backdrop that is disabled. The content
+   * behind the sheet should be focusable until
+   * the backdrop is enabled.
    */
-  if (lastOverlay === target) {
-    lastOverlay.lastFocus = undefined;
-    /**
-     * Otherwise, we must be focusing an element
-     * inside of the overlay. The two possible options
-     * here are an input/button/etc or the ion-focus-trap
-     * element. The focus trap element is used to prevent
-     * the keyboard focus from leaving the overlay when
-     * using Tab or screen assistants.
-     */
+  if (lastOverlay.classList.contains('ion-disable-focus-trap')) {
+    return;
   }
-  else {
+  const trapScopedFocus = () => {
     /**
-     * We do not want to focus the traps, so get the overlay
-     * wrapper element as the traps live outside of the wrapper.
+     * If we are focusing the overlay, clear
+     * the last focused element so that hitting
+     * tab activates the first focusable element
+     * in the overlay wrapper.
      */
-    const overlayRoot = helpers.getElementRoot(lastOverlay);
-    if (!overlayRoot.contains(target)) {
-      return;
+    if (lastOverlay === target) {
+      lastOverlay.lastFocus = undefined;
+      /**
+       * Otherwise, we must be focusing an element
+       * inside of the overlay. The two possible options
+       * here are an input/button/etc or the ion-focus-trap
+       * element. The focus trap element is used to prevent
+       * the keyboard focus from leaving the overlay when
+       * using Tab or screen assistants.
+       */
     }
-    const overlayWrapper = overlayRoot.querySelector('.ion-overlay-wrapper');
-    if (!overlayWrapper) {
-      return;
+    else {
+      /**
+       * We do not want to focus the traps, so get the overlay
+       * wrapper element as the traps live outside of the wrapper.
+       */
+      const overlayRoot = helpers.getElementRoot(lastOverlay);
+      if (!overlayRoot.contains(target)) {
+        return;
+      }
+      const overlayWrapper = overlayRoot.querySelector('.ion-overlay-wrapper');
+      if (!overlayWrapper) {
+        return;
+      }
+      /**
+       * If the target is inside the wrapper, let the browser
+       * focus as normal and keep a log of the last focused element.
+       */
+      if (overlayWrapper.contains(target)) {
+        lastOverlay.lastFocus = target;
+      }
+      else {
+        /**
+         * Otherwise, we must have focused one of the focus traps.
+         * We need to wrap the focus to either the first element
+         * or the last element.
+         */
+        /**
+         * Once we call `focusFirstDescendant` and focus the first
+         * descendant, another focus event will fire which will
+         * cause `lastOverlay.lastFocus` to be updated before
+         * we can run the code after that. We will cache the value
+         * here to avoid that.
+         */
+        const lastFocus = lastOverlay.lastFocus;
+        // Focus the first element in the overlay wrapper
+        focusFirstDescendant(overlayWrapper, lastOverlay);
+        /**
+         * If the cached last focused element is the
+         * same as the active element, then we need
+         * to wrap focus to the last descendant. This happens
+         * when the first descendant is focused, and the user
+         * presses Shift + Tab. The previous line will focus
+         * the same descendant again (the first one), causing
+         * last focus to equal the active element.
+         */
+        if (lastFocus === doc.activeElement) {
+          focusLastDescendant(overlayWrapper, lastOverlay);
+        }
+        lastOverlay.lastFocus = doc.activeElement;
+      }
     }
+  };
+  const trapShadowFocus = () => {
     /**
      * If the target is inside the wrapper, let the browser
      * focus as normal and keep a log of the last focused element.
      */
-    if (overlayWrapper.contains(target)) {
+    if (lastOverlay.contains(target)) {
       lastOverlay.lastFocus = target;
     }
     else {
       /**
-       * Otherwise, we must have focused one of the focus traps.
-       * We need to wrap the focus to either the first element
+       * Otherwise, we are about to have focus
+       * go out of the overlay. We need to wrap
+       * the focus to either the first element
        * or the last element.
        */
       /**
@@ -149,7 +226,7 @@ const trapKeyboardFocus = (ev, doc) => {
        */
       const lastFocus = lastOverlay.lastFocus;
       // Focus the first element in the overlay wrapper
-      focusFirstDescendant(overlayWrapper, lastOverlay);
+      focusFirstDescendant(lastOverlay, lastOverlay);
       /**
        * If the cached last focused element is the
        * same as the active element, then we need
@@ -160,30 +237,38 @@ const trapKeyboardFocus = (ev, doc) => {
        * last focus to equal the active element.
        */
       if (lastFocus === doc.activeElement) {
-        focusLastDescendant(overlayWrapper, lastOverlay);
+        focusLastDescendant(lastOverlay, lastOverlay);
       }
       lastOverlay.lastFocus = doc.activeElement;
     }
+  };
+  if (lastOverlay.shadowRoot) {
+    trapShadowFocus();
+  }
+  else {
+    trapScopedFocus();
   }
 };
 const connectListeners = (doc) => {
   if (lastId === 0) {
     lastId = 1;
-    doc.addEventListener('focus', ev => trapKeyboardFocus(ev, doc), true);
+    doc.addEventListener('focus', (ev) => {
+      trapKeyboardFocus(ev, doc);
+    }, true);
     // handle back-button click
-    doc.addEventListener('ionBackButton', ev => {
+    doc.addEventListener('ionBackButton', (ev) => {
       const lastOverlay = getOverlay(doc);
-      if (lastOverlay && lastOverlay.backdropDismiss) {
+      if (lastOverlay === null || lastOverlay === void 0 ? void 0 : lastOverlay.backdropDismiss) {
         ev.detail.register(hardwareBackButton.OVERLAY_BACK_BUTTON_PRIORITY, () => {
           return lastOverlay.dismiss(undefined, BACKDROP);
         });
       }
     });
     // handle ESC to close overlay
-    doc.addEventListener('keyup', ev => {
+    doc.addEventListener('keyup', (ev) => {
       if (ev.key === 'Escape') {
         const lastOverlay = getOverlay(doc);
-        if (lastOverlay && lastOverlay.backdropDismiss) {
+        if (lastOverlay === null || lastOverlay === void 0 ? void 0 : lastOverlay.backdropDismiss) {
           lastOverlay.dismiss(undefined, BACKDROP);
         }
       }
@@ -201,14 +286,18 @@ const getOverlays = (doc, selector) => {
   if (selector === undefined) {
     selector = 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-picker,ion-popover,ion-toast';
   }
-  return Array.from(doc.querySelectorAll(selector))
-    .filter(c => c.overlayIndex > 0);
+  return Array.from(doc.querySelectorAll(selector)).filter((c) => c.overlayIndex > 0);
 };
+/**
+ * Returns an overlay element
+ * @param doc The document to find the element within.
+ * @param overlayTag The selector for the overlay, defaults to Ionic overlay components.
+ * @param id The unique identifier for the overlay instance.
+ * @returns The overlay element or `undefined` if no overlay element is found.
+ */
 const getOverlay = (doc, overlayTag, id) => {
-  const overlays = getOverlays(doc, overlayTag);
-  return (id === undefined)
-    ? overlays[overlays.length - 1]
-    : overlays.find(o => o.id === id);
+  const overlays = getOverlays(doc, overlayTag).filter((o) => !isOverlayHidden(o));
+  return id === undefined ? overlays[overlays.length - 1] : overlays.find((o) => o.id === id);
 };
 /**
  * When an overlay is presented, the main
@@ -246,20 +335,23 @@ const setRootAriaHidden = (hidden = false) => {
   }
 };
 const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts) => {
+  var _a, _b;
   if (overlay.presented) {
     return;
   }
   setRootAriaHidden(true);
   overlay.presented = true;
   overlay.willPresent.emit();
+  (_a = overlay.willPresentShorthand) === null || _a === void 0 ? void 0 : _a.emit();
   const mode = ionicGlobal.getIonMode(overlay);
   // get the user's animation fn if one was provided
-  const animationBuilder = (overlay.enterAnimation)
+  const animationBuilder = overlay.enterAnimation
     ? overlay.enterAnimation
     : ionicGlobal.config.get(name, mode === 'ios' ? iosEnterAnimation : mdEnterAnimation);
   const completed = await overlayAnimation(overlay, animationBuilder, overlay.el, opts);
   if (completed) {
     overlay.didPresent.emit();
+    (_b = overlay.didPresentShorthand) === null || _b === void 0 ? void 0 : _b.emit();
   }
   /**
    * When an overlay that steals focus
@@ -272,7 +364,13 @@ const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts)
   if (overlay.el.tagName !== 'ION-TOAST') {
     focusPreviousElementOnDismiss(overlay.el);
   }
-  if (overlay.keyboardClose) {
+  /**
+   * If the focused element is already
+   * inside the overlay component then
+   * focus should not be moved from that
+   * to the overlay container.
+   */
+  if (overlay.keyboardClose && (document.activeElement === null || !overlay.el.contains(document.activeElement))) {
     overlay.el.focus();
   }
 };
@@ -291,15 +389,16 @@ const focusPreviousElementOnDismiss = async (overlayEl) => {
   if (!previousElement) {
     return;
   }
-  const shadowRoot = previousElement && previousElement.shadowRoot;
+  const shadowRoot = previousElement === null || previousElement === void 0 ? void 0 : previousElement.shadowRoot;
   if (shadowRoot) {
     // If there are no inner focusable elements, just focus the host element.
-    previousElement = shadowRoot.querySelector(innerFocusableQueryString) || previousElement;
+    previousElement = shadowRoot.querySelector(focusableQueryString) || previousElement;
   }
   await overlayEl.onDidDismiss();
   previousElement.focus();
 };
 const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnimation, opts) => {
+  var _a, _b;
   if (!overlay.presented) {
     return false;
   }
@@ -309,8 +408,9 @@ const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnim
     // Overlay contents should not be clickable during dismiss
     overlay.el.style.setProperty('pointer-events', 'none');
     overlay.willDismiss.emit({ data, role });
+    (_a = overlay.willDismissShorthand) === null || _a === void 0 ? void 0 : _a.emit({ data, role });
     const mode = ionicGlobal.getIonMode(overlay);
-    const animationBuilder = (overlay.leaveAnimation)
+    const animationBuilder = overlay.leaveAnimation
       ? overlay.leaveAnimation
       : ionicGlobal.config.get(name, mode === 'ios' ? iosLeaveAnimation : mdLeaveAnimation);
     // If dismissed via gesture, no need to play leaving animation again
@@ -318,7 +418,15 @@ const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnim
       await overlayAnimation(overlay, animationBuilder, overlay.el, opts);
     }
     overlay.didDismiss.emit({ data, role });
+    (_b = overlay.didDismissShorthand) === null || _b === void 0 ? void 0 : _b.emit({ data, role });
     activeAnimations.delete(overlay);
+    /**
+     * Make overlay hidden again in case it is being reused.
+     * We can safely remove pointer-events: none as
+     * overlay-hidden will set display: none.
+     */
+    overlay.el.classList.add('overlay-hidden');
+    overlay.el.style.removeProperty('pointer-events');
   }
   catch (err) {
     console.error(err);
@@ -332,7 +440,7 @@ const getAppRoot = (doc) => {
 const overlayAnimation = async (overlay, animationBuilder, baseEl, opts) => {
   // Make overlay visible in case it's hidden
   baseEl.classList.remove('overlay-hidden');
-  const aniRoot = baseEl.shadowRoot || overlay.el;
+  const aniRoot = overlay.el;
   const animation = animationBuilder(aniRoot, opts);
   if (!overlay.animated || !ionicGlobal.config.getBoolean('animated', true)) {
     animation.duration(0);
@@ -340,7 +448,7 @@ const overlayAnimation = async (overlay, animationBuilder, baseEl, opts) => {
   if (overlay.keyboardClose) {
     animation.beforeAddWrite(() => {
       const activeElement = baseEl.ownerDocument.activeElement;
-      if (activeElement && activeElement.matches('input, ion-input, ion-textarea')) {
+      if (activeElement === null || activeElement === void 0 ? void 0 : activeElement.matches('input,ion-input, ion-textarea')) {
         activeElement.blur();
       }
     });
@@ -352,7 +460,7 @@ const overlayAnimation = async (overlay, animationBuilder, baseEl, opts) => {
 };
 const eventMethod = (element, eventName) => {
   let resolve;
-  const promise = new Promise(r => resolve = r);
+  const promise = new Promise((r) => (resolve = r));
   onceEvent(element, eventName, (event) => {
     resolve(event.detail);
   });
@@ -369,6 +477,13 @@ const isCancel = (role) => {
   return role === 'cancel' || role === BACKDROP;
 };
 const defaultGate = (h) => h();
+/**
+ * Calls a developer provided method while avoiding
+ * Angular Zones. Since the handler is provided by
+ * the developer, we should throw any errors
+ * received so that developer-provided bug
+ * tracking software can log it.
+ */
 const safeCall = (handler, arg) => {
   if (typeof handler === 'function') {
     const jmp = ionicGlobal.config.get('_zoneGate', defaultGate);
@@ -377,7 +492,7 @@ const safeCall = (handler, arg) => {
         return handler(arg);
       }
       catch (e) {
-        console.error(e);
+        throw e;
       }
     });
   }
@@ -391,8 +506,9 @@ exports.activeAnimations = activeAnimations;
 exports.alertController = alertController;
 exports.dismiss = dismiss;
 exports.eventMethod = eventMethod;
+exports.focusFirstDescendant = focusFirstDescendant;
+exports.getOverlay = getOverlay;
 exports.isCancel = isCancel;
-exports.pickerController = pickerController;
 exports.popoverController = popoverController;
 exports.prepareOverlay = prepareOverlay;
 exports.present = present;

package/dist/cjs/spinner-configs-cd0abbeb.js

@@ -0,0 +1,147 @@
+'use strict';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const spinners = {
+  bubbles: {
+    dur: 1000,
+    circles: 9,
+    fn: (dur, index, total) => {
+      const animationDelay = `${(dur * index) / total - dur}ms`;
+      const angle = (2 * Math.PI * index) / total;
+      return {
+        r: 5,
+        style: {
+          top: `${9 * Math.sin(angle)}px`,
+          left: `${9 * Math.cos(angle)}px`,
+          'animation-delay': animationDelay,
+        },
+      };
+    },
+  },
+  circles: {
+    dur: 1000,
+    circles: 8,
+    fn: (dur, index, total) => {
+      const step = index / total;
+      const animationDelay = `${dur * step - dur}ms`;
+      const angle = 2 * Math.PI * step;
+      return {
+        r: 5,
+        style: {
+          top: `${9 * Math.sin(angle)}px`,
+          left: `${9 * Math.cos(angle)}px`,
+          'animation-delay': animationDelay,
+        },
+      };
+    },
+  },
+  circular: {
+    dur: 1400,
+    elmDuration: true,
+    circles: 1,
+    fn: () => {
+      return {
+        r: 20,
+        cx: 48,
+        cy: 48,
+        fill: 'none',
+        viewBox: '24 24 48 48',
+        transform: 'translate(0,0)',
+        style: {},
+      };
+    },
+  },
+  crescent: {
+    dur: 750,
+    circles: 1,
+    fn: () => {
+      return {
+        r: 26,
+        style: {},
+      };
+    },
+  },
+  dots: {
+    dur: 750,
+    circles: 3,
+    fn: (_, index) => {
+      const animationDelay = -(110 * index) + 'ms';
+      return {
+        r: 6,
+        style: {
+          left: `${9 - 9 * index}px`,
+          'animation-delay': animationDelay,
+        },
+      };
+    },
+  },
+  lines: {
+    dur: 1000,
+    lines: 8,
+    fn: (dur, index, total) => {
+      const transform = `rotate(${(360 / total) * index + (index < total / 2 ? 180 : -180)}deg)`;
+      const animationDelay = `${(dur * index) / total - dur}ms`;
+      return {
+        y1: 14,
+        y2: 26,
+        style: {
+          transform: transform,
+          'animation-delay': animationDelay,
+        },
+      };
+    },
+  },
+  'lines-small': {
+    dur: 1000,
+    lines: 8,
+    fn: (dur, index, total) => {
+      const transform = `rotate(${(360 / total) * index + (index < total / 2 ? 180 : -180)}deg)`;
+      const animationDelay = `${(dur * index) / total - dur}ms`;
+      return {
+        y1: 12,
+        y2: 20,
+        style: {
+          transform: transform,
+          'animation-delay': animationDelay,
+        },
+      };
+    },
+  },
+  'lines-sharp': {
+    dur: 1000,
+    lines: 12,
+    fn: (dur, index, total) => {
+      const transform = `rotate(${30 * index + (index < 6 ? 180 : -180)}deg)`;
+      const animationDelay = `${(dur * index) / total - dur}ms`;
+      return {
+        y1: 17,
+        y2: 29,
+        style: {
+          transform: transform,
+          'animation-delay': animationDelay,
+        },
+      };
+    },
+  },
+  'lines-sharp-small': {
+    dur: 1000,
+    lines: 12,
+    fn: (dur, index, total) => {
+      const transform = `rotate(${30 * index + (index < 6 ? 180 : -180)}deg)`;
+      const animationDelay = `${(dur * index) / total - dur}ms`;
+      return {
+        y1: 12,
+        y2: 20,
+        style: {
+          transform: transform,
+          'animation-delay': animationDelay,
+        },
+      };
+    },
+  },
+};
+const SPINNERS = spinners;
+
+exports.SPINNERS = SPINNERS;

package/dist/cjs/{status-tap-ada894ff.js → status-tap-beaa3a71.js}

@@ -1,8 +1,13 @@
 'use strict';
 
-const index = require('./index-b4a9ece2.js');
-const helpers = require('./helpers-398ced09.js');
+const index = require('./index-eaa0d16e.js');
+const index$1 = require('./index-9fca5d6f.js');
+const helpers = require('./helpers-cb08f5ae.js');
+require('./index-b2a479e4.js');
 
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
 const startStatusTap = () => {
   const win = window;
   win.addEventListener('statusTap', () => {
@@ -13,9 +18,9 @@ const startStatusTap = () => {
       if (!el) {
         return;
       }
-      const contentEl = el.closest('ion-content');
+      const contentEl = index$1.findClosestIonContent(el);
       if (contentEl) {
-        new Promise(resolve => helpers.componentOnReady(contentEl, resolve)).then(() => {
+        new Promise((resolve) => helpers.componentOnReady(contentEl, resolve)).then(() => {
           index.writeTask(async () => {
             /**
              * If scrolling and user taps status bar,
@@ -25,7 +30,7 @@ const startStatusTap = () => {
              * any in-progress momentum scrolling.
              */
             contentEl.style.setProperty('--overflow', 'hidden');
-            await contentEl.scrollToTop(300);
+            await index$1.scrollToTop(contentEl, 300);
             contentEl.style.removeProperty('--overflow');
           });
         });