@ionic/core 8.3.4-dev.11730140347.1a5a7bee → 8.3.4-dev.11730315987.18af6259

package/dist/esm/{animation-16546c84.js → animation-eab5a4ca.js}

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { w as win } from './ionic-global-d7017fd9.js';
+import { w as win } from './index-a5d50daf.js';
 
 let animationPrefix;
 const getAnimationPrefix = (el) => {

package/dist/esm/{app-globals-35381e66.js → app-globals-5dbb61a5.js}

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { i as initialize } from './ionic-global-d7017fd9.js';
+import { i as initialize } from './ionic-global-c81d82ab.js';
 
 const globalScripts = initialize;
 

package/dist/esm/{button-active-c768aceb.js → button-active-f6503382.js}

@@ -1,8 +1,8 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { w as writeTask } from './config-0b6b1b3d.js';
-import { h as hapticSelectionEnd, a as hapticSelectionStart, b as hapticSelectionChanged } from './haptic-d9a770b8.js';
+import { w as writeTask } from './index-28849c61.js';
+import { h as hapticSelectionEnd, a as hapticSelectionStart, b as hapticSelectionChanged } from './haptic-ac164e4c.js';
 import { createGesture } from './index-39782642.js';
 
 const createButtonActiveGesture = (el, isButton) => {

package/dist/esm/{capacitor-0897b83c.js → capacitor-59395cbd.js}

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { w as win } from './ionic-global-d7017fd9.js';
+import { w as win } from './index-a5d50daf.js';
 
 const getCapacitor = () => {
     if (win !== undefined) {

package/dist/esm/{data-d9b1fbdb.js → data-ae11fd43.js}

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { p as printIonWarning } from './ionic-global-d7017fd9.js';
+import { p as printIonWarning } from './index-9b0d46f4.js';
 
 /**
  * Returns true if the selected day is equal to the reference day
@@ -1147,20 +1147,20 @@ const hour23 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
 // h24 hour system uses 1-24. Midnight starts at 24:00.
 const hour24 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 0];
 /**
- * Given a locale and a theme,
+ * Given a locale and a mode,
  * return an array with formatted days
  * of the week. iOS should display days
  * such as "Mon" or "Tue".
  * MD should display days such as "M"
  * or "T".
  */
-const getDaysOfWeek = (locale, theme, firstDayOfWeek = 0) => {
+const getDaysOfWeek = (locale, mode, firstDayOfWeek = 0) => {
     /**
      * Nov 1st, 2020 starts on a Sunday.
      * ion-datetime assumes weeks start on Sunday,
      * but is configurable via `firstDayOfWeek`.
      */
-    const weekdayFormat = theme === 'ios' ? 'short' : 'narrow';
+    const weekdayFormat = mode === 'ios' ? 'short' : 'narrow';
     const intl = new Intl.DateTimeFormat(locale, { weekday: weekdayFormat });
     const startDate = new Date('11/01/2020');
     const daysOfWeek = [];

package/dist/{cjs/focus-visible-9aa87fa3.js → esm/focus-visible-dd40d69f.js}

@@ -1,8 +1,6 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-'use strict';
-
 const ION_FOCUSED = 'ion-focused';
 const ION_FOCUSABLE = 'ion-focusable';
 const FOCUS_KEYS = [
@@ -19,13 +17,6 @@ const FOCUS_KEYS = [
     'Home',
     'End',
 ];
-let focusVisibleUtility = null;
-const getOrInitFocusVisibleUtility = () => {
-    if (!focusVisibleUtility) {
-        focusVisibleUtility = startFocusVisible();
-    }
-    return focusVisibleUtility;
-};
 const startFocusVisible = (rootEl) => {
     let currentFocus = [];
     let keyboardMode = true;
@@ -81,5 +72,4 @@ const startFocusVisible = (rootEl) => {
     };
 };
 
-exports.getOrInitFocusVisibleUtility = getOrInitFocusVisibleUtility;
-exports.startFocusVisible = startFocusVisible;
+export { startFocusVisible };

package/dist/esm/{framework-delegate-56698eb0.js → framework-delegate-63d1a679.js}

@@ -1,8 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { c as config } from './config-0b6b1b3d.js';
-import { c as componentOnReady } from './helpers-d57f52c8.js';
+import { c as componentOnReady } from './helpers-da915de8.js';
 
 // TODO(FW-2832): types
 const attachComponent = async (delegate, container, component, cssClasses, componentProps, inline) => {
@@ -103,8 +102,7 @@ const CoreDelegate = () => {
          * Get the root of the app and
          * add the overlay there.
          */
-        const appRootSelector = config.get('appRootSelector', 'ion-app');
-        const app = document.querySelector(appRootSelector) || document.body;
+        const app = document.querySelector('ion-app') || document.body;
         /**
          * Create a placeholder comment so that
          * we can return this component to where

package/dist/esm/{haptic-d9a770b8.js → haptic-ac164e4c.js}

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { g as getCapacitor } from './capacitor-0897b83c.js';
+import { g as getCapacitor } from './capacitor-59395cbd.js';
 
 var ImpactStyle;
 (function (ImpactStyle) {

package/dist/esm/hardware-back-button-06ef3c3e.js

@@ -0,0 +1,116 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { w as win } from './index-a5d50daf.js';
+import { c as config } from './ionic-global-c81d82ab.js';
+import './index-28849c61.js';
+
+/**
+ * CloseWatcher is a newer API that lets
+ * use detect the hardware back button event
+ * in a web browser: https://caniuse.com/?search=closewatcher
+ * However, not every browser supports it yet.
+ *
+ * This needs to be a function so that we can
+ * check the config once it has been set.
+ * Otherwise, this code would be evaluated the
+ * moment this file is evaluated which could be
+ * before the config is set.
+ */
+const shouldUseCloseWatcher = () => config.get('experimentalCloseWatcher', false) && win !== undefined && 'CloseWatcher' in win;
+/**
+ * When hardwareBackButton: false in config,
+ * we need to make sure we also block the default
+ * webview behavior. If we don't then it will be
+ * possible for users to navigate backward while
+ * an overlay is still open. Additionally, it will
+ * give the appearance that the hardwareBackButton
+ * config is not working as the page transition
+ * will still happen.
+ */
+const blockHardwareBackButton = () => {
+    document.addEventListener('backbutton', () => { }); // eslint-disable-line
+};
+const startHardwareBackButton = () => {
+    const doc = document;
+    let busy = false;
+    const backButtonCallback = () => {
+        if (busy) {
+            return;
+        }
+        let index = 0;
+        let handlers = [];
+        const ev = new CustomEvent('ionBackButton', {
+            bubbles: false,
+            detail: {
+                register(priority, handler) {
+                    handlers.push({ priority, handler, id: index++ });
+                },
+            },
+        });
+        doc.dispatchEvent(ev);
+        const executeAction = async (handlerRegister) => {
+            try {
+                if (handlerRegister === null || handlerRegister === void 0 ? void 0 : handlerRegister.handler) {
+                    const result = handlerRegister.handler(processHandlers);
+                    if (result != null) {
+                        await result;
+                    }
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        };
+        const processHandlers = () => {
+            if (handlers.length > 0) {
+                let selectedHandler = {
+                    priority: Number.MIN_SAFE_INTEGER,
+                    handler: () => undefined,
+                    id: -1,
+                };
+                handlers.forEach((handler) => {
+                    if (handler.priority >= selectedHandler.priority) {
+                        selectedHandler = handler;
+                    }
+                });
+                busy = true;
+                handlers = handlers.filter((handler) => handler.id !== selectedHandler.id);
+                executeAction(selectedHandler).then(() => (busy = false));
+            }
+        };
+        processHandlers();
+    };
+    /**
+     * If the CloseWatcher is defined then
+     * we don't want to also listen for the native
+     * backbutton event otherwise we may get duplicate
+     * events firing.
+     */
+    if (shouldUseCloseWatcher()) {
+        let watcher;
+        const configureWatcher = () => {
+            watcher === null || watcher === void 0 ? void 0 : watcher.destroy();
+            watcher = new win.CloseWatcher();
+            /**
+             * Once a close request happens
+             * the watcher gets destroyed.
+             * As a result, we need to re-configure
+             * the watcher so we can respond to other
+             * close requests.
+             */
+            watcher.onclose = () => {
+                backButtonCallback();
+                configureWatcher();
+            };
+        };
+        configureWatcher();
+    }
+    else {
+        doc.addEventListener('backbutton', backButtonCallback);
+    }
+};
+const OVERLAY_BACK_BUTTON_PRIORITY = 100;
+const MENU_BACK_BUTTON_PRIORITY = 99; // 1 less than overlay priority since menu is displayed behind overlays
+
+export { MENU_BACK_BUTTON_PRIORITY, OVERLAY_BACK_BUTTON_PRIORITY, blockHardwareBackButton, shouldUseCloseWatcher, startHardwareBackButton };

package/dist/esm/{helpers-d57f52c8.js → helpers-da915de8.js}

@@ -1,8 +1,6 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { c as config } from './config-0b6b1b3d.js';
-
 const transitionEndAsync = (el, expectedDuration = 0) => {
     return new Promise((resolve) => {
         transitionEnd(el, expectedDuration, resolve);
@@ -243,8 +241,7 @@ const focusVisibleElement = (el) => {
      * which will let us explicitly set the elements to focus.
      */
     if (el.classList.contains('ion-focusable')) {
-        const appRootSelector = config.get('appRootSelector', 'ion-app');
-        const app = el.closest(appRootSelector);
+        const app = el.closest('ion-app');
         if (app) {
             app.setFocus([el]);
         }

package/dist/esm/{index-82405a4a.js → index-24b48b06.js}

@@ -1,9 +1,12 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { b as getIonMode, p as printIonWarning, d as doc, M as MENU_BACK_BUTTON_PRIORITY } from './ionic-global-d7017fd9.js';
-import { c as componentOnReady } from './helpers-d57f52c8.js';
-import { c as createAnimation } from './animation-16546c84.js';
+import { d as doc } from './index-a5d50daf.js';
+import { MENU_BACK_BUTTON_PRIORITY } from './hardware-back-button-06ef3c3e.js';
+import { p as printIonWarning } from './index-9b0d46f4.js';
+import { c as componentOnReady } from './helpers-da915de8.js';
+import { b as getIonMode } from './ionic-global-c81d82ab.js';
+import { c as createAnimation } from './animation-eab5a4ca.js';
 
 /**
  * baseAnimation
@@ -45,10 +48,10 @@ const menuOverlayAnimation = (menu) => {
     }
     menuAnimation.addElement(menu.menuInnerEl).fromTo('transform', `translateX(${closedX})`, `translateX(${openedX})`);
     const mode = getIonMode(menu);
-    const isIOS = mode === 'ios';
-    const opacity = isIOS ? 0.2 : 0.25;
+    const isIos = mode === 'ios';
+    const opacity = isIos ? 0.2 : 0.25;
     backdropAnimation.addElement(menu.backdropEl).fromTo('opacity', 0.01, opacity);
-    return baseAnimation(isIOS).addAnimation([menuAnimation, backdropAnimation]);
+    return baseAnimation(isIos).addAnimation([menuAnimation, backdropAnimation]);
 };
 
 /**
@@ -61,7 +64,6 @@ const menuPushAnimation = (menu) => {
     let menuClosedX;
     const mode = getIonMode(menu);
     const width = menu.width;
-    const isIOS = mode === 'ios';
     if (menu.isEndSide) {
         contentOpenedX = -width + 'px';
         menuClosedX = width + 'px';
@@ -77,7 +79,7 @@ const menuPushAnimation = (menu) => {
         .addElement(menu.contentEl)
         .fromTo('transform', 'translateX(0px)', `translateX(${contentOpenedX})`);
     const backdropAnimation = createAnimation().addElement(menu.backdropEl).fromTo('opacity', 0.01, 0.32);
-    return baseAnimation(isIOS).addAnimation([menuAnimation, contentAnimation, backdropAnimation]);
+    return baseAnimation(mode === 'ios').addAnimation([menuAnimation, contentAnimation, backdropAnimation]);
 };
 
 /**
@@ -87,12 +89,11 @@ const menuPushAnimation = (menu) => {
  */
 const menuRevealAnimation = (menu) => {
     const mode = getIonMode(menu);
-    const isIOS = mode === 'ios';
     const openedX = menu.width * (menu.isEndSide ? -1 : 1) + 'px';
     const contentOpen = createAnimation()
         .addElement(menu.contentEl) // REVIEW
         .fromTo('transform', 'translateX(0px)', `translateX(${openedX})`);
-    return baseAnimation(isIOS).addAnimation(contentOpen);
+    return baseAnimation(mode === 'ios').addAnimation(contentOpen);
 };
 
 const createMenuController = () => {
@@ -230,7 +231,7 @@ const createMenuController = () => {
             menus.splice(index, 1);
         }
     };
-    const _setOpen = async (menu, shouldOpen, animated) => {
+    const _setOpen = async (menu, shouldOpen, animated, role) => {
         if (isAnimatingSync()) {
             return false;
         }
@@ -240,7 +241,7 @@ const createMenuController = () => {
                 await openedMenu.setOpen(false, false);
             }
         }
-        return menu._setOpen(shouldOpen, animated);
+        return menu._setOpen(shouldOpen, animated, role);
     };
     const _createAnimation = (type, menuCmp) => {
         const animationBuilder = menuAnimations.get(type); // TODO(FW-2832): type

package/dist/esm/{config-0b6b1b3d.js → index-28849c61.js}

@@ -2285,79 +2285,4 @@ var hostListenerOpts = (flags) => supportsListenerOptions ? {
 // src/runtime/nonce.ts
 var setNonce = (nonce) => plt.$nonce$ = nonce;
 
-// TODO(FW-2832): types
-class Config {
-    constructor() {
-        this.m = new Map();
-    }
-    reset(configObj) {
-        this.m = new Map(Object.entries(configObj));
-    }
-    get(key, fallback) {
-        const value = this.m.get(key);
-        return value !== undefined ? value : fallback;
-    }
-    getBoolean(key, fallback = false) {
-        const val = this.m.get(key);
-        if (val === undefined) {
-            return fallback;
-        }
-        if (typeof val === 'string') {
-            return val === 'true';
-        }
-        return !!val;
-    }
-    getNumber(key, fallback) {
-        const val = parseFloat(this.m.get(key));
-        return isNaN(val) ? (fallback !== undefined ? fallback : NaN) : val;
-    }
-    set(key, value) {
-        this.m.set(key, value);
-    }
-}
-const config = /*@__PURE__*/ new Config();
-const configFromSession = (win) => {
-    try {
-        const configStr = win.sessionStorage.getItem(IONIC_SESSION_KEY);
-        return configStr !== null ? JSON.parse(configStr) : {};
-    }
-    catch (e) {
-        return {};
-    }
-};
-const saveConfig = (win, c) => {
-    try {
-        win.sessionStorage.setItem(IONIC_SESSION_KEY, JSON.stringify(c));
-    }
-    catch (e) {
-        return;
-    }
-};
-const configFromURL = (win) => {
-    const configObj = {};
-    win.location.search
-        .slice(1)
-        .split('&')
-        .map((entry) => entry.split('='))
-        .map(([key, value]) => {
-        try {
-            return [decodeURIComponent(key), decodeURIComponent(value)];
-        }
-        catch (e) {
-            return ['', ''];
-        }
-    })
-        .filter(([key]) => startsWith(key, IONIC_PREFIX))
-        .map(([key, value]) => [key.slice(IONIC_PREFIX.length), value])
-        .forEach(([key, value]) => {
-        configObj[key] = value;
-    });
-    return configObj;
-};
-const startsWith = (input, search) => {
-    return input.substr(0, search.length) === search;
-};
-const IONIC_PREFIX = 'ionic:';
-const IONIC_SESSION_KEY = 'ionic-persist-config';
-
-export { Build as B, H, setPlatformHelpers as a, bootstrapLazy as b, config as c, configFromSession as d, configFromURL as e, saveConfig as f, getElement as g, getMode as h, setMode as i, createEvent as j, readTask as k, h as l, Host as m, forceUpdate as n, getAssetPath as o, promiseResolve as p, registerInstance as r, setNonce as s, writeTask as w };
+export { Build as B, H, setPlatformHelpers as a, bootstrapLazy as b, setMode as c, createEvent as d, readTask as e, Host as f, getMode as g, h, getElement as i, forceUpdate as j, getAssetPath as k, promiseResolve as p, registerInstance as r, setNonce as s, writeTask as w };

package/dist/esm/{index-edf94b3b.js → index-3ad7f18b.js}

@@ -1,9 +1,10 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { c as config, w as writeTask, B as Build } from './config-0b6b1b3d.js';
-import { p as printIonWarning } from './ionic-global-d7017fd9.js';
-import { r as raf } from './helpers-d57f52c8.js';
+import { c as config } from './ionic-global-c81d82ab.js';
+import { w as writeTask, B as Build } from './index-28849c61.js';
+import { p as printIonWarning } from './index-9b0d46f4.js';
+import { r as raf } from './helpers-da915de8.js';
 
 const LIFECYCLE_WILL_ENTER = 'ionViewWillEnter';
 const LIFECYCLE_DID_ENTER = 'ionViewDidEnter';
@@ -119,8 +120,8 @@ const createFocusController = () => {
 };
 const LAST_FOCUS = 'ion-last-focus';
 
-const iosTransitionAnimation = () => import('./ios.transition-4b9fe79e.js');
-const mdTransitionAnimation = () => import('./md.transition-a71dc418.js');
+const iosTransitionAnimation = () => import('./ios.transition-4ee1a3af.js');
+const mdTransitionAnimation = () => import('./md.transition-5106a0d2.js');
 const focusController = createFocusController();
 // TODO(FW-2832): types
 const transition = (opts) => {

package/dist/esm/{index-f8ad386a.js → index-5cc724f3.js}

@@ -1,8 +1,8 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { c as componentOnReady } from './helpers-d57f52c8.js';
-import { f as printRequiredElementError } from './ionic-global-d7017fd9.js';
+import { c as componentOnReady } from './helpers-da915de8.js';
+import { b as printRequiredElementError } from './index-9b0d46f4.js';
 
 const ION_CONTENT_TAG_NAME = 'ION-CONTENT';
 const ION_CONTENT_ELEMENT_SELECTOR = 'ion-content';

package/dist/esm/index-79b30591.js

@@ -0,0 +1,167 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { d as doc } from './index-a5d50daf.js';
+import { p as pointerCoord } from './helpers-da915de8.js';
+
+const startTapClick = (config) => {
+    if (doc === undefined) {
+        return;
+    }
+    let lastActivated = 0;
+    let activatableEle;
+    let activeRipple;
+    let activeDefer;
+    const useRippleEffect = config.getBoolean('animated', true) && config.getBoolean('rippleEffect', true);
+    const clearDefers = new WeakMap();
+    const cancelActive = () => {
+        if (activeDefer)
+            clearTimeout(activeDefer);
+        activeDefer = undefined;
+        if (activatableEle) {
+            removeActivated(false);
+            activatableEle = undefined;
+        }
+    };
+    const pointerDown = (ev) => {
+        // Ignore right clicks
+        if (activatableEle || ev.button === 2) {
+            return;
+        }
+        setActivatedElement(getActivatableTarget(ev), ev);
+    };
+    const pointerUp = (ev) => {
+        setActivatedElement(undefined, ev);
+    };
+    const setActivatedElement = (el, ev) => {
+        // do nothing
+        if (el && el === activatableEle) {
+            return;
+        }
+        if (activeDefer)
+            clearTimeout(activeDefer);
+        activeDefer = undefined;
+        const { x, y } = pointerCoord(ev);
+        // deactivate selected
+        if (activatableEle) {
+            if (clearDefers.has(activatableEle)) {
+                throw new Error('internal error');
+            }
+            if (!activatableEle.classList.contains(ACTIVATED)) {
+                addActivated(activatableEle, x, y);
+            }
+            removeActivated(true);
+        }
+        // activate
+        if (el) {
+            const deferId = clearDefers.get(el);
+            if (deferId) {
+                clearTimeout(deferId);
+                clearDefers.delete(el);
+            }
+            el.classList.remove(ACTIVATED);
+            const callback = () => {
+                addActivated(el, x, y);
+                activeDefer = undefined;
+            };
+            if (isInstant(el)) {
+                callback();
+            }
+            else {
+                activeDefer = setTimeout(callback, ADD_ACTIVATED_DEFERS);
+            }
+        }
+        activatableEle = el;
+    };
+    const addActivated = (el, x, y) => {
+        lastActivated = Date.now();
+        el.classList.add(ACTIVATED);
+        if (!useRippleEffect)
+            return;
+        const rippleEffect = getRippleEffect(el);
+        if (rippleEffect !== null) {
+            removeRipple();
+            activeRipple = rippleEffect.addRipple(x, y);
+        }
+    };
+    const removeRipple = () => {
+        if (activeRipple !== undefined) {
+            activeRipple.then((remove) => remove());
+            activeRipple = undefined;
+        }
+    };
+    const removeActivated = (smooth) => {
+        removeRipple();
+        const active = activatableEle;
+        if (!active) {
+            return;
+        }
+        const time = CLEAR_STATE_DEFERS - Date.now() + lastActivated;
+        if (smooth && time > 0 && !isInstant(active)) {
+            const deferId = setTimeout(() => {
+                active.classList.remove(ACTIVATED);
+                clearDefers.delete(active);
+            }, CLEAR_STATE_DEFERS);
+            clearDefers.set(active, deferId);
+        }
+        else {
+            active.classList.remove(ACTIVATED);
+        }
+    };
+    doc.addEventListener('ionGestureCaptured', cancelActive);
+    doc.addEventListener('pointerdown', pointerDown, true);
+    doc.addEventListener('pointerup', pointerUp, true);
+    /**
+     * Tap click effects such as the ripple effect should
+     * not happen when scrolling. For example, if a user scrolls
+     * the page but also happens to do a touchstart on a button
+     * as part of the scroll, the ripple effect should not
+     * be dispatched. The ripple effect should only happen
+     * if the button is activated and the page is not scrolling.
+     *
+     * pointercancel is dispatched on a gesture when scrolling
+     * starts, so this lets us avoid having to listen for
+     * ion-content's scroll events.
+     */
+    doc.addEventListener('pointercancel', cancelActive, true);
+};
+// TODO(FW-2832): type
+const getActivatableTarget = (ev) => {
+    if (ev.composedPath !== undefined) {
+        /**
+         * composedPath returns EventTarget[]. However,
+         * objects other than Element can be targets too.
+         * For example, AudioContext can be a target. In this
+         * case, we know that the event is a UIEvent so we
+         * can assume that the path will contain either Element
+         * or ShadowRoot.
+         */
+        const path = ev.composedPath();
+        for (let i = 0; i < path.length - 2; i++) {
+            const el = path[i];
+            if (!(el instanceof ShadowRoot) && el.classList.contains('ion-activatable')) {
+                return el;
+            }
+        }
+    }
+    else {
+        return ev.target.closest('.ion-activatable');
+    }
+};
+const isInstant = (el) => {
+    return el.classList.contains('ion-activatable-instant');
+};
+const getRippleEffect = (el) => {
+    if (el.shadowRoot) {
+        const ripple = el.shadowRoot.querySelector('ion-ripple-effect');
+        if (ripple) {
+            return ripple;
+        }
+    }
+    return el.querySelector('ion-ripple-effect');
+};
+const ACTIVATED = 'ion-activated';
+const ADD_ACTIVATED_DEFERS = 100;
+const CLEAR_STATE_DEFERS = 150;
+
+export { startTapClick };

package/dist/esm/index-9b0d46f4.js

@@ -0,0 +1,34 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Logs a warning to the console with an Ionic prefix
+ * to indicate the library that is warning the developer.
+ *
+ * @param message - The string message to be logged to the console.
+ */
+const printIonWarning = (message, ...params) => {
+    return console.warn(`[Ionic Warning]: ${message}`, ...params);
+};
+/*
+ * Logs an error to the console with an Ionic prefix
+ * to indicate the library that is warning the developer.
+ *
+ * @param message - The string message to be logged to the console.
+ * @param params - Additional arguments to supply to the console.error.
+ */
+const printIonError = (message, ...params) => {
+    return console.error(`[Ionic Error]: ${message}`, ...params);
+};
+/**
+ * Prints an error informing developers that an implementation requires an element to be used
+ * within a specific selector.
+ *
+ * @param el The web component element this is requiring the element.
+ * @param targetSelectors The selector or selectors that were not found.
+ */
+const printRequiredElementError = (el, ...targetSelectors) => {
+    return console.error(`<${el.tagName.toLowerCase()}> must be used inside ${targetSelectors.join(' or ')}.`);
+};
+
+export { printIonError as a, printRequiredElementError as b, printIonWarning as p };