@ionic/core 8.5.4-dev.11743804857.1f3f3ee1 → 8.5.4-dev.11743808789.130d15f2

package/dist/cjs/animation-Bz5ImL40.js.map

@@ -0,0 +1 @@
+{"sourcesContent":[]}

package/dist/cjs/app-globals-D7rrMPwl.js

@@ -0,0 +1,12 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+'use strict';
+
+var ionicGlobal = require('./ionic-global-CW0UxPhG.js');
+
+const globalScripts = ionicGlobal.initialize;
+
+exports.globalScripts = globalScripts;
+
+//# sourceMappingURL=app-globals-D7rrMPwl.js.map

package/dist/cjs/app-globals-D7rrMPwl.js.map

@@ -0,0 +1 @@
+{"sourcesContent":[]}

package/dist/cjs/button-active-CKBDMnM4.js

@@ -0,0 +1,71 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+'use strict';
+
+var index$1 = require('./index-D2ttgJ1p.js');
+var haptic = require('./haptic-ClPPQ_PS.js');
+var index = require('./index-CAvQ7Tka.js');
+
+const createButtonActiveGesture = (el, isButton) => {
+    let currentTouchedButton;
+    let initialTouchedButton;
+    const activateButtonAtPoint = (x, y, hapticFeedbackFn) => {
+        if (typeof document === 'undefined') {
+            return;
+        }
+        const target = document.elementFromPoint(x, y);
+        if (!target || !isButton(target) || target.disabled) {
+            clearActiveButton();
+            return;
+        }
+        if (target !== currentTouchedButton) {
+            clearActiveButton();
+            setActiveButton(target, hapticFeedbackFn);
+        }
+    };
+    const setActiveButton = (button, hapticFeedbackFn) => {
+        currentTouchedButton = button;
+        if (!initialTouchedButton) {
+            initialTouchedButton = currentTouchedButton;
+        }
+        const buttonToModify = currentTouchedButton;
+        index$1.writeTask(() => buttonToModify.classList.add('ion-activated'));
+        hapticFeedbackFn();
+    };
+    const clearActiveButton = (dispatchClick = false) => {
+        if (!currentTouchedButton) {
+            return;
+        }
+        const buttonToModify = currentTouchedButton;
+        index$1.writeTask(() => buttonToModify.classList.remove('ion-activated'));
+        /**
+         * Clicking on one button, but releasing on another button
+         * does not dispatch a click event in browsers, so we
+         * need to do it manually here. Some browsers will
+         * dispatch a click if clicking on one button, dragging over
+         * another button, and releasing on the original button. In that
+         * case, we need to make sure we do not cause a double click there.
+         */
+        if (dispatchClick && initialTouchedButton !== currentTouchedButton) {
+            currentTouchedButton.click();
+        }
+        currentTouchedButton = undefined;
+    };
+    return index.createGesture({
+        el,
+        gestureName: 'buttonActiveDrag',
+        threshold: 0,
+        onStart: (ev) => activateButtonAtPoint(ev.currentX, ev.currentY, haptic.hapticSelectionStart),
+        onMove: (ev) => activateButtonAtPoint(ev.currentX, ev.currentY, haptic.hapticSelectionChanged),
+        onEnd: () => {
+            clearActiveButton(true);
+            haptic.hapticSelectionEnd();
+            initialTouchedButton = undefined;
+        },
+    });
+};
+
+exports.createButtonActiveGesture = createButtonActiveGesture;
+
+//# sourceMappingURL=button-active-CKBDMnM4.js.map

package/dist/cjs/button-active-CKBDMnM4.js.map

@@ -0,0 +1 @@
+{"sourcesContent":[]}

package/dist/cjs/capacitor-DmA66EwP.js

@@ -0,0 +1,17 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+'use strict';
+
+var index = require('./index-DkNv4J_i.js');
+
+const getCapacitor = () => {
+    if (index.win !== undefined) {
+        return index.win.Capacitor;
+    }
+    return undefined;
+};
+
+exports.getCapacitor = getCapacitor;
+
+//# sourceMappingURL=capacitor-DmA66EwP.js.map

package/dist/cjs/capacitor-DmA66EwP.js.map

@@ -0,0 +1 @@
+{"sourcesContent":[]}

package/dist/cjs/compare-with-utils-DSicavqM.js

@@ -0,0 +1,46 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+'use strict';
+
+/**
+ * Uses the compareWith param to compare two values to determine if they are equal.
+ *
+ * @param currentValue The current value of the control.
+ * @param compareValue The value to compare against.
+ * @param compareWith The function or property name to use to compare values.
+ */
+const compareOptions = (currentValue, compareValue, compareWith) => {
+    if (typeof compareWith === 'function') {
+        return compareWith(currentValue, compareValue);
+    }
+    else if (typeof compareWith === 'string') {
+        return currentValue[compareWith] === compareValue[compareWith];
+    }
+    else {
+        return Array.isArray(compareValue) ? compareValue.includes(currentValue) : currentValue === compareValue;
+    }
+};
+/**
+ * Compares a value against the current value(s) to determine if it is selected.
+ *
+ * @param currentValue The current value of the control.
+ * @param compareValue The value to compare against.
+ * @param compareWith The function or property name to use to compare values.
+ */
+const isOptionSelected = (currentValue, compareValue, compareWith) => {
+    if (currentValue === undefined) {
+        return false;
+    }
+    if (Array.isArray(currentValue)) {
+        return currentValue.some((val) => compareOptions(val, compareValue, compareWith));
+    }
+    else {
+        return compareOptions(currentValue, compareValue, compareWith);
+    }
+};
+
+exports.compareOptions = compareOptions;
+exports.isOptionSelected = isOptionSelected;
+
+//# sourceMappingURL=compare-with-utils-DSicavqM.js.map

package/dist/cjs/compare-with-utils-DSicavqM.js.map

@@ -0,0 +1 @@
+{"sourcesContent":[]}

package/dist/cjs/config-BHiHGeHc.js

@@ -0,0 +1,201 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+'use strict';
+
+/**
+ * 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) {
+        console.error(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;
+
+exports.ENABLE_HTML_CONTENT_DEFAULT = ENABLE_HTML_CONTENT_DEFAULT;
+exports.IonicSafeString = IonicSafeString;
+exports.getMode = getMode;
+exports.sanitizeDOMString = sanitizeDOMString;
+exports.setupConfig = setupConfig;
+
+//# sourceMappingURL=config-BHiHGeHc.js.map

package/dist/cjs/config-BHiHGeHc.js.map

@@ -0,0 +1 @@
+{"sourcesContent":[]}

package/dist/cjs/cubic-bezier-DAjy1V-e.js

@@ -0,0 +1,94 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+'use strict';
+
+/**
+ * Based on:
+ * https://stackoverflow.com/questions/7348009/y-coordinate-for-a-given-x-cubic-bezier
+ * https://math.stackexchange.com/questions/26846/is-there-an-explicit-form-for-cubic-b%C3%A9zier-curves
+ */
+/**
+ * EXPERIMENTAL
+ * Given a cubic-bezier curve, get the x value (time) given
+ * the y value (progression).
+ * Ex: cubic-bezier(0.32, 0.72, 0, 1);
+ * P0: (0, 0)
+ * P1: (0.32, 0.72)
+ * P2: (0, 1)
+ * P3: (1, 1)
+ *
+ * If you give a cubic bezier curve that never reaches the
+ * provided progression, this function will return an empty array.
+ */
+const getTimeGivenProgression = (p0, p1, p2, p3, progression) => {
+    return solveCubicBezier(p0[1], p1[1], p2[1], p3[1], progression).map((tValue) => {
+        return solveCubicParametricEquation(p0[0], p1[0], p2[0], p3[0], tValue);
+    });
+};
+/**
+ * Solve a cubic equation in one dimension (time)
+ */
+const solveCubicParametricEquation = (p0, p1, p2, p3, t) => {
+    const partA = 3 * p1 * Math.pow(t - 1, 2);
+    const partB = -3 * p2 * t + 3 * p2 + p3 * t;
+    const partC = p0 * Math.pow(t - 1, 3);
+    return t * (partA + t * partB) - partC;
+};
+/**
+ * Find the `t` value for a cubic bezier using Cardano's formula
+ */
+const solveCubicBezier = (p0, p1, p2, p3, refPoint) => {
+    p0 -= refPoint;
+    p1 -= refPoint;
+    p2 -= refPoint;
+    p3 -= refPoint;
+    const roots = solveCubicEquation(p3 - 3 * p2 + 3 * p1 - p0, 3 * p2 - 6 * p1 + 3 * p0, 3 * p1 - 3 * p0, p0);
+    return roots.filter((root) => root >= 0 && root <= 1);
+};
+const solveQuadraticEquation = (a, b, c) => {
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < 0) {
+        return [];
+    }
+    else {
+        return [(-b + Math.sqrt(discriminant)) / (2 * a), (-b - Math.sqrt(discriminant)) / (2 * a)];
+    }
+};
+const solveCubicEquation = (a, b, c, d) => {
+    if (a === 0) {
+        return solveQuadraticEquation(b, c, d);
+    }
+    b /= a;
+    c /= a;
+    d /= a;
+    const p = (3 * c - b * b) / 3;
+    const q = (2 * b * b * b - 9 * b * c + 27 * d) / 27;
+    if (p === 0) {
+        return [Math.pow(-q, 1 / 3)];
+    }
+    else if (q === 0) {
+        return [Math.sqrt(-p), -Math.sqrt(-p)];
+    }
+    const discriminant = Math.pow(q / 2, 2) + Math.pow(p / 3, 3);
+    if (discriminant === 0) {
+        return [Math.pow(q / 2, 1 / 2) - b / 3];
+    }
+    else if (discriminant > 0) {
+        return [
+            Math.pow(-(q / 2) + Math.sqrt(discriminant), 1 / 3) - Math.pow(q / 2 + Math.sqrt(discriminant), 1 / 3) - b / 3,
+        ];
+    }
+    const r = Math.sqrt(Math.pow(-(p / 3), 3));
+    const phi = Math.acos(-(q / (2 * Math.sqrt(Math.pow(-(p / 3), 3)))));
+    const s = 2 * Math.pow(r, 1 / 3);
+    return [
+        s * Math.cos(phi / 3) - b / 3,
+        s * Math.cos((phi + 2 * Math.PI) / 3) - b / 3,
+        s * Math.cos((phi + 4 * Math.PI) / 3) - b / 3,
+    ];
+};
+
+exports.getTimeGivenProgression = getTimeGivenProgression;
+
+//# sourceMappingURL=cubic-bezier-DAjy1V-e.js.map

package/dist/cjs/cubic-bezier-DAjy1V-e.js.map

@@ -0,0 +1 @@
+{"sourcesContent":[]}