@ionic/core 8.7.19-dev.11772655618.1af0949f → 8.7.19-dev.11773072221.15efeed0

package/dist/esm/{animation-CnGMT4ji.js → animation-Dt8bGnA-.js}

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { j as printIonError } from './index-IGIE5vDm.js';
+import { j as printIonError } from './index-C8IsBmNU.js';
 import { w as win } from './index-ZjP4CjeZ.js';
 
 let animationPrefix;

package/dist/esm/app-globals-BDSf8fOA.js

@@ -0,0 +1,8 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { i as initialize } from './ionic-global-CDrldh-5.js';
+
+const globalScripts = initialize;
+
+export { globalScripts as g };

package/dist/esm/{button-active-BBx21brx.js → button-active-L570Swow.js}

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { w as writeTask } from './index-IGIE5vDm.js';
+import { w as writeTask } from './index-C8IsBmNU.js';
 import { h as hapticSelectionEnd, a as hapticSelectionChanged, b as hapticSelectionStart } from './haptic-DzAMWJuk.js';
 import { createGesture } from './index-CfgBF1SE.js';
 

package/dist/esm/config-mCdtaoPe.js

@@ -0,0 +1,195 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { j as printIonError } from './index-C8IsBmNU.js';
+
+/**
+ * Does a simple sanitization of all elements
+ * in an untrusted string
+ */
+const sanitizeDOMString = (untrustedString) => {
+    try {
+        if (untrustedString instanceof IonicSafeString) {
+            return untrustedString.value;
+        }
+        if (!isSanitizerEnabled() || typeof untrustedString !== 'string' || untrustedString === '') {
+            return untrustedString;
+        }
+        /**
+         * onload is fired when appending to a document
+         * fragment in Chrome. If a string
+         * contains onload then we should not
+         * attempt to add this to the fragment.
+         */
+        if (untrustedString.includes('onload=')) {
+            return '';
+        }
+        /**
+         * Create a document fragment
+         * separate from the main DOM,
+         * create a div to do our work in
+         */
+        const documentFragment = document.createDocumentFragment();
+        const workingDiv = document.createElement('div');
+        documentFragment.appendChild(workingDiv);
+        workingDiv.innerHTML = untrustedString;
+        /**
+         * Remove any elements
+         * that are blocked
+         */
+        blockedTags.forEach((blockedTag) => {
+            const getElementsToRemove = documentFragment.querySelectorAll(blockedTag);
+            for (let elementIndex = getElementsToRemove.length - 1; elementIndex >= 0; elementIndex--) {
+                const element = getElementsToRemove[elementIndex];
+                if (element.parentNode) {
+                    element.parentNode.removeChild(element);
+                }
+                else {
+                    documentFragment.removeChild(element);
+                }
+                /**
+                 * We still need to sanitize
+                 * the children of this element
+                 * as they are left behind
+                 */
+                const childElements = getElementChildren(element);
+                /* eslint-disable-next-line */
+                for (let childIndex = 0; childIndex < childElements.length; childIndex++) {
+                    sanitizeElement(childElements[childIndex]);
+                }
+            }
+        });
+        /**
+         * Go through remaining elements and remove
+         * non-allowed attribs
+         */
+        // IE does not support .children on document fragments, only .childNodes
+        const dfChildren = getElementChildren(documentFragment);
+        /* eslint-disable-next-line */
+        for (let childIndex = 0; childIndex < dfChildren.length; childIndex++) {
+            sanitizeElement(dfChildren[childIndex]);
+        }
+        // Append document fragment to div
+        const fragmentDiv = document.createElement('div');
+        fragmentDiv.appendChild(documentFragment);
+        // First child is always the div we did our work in
+        const getInnerDiv = fragmentDiv.querySelector('div');
+        return getInnerDiv !== null ? getInnerDiv.innerHTML : fragmentDiv.innerHTML;
+    }
+    catch (err) {
+        printIonError('sanitizeDOMString', err);
+        return '';
+    }
+};
+/**
+ * Clean up current element based on allowed attributes
+ * and then recursively dig down into any child elements to
+ * clean those up as well
+ */
+// TODO(FW-2832): type (using Element triggers other type errors as well)
+const sanitizeElement = (element) => {
+    // IE uses childNodes, so ignore nodes that are not elements
+    if (element.nodeType && element.nodeType !== 1) {
+        return;
+    }
+    /**
+     * If attributes is not a NamedNodeMap
+     * then we should remove the element entirely.
+     * This helps avoid DOM Clobbering attacks where
+     * attributes is overridden.
+     */
+    if (typeof NamedNodeMap !== 'undefined' && !(element.attributes instanceof NamedNodeMap)) {
+        element.remove();
+        return;
+    }
+    for (let i = element.attributes.length - 1; i >= 0; i--) {
+        const attribute = element.attributes.item(i);
+        const attributeName = attribute.name;
+        // remove non-allowed attribs
+        if (!allowedAttributes.includes(attributeName.toLowerCase())) {
+            element.removeAttribute(attributeName);
+            continue;
+        }
+        // clean up any allowed attribs
+        // that attempt to do any JS funny-business
+        const attributeValue = attribute.value;
+        /**
+         * We also need to check the property value
+         * as javascript: can allow special characters
+         * such as &Tab; and still be valid (i.e. java&Tab;script)
+         */
+        const propertyValue = element[attributeName];
+        /* eslint-disable */
+        if ((attributeValue != null && attributeValue.toLowerCase().includes('javascript:')) ||
+            (propertyValue != null && propertyValue.toLowerCase().includes('javascript:'))) {
+            element.removeAttribute(attributeName);
+        }
+        /* eslint-enable */
+    }
+    /**
+     * Sanitize any nested children
+     */
+    const childElements = getElementChildren(element);
+    /* eslint-disable-next-line */
+    for (let i = 0; i < childElements.length; i++) {
+        sanitizeElement(childElements[i]);
+    }
+};
+/**
+ * IE doesn't always support .children
+ * so we revert to .childNodes instead
+ */
+// TODO(FW-2832): type
+const getElementChildren = (el) => {
+    return el.children != null ? el.children : el.childNodes;
+};
+const isSanitizerEnabled = () => {
+    var _a;
+    const win = window;
+    const config = (_a = win === null || win === void 0 ? void 0 : win.Ionic) === null || _a === void 0 ? void 0 : _a.config;
+    if (config) {
+        if (config.get) {
+            return config.get('sanitizerEnabled', true);
+        }
+        else {
+            return config.sanitizerEnabled === true || config.sanitizerEnabled === undefined;
+        }
+    }
+    return true;
+};
+const allowedAttributes = ['class', 'id', 'href', 'src', 'name', 'slot'];
+const blockedTags = ['script', 'style', 'iframe', 'meta', 'link', 'object', 'embed'];
+class IonicSafeString {
+    constructor(value) {
+        this.value = value;
+    }
+}
+
+const setupConfig = (config) => {
+    const win = window;
+    const Ionic = win.Ionic;
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (Ionic && Ionic.config && Ionic.config.constructor.name !== 'Object') {
+        return;
+    }
+    win.Ionic = win.Ionic || {};
+    win.Ionic.config = Object.assign(Object.assign({}, win.Ionic.config), config);
+    return win.Ionic.config;
+};
+const getMode = () => {
+    var _a;
+    const win = window;
+    const config = (_a = win === null || win === void 0 ? void 0 : win.Ionic) === null || _a === void 0 ? void 0 : _a.config;
+    if (config) {
+        if (config.mode) {
+            return config.mode;
+        }
+        else {
+            return config.get('mode');
+        }
+    }
+    return 'md';
+};
+const ENABLE_HTML_CONTENT_DEFAULT = false;
+
+export { ENABLE_HTML_CONTENT_DEFAULT as E, IonicSafeString as I, sanitizeDOMString as a, getMode as g, setupConfig as s };

package/dist/esm/{data-B9iGR5YO.js → data-DCORV9FH.js}

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { f as printIonWarning } from './index-IGIE5vDm.js';
+import { f as printIonWarning } from './index-C8IsBmNU.js';
 
 /**
  * Returns true if the selected day is equal to the reference day

package/dist/esm/framework-delegate-BYawdMXj.js

@@ -0,0 +1,140 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { c as componentOnReady } from './helpers-DEn3pfjm.js';
+
+// TODO(FW-2832): types
+const attachComponent = async (delegate, container, component, cssClasses, componentProps, inline) => {
+    var _a;
+    if (delegate) {
+        return delegate.attachViewToDom(container, component, componentProps, cssClasses);
+    }
+    if (!inline && typeof component !== 'string' && !(component instanceof HTMLElement)) {
+        throw new Error('framework delegate is missing');
+    }
+    const el = typeof component === 'string' ? (_a = container.ownerDocument) === null || _a === void 0 ? void 0 : _a.createElement(component) : component;
+    if (cssClasses) {
+        cssClasses.forEach((c) => el.classList.add(c));
+    }
+    if (componentProps) {
+        Object.assign(el, componentProps);
+    }
+    container.appendChild(el);
+    await new Promise((resolve) => componentOnReady(el, resolve));
+    return el;
+};
+const detachComponent = (delegate, element) => {
+    if (element) {
+        if (delegate) {
+            const container = element.parentElement;
+            return delegate.removeViewFromDom(container, element);
+        }
+        element.remove();
+    }
+    return Promise.resolve();
+};
+const CoreDelegate = () => {
+    let BaseComponent;
+    let Reference;
+    const attachViewToDom = async (parentElement, userComponent, userComponentProps = {}, cssClasses = []) => {
+        var _a, _b;
+        BaseComponent = parentElement;
+        let ChildComponent;
+        /**
+         * If passing in a component via the `component` props
+         * we need to append it inside of our overlay component.
+         */
+        if (userComponent) {
+            /**
+             * If passing in the tag name, create
+             * the element otherwise just get a reference
+             * to the component.
+             */
+            const el = typeof userComponent === 'string' ? (_a = BaseComponent.ownerDocument) === null || _a === void 0 ? void 0 : _a.createElement(userComponent) : userComponent;
+            /**
+             * Add any css classes passed in
+             * via the cssClasses prop on the overlay.
+             */
+            cssClasses.forEach((c) => el.classList.add(c));
+            /**
+             * Add any props passed in
+             * via the componentProps prop on the overlay.
+             */
+            Object.assign(el, userComponentProps);
+            /**
+             * Finally, append the component
+             * inside of the overlay component.
+             */
+            BaseComponent.appendChild(el);
+            ChildComponent = el;
+            await new Promise((resolve) => componentOnReady(el, resolve));
+        }
+        else if (BaseComponent.children.length > 0 &&
+            (BaseComponent.tagName === 'ION-MODAL' || BaseComponent.tagName === 'ION-POPOVER')) {
+            /**
+             * The delegate host wrapper el is only needed for modals and popovers
+             * because they allow the dev to provide custom content to the overlay.
+             */
+            const root = (ChildComponent = BaseComponent.children[0]);
+            if (!root.classList.contains('ion-delegate-host')) {
+                /**
+                 * If the root element is not a delegate host, it means
+                 * that the overlay has not been presented yet and we need
+                 * to create the containing element with the specified classes.
+                 */
+                const el = (_b = BaseComponent.ownerDocument) === null || _b === void 0 ? void 0 : _b.createElement('div');
+                // Add a class to track if the root element was created by the delegate.
+                el.classList.add('ion-delegate-host');
+                cssClasses.forEach((c) => el.classList.add(c));
+                // Move each child from the original template to the new parent element.
+                el.append(...BaseComponent.children);
+                // Append the new parent element to the original parent element.
+                BaseComponent.appendChild(el);
+                /**
+                 * Update the ChildComponent to be the
+                 * newly created div in the event that one
+                 * does not already exist.
+                 */
+                ChildComponent = el;
+            }
+        }
+        /**
+         * Get the root of the app and
+         * add the overlay there.
+         */
+        const app = document.querySelector('ion-app') || document.body;
+        /**
+         * Create a placeholder comment so that
+         * we can return this component to where
+         * it was previously.
+         */
+        Reference = document.createComment('ionic teleport');
+        BaseComponent.parentNode.insertBefore(Reference, BaseComponent);
+        app.appendChild(BaseComponent);
+        /**
+         * We return the child component rather than the overlay
+         * reference itself since modal and popover will
+         * use this to wait for any Ionic components in the child view
+         * to be ready (i.e. componentOnReady) when using the
+         * lazy loaded component bundle.
+         *
+         * However, we fall back to returning BaseComponent
+         * in the event that a modal or popover is presented
+         * with no child content.
+         */
+        return ChildComponent !== null && ChildComponent !== void 0 ? ChildComponent : BaseComponent;
+    };
+    const removeViewFromDom = () => {
+        /**
+         * Return component to where it was previously in the DOM.
+         */
+        if (BaseComponent && Reference) {
+            Reference.parentNode.insertBefore(BaseComponent, Reference);
+            Reference.remove();
+        }
+        return Promise.resolve();
+    };
+    return { attachViewToDom, removeViewFromDom };
+};
+
+export { CoreDelegate as C, attachComponent as a, detachComponent as d };

package/dist/esm/{hardware-back-button-CTe4XmL7.js → hardware-back-button-CPLxO-Ev.js}

@@ -2,7 +2,7 @@
  * (C) Ionic http://ionicframework.com - MIT License
  */
 import { w as win } from './index-ZjP4CjeZ.js';
-import { e as config, j as printIonError } from './index-IGIE5vDm.js';
+import { e as config, j as printIonError } from './index-C8IsBmNU.js';
 
 /**
  * CloseWatcher is a newer API that lets

package/dist/esm/{helpers-Tl8jw6S2.js → helpers-DEn3pfjm.js}

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { j as printIonError } from './index-IGIE5vDm.js';
+import { j as printIonError } from './index-C8IsBmNU.js';
 
 const transitionEndAsync = (el, expectedDuration = 0) => {
     return new Promise((resolve) => {

package/dist/esm/{index-hW6eNZ3o.js → index-Bs3kT4bc.js}

@@ -1,8 +1,8 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { c as componentOnReady } from './helpers-Tl8jw6S2.js';
-import { t as printRequiredElementError } from './index-IGIE5vDm.js';
+import { c as componentOnReady } from './helpers-DEn3pfjm.js';
+import { t as printRequiredElementError } from './index-C8IsBmNU.js';
 
 const ION_CONTENT_TAG_NAME = 'ION-CONTENT';
 const ION_CONTENT_ELEMENT_SELECTOR = 'ion-content';