"use strict";
(self["webpackChunkapp"] = self["webpackChunkapp"] || []).push([["node_modules_ionic_core_dist_esm_ion-picker-column_entry_js"],{

/***/ 43110:
/*!**********************************************************************!*\
  !*** ./node_modules/@ionic/core/dist/esm/ion-picker-column.entry.js ***!
  \**********************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   ion_picker_column: () => (/* binding */ PickerColumn)
/* harmony export */ });
/* harmony import */ var _workdir_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js */ 89204);
/* harmony import */ var _index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index-C8IsBmNU.js */ 66922);
/* harmony import */ var _index_ZjP4CjeZ_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index-ZjP4CjeZ.js */ 10575);
/* harmony import */ var _helpers_DEn3pfjm_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./helpers-DEn3pfjm.js */ 86341);
/* harmony import */ var _haptic_DzAMWJuk_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./haptic-DzAMWJuk.js */ 8235);
/* harmony import */ var _ionic_global_CDrldh_5_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./ionic-global-CDrldh-5.js */ 27854);
/* harmony import */ var _theme_DiVJyqlX_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./theme-DiVJyqlX.js */ 70247);
/* harmony import */ var _capacitor_CFERIeaU_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./capacitor-CFERIeaU.js */ 25051);

/*!
 * (C) Ionic http://ionicframework.com - MIT License
 */







const pickerColumnCss = ":host{display:-ms-flexbox;display:flex;position:relative;-ms-flex-align:center;align-items:center;-ms-flex-pack:center;justify-content:center;max-width:100%;height:200px;font-size:22px;text-align:center}.assistive-focusable{left:0;right:0;top:0;bottom:0;position:absolute;z-index:1;pointer-events:none}.assistive-focusable:focus{outline:none}.picker-opts{-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px;padding-top:0px;padding-bottom:0px;min-width:26px;max-height:200px;outline:none;text-align:inherit;-webkit-scroll-snap-type:y mandatory;-ms-scroll-snap-type:y mandatory;scroll-snap-type:y mandatory;overflow-x:hidden;overflow-y:scroll;scrollbar-width:none}.picker-item-empty{padding-left:0;padding-right:0;padding-top:0;padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;display:block;width:100%;height:34px;border:0px;outline:none;background:transparent;color:inherit;font-family:var(--ion-font-family, inherit);font-size:inherit;line-height:34px;text-align:inherit;text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.picker-opts::-webkit-scrollbar{display:none}::slotted(ion-picker-column-option){display:block;scroll-snap-align:center}.picker-item-empty,:host(:not([disabled])) ::slotted(ion-picker-column-option.option-disabled){scroll-snap-align:none}::slotted([slot=prefix]),::slotted([slot=suffix]){max-width:200px;text-overflow:ellipsis;white-space:nowrap;overflow:hidden}::slotted([slot=prefix]){-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px;padding-top:0;padding-bottom:0;-ms-flex-pack:end;justify-content:end}::slotted([slot=suffix]){-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px;padding-top:0;padding-bottom:0;-ms-flex-pack:start;justify-content:start}:host(.picker-column-disabled) .picker-opts{overflow-y:hidden}:host(.picker-column-disabled) ::slotted(ion-picker-column-option){cursor:default;opacity:0.4;pointer-events:none}@media (any-hover: hover){:host(:focus) .picker-opts{outline:none;background:rgba(var(--ion-color-base-rgb), 0.2)}}";
const PickerColumn = class {
  constructor(hostRef) {
    (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.r)(this, hostRef);
    this.ionChange = (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.c)(this, "ionChange", 7);
    this.isScrolling = false;
    this.isColumnVisible = false;
    this.canExitInputMode = true;
    this.updateValueTextOnScroll = false;
    this.ariaLabel = null;
    this.isActive = false;
    /**
     * If `true`, the user cannot interact with the picker.
     */
    this.disabled = false;
    /**
     * The color to use from your application's color palette.
     * Default options are: `"primary"`, `"secondary"`, `"tertiary"`, `"success"`, `"warning"`, `"danger"`, `"light"`, `"medium"`, and `"dark"`.
     * For more information on colors, see [theming](/docs/theming/basics).
     */
    this.color = 'primary';
    /**
     * If `true`, tapping the picker will
     * reveal a number input keyboard that lets
     * the user type in values for each picker
     * column. This is useful when working
     * with time pickers.
     *
     * @internal
     */
    this.numericInput = false;
    this.centerPickerItemInView = (target, smooth = true, canExitInputMode = true) => {
      const {
        isColumnVisible,
        scrollEl
      } = this;
      if (isColumnVisible && scrollEl) {
        // (Vertical offset from parent) - (three empty picker rows) + (half the height of the target to ensure the scroll triggers)
        const top = target.offsetTop - 3 * target.clientHeight + target.clientHeight / 2;
        if (scrollEl.scrollTop !== top) {
          /**
           * Setting this flag prevents input
           * mode from exiting in the picker column's
           * scroll callback. This is useful when the user manually
           * taps an item or types on the keyboard as both
           * of these can cause a scroll to occur.
           */
          this.canExitInputMode = canExitInputMode;
          this.updateValueTextOnScroll = false;
          scrollEl.scroll({
            top,
            left: 0,
            behavior: smooth ? 'smooth' : undefined
          });
        }
      }
    };
    this.setPickerItemActiveState = (item, isActive) => {
      if (isActive) {
        item.classList.add(PICKER_ITEM_ACTIVE_CLASS);
      } else {
        item.classList.remove(PICKER_ITEM_ACTIVE_CLASS);
      }
    };
    /**
     * When ionInputModeChange is emitted, each column
     * needs to check if it is the one being made available
     * for text entry.
     */
    this.inputModeChange = ev => {
      if (!this.numericInput) {
        return;
      }
      const {
        useInputMode,
        inputModeColumn
      } = ev.detail;
      /**
       * If inputModeColumn is undefined then this means
       * all numericInput columns are being selected.
       */
      const isColumnActive = inputModeColumn === undefined || inputModeColumn === this.el;
      if (!useInputMode || !isColumnActive) {
        this.setInputModeActive(false);
        return;
      }
      this.setInputModeActive(true);
    };
    /**
     * Setting isActive will cause a re-render.
     * As a result, we do not want to cause the
     * re-render mid scroll as this will cause
     * the picker column to jump back to
     * whatever value was selected at the
     * start of the scroll interaction.
     */
    this.setInputModeActive = state => {
      if (this.isScrolling) {
        this.scrollEndCallback = () => {
          this.isActive = state;
        };
        return;
      }
      this.isActive = state;
    };
    /**
     * When the column scrolls, the component
     * needs to determine which item is centered
     * in the view and will emit an ionChange with
     * the item object.
     */
    this.initializeScrollListener = () => {
      /**
       * The haptics for the wheel picker are
       * an iOS-only feature. As a result, they should
       * be disabled on Android.
       */
      const enableHaptics = (0,_ionic_global_CDrldh_5_js__WEBPACK_IMPORTED_MODULE_5__.a)('ios');
      const {
        el,
        scrollEl
      } = this;
      let timeout;
      let activeEl = this.activeItem;
      const scrollCallback = () => {
        (0,_helpers_DEn3pfjm_js__WEBPACK_IMPORTED_MODULE_3__.r)(() => {
          var _a;
          if (!scrollEl) return;
          if (timeout) {
            clearTimeout(timeout);
            timeout = undefined;
          }
          if (!this.isScrolling) {
            enableHaptics && (0,_haptic_DzAMWJuk_js__WEBPACK_IMPORTED_MODULE_4__.b)();
            this.isScrolling = true;
          }
          /**
           * Select item in the center of the column
           * which is the month/year that we want to select
           */
          const bbox = scrollEl.getBoundingClientRect();
          const centerX = bbox.x + bbox.width / 2;
          const centerY = bbox.y + bbox.height / 2;
          /**
           * elementFromPoint returns the top-most element.
           * This means that if an ion-backdrop is overlaying the
           * picker then the appropriate picker column option will
           * not be selected. To account for this, we use elementsFromPoint
           * and use an Array.find to find the appropriate column option
           * at that point.
           *
           * Additionally, the picker column could be used in the
           * Shadow DOM (i.e. in ion-datetime) so we need to make
           * sure we are choosing the correct host otherwise
           * the elements returns by elementsFromPoint will be
           * retargeted. To account for this, we check to see
           * if the picker column has a parent shadow root. If
           * so, we use that shadow root when doing elementsFromPoint.
           * Otherwise, we just use the document.
           */
          const rootNode = el.getRootNode();
          const hasParentShadow = rootNode instanceof ShadowRoot;
          const referenceNode = hasParentShadow ? rootNode : _index_ZjP4CjeZ_js__WEBPACK_IMPORTED_MODULE_2__.d;
          /**
           * If the reference node is undefined
           * then it's likely that doc is undefined
           * due to being in an SSR environment.
           */
          if (referenceNode === undefined) {
            return;
          }
          const elementsAtPoint = referenceNode.elementsFromPoint(centerX, centerY);
          /**
           * elementsFromPoint can returns multiple elements
           * so find the relevant picker column option if one exists.
           */
          let newActiveElement = elementsAtPoint.find(el => el.tagName === 'ION-PICKER-COLUMN-OPTION');
          /**
           * TODO(FW-6594): Remove this workaround when iOS 16 is no longer
           * supported.
           *
           * If `elementsFromPoint` failed to find the active element (a known
           * issue on iOS 16 when elements are in a Shadow DOM and the
           * referenceNode is the document), a fallback to `elementFromPoint`
           * is used. While `elementsFromPoint` returns all elements,
           * `elementFromPoint` returns only the top-most, which is sufficient
           * for this use case and appears to handle Shadow DOM retargeting
           * more reliably in this specific iOS bug.
           */
          if (newActiveElement === undefined) {
            const fallbackActiveElement = referenceNode.elementFromPoint(centerX, centerY);
            if ((fallbackActiveElement === null || fallbackActiveElement === void 0 ? void 0 : fallbackActiveElement.tagName) === 'ION-PICKER-COLUMN-OPTION') {
              newActiveElement = fallbackActiveElement;
            }
          }
          if (activeEl !== undefined) {
            this.setPickerItemActiveState(activeEl, false);
          }
          if (newActiveElement === undefined || newActiveElement.disabled) {
            return;
          }
          /**
           * If we are selecting a new value,
           * we need to run haptics again.
           */
          if (newActiveElement !== activeEl) {
            enableHaptics && (0,_haptic_DzAMWJuk_js__WEBPACK_IMPORTED_MODULE_4__.a)();
            if (this.canExitInputMode) {
              /**
               * The native iOS wheel picker
               * only dismisses the keyboard
               * once the selected item has changed
               * as a result of a swipe
               * from the user. If `canExitInputMode` is
               * `false` then this means that the
               * scroll is happening as a result of
               * the `value` property programmatically changing
               * either by an application or by the user via the keyboard.
               */
              this.exitInputMode();
            }
          }
          activeEl = newActiveElement;
          this.setPickerItemActiveState(newActiveElement, true);
          /**
           * Set the aria-valuetext even though the value prop has not been updated yet.
           * This enables some screen readers to announce the value as the users drag
           * as opposed to when their release their pointer from the screen.
           *
           * When the value is programmatically updated, we will smoothly scroll
           * to the new option. However, we do not want to update aria-valuetext mid-scroll
           * as that can cause the old value to be briefly set before being set to the
           * correct option. This will cause some screen readers to announce the old value
           * again before announcing the new value. The correct valuetext will be set on render.
           */
          if (this.updateValueTextOnScroll) {
            (_a = this.assistiveFocusable) === null || _a === void 0 ? void 0 : _a.setAttribute('aria-valuetext', this.getOptionValueText(newActiveElement));
          }
          timeout = setTimeout(() => {
            this.isScrolling = false;
            this.updateValueTextOnScroll = true;
            enableHaptics && (0,_haptic_DzAMWJuk_js__WEBPACK_IMPORTED_MODULE_4__.h)();
            /**
             * Certain tasks (such as those that
             * cause re-renders) should only be done
             * once scrolling has finished, otherwise
             * flickering may occur.
             */
            const {
              scrollEndCallback
            } = this;
            if (scrollEndCallback) {
              scrollEndCallback();
              this.scrollEndCallback = undefined;
            }
            /**
             * Reset this flag as the
             * next scroll interaction could
             * be a scroll from the user. In this
             * case, we should exit input mode.
             */
            this.canExitInputMode = true;
            this.setValue(newActiveElement.value);
          }, 250);
        });
      };
      /**
       * Wrap this in an raf so that the scroll callback
       * does not fire when component is initially shown.
       */
      (0,_helpers_DEn3pfjm_js__WEBPACK_IMPORTED_MODULE_3__.r)(() => {
        if (!scrollEl) return;
        scrollEl.addEventListener('scroll', scrollCallback);
        this.destroyScrollListener = () => {
          scrollEl.removeEventListener('scroll', scrollCallback);
        };
      });
    };
    /**
     * Tells the parent picker to
     * exit text entry mode. This is only called
     * when the selected item changes during scroll, so
     * we know that the user likely wants to scroll
     * instead of type.
     */
    this.exitInputMode = () => {
      const {
        parentEl
      } = this;
      if (parentEl == null) return;
      parentEl.exitInputMode();
      /**
       * setInputModeActive only takes
       * effect once scrolling stops to avoid
       * a component re-render while scrolling.
       * However, we want the visual active
       * indicator to go away immediately, so
       * we call classList.remove here.
       */
      this.el.classList.remove('picker-column-active');
    };
    /**
     * Find the next enabled option after the active option.
     * @param stride - How many options to "jump" over in order to select the next option.
     * This can be used to implement PageUp/PageDown behaviors where pressing these keys
     * scrolls the picker by more than 1 option. For example, a stride of 5 means select
     * the enabled option 5 options after the active one. Note that the actual option selected
     * may be past the stride if the option at the stride is disabled.
     */
    this.findNextOption = (stride = 1) => {
      const {
        activeItem
      } = this;
      if (!activeItem) return null;
      let prevNode = activeItem;
      let node = activeItem.nextElementSibling;
      while (node != null) {
        if (stride > 0) {
          stride--;
        }
        if (node.tagName === 'ION-PICKER-COLUMN-OPTION' && !node.disabled && stride === 0) {
          return node;
        }
        prevNode = node;
        // Use nextElementSibling instead of nextSibling to avoid text/comment nodes
        node = node.nextElementSibling;
      }
      return prevNode;
    };
    /**
     * Find the next enabled option after the active option.
     * @param stride - How many options to "jump" over in order to select the next option.
     * This can be used to implement PageUp/PageDown behaviors where pressing these keys
     * scrolls the picker by more than 1 option. For example, a stride of 5 means select
     * the enabled option 5 options before the active one. Note that the actual option selected
     *  may be past the stride if the option at the stride is disabled.
     */
    this.findPreviousOption = (stride = 1) => {
      const {
        activeItem
      } = this;
      if (!activeItem) return null;
      let nextNode = activeItem;
      let node = activeItem.previousElementSibling;
      while (node != null) {
        if (stride > 0) {
          stride--;
        }
        if (node.tagName === 'ION-PICKER-COLUMN-OPTION' && !node.disabled && stride === 0) {
          return node;
        }
        nextNode = node;
        // Use previousElementSibling instead of previousSibling to avoid text/comment nodes
        node = node.previousElementSibling;
      }
      return nextNode;
    };
    this.onKeyDown = ev => {
      /**
       * The below operations should be inverted when running on a mobile device.
       * For example, swiping up will dispatch an "ArrowUp" event. On desktop,
       * this should cause the previous option to be selected. On mobile, swiping
       * up causes a view to scroll down. As a result, swiping up on mobile should
       * cause the next option to be selected. The Home/End operations remain
       * unchanged because those always represent the first/last options, respectively.
       */
      const mobile = (0,_ionic_global_CDrldh_5_js__WEBPACK_IMPORTED_MODULE_5__.a)('mobile');
      let newOption = null;
      switch (ev.key) {
        case 'ArrowDown':
          newOption = mobile ? this.findPreviousOption() : this.findNextOption();
          break;
        case 'ArrowUp':
          newOption = mobile ? this.findNextOption() : this.findPreviousOption();
          break;
        case 'PageUp':
          newOption = mobile ? this.findNextOption(5) : this.findPreviousOption(5);
          break;
        case 'PageDown':
          newOption = mobile ? this.findPreviousOption(5) : this.findNextOption(5);
          break;
        case 'Home':
          /**
           * There is no guarantee that the first child will be an ion-picker-column-option,
           * so we do not use firstElementChild.
           */
          newOption = this.el.querySelector('ion-picker-column-option:first-of-type');
          break;
        case 'End':
          /**
           * There is no guarantee that the last child will be an ion-picker-column-option,
           * so we do not use lastElementChild.
           */
          newOption = this.el.querySelector('ion-picker-column-option:last-of-type');
          break;
      }
      if (newOption !== null) {
        this.setValue(newOption.value);
        // This stops any default browser behavior such as scrolling
        ev.preventDefault();
      }
    };
    /**
     * Utility to generate the correct text for aria-valuetext.
     */
    this.getOptionValueText = el => {
      var _a;
      return el ? (_a = el.getAttribute('aria-label')) !== null && _a !== void 0 ? _a : el.innerText : '';
    };
  }
  ariaLabelChanged(newValue) {
    this.ariaLabel = newValue;
  }
  valueChange() {
    if (this.isColumnVisible) {
      /**
       * Only scroll the active item into view when the picker column
       * is actively visible to the user.
       */
      this.scrollActiveItemIntoView(true);
    }
  }
  /**
   * Only setup scroll listeners
   * when the picker is visible, otherwise
   * the container will have a scroll
   * height of 0px.
   */
  componentWillLoad() {
    /**
     * We cache parentEl in a local variable
     * so we don't need to keep accessing
     * the class variable (which comes with
     * a small performance hit)
     */
    const parentEl = this.parentEl = this.el.closest('ion-picker');
    const visibleCallback = entries => {
      /**
       * Browsers will sometimes group multiple IO events into a single callback.
       * As a result, we want to grab the last/most recent event in case there are multiple events.
       */
      const ev = entries[entries.length - 1];
      if (ev.isIntersecting) {
        const {
          activeItem,
          el
        } = this;
        this.isColumnVisible = true;
        /**
         * Because this initial call to scrollActiveItemIntoView has to fire before
         * the scroll listener is set up, we need to manage the active class manually.
         */
        const oldActive = (0,_helpers_DEn3pfjm_js__WEBPACK_IMPORTED_MODULE_3__.g)(el).querySelector(`.${PICKER_ITEM_ACTIVE_CLASS}`);
        if (oldActive) {
          this.setPickerItemActiveState(oldActive, false);
        }
        this.scrollActiveItemIntoView();
        if (activeItem) {
          this.setPickerItemActiveState(activeItem, true);
        }
        this.initializeScrollListener();
      } else {
        this.isColumnVisible = false;
        if (this.destroyScrollListener) {
          this.destroyScrollListener();
          this.destroyScrollListener = undefined;
        }
      }
    };
    /**
     * Set the root to be the parent picker element
     * This causes the IO callback
     * to be fired in WebKit as soon as the element
     * is visible. If we used the default root value
     * then WebKit would only fire the IO callback
     * after any animations (such as a modal transition)
     * finished, and there would potentially be a flicker.
     */
    new IntersectionObserver(visibleCallback, {
      threshold: 0.001,
      root: this.parentEl
    }).observe(this.el);
    if (parentEl !== null) {
      // TODO(FW-2832): type
      parentEl.addEventListener('ionInputModeChange', ev => this.inputModeChange(ev));
    }
  }
  componentDidRender() {
    const {
      el,
      activeItem,
      isColumnVisible,
      value
    } = this;
    if (isColumnVisible && !activeItem) {
      const firstOption = el.querySelector('ion-picker-column-option');
      /**
       * If the picker column does not have an active item and the current value
       * does not match the first item in the picker column, that means
       * the value is out of bounds. In this case, we assign the value to the
       * first item to match the scroll position of the column.
       *
       */
      if (firstOption !== null && firstOption.value !== value) {
        this.setValue(firstOption.value);
      }
    }
  }
  /** @internal  */
  scrollActiveItemIntoView() {
    var _this = this;
    return (0,_workdir_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (smooth = false) {
      const activeEl = _this.activeItem;
      if (activeEl) {
        _this.centerPickerItemInView(activeEl, smooth, false);
      }
    }).apply(this, arguments);
  }
  /**
   * Sets the value prop and fires the ionChange event.
   * This is used when we need to fire ionChange from
   * user-generated events that cannot be caught with normal
   * input/change event listeners.
   * @internal
   */
  setValue(value) {
    var _this2 = this;
    return (0,_workdir_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* () {
      if (_this2.disabled === true || _this2.value === value) {
        return;
      }
      _this2.value = value;
      _this2.ionChange.emit({
        value
      });
    })();
  }
  /**
   * Sets focus on the scrollable container within the picker column.
   * Use this method instead of the global `pickerColumn.focus()`.
   */
  setFocus() {
    var _this3 = this;
    return (0,_workdir_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* () {
      if (_this3.assistiveFocusable) {
        _this3.assistiveFocusable.focus();
      }
    })();
  }
  connectedCallback() {
    var _a;
    this.ariaLabel = (_a = this.el.getAttribute('aria-label')) !== null && _a !== void 0 ? _a : 'Select a value';
  }
  get activeItem() {
    const {
      value
    } = this;
    const options = Array.from(this.el.querySelectorAll('ion-picker-column-option'));
    return options.find(option => {
      /**
       * If the whole picker column is disabled, the current value should appear active
       * If the current value item is specifically disabled, it should not appear active
       */
      if (!this.disabled && option.disabled) {
        return false;
      }
      return option.value === value;
    });
  }
  render() {
    const {
      color,
      disabled,
      isActive,
      numericInput
    } = this;
    const mode = (0,_ionic_global_CDrldh_5_js__WEBPACK_IMPORTED_MODULE_5__.b)(this);
    return (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)(_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.d, {
      key: 'db903fd415f8a2d91994dececca481c1af8ba6a9',
      class: (0,_theme_DiVJyqlX_js__WEBPACK_IMPORTED_MODULE_6__.c)(color, {
        [mode]: true,
        ['picker-column-active']: isActive,
        ['picker-column-numeric-input']: numericInput,
        ['picker-column-disabled']: disabled
      })
    }, (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("slot", {
      key: '02ce9e1dd7df91afcd50b06416552bcffb5dec98',
      name: "prefix"
    }), (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("div", {
      key: '6dfd7d2429bec19244a6b1afb4448121963a031b',
      class: "picker-opts",
      ref: el => {
        this.scrollEl = el;
      },
      role: "slider",
      tabindex: this.disabled ? undefined : 0,
      "aria-label": this.ariaLabel,
      "aria-valuemin": 0,
      "aria-valuemax": 0,
      "aria-valuenow": 0,
      "aria-valuetext": this.getOptionValueText(this.activeItem),
      "aria-orientation": "vertical",
      onKeyDown: ev => this.onKeyDown(ev)
    }, (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("div", {
      key: 'e30ce0b9cefbfe4d4441fa33acf595da31855c3f',
      class: "picker-item-empty",
      "aria-hidden": "true"
    }, "\u00A0"), (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("div", {
      key: '8be2bd293c12c6ba720d9b31d0d561a96f42e97d',
      class: "picker-item-empty",
      "aria-hidden": "true"
    }, "\u00A0"), (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("div", {
      key: '8afdcddddabbf646fbb55cb0ba4448309a2c1dd9',
      class: "picker-item-empty",
      "aria-hidden": "true"
    }, "\u00A0"), (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("slot", {
      key: '6aa0dacc34d6848575ad5b122b9046982308ca43'
    }), (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("div", {
      key: '92ec8a357414c1b779b11d1dd18fb87a7ee63982',
      class: "picker-item-empty",
      "aria-hidden": "true"
    }, "\u00A0"), (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("div", {
      key: 'b89457cb74b5907c25594ff6720ac54ca537e933',
      class: "picker-item-empty",
      "aria-hidden": "true"
    }, "\u00A0"), (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("div", {
      key: '5bbc92e6bc24de08e39873bf08c5b668373ac0f8',
      class: "picker-item-empty",
      "aria-hidden": "true"
    }, "\u00A0")), (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.h)("slot", {
      key: 'd7bf2b519214f0f3576a4ca79844ad97827dd97f',
      name: "suffix"
    }));
  }
  get el() {
    return (0,_index_C8IsBmNU_js__WEBPACK_IMPORTED_MODULE_1__.g)(this);
  }
  static get watchers() {
    return {
      "aria-label": ["ariaLabelChanged"],
      "value": ["valueChange"]
    };
  }
};
const PICKER_ITEM_ACTIVE_CLASS = 'option-active';
PickerColumn.style = pickerColumnCss;


/***/ })

}]);
//# sourceMappingURL=node_modules_ionic_core_dist_esm_ion-picker-column_entry_js.js.map