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

package/dist/esm/{overlays-fc9a0625.js → overlays-0c7f05e1.js}

@@ -1,7 +1,10 @@
-import { g as getIonMode, c as config } from './ionic-global-2e28f7c7.js';
-import { OVERLAY_BACK_BUTTON_PRIORITY } from './hardware-back-button-bb4c578a.js';
-import { a as componentOnReady, b as addEventListener, e as removeEventListener, g as getElementRoot } from './helpers-44e3bd9f.js';
+import { g as getIonMode, c as config } from './ionic-global-6cd57191.js';
+import { OVERLAY_BACK_BUTTON_PRIORITY } from './hardware-back-button-242191a7.js';
+import { c as componentOnReady, e as addEventListener, m as focusElement, f as removeEventListener, g as getElementRoot } from './helpers-aeff219b.js';
 
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
 let lastId = 0;
 const activeAnimations = new WeakMap();
 const createController = (tagName) => {
@@ -14,15 +17,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);
   }
@@ -33,45 +34,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 => componentOnReady(element, resolve));
+      return new Promise((resolve) => 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();
+    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();
@@ -89,53 +103,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 = 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 = 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.
        */
       /**
@@ -147,7 +224,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
@@ -158,30 +235,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(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);
         }
       }
@@ -199,14 +284,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
@@ -244,20 +333,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 = getIonMode(overlay);
   // get the user's animation fn if one was provided
-  const animationBuilder = (overlay.enterAnimation)
+  const animationBuilder = overlay.enterAnimation
     ? overlay.enterAnimation
     : 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
@@ -270,7 +362,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();
   }
 };
@@ -289,15 +387,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;
   }
@@ -307,8 +406,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 = getIonMode(overlay);
-    const animationBuilder = (overlay.leaveAnimation)
+    const animationBuilder = overlay.leaveAnimation
       ? overlay.leaveAnimation
       : config.get(name, mode === 'ios' ? iosLeaveAnimation : mdLeaveAnimation);
     // If dismissed via gesture, no need to play leaving animation again
@@ -316,7 +416,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);
@@ -330,7 +438,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 || !config.getBoolean('animated', true)) {
     animation.duration(0);
@@ -338,7 +446,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();
       }
     });
@@ -350,7 +458,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);
   });
@@ -367,6 +475,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 = config.get('_zoneGate', defaultGate);
@@ -375,7 +490,7 @@ const safeCall = (handler, arg) => {
         return handler(arg);
       }
       catch (e) {
-        console.error(e);
+        throw e;
       }
     });
   }
@@ -383,4 +498,4 @@ const safeCall = (handler, arg) => {
 };
 const BACKDROP = 'backdrop';
 
-export { BACKDROP as B, prepareOverlay as a, pickerController as b, activeAnimations as c, dismiss as d, eventMethod as e, popoverController as f, actionSheetController as g, alertController as h, isCancel as i, present as p, safeCall as s };
+export { BACKDROP as B, present as a, activeAnimations as b, popoverController as c, dismiss as d, eventMethod as e, actionSheetController as f, getOverlay as g, alertController as h, isCancel as i, focusFirstDescendant as j, prepareOverlay as p, safeCall as s };

package/dist/esm/spinner-configs-cbcd1f62.js

@@ -0,0 +1,145 @@
+/*!
+ * (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;
+
+export { SPINNERS as S };

package/dist/esm/{status-tap-69e62ad6.js → status-tap-ad757b8a.js}

@@ -1,6 +1,11 @@
-import { d as readTask, w as writeTask } from './index-e4deec27.js';
-import { a as componentOnReady } from './helpers-44e3bd9f.js';
+import { e as readTask, w as writeTask } from './index-cb938ffb.js';
+import { a as findClosestIonContent, s as scrollToTop } from './index-ebf7f059.js';
+import { c as componentOnReady } from './helpers-aeff219b.js';
+import './index-1f3d8582.js';
 
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
 const startStatusTap = () => {
   const win = window;
   win.addEventListener('statusTap', () => {
@@ -11,9 +16,9 @@ const startStatusTap = () => {
       if (!el) {
         return;
       }
-      const contentEl = el.closest('ion-content');
+      const contentEl = findClosestIonContent(el);
       if (contentEl) {
-        new Promise(resolve => componentOnReady(contentEl, resolve)).then(() => {
+        new Promise((resolve) => componentOnReady(contentEl, resolve)).then(() => {
           writeTask(async () => {
             /**
              * If scrolling and user taps status bar,
@@ -23,7 +28,7 @@ const startStatusTap = () => {
              * any in-progress momentum scrolling.
              */
             contentEl.style.setProperty('--overflow', 'hidden');
-            await contentEl.scrollToTop(300);
+            await scrollToTop(contentEl, 300);
             contentEl.style.removeProperty('--overflow');
           });
         });