@ionic/core 8.8.19-dev.11787007863.1976a30e → 8.8.19-dev.11787083540.1511caf2

package/dist/collection/utils/sanitization/index.js

@@ -3,26 +3,8 @@
  */
 import { printIonError } from "../logging/index";
 /**
- * Sanitize an untrusted HTML string.
- *
- * Parses the string into a detached DOM, removes blocked tags, strips
- * attributes outside the narrow `domStringAllowedAttributes` list (refer
- * `sanitizeElement`), and scrubs script-scheme URLs. Returns the sanitized
- * HTML string.
- *
- * Use this when you have an HTML string from an unknown source and need to
- * render it via `innerHTML`. Use `sanitizeDOMTree` instead when you already
- * have a DOM tree and want to sanitize it in place without a string round
- * trip. The two apply the same dangerous-vector scrubbing but different
- * attribute allowlists: this path stays narrow so existing consumers
- * (toast, loading, alert message, etc.) are unaffected, while
- * `sanitizeDOMTree` uses the wider rich-content allowlist.
- *
- * @param untrustedString - The HTML string to sanitize. Pass an
- * `IonicSafeString` to bypass sanitization, or `undefined` to short-circuit.
- * @returns The sanitized HTML string, or `undefined` if the input was
- * `undefined`. Returns `''` if sanitization fails or the input contains
- * an inline `onload=` handler.
+ * Does a simple sanitization of all elements
+ * in an untrusted string
  */
 export const sanitizeDOMString = (untrustedString) => {
     try {
@@ -72,7 +54,7 @@ export const sanitizeDOMString = (untrustedString) => {
                 const childElements = getElementChildren(element);
                 /* eslint-disable-next-line */
                 for (let childIndex = 0; childIndex < childElements.length; childIndex++) {
-                    sanitizeElement(childElements[childIndex], domStringAllowedAttributes);
+                    sanitizeElement(childElements[childIndex]);
                 }
             }
         });
@@ -84,7 +66,7 @@ export const sanitizeDOMString = (untrustedString) => {
         const dfChildren = getElementChildren(documentFragment);
         /* eslint-disable-next-line */
         for (let childIndex = 0; childIndex < dfChildren.length; childIndex++) {
-            sanitizeElement(dfChildren[childIndex], domStringAllowedAttributes);
+            sanitizeElement(dfChildren[childIndex]);
         }
         // Append document fragment to div
         const fragmentDiv = document.createElement('div');
@@ -98,43 +80,13 @@ export const sanitizeDOMString = (untrustedString) => {
         return '';
     }
 };
-/**
- * Sanitize an entire trusted DOM tree in place.
- *
- * Removes blocked tags (`script`, `iframe`, etc.) from the subtree and
- * then sanitizes attributes on every remaining element using the wider
- * `richContentAllowedAttributes` allowlist (refer `sanitizeElement`).
- * Component presentational attributes (`size`, `color`, `shape`, inline
- * SVG, `aria-*`, `data-*`) are preserved; `style`, event handlers (`on*`),
- * form/navigation-hijack attributes, script-scheme URLs, and non-image
- * `data:` URLs are stripped.
- *
- * Use this when you have a DOM tree the developer controls (e.g.
- * cloned slot content from a component) and you need to render it
- * elsewhere safely.
- *
- * @param root - The root element whose subtree will be sanitized in
- * place. No-op when the sanitizer is disabled via `Ionic.config`.
- */
-export const sanitizeDOMTree = (root) => {
-    if (!isSanitizerEnabled()) {
-        return;
-    }
-    blockedTags.forEach((tag) => {
-        const matches = root.querySelectorAll(tag);
-        for (let i = matches.length - 1; i >= 0; i--) {
-            matches[i].remove();
-        }
-    });
-    sanitizeElement(root, richContentAllowedAttributes, richContentAllowedAttributePrefixes);
-};
 /**
  * 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, allowedAttributes, allowedAttributePrefixes = []) => {
+const sanitizeElement = (element) => {
     // IE uses childNodes, so ignore nodes that are not elements
     if (element.nodeType && element.nodeType !== 1) {
         return;
@@ -149,60 +101,29 @@ const sanitizeElement = (element, allowedAttributes, allowedAttributePrefixes =
         element.remove();
         return;
     }
-    /**
-     * Always strip `style` (CSS injection, `background:url()` beaconing, UI
-     * spoofing). It is never on the allowlist, but it is removed explicitly
-     * here because some engines (e.g. jsdom) don't enumerate the CSSOM-backed
-     * `style` attribute in `element.attributes`, which would let the loop
-     * below skip over it.
-     */
-    element.removeAttribute('style');
     for (let i = element.attributes.length - 1; i >= 0; i--) {
         const attribute = element.attributes.item(i);
         const attributeName = attribute.name;
-        const lowerName = attributeName.toLowerCase();
-        /**
-         * Remove any attribute that is not on the allowlist. This drops event
-         * handlers (`on*`), `style`, the form/navigation-hijack attributes
-         * (`formaction`, `action`, `target`), namespaced attributes like
-         * `xlink:href`, and anything else not explicitly known to be safe.
-         */
-        if (!isAttributeAllowed(lowerName, allowedAttributes, allowedAttributePrefixes)) {
+        // 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;
-        if (attributeValue == null) {
-            continue;
-        }
         /**
-         * Scrub dangerous schemes from the value. The value is normalized first
-         * (whitespace and ASCII control characters removed) so entity-obfuscated
-         * payloads such as `java&#9;script:`, which the parser decodes to
-         * `java\tscript:`, are still caught. Normalizing the value also covers
-         * namespaced attributes, where the previous `element[attributeName]`
-         * property reflection returned `undefined` and let them slip through.
+         * 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 normalizedValue = attributeValue.replace(controlCharactersAndWhitespace, '').toLowerCase();
-        // Script schemes are never allowed, on any attribute.
-        if (normalizedValue.includes('javascript:') || normalizedValue.includes('vbscript:')) {
-            element.removeAttribute(attributeName);
-            continue;
-        }
-        /**
-         * For URL-bearing attributes, allow `data:` URIs only for raster
-         * images. Document-bearing types (`text/html`, `image/svg+xml`,
-         * `application/*`, etc.) can carry markup or script when navigated to
-         * or rendered, so they are stripped, while safe image types are kept so
-         * inline images keep working.
-         */
-        if (urlAttributes.includes(lowerName) &&
-            normalizedValue.startsWith('data:') &&
-            !safeDataImageUri.test(normalizedValue)) {
+        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
@@ -210,7 +131,7 @@ const sanitizeElement = (element, allowedAttributes, allowedAttributePrefixes =
     const childElements = getElementChildren(element);
     /* eslint-disable-next-line */
     for (let i = 0; i < childElements.length; i++) {
-        sanitizeElement(childElements[i], allowedAttributes, allowedAttributePrefixes);
+        sanitizeElement(childElements[i]);
     }
 };
 /**
@@ -222,8 +143,9 @@ const getElementChildren = (el) => {
     return el.children != null ? el.children : el.childNodes;
 };
 const isSanitizerEnabled = () => {
+    var _a;
     const win = window;
-    const config = win?.Ionic?.config;
+    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);
@@ -234,187 +156,9 @@ const isSanitizerEnabled = () => {
     }
     return true;
 };
-/**
- * Mirror known custom-element DOM properties onto attributes so they
- * survive `cloneNode`. Call this on a DOM subtree before cloning it for
- * rendering elsewhere (e.g. cloning slotted option content into an
- * overlay).
- *
- * Only sets the attribute when the property holds a non-empty string
- * and the attribute isn't already present, so existing attributes
- * take precedence.
- *
- * @param root - The root element whose subtree (and itself) will be
- * inspected.
- */
-export const reflectPropertiesToAttributes = (root) => {
-    const candidates = [];
-    if (root.tagName in elementPropsToReflect) {
-        candidates.push(root);
-    }
-    for (const tagName of Object.keys(elementPropsToReflect)) {
-        candidates.push(...Array.from(root.querySelectorAll(tagName.toLowerCase())));
-    }
-    for (const el of candidates) {
-        if (!(el.tagName in elementPropsToReflect)) {
-            continue;
-        }
-        const props = elementPropsToReflect[el.tagName];
-        for (const prop of props) {
-            const value = el[prop];
-            if (typeof value === 'string' && value.length > 0 && !el.hasAttribute(prop)) {
-                el.setAttribute(prop, value);
-            }
-        }
-    }
-};
-/**
- * Attribute allowlist for `sanitizeDOMString`. Intentionally narrow: this
- * path sanitizes developer HTML strings rendered via `innerHTML` by
- * `ion-toast`, `ion-loading`, the `ion-alert` message,
- * `ion-refresher-content`, and `ion-infinite-scroll-content`, so the list
- * is kept to the minimum those have always needed. Broadening it here would
- * change sanitization output for all of those consumers, so the wider
- * rich-content allowlist below is deliberately scoped to `sanitizeDOMTree`
- * instead.
- */
-const domStringAllowedAttributes = ['class', 'id', 'href', 'src', 'name', 'slot'];
-/**
- * Attribute allowlist for `sanitizeDOMTree` (the select rich-content path).
- * Covers global HTML attributes, the Ionic component presentational props
- * that cloned rich content (e.g. `ion-select-option` markup) relies on, and
- * the inert SVG presentation attributes used by inline icons.
- *
- * `aria-*` and `data-*` are allowed separately by prefix (refer
- * `richContentAllowedAttributePrefixes`) since they are inert and not worth
- * enumerating. URL-bearing names (`href`, `src`) are allowed here, but
- * their values are still scrubbed for script schemes in `sanitizeElement`.
- *
- * Notably absent: `style`, event handlers (`on*`), and the
- * form/navigation-hijack attributes (`formaction`, `action`, `target`),
- * which are therefore stripped.
- */
-const richContentAllowedAttributes = [
-    // Global / structural
-    'class',
-    'id',
-    'slot',
-    'name',
-    'title',
-    'alt',
-    'lang',
-    'dir',
-    'role',
-    'type',
-    'value',
-    'disabled',
-    'width',
-    'height',
-    'href',
-    'src',
-    // Ionic component presentational props
-    'color',
-    'size',
-    'shape',
-    'fill',
-    'expand',
-    'mode',
-    'theme',
-    'icon',
-    'label',
-    'label-placement',
-    'justify',
-    'inset',
-    'lines',
-    'ios',
-    'md',
-    // SVG presentation attributes (compared lowercased, e.g. `viewBox`)
-    'xmlns',
-    'viewbox',
-    'preserveaspectratio',
-    'stroke',
-    'stroke-width',
-    'stroke-linecap',
-    'stroke-linejoin',
-    'stroke-opacity',
-    'stroke-dasharray',
-    'fill-rule',
-    'fill-opacity',
-    'clip-rule',
-    'd',
-    'points',
-    'cx',
-    'cy',
-    'r',
-    'rx',
-    'ry',
-    'x',
-    'y',
-    'x1',
-    'y1',
-    'x2',
-    'y2',
-    'transform',
-    'opacity',
-];
-/**
- * Attribute-name prefixes that are always safe to keep in the rich-content
- * path. `aria-*` and `data-*` attributes cannot execute script or load
- * resources, so they are allowed wholesale rather than enumerated by name.
- */
-const richContentAllowedAttributePrefixes = ['aria-', 'data-'];
-/**
- * Whether an attribute name (already lowercased) is safe to keep, by exact
- * match or by an allowed prefix.
- */
-const isAttributeAllowed = (lowerName, allowedAttributes, allowedAttributePrefixes) => {
-    if (allowedAttributes.includes(lowerName)) {
-        return true;
-    }
-    return allowedAttributePrefixes.some((prefix) => lowerName.startsWith(prefix));
-};
-/**
- * Matches ASCII control characters and whitespace (including the
- * non-breaking space). Used to normalize attribute values before matching
- * a URL scheme so entity-obfuscated payloads such as `java&#9;script:`
- * (decoded by the parser to `java\tscript:`) can't smuggle a scheme past
- * the check.
- */
-// eslint-disable-next-line no-control-regex -- matching control characters is the point
-const controlCharactersAndWhitespace = /[\u0000-\u0020\u007f-\u00a0]/g;
-/**
- * Attributes whose values are URLs. Their values are scheme-checked in
- * `sanitizeElement` (e.g. `data:` filtering) beyond the script-scheme scrub
- * applied to every attribute.
- */
-const urlAttributes = ['href', 'src'];
-/**
- * Matches a `data:` URI for a raster image type that cannot carry script.
- * `image/svg+xml` is deliberately excluded (SVG can execute script), as are
- * document types like `text/html` and `application/*`. The value is already
- * lowercased and whitespace-stripped before this is tested.
- */
-const safeDataImageUri = /^data:image\/(?:png|jpe?g|gif|webp|bmp|avif|x-icon|vnd\.microsoft\.icon)[;,]/;
-/**
- * Tags removed entirely (with their subtree) before attribute sanitization.
- * Exported so tests can assert the set without hardcoding it.
- */
-export const blockedTags = ['script', 'style', 'iframe', 'meta', 'link', 'object', 'embed', 'base'];
-/**
- * Properties on custom elements that frameworks (Vue, Angular) often
- * set as DOM properties rather than attributes. `cloneNode` only copies
- * attributes, so these values are lost when slotted content is cloned
- * into an overlay. For each known custom element, we mirror the listed
- * properties onto attributes so the cloned copy still has the data it
- * needs to render.
- *
- * Keyed by uppercased tagName so the lookup matches `Element.tagName`.
- */
-const elementPropsToReflect = {
-    'ION-ICON': ['icon', 'name', 'src', 'ios', 'md'],
-};
+const allowedAttributes = ['class', 'id', 'href', 'src', 'name', 'slot'];
+const blockedTags = ['script', 'style', 'iframe', 'meta', 'link', 'object', 'embed'];
 export class IonicSafeString {
-    value;
     constructor(value) {
         this.value = value;
     }

package/dist/collection/utils/slot-mutation-controller.js

@@ -69,6 +69,7 @@ export const createSlotMutationController = (el, slotName, mutationCallback) =>
      * of the component.
      */
     const watchForSlotChange = (slottedEl) => {
+        var _a;
         if (slottedContentMutationObserver) {
             slottedContentMutationObserver.disconnect();
             slottedContentMutationObserver = undefined;
@@ -94,7 +95,7 @@ export const createSlotMutationController = (el, slotName, mutationCallback) =>
          * We listen on the parentElement so that we can
          * detect when slotted element itself is removed.
          */
-        slottedContentMutationObserver.observe(slottedEl.parentElement ?? slottedEl, { subtree: true, childList: true });
+        slottedContentMutationObserver.observe((_a = slottedEl.parentElement) !== null && _a !== void 0 ? _a : slottedEl, { subtree: true, childList: true });
     };
     const destroy = () => {
         if (hostMutationObserver) {

package/dist/collection/utils/test/playwright/apply-keyboard-focus.js

@@ -17,7 +17,7 @@ import { expect } from "@playwright/test";
  */
 export const applyKeyboardFocus = async (page, locator, indicatorLocator = locator) => {
     await expect(async () => {
-        await page.evaluate(() => document.activeElement?.blur());
+        await page.evaluate(() => { var _a; return (_a = document.activeElement) === null || _a === void 0 ? void 0 : _a.blur(); });
         await page.keyboard.press('Shift');
         await locator.focus();
         await expect(indicatorLocator).toHaveClass(/ion-focused/, { timeout: 250 });

package/dist/collection/utils/test/playwright/drag-element.js

@@ -9,6 +9,7 @@
  * See https://playwright.dev/docs/api/class-mouse#mouse-move for more information.
  */
 export const dragElementBy = async (el, page, dragByX = 0, dragByY = 0, startXCoord, startYCoord, releaseDrag = true) => {
+    var _a;
     const boundingBox = await el.boundingBox();
     if (!boundingBox) {
         throw new Error('Cannot get a bounding box for an element that is not visible. See https://playwright.dev/docs/api/class-locator#locator-bounding-box for more information');
@@ -29,8 +30,8 @@ export const dragElementBy = async (el, page, dragByX = 0, dragByY = 0, startXCo
     // WebKit that latency perturbs the timing-derived gesture velocity, causing
     // the item to settle a few pixels off and flaking screenshot comparisons
     // (e.g. item-sliding safe-area tests).
-    if (page.context().browser()?.browserType().name() === 'firefox') {
-        await page.evaluate(() => window.getSelection()?.removeAllRanges());
+    if (((_a = page.context().browser()) === null || _a === void 0 ? void 0 : _a.browserType().name()) === 'firefox') {
+        await page.evaluate(() => { var _a; return (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges(); });
     }
     // Drag the element.
     await moveElement(page, startX, startY, dragByX, dragByY);

package/dist/collection/utils/test/playwright/generator.js

@@ -41,15 +41,16 @@ const generateScreenshotName = (fileName, config) => {
  * Given a config generate an array of test variants.
  */
 export const configs = (testConfig = DEFAULT_TEST_CONFIG_OPTION) => {
+    var _a;
     const { modes, directions } = testConfig;
     const configs = [];
     /**
      * If certain options are not provided,
      * fall back to the defaults.
      */
-    const processedMode = modes ?? DEFAULT_MODES;
-    const processedDirection = directions ?? DEFAULT_DIRECTIONS;
-    const processedPalette = testConfig.palettes ?? DEFAULT_PALETTES;
+    const processedMode = modes !== null && modes !== void 0 ? modes : DEFAULT_MODES;
+    const processedDirection = directions !== null && directions !== void 0 ? directions : DEFAULT_DIRECTIONS;
+    const processedPalette = (_a = testConfig.palettes) !== null && _a !== void 0 ? _a : DEFAULT_PALETTES;
     processedMode.forEach((mode) => {
         processedDirection.forEach((direction) => {
             processedPalette.forEach((palette) => {

package/dist/collection/utils/test/playwright/page/event-spy.js

@@ -10,26 +10,27 @@
  * Based off https://github.com/ionic-team/stencil/blob/16b8ea4dabb22024872a38bc58ba1dcf1c7cc25b/src/testing/puppeteer/puppeteer-events.ts#L64
  */
 export class EventSpy {
-    eventName;
-    /**
-     * Keeping track of a cursor
-     * ensures that no two spy.next()
-     * calls point to the same event.
-     */
-    cursor = 0;
-    queuedHandler = [];
-    events = [];
     constructor(eventName) {
         this.eventName = eventName;
+        /**
+         * Keeping track of a cursor
+         * ensures that no two spy.next()
+         * calls point to the same event.
+         */
+        this.cursor = 0;
+        this.queuedHandler = [];
+        this.events = [];
     }
     get length() {
         return this.events.length;
     }
     get firstEvent() {
-        return this.events[0] ?? null;
+        var _a;
+        return (_a = this.events[0]) !== null && _a !== void 0 ? _a : null;
     }
     get lastEvent() {
-        return this.events[this.events.length - 1] ?? null;
+        var _a;
+        return (_a = this.events[this.events.length - 1]) !== null && _a !== void 0 ? _a : null;
     }
     next() {
         const { cursor } = this;

package/dist/collection/utils/test/playwright/page/utils/goto.js

@@ -9,6 +9,7 @@
  * to be hydrated before proceeding with the test.
  */
 export const goto = async (page, url, testInfo, originalFn, options) => {
+    var _a, _b, _c, _d;
     if (options === undefined && testInfo.project.metadata.mode === undefined) {
         throw new Error(`
 A config must be passed to page.goto to use a generator test:
@@ -40,10 +41,10 @@ configs().forEach(({ config, title }) => {
      * certain mode or LTR/RTL config per test.
      */
     const urlToParams = new URLSearchParams(paramsString);
-    const formattedMode = urlToParams.get('ionic:mode') ?? mode;
-    const formattedRtl = urlToParams.get('rtl') ?? rtlString;
-    const formattedPalette = urlToParams.get('palette') ?? palette;
-    const ionicTesting = urlToParams.get('ionic:_testing') ?? true;
+    const formattedMode = (_a = urlToParams.get('ionic:mode')) !== null && _a !== void 0 ? _a : mode;
+    const formattedRtl = (_b = urlToParams.get('rtl')) !== null && _b !== void 0 ? _b : rtlString;
+    const formattedPalette = (_c = urlToParams.get('palette')) !== null && _c !== void 0 ? _c : palette;
+    const ionicTesting = (_d = urlToParams.get('ionic:_testing')) !== null && _d !== void 0 ? _d : true;
     /**
      * Pass through other custom query params
      */

package/dist/collection/utils/test/playwright/page/utils/set-content.js

@@ -39,7 +39,7 @@ export const setContent = async (page, html, testInfo, options) => {
     let ionicJSImports = `
     <script type="module" src="${baseUrl}/dist/ionic/ionic.esm.js"></script>
   `;
-    if (options?.importIonicFromCDN) {
+    if (options === null || options === void 0 ? void 0 : options.importIonicFromCDN) {
         ionicCSSImports = `
       <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@ionic/core/css/ionic.bundle.css" />
     `;

package/dist/collection/utils/test/playwright/page/utils/set-ion-viewport.js

@@ -13,6 +13,7 @@
  *
  */
 export const setIonViewport = async (page, options) => {
+    var _a, _b;
     const currentViewport = page.viewportSize();
     const ionContent = await page.$('ion-content');
     if (ionContent) {
@@ -26,8 +27,8 @@ export const setIonViewport = async (page, options) => {
         }
         return [0, 0];
     });
-    const width = (currentViewport?.width ?? 640) + (options?.resizeViewportWidth ? x : 0);
-    const height = (currentViewport?.height ?? 480) + y;
+    const width = ((_a = currentViewport === null || currentViewport === void 0 ? void 0 : currentViewport.width) !== null && _a !== void 0 ? _a : 640) + ((options === null || options === void 0 ? void 0 : options.resizeViewportWidth) ? x : 0);
+    const height = ((_b = currentViewport === null || currentViewport === void 0 ? void 0 : currentViewport.height) !== null && _b !== void 0 ? _b : 480) + y;
     await page.setViewportSize({
         width,
         height,

package/dist/collection/utils/test/press-keys.js

@@ -1,6 +1,18 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 /**
  * The purpose of this utility is to provide a way to press keys in a way that
  * is consistent across browsers and platforms. Playwright does not automatically
@@ -21,15 +33,12 @@ const COMMAND = 'meta';
  * Slimmed down version of WordPress' pressKeys utility.
  */
 export class PageUtils {
-    browser;
-    page;
-    context;
     constructor({ page }) {
+        this.pressKeys = pressKeys.bind(this);
         this.page = page;
         this.context = page.context();
         this.browser = this.context.browser();
     }
-    pressKeys = pressKeys.bind(this);
 }
 const baseModifiers = {
     primary: (_isApple) => (_isApple() ? [COMMAND] : [CTRL]),
@@ -68,10 +77,7 @@ const getHasNaturalTabNavigation = async (page) => {
     await testPage.close();
     return featureDetected;
 };
-const modifiers = {
-    ...baseModifiers,
-    shiftAlt: (_isApple) => (_isApple() ? [SHIFT, ALT] : [SHIFT, CTRL]),
-};
+const modifiers = Object.assign(Object.assign({}, baseModifiers), { shiftAlt: (_isApple) => (_isApple() ? [SHIFT, ALT] : [SHIFT, CTRL]) });
 /**
  * Presses a key combination.
  * @param key - Key combination to press.
@@ -84,7 +90,8 @@ const modifiers = {
  * await pressKeys('Shift+Tab');
  * ```
  */
-export async function pressKeys(key, { times, ...pressOptions } = {}) {
+export async function pressKeys(key, _a = {}) {
+    var { times } = _a, pressOptions = __rest(_a, ["times"]);
     const hasNaturalTabNavigation = await getHasNaturalTabNavigation(this.page);
     /**
      * Split the key combination into individual keys and map each key to its
@@ -111,7 +118,7 @@ export async function pressKeys(key, { times, ...pressOptions } = {}) {
     });
     const normalizedKeys = keys.join('+');
     const command = () => this.page.keyboard.press(normalizedKeys);
-    times = times ?? 1;
+    times = times !== null && times !== void 0 ? times : 1;
     for (let i = 0; i < times; i += 1) {
         await command();
         if (times > 1 && pressOptions.delay !== undefined) {

package/dist/collection/utils/theme.js

@@ -9,12 +9,7 @@ export const hostContext = (selector, el) => {
  */
 export const createColorClasses = (color, cssClassMap) => {
     return typeof color === 'string' && color.length > 0
-        ? {
-            'ion-color': true,
-            [`ion-color-${color}`]: true,
-            ...cssClassMap,
-        }
-        : cssClassMap;
+        ? Object.assign({ 'ion-color': true, [`ion-color-${color}`]: true }, cssClassMap) : cssClassMap;
 };
 export const getClassList = (classes) => {
     if (classes !== undefined) {