@amwaljs/checkout-button 0.3.1 → 0.3.2

package/dist/{esm/refresher.utils-D4tPnZsM.js → components/p-74e68924.js}

@@ -1,6 +1,6 @@
-import { w as writeTask } from './index-93OyAGoo.js';
-import { c as createAnimation } from './animation-DRf3dwMu.js';
-import { c as componentOnReady, t as transitionEndAsync, e as clamp } from './helpers-C6kqtbmV.js';
+import { w as writeTask } from './p-96073863.js';
+import { c as createAnimation } from './p-89c4c5cb.js';
+import { t as transitionEndAsync, c as componentOnReady, m as clamp } from './p-2bb89b46.js';
 
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
@@ -193,4 +193,4 @@ const shouldUseNativeRefresher = async (referenceEl, mode) => {
         ((mode === 'ios' && supportsRubberBandScrolling()) || mode === 'md'));
 };
 
-export { shouldUseNativeRefresher as a, setSpinnerOpacity as b, handleScrollWhilePulling as c, createSnapBackAnimation as d, createPullingAnimation as e, getRefresherAnimationType as g, handleScrollWhileRefreshing as h, supportsRubberBandScrolling as s, translateElement as t };
+export { setSpinnerOpacity as a, handleScrollWhilePulling as b, createPullingAnimation as c, createSnapBackAnimation as d, supportsRubberBandScrolling as e, getRefresherAnimationType as g, handleScrollWhileRefreshing as h, shouldUseNativeRefresher as s, translateElement as t };

package/dist/{esm/framework-delegate-D_uGiYYw.js → components/p-76525f0f.js}

@@ -1,4 +1,4 @@
-import { c as componentOnReady } from './helpers-C6kqtbmV.js';
+import { c as componentOnReady } from './p-2bb89b46.js';
 
 /*!
  * (C) Ionic http://ionicframework.com - MIT License

package/dist/{esm/index-CcopIPA0.js → components/p-77104220.js}

@@ -1,4 +1,5 @@
-import { G as GESTURE_CONTROLLER } from './gesture-controller-CukVBo5-.js';
+import { G as GESTURE_CONTROLLER } from './p-f728a68f.js';
+export { G as GESTURE_CONTROLLER } from './p-f728a68f.js';
 
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
@@ -9,10 +10,10 @@ eventName, callback, opts) => {
     // otherwise it's just a boolean for the "capture" arg
     const listenerOpts = supportsPassive(el)
         ? {
-            capture: false,
+            capture: !!opts.capture,
             passive: !!opts.passive,
         }
-        : false;
+        : !!opts.capture;
     let add;
     let remove;
     if (el['__zone_symbol__addEventListener']) {
@@ -390,6 +391,7 @@ const createGesture = (config) => {
         }
     };
     const pointerEvents = createPointerEvents(finalConfig.el, pointerDown, pointerMove, pointerUp, {
+        capture: false,
         passive,
     });
     const abortGesture = () => {
@@ -461,4 +463,4 @@ const now = (ev) => {
     return ev.timeStamp || Date.now();
 };
 
-export { GESTURE_CONTROLLER, createGesture };
+export { createGesture };

package/dist/components/p-77ccb793.js

@@ -0,0 +1,185 @@
+import { p as proxyCustomElement, H, c as createEvent, h, d as Host } from './p-ec0e3f3f.js';
+import { e as renderHiddenInput } from './p-2bb89b46.js';
+import { g as getIonMode } from './p-901c16c5.js';
+
+const RadioGroup = /*@__PURE__*/ proxyCustomElement(class RadioGroup extends H {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.ionChange = createEvent(this, "ionChange", 7);
+    this.ionValueChange = createEvent(this, "ionValueChange", 7);
+    this.inputId = `ion-rg-${radioGroupIds++}`;
+    this.labelId = `${this.inputId}-lbl`;
+    this.setRadioTabindex = (value) => {
+      const radios = this.getRadios();
+      // Get the first radio that is not disabled and the checked one
+      const first = radios.find((radio) => !radio.disabled);
+      const checked = radios.find((radio) => radio.value === value && !radio.disabled);
+      if (!first && !checked) {
+        return;
+      }
+      // If an enabled checked radio exists, set it to be the focusable radio
+      // otherwise we default to focus the first radio
+      const focusable = checked || first;
+      for (const radio of radios) {
+        const tabindex = radio === focusable ? 0 : -1;
+        radio.setButtonTabindex(tabindex);
+      }
+    };
+    this.onClick = (ev) => {
+      ev.preventDefault();
+      /**
+       * The Radio Group component mandates that only one radio button
+       * within the group can be selected at any given time. Since `ion-radio`
+       * is a shadow DOM component, it cannot natively perform this behavior
+       * using the `name` attribute.
+       */
+      const selectedRadio = ev.target && ev.target.closest('ion-radio');
+      /**
+       * Our current disabled prop definition causes Stencil to mark it
+       * as optional. While this is not desired, fixing this behavior
+       * in Stencil is a significant breaking change, so this effort is
+       * being de-risked in STENCIL-917. Until then, we compromise
+       * here by checking for falsy `disabled` values instead of strictly
+       * checking `disabled === false`.
+       */
+      if (selectedRadio && !selectedRadio.disabled) {
+        const currentValue = this.value;
+        const newValue = selectedRadio.value;
+        if (newValue !== currentValue) {
+          this.value = newValue;
+          this.emitValueChange(ev);
+        }
+        else if (this.allowEmptySelection) {
+          this.value = undefined;
+          this.emitValueChange(ev);
+        }
+      }
+    };
+    this.allowEmptySelection = false;
+    this.compareWith = undefined;
+    this.name = this.inputId;
+    this.value = undefined;
+  }
+  valueChanged(value) {
+    this.setRadioTabindex(value);
+    this.ionValueChange.emit({ value });
+  }
+  componentDidLoad() {
+    /**
+     * There's an issue when assigning a value to the radio group
+     * within the Angular primary content (rendering within the
+     * app component template). When the template is isolated to a route,
+     * the value is assigned correctly.
+     * To address this issue, we need to ensure that the watcher is
+     * called after the component has finished loading,
+     * allowing the emit to be dispatched correctly.
+     */
+    this.valueChanged(this.value);
+  }
+  async connectedCallback() {
+    // Get the list header if it exists and set the id
+    // this is used to set aria-labelledby
+    const header = this.el.querySelector('ion-list-header') || this.el.querySelector('ion-item-divider');
+    if (header) {
+      const label = (this.label = header.querySelector('ion-label'));
+      if (label) {
+        this.labelId = label.id = this.name + '-lbl';
+      }
+    }
+  }
+  getRadios() {
+    return Array.from(this.el.querySelectorAll('ion-radio'));
+  }
+  /**
+   * Emits an `ionChange` event.
+   *
+   * This API should be called for user committed changes.
+   * This API should not be used for external value changes.
+   */
+  emitValueChange(event) {
+    const { value } = this;
+    this.ionChange.emit({ value, event });
+  }
+  onKeydown(ev) {
+    const inSelectPopover = !!this.el.closest('ion-select-popover');
+    if (ev.target && !this.el.contains(ev.target)) {
+      return;
+    }
+    // Get all radios inside of the radio group and then
+    // filter out disabled radios since we need to skip those
+    const radios = this.getRadios().filter((radio) => !radio.disabled);
+    // Only move the radio if the current focus is in the radio group
+    if (ev.target && radios.includes(ev.target)) {
+      const index = radios.findIndex((radio) => radio === ev.target);
+      const current = radios[index];
+      let next;
+      // If hitting arrow down or arrow right, move to the next radio
+      // If we're on the last radio, move to the first radio
+      if (['ArrowDown', 'ArrowRight'].includes(ev.key)) {
+        next = index === radios.length - 1 ? radios[0] : radios[index + 1];
+      }
+      // If hitting arrow up or arrow left, move to the previous radio
+      // If we're on the first radio, move to the last radio
+      if (['ArrowUp', 'ArrowLeft'].includes(ev.key)) {
+        next = index === 0 ? radios[radios.length - 1] : radios[index - 1];
+      }
+      if (next && radios.includes(next)) {
+        next.setFocus(ev);
+        if (!inSelectPopover) {
+          this.value = next.value;
+          this.emitValueChange(ev);
+        }
+      }
+      // Update the radio group value when a user presses the
+      // space bar on top of a selected radio
+      if ([' '].includes(ev.key)) {
+        const previousValue = this.value;
+        this.value = this.allowEmptySelection && this.value !== undefined ? undefined : current.value;
+        if (previousValue !== this.value || this.allowEmptySelection) {
+          /**
+           * Value change should only be emitted if the value is different,
+           * such as selecting a new radio with the space bar or if
+           * the radio group allows for empty selection and the user
+           * is deselecting a checked radio.
+           */
+          this.emitValueChange(ev);
+        }
+        // Prevent browsers from jumping
+        // to the bottom of the screen
+        ev.preventDefault();
+      }
+    }
+  }
+  render() {
+    const { label, labelId, el, name, value } = this;
+    const mode = getIonMode(this);
+    renderHiddenInput(true, el, name, value, false);
+    return h(Host, { key: '6065674a08ac2ead25e87219b5628879a759b75a', role: "radiogroup", "aria-labelledby": label ? labelId : null, onClick: this.onClick, class: mode });
+  }
+  get el() { return this; }
+  static get watchers() { return {
+    "value": ["valueChanged"]
+  }; }
+}, [0, "ion-radio-group", {
+    "allowEmptySelection": [4, "allow-empty-selection"],
+    "compareWith": [1, "compare-with"],
+    "name": [1],
+    "value": [1032]
+  }, [[4, "keydown", "onKeydown"]]]);
+let radioGroupIds = 0;
+function defineCustomElement() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["ion-radio-group"];
+  components.forEach(tagName => { switch (tagName) {
+    case "ion-radio-group":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, RadioGroup);
+      }
+      break;
+  } });
+}
+
+export { RadioGroup as R, defineCustomElement as d };

package/dist/components/p-83e529db.js

@@ -0,0 +1,380 @@
+import { p as proxyCustomElement, H, h, d as Host } from './p-ec0e3f3f.js';
+import { a as getAssetPath } from './p-96073863.js';
+
+let CACHED_MAP;
+const getIconMap = () => {
+  if (typeof window === 'undefined') {
+    return new Map();
+  }
+  else {
+    if (!CACHED_MAP) {
+      const win = window;
+      win.Ionicons = win.Ionicons || {};
+      CACHED_MAP = win.Ionicons.map = win.Ionicons.map || new Map();
+    }
+    return CACHED_MAP;
+  }
+};
+const getUrl = (i) => {
+  let url = getSrc(i.src);
+  if (url) {
+    return url;
+  }
+  url = getName(i.name, i.icon, i.mode, i.ios, i.md);
+  if (url) {
+    return getNamedUrl(url, i);
+  }
+  if (i.icon) {
+    url = getSrc(i.icon);
+    if (url) {
+      return url;
+    }
+    url = getSrc(i.icon[i.mode]);
+    if (url) {
+      return url;
+    }
+  }
+  return null;
+};
+const getNamedUrl = (iconName, iconEl) => {
+  const url = getIconMap().get(iconName);
+  if (url) {
+    return url;
+  }
+  try {
+    return getAssetPath(`svg/${iconName}.svg`);
+  }
+  catch (e) {
+    /**
+     * In the custom elements build version of ionicons, referencing an icon
+     * by name will throw an invalid URL error because the asset path is not defined.
+     * This catches that error and logs something that is more developer-friendly.
+     * We also include a reference to the ion-icon element so developers can
+     * figure out which instance of ion-icon needs to be updated.
+     */
+    console.warn(`[Ionicons Warning]: Could not load icon with name "${iconName}". Ensure that the icon is registered using addIcons or that the icon SVG data is passed directly to the icon component.`, iconEl);
+  }
+};
+const getName = (iconName, icon, mode, ios, md) => {
+  // default to "md" if somehow the mode wasn't set
+  mode = (mode && toLower(mode)) === 'ios' ? 'ios' : 'md';
+  // if an icon was passed in using the ios or md attributes
+  // set the iconName to whatever was passed in
+  if (ios && mode === 'ios') {
+    iconName = toLower(ios);
+  }
+  else if (md && mode === 'md') {
+    iconName = toLower(md);
+  }
+  else {
+    if (!iconName && icon && !isSrc(icon)) {
+      iconName = icon;
+    }
+    if (isStr(iconName)) {
+      iconName = toLower(iconName);
+    }
+  }
+  if (!isStr(iconName) || iconName.trim() === '') {
+    return null;
+  }
+  // only allow alpha characters and dash
+  const invalidChars = iconName.replace(/[a-z]|-|\d/gi, '');
+  if (invalidChars !== '') {
+    return null;
+  }
+  return iconName;
+};
+const getSrc = (src) => {
+  if (isStr(src)) {
+    src = src.trim();
+    if (isSrc(src)) {
+      return src;
+    }
+  }
+  return null;
+};
+const isSrc = (str) => str.length > 0 && /(\/|\.)/.test(str);
+const isStr = (val) => typeof val === 'string';
+const toLower = (val) => val.toLowerCase();
+/**
+ * Elements inside of web components sometimes need to inherit global attributes
+ * set on the host. For example, the inner input in `ion-input` should inherit
+ * the `title` attribute that developers set directly on `ion-input`. This
+ * helper function should be called in componentWillLoad and assigned to a variable
+ * that is later used in the render function.
+ *
+ * This does not need to be reactive as changing attributes on the host element
+ * does not trigger a re-render.
+ */
+const inheritAttributes = (el, attributes = []) => {
+  const attributeObject = {};
+  attributes.forEach(attr => {
+    if (el.hasAttribute(attr)) {
+      const value = el.getAttribute(attr);
+      if (value !== null) {
+        attributeObject[attr] = el.getAttribute(attr);
+      }
+      el.removeAttribute(attr);
+    }
+  });
+  return attributeObject;
+};
+/**
+ * Returns `true` if the document or host element
+ * has a `dir` set to `rtl`. The host value will always
+ * take priority over the root document value.
+ */
+const isRTL = (hostEl) => {
+  if (hostEl) {
+    if (hostEl.dir !== '') {
+      return hostEl.dir.toLowerCase() === 'rtl';
+    }
+  }
+  return (document === null || document === void 0 ? void 0 : document.dir.toLowerCase()) === 'rtl';
+};
+
+const validateContent = (svgContent) => {
+  const div = document.createElement('div');
+  div.innerHTML = svgContent;
+  // setup this way to ensure it works on our buddy IE
+  for (let i = div.childNodes.length - 1; i >= 0; i--) {
+    if (div.childNodes[i].nodeName.toLowerCase() !== 'svg') {
+      div.removeChild(div.childNodes[i]);
+    }
+  }
+  // must only have 1 root element
+  const svgElm = div.firstElementChild;
+  if (svgElm && svgElm.nodeName.toLowerCase() === 'svg') {
+    const svgClass = svgElm.getAttribute('class') || '';
+    svgElm.setAttribute('class', (svgClass + ' s-ion-icon').trim());
+    // root element must be an svg
+    // lets double check we've got valid elements
+    // do not allow scripts
+    if (isValid(svgElm)) {
+      return div.innerHTML;
+    }
+  }
+  return '';
+};
+const isValid = (elm) => {
+  if (elm.nodeType === 1) {
+    if (elm.nodeName.toLowerCase() === 'script') {
+      return false;
+    }
+    for (let i = 0; i < elm.attributes.length; i++) {
+      const name = elm.attributes[i].name;
+      if (isStr(name) && name.toLowerCase().indexOf('on') === 0) {
+        return false;
+      }
+    }
+    for (let i = 0; i < elm.childNodes.length; i++) {
+      if (!isValid(elm.childNodes[i])) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+const isSvgDataUrl = (url) => url.startsWith('data:image/svg+xml');
+const isEncodedDataUrl = (url) => url.indexOf(';utf8,') !== -1;
+
+const ioniconContent = new Map();
+const requests = new Map();
+let parser;
+const getSvgContent = (url, sanitize) => {
+  // see if we already have a request for this url
+  let req = requests.get(url);
+  if (!req) {
+    if (typeof fetch !== 'undefined' && typeof document !== 'undefined') {
+      /**
+       * If the url is a data url of an svg, then try to parse it
+       * with the DOMParser. This works with content security policies enabled.
+       */
+      if (isSvgDataUrl(url) && isEncodedDataUrl(url)) {
+        if (!parser) {
+          /**
+           * Create an instance of the DOM parser. This creates a single
+           * parser instance for the entire app, which is more efficient.
+           */
+          parser = new DOMParser();
+        }
+        const doc = parser.parseFromString(url, 'text/html');
+        const svg = doc.querySelector('svg');
+        if (svg) {
+          ioniconContent.set(url, svg.outerHTML);
+        }
+        return Promise.resolve();
+      }
+      else {
+        // we don't already have a request
+        req = fetch(url).then((rsp) => {
+          if (rsp.ok) {
+            return rsp.text().then((svgContent) => {
+              if (svgContent && sanitize !== false) {
+                svgContent = validateContent(svgContent);
+              }
+              ioniconContent.set(url, svgContent || '');
+            });
+          }
+          ioniconContent.set(url, '');
+        });
+        // cache for the same requests
+        requests.set(url, req);
+      }
+    }
+    else {
+      // set to empty for ssr scenarios and resolve promise
+      ioniconContent.set(url, '');
+      return Promise.resolve();
+    }
+  }
+  return req;
+};
+
+const iconCss = ":host{display:inline-block;width:1em;height:1em;contain:strict;fill:currentColor;box-sizing:content-box !important}:host .ionicon{stroke:currentColor}.ionicon-fill-none{fill:none}.ionicon-stroke-width{stroke-width:32px;stroke-width:var(--ionicon-stroke-width, 32px)}.icon-inner,.ionicon,svg{display:block;height:100%;width:100%}@supports (background: -webkit-named-image(i)){:host(.icon-rtl) .icon-inner{transform:scaleX(-1)}}@supports not selector(:dir(rtl)) and selector(:host-context([dir='rtl'])){:host(.icon-rtl) .icon-inner{transform:scaleX(-1)}}:host(.flip-rtl):host-context([dir='rtl']) .icon-inner{transform:scaleX(-1)}@supports selector(:dir(rtl)){:host(.flip-rtl:dir(rtl)) .icon-inner{transform:scaleX(-1)}:host(.flip-rtl:dir(ltr)) .icon-inner{transform:scaleX(1)}}:host(.icon-small){font-size:1.125rem !important}:host(.icon-large){font-size:2rem !important}:host(.ion-color){color:var(--ion-color-base) !important}:host(.ion-color-primary){--ion-color-base:var(--ion-color-primary, #3880ff)}:host(.ion-color-secondary){--ion-color-base:var(--ion-color-secondary, #0cd1e8)}:host(.ion-color-tertiary){--ion-color-base:var(--ion-color-tertiary, #f4a942)}:host(.ion-color-success){--ion-color-base:var(--ion-color-success, #10dc60)}:host(.ion-color-warning){--ion-color-base:var(--ion-color-warning, #ffce00)}:host(.ion-color-danger){--ion-color-base:var(--ion-color-danger, #f14141)}:host(.ion-color-light){--ion-color-base:var(--ion-color-light, #f4f5f8)}:host(.ion-color-medium){--ion-color-base:var(--ion-color-medium, #989aa2)}:host(.ion-color-dark){--ion-color-base:var(--ion-color-dark, #222428)}";
+
+const Icon = /*@__PURE__*/ proxyCustomElement(class Icon extends H {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.__attachShadow();
+    this.iconName = null;
+    this.inheritedAttributes = {};
+    this.didLoadIcon = false;
+    this.svgContent = undefined;
+    this.isVisible = false;
+    this.mode = getIonMode();
+    this.color = undefined;
+    this.ios = undefined;
+    this.md = undefined;
+    this.flipRtl = undefined;
+    this.name = undefined;
+    this.src = undefined;
+    this.icon = undefined;
+    this.size = undefined;
+    this.lazy = false;
+    this.sanitize = true;
+  }
+  componentWillLoad() {
+    this.inheritedAttributes = inheritAttributes(this.el, ['aria-label']);
+  }
+  connectedCallback() {
+    // purposely do not return the promise here because loading
+    // the svg file should not hold up loading the app
+    // only load the svg if it's visible
+    this.waitUntilVisible(this.el, '50px', () => {
+      this.isVisible = true;
+      this.loadIcon();
+    });
+  }
+  componentDidLoad() {
+    /**
+     * Addresses an Angular issue where property values are assigned after the 'connectedCallback' but prior to the registration of watchers.
+     * This enhancement ensures the loading of an icon when the component has finished rendering and the icon has yet to apply the SVG data.
+     * This modification pertains to the usage of Angular's binding syntax:
+     * `<ion-icon [name]="myIconName"></ion-icon>`
+     */
+    if (!this.didLoadIcon) {
+      this.loadIcon();
+    }
+  }
+  disconnectedCallback() {
+    if (this.io) {
+      this.io.disconnect();
+      this.io = undefined;
+    }
+  }
+  waitUntilVisible(el, rootMargin, cb) {
+    if (this.lazy && typeof window !== 'undefined' && window.IntersectionObserver) {
+      const io = (this.io = new window.IntersectionObserver((data) => {
+        if (data[0].isIntersecting) {
+          io.disconnect();
+          this.io = undefined;
+          cb();
+        }
+      }, { rootMargin }));
+      io.observe(el);
+    }
+    else {
+      // browser doesn't support IntersectionObserver
+      // so just fallback to always show it
+      cb();
+    }
+  }
+  loadIcon() {
+    if (this.isVisible) {
+      const url = getUrl(this);
+      if (url) {
+        if (ioniconContent.has(url)) {
+          // sync if it's already loaded
+          this.svgContent = ioniconContent.get(url);
+        }
+        else {
+          // async if it hasn't been loaded
+          getSvgContent(url, this.sanitize).then(() => (this.svgContent = ioniconContent.get(url)));
+        }
+        this.didLoadIcon = true;
+      }
+    }
+    this.iconName = getName(this.name, this.icon, this.mode, this.ios, this.md);
+  }
+  render() {
+    const { flipRtl, iconName, inheritedAttributes, el } = this;
+    const mode = this.mode || 'md';
+    // we have designated that arrows & chevrons should automatically flip (unless flip-rtl is set to false) because "back" is left in ltr and right in rtl, and "forward" is the opposite
+    const shouldAutoFlip = iconName
+      ? (iconName.includes('arrow') || iconName.includes('chevron')) && flipRtl !== false
+      : false;
+    // if shouldBeFlippable is true, the icon should change direction when `dir` changes
+    const shouldBeFlippable = flipRtl || shouldAutoFlip;
+    return (h(Host, Object.assign({ role: "img", class: Object.assign(Object.assign({ [mode]: true }, createColorClasses(this.color)), { [`icon-${this.size}`]: !!this.size, 'flip-rtl': shouldBeFlippable, 'icon-rtl': shouldBeFlippable && isRTL(el) }) }, inheritedAttributes), this.svgContent ? (h("div", { class: "icon-inner", innerHTML: this.svgContent })) : (h("div", { class: "icon-inner" }))));
+  }
+  static get assetsDirs() { return ["svg"]; }
+  get el() { return this; }
+  static get watchers() { return {
+    "name": ["loadIcon"],
+    "src": ["loadIcon"],
+    "icon": ["loadIcon"],
+    "ios": ["loadIcon"],
+    "md": ["loadIcon"]
+  }; }
+  static get style() { return iconCss; }
+}, [1, "ion-icon", {
+    "mode": [1025],
+    "color": [1],
+    "ios": [1],
+    "md": [1],
+    "flipRtl": [4, "flip-rtl"],
+    "name": [513],
+    "src": [1],
+    "icon": [8],
+    "size": [1],
+    "lazy": [4],
+    "sanitize": [4],
+    "svgContent": [32],
+    "isVisible": [32]
+  }]);
+const getIonMode = () => (typeof document !== 'undefined' && document.documentElement.getAttribute('mode')) || 'md';
+const createColorClasses = (color) => {
+  return color
+    ? {
+      'ion-color': true,
+      [`ion-color-${color}`]: true,
+    }
+    : null;
+};
+function defineCustomElement() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["ion-icon"];
+  components.forEach(tagName => { switch (tagName) {
+    case "ion-icon":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, Icon);
+      }
+      break;
+  } });
+}
+
+export { Icon as I, defineCustomElement as d };

package/dist/{esm/animation-DRf3dwMu.js → components/p-89c4c5cb.js}

@@ -1,5 +1,5 @@
-import { w as win } from './index-ZjP4CjeZ.js';
-import { d as raf } from './helpers-C6kqtbmV.js';
+import { w as win } from './p-d7fe59ee.js';
+import { b as raf } from './p-2bb89b46.js';
 
 /*!
  * (C) Ionic http://ionicframework.com - MIT License