/*! elementor - v3.16.0 - 14-09-2023 */
(self["webpackChunkelementor"] = self["webpackChunkelementor"] || []).push([["frontend-modules"],{

/***/ "../assets/dev/js/editor/utils/is-instanceof.js":
/*!******************************************************!*\
  !*** ../assets/dev/js/editor/utils/is-instanceof.js ***!
  \******************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
/**
 * Some FileAPI objects such as FileList, DataTransferItem and DataTransferItemList has inconsistency with the retrieved
 * object (from events, etc.) and the actual JavaScript object so a regular instanceof doesn't work. This function can
 * check whether it's instanceof by using the objects constructor and prototype names.
 *
 * @param  object
 * @param  constructors
 * @return {boolean}
 */
var _default = (object, constructors) => {
  constructors = Array.isArray(constructors) ? constructors : [constructors];
  for (const constructor of constructors) {
    if (object.constructor.name === constructor.prototype[Symbol.toStringTag]) {
      return true;
    }
  }
  return false;
};
exports["default"] = _default;

/***/ }),

/***/ "../assets/dev/js/frontend/document.js":
/*!*********************************************!*\
  !*** ../assets/dev/js/frontend/document.js ***!
  \*********************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
class _default extends elementorModules.ViewModule {
  getDefaultSettings() {
    return {
      selectors: {
        elements: '.elementor-element',
        nestedDocumentElements: '.elementor .elementor-element'
      },
      classes: {
        editMode: 'elementor-edit-mode'
      }
    };
  }
  getDefaultElements() {
    const selectors = this.getSettings('selectors');
    return {
      $elements: this.$element.find(selectors.elements).not(this.$element.find(selectors.nestedDocumentElements))
    };
  }
  getDocumentSettings(setting) {
    let elementSettings;
    if (this.isEdit) {
      elementSettings = {};
      const settings = elementor.settings.page.model;
      jQuery.each(settings.getActiveControls(), controlKey => {
        elementSettings[controlKey] = settings.attributes[controlKey];
      });
    } else {
      elementSettings = this.$element.data('elementor-settings') || {};
    }
    return this.getItems(elementSettings, setting);
  }
  runElementsHandlers() {
    this.elements.$elements.each((index, element) => setTimeout(() => elementorFrontend.elementsHandler.runReadyTrigger(element)));
  }
  onInit() {
    this.$element = this.getSettings('$element');
    super.onInit();
    this.isEdit = this.$element.hasClass(this.getSettings('classes.editMode'));
    if (this.isEdit) {
      elementor.on('document:loaded', () => {
        elementor.settings.page.model.on('change', this.onSettingsChange.bind(this));
      });
    } else {
      this.runElementsHandlers();
    }
  }
  onSettingsChange() {}
}
exports["default"] = _default;

/***/ }),

/***/ "../assets/dev/js/frontend/handlers/accessibility/nested-title-keyboard-handler.js":
/*!*****************************************************************************************!*\
  !*** ../assets/dev/js/frontend/handlers/accessibility/nested-title-keyboard-handler.js ***!
  \*****************************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _base = _interopRequireDefault(__webpack_require__(/*! ../base */ "../assets/dev/js/frontend/handlers/base.js"));
class NestedTitleKeyboardHandler extends _base.default {
  __construct(settings) {
    super.__construct(settings);
    this.directionNext = 'next';
    this.directionPrevious = 'previous';
    this.focusableElementSelector = 'audio, button, canvas, details, iframe, input, select, summary, textarea, video, [accesskey], [contenteditable], [href], [tabindex]:not([tabindex="-1"])';
  }
  getDefaultSettings() {
    return {
      selectors: {
        itemTitle: '.e-n-tab-title',
        itemContainer: '.e-n-tabs-content > .e-con'
      },
      ariaAttributes: {
        titleStateAttribute: 'aria-selected',
        activeTitleSelector: '[aria-selected="true"]'
      },
      datasets: {
        titleIndex: 'data-tab-index'
      },
      keyDirection: {
        ArrowLeft: elementorFrontendConfig.is_rtl ? this.directionNext : this.directionPrevious,
        ArrowUp: this.directionPrevious,
        ArrowRight: elementorFrontendConfig.is_rtl ? this.directionPrevious : this.directionNext,
        ArrowDown: this.directionNext
      }
    };
  }
  getDefaultElements() {
    const selectors = this.getSettings('selectors');
    return {
      $itemTitles: this.findElement(selectors.itemTitle),
      $itemContainers: this.findElement(selectors.itemContainer),
      $focusableContainerElements: this.getFocusableElements(this.findElement(selectors.itemContainer))
    };
  }
  getFocusableElements($elements) {
    return $elements.find(this.focusableElementSelector).not('[disabled], [inert]');
  }
  getKeyDirectionValue(event) {
    const direction = this.getSettings('keyDirection')[event.key];
    return this.directionNext === direction ? 1 : -1;
  }

  /**
   * @param {HTMLElement} itemTitleElement
   *
   * @return {string}
   */
  getTitleIndex(itemTitleElement) {
    const {
      titleIndex: indexAttribute
    } = this.getSettings('datasets');
    return itemTitleElement.getAttribute(indexAttribute);
  }

  /**
   * @param {string|number} titleIndex
   *
   * @return {string}
   */
  getTitleFilterSelector(titleIndex) {
    const {
      titleIndex: indexAttribute
    } = this.getSettings('datasets');
    return `[${indexAttribute}="${titleIndex}"]`;
  }
  getActiveTitleElement() {
    const activeTitleFilter = this.getSettings('ariaAttributes').activeTitleSelector;
    return this.elements.$itemTitles.filter(activeTitleFilter);
  }
  onInit() {
    super.onInit(...arguments);
  }
  bindEvents() {
    this.elements.$itemTitles.on(this.getTitleEvents());
    this.elements.$focusableContainerElements.on(this.getContentElementEvents());
  }
  unbindEvents() {
    this.elements.$itemTitles.off();
    this.elements.$itemContainers.children().off();
  }
  getTitleEvents() {
    return {
      keydown: this.handleTitleKeyboardNavigation.bind(this)
    };
  }
  getContentElementEvents() {
    return {
      keydown: this.handleContentElementKeyboardNavigation.bind(this)
    };
  }
  isDirectionKey(event) {
    const directionKeys = ['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown', 'Home', 'End'];
    return directionKeys.includes(event.key);
  }
  isActivationKey(event) {
    const activationKeys = ['Enter', ' '];
    return activationKeys.includes(event.key);
  }
  handleTitleKeyboardNavigation(event) {
    if (this.isDirectionKey(event)) {
      event.preventDefault();
      const currentTitleIndex = parseInt(this.getTitleIndex(event.currentTarget)) || 1,
        numberOfTitles = this.elements.$itemTitles.length,
        titleIndexUpdated = this.getTitleIndexFocusUpdated(event, currentTitleIndex, numberOfTitles);
      this.changeTitleFocus(titleIndexUpdated);
      event.stopPropagation();
    } else if (this.isActivationKey(event)) {
      event.preventDefault();
      if (this.handeTitleLinkEnterOrSpaceEvent(event)) {
        return;
      }
      const titleIndex = this.getTitleIndex(event.currentTarget);
      elementorFrontend.elements.$window.trigger('elementor/nested-elements/activate-by-keyboard', {
        widgetId: this.getID(),
        titleIndex
      });
    } else if ('Escape' === event.key) {
      this.handleTitleEscapeKeyEvents(event);
    }
  }
  handeTitleLinkEnterOrSpaceEvent(event) {
    const isLinkElement = 'a' === event?.currentTarget?.tagName?.toLowerCase();
    if (!elementorFrontend.isEditMode() && isLinkElement) {
      event?.currentTarget?.click();
      event.stopPropagation();
    }
    return isLinkElement;
  }
  getTitleIndexFocusUpdated(event, currentTitleIndex, numberOfTitles) {
    let titleIndexUpdated = 0;
    switch (event.key) {
      case 'Home':
        titleIndexUpdated = 1;
        break;
      case 'End':
        titleIndexUpdated = numberOfTitles;
        break;
      default:
        const directionValue = this.getKeyDirectionValue(event),
          isEndReached = numberOfTitles < currentTitleIndex + directionValue,
          isStartReached = 0 === currentTitleIndex + directionValue;
        if (isEndReached) {
          titleIndexUpdated = 1;
        } else if (isStartReached) {
          titleIndexUpdated = numberOfTitles;
        } else {
          titleIndexUpdated = currentTitleIndex + directionValue;
        }
    }
    return titleIndexUpdated;
  }
  changeTitleFocus(titleIndexUpdated) {
    const $newTitle = this.elements.$itemTitles.filter(this.getTitleFilterSelector(titleIndexUpdated));
    this.setTitleTabindex(titleIndexUpdated);
    $newTitle.trigger('focus');
  }
  setTitleTabindex(titleIndex) {
    this.elements.$itemTitles.attr('tabindex', '-1');
    const $newTitle = this.elements.$itemTitles.filter(this.getTitleFilterSelector(titleIndex));
    $newTitle.attr('tabindex', '0');
  }
  handleTitleEscapeKeyEvents() {}
  handleContentElementKeyboardNavigation(event) {
    if ('Tab' === event.key && !event.shiftKey) {
      this.handleContentElementTabEvents(event);
    } else if ('Escape' === event.key) {
      event.preventDefault();
      event.stopPropagation();
      this.handleContentElementEscapeEvents();
    }
  }
  handleContentElementEscapeEvents() {
    this.getActiveTitleElement().trigger('focus');
  }
  handleContentElementTabEvents() {}
}
exports["default"] = NestedTitleKeyboardHandler;

/***/ }),

/***/ "../assets/dev/js/frontend/handlers/base-carousel.js":
/*!***********************************************************!*\
  !*** ../assets/dev/js/frontend/handlers/base-carousel.js ***!
  \***********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _baseSwiper = _interopRequireDefault(__webpack_require__(/*! ./base-swiper */ "../assets/dev/js/frontend/handlers/base-swiper.js"));
class CarouselHandlerBase extends _baseSwiper.default {
  getDefaultSettings() {
    return {
      selectors: {
        carousel: `.${elementorFrontend.config.swiperClass}`,
        swiperWrapper: '.swiper-wrapper',
        slideContent: '.swiper-slide',
        swiperArrow: '.elementor-swiper-button',
        paginationWrapper: '.swiper-pagination',
        paginationBullet: '.swiper-pagination-bullet',
        paginationBulletWrapper: '.swiper-pagination-bullets'
      }
    };
  }
  getDefaultElements() {
    const selectors = this.getSettings('selectors'),
      elements = {
        $swiperContainer: this.$element.find(selectors.carousel),
        $swiperWrapper: this.$element.find(selectors.swiperWrapper),
        $swiperArrows: this.$element.find(selectors.swiperArrow),
        $paginationWrapper: this.$element.find(selectors.paginationWrapper),
        $paginationBullets: this.$element.find(selectors.paginationBullet),
        $paginationBulletWrapper: this.$element.find(selectors.paginationBulletWrapper)
      };
    elements.$slides = elements.$swiperContainer.find(selectors.slideContent);
    return elements;
  }
  getSwiperSettings() {
    const elementSettings = this.getElementSettings(),
      slidesToShow = +elementSettings.slides_to_show || 3,
      isSingleSlide = 1 === slidesToShow,
      elementorBreakpoints = elementorFrontend.config.responsive.activeBreakpoints,
      defaultSlidesToShowMap = {
        mobile: 1,
        tablet: isSingleSlide ? 1 : 2
      };
    const swiperOptions = {
      slidesPerView: slidesToShow,
      loop: 'yes' === elementSettings.infinite,
      speed: elementSettings.speed,
      handleElementorBreakpoints: true
    };
    swiperOptions.breakpoints = {};
    let lastBreakpointSlidesToShowValue = slidesToShow;
    Object.keys(elementorBreakpoints).reverse().forEach(breakpointName => {
      // Tablet has a specific default `slides_to_show`.
      const defaultSlidesToShow = defaultSlidesToShowMap[breakpointName] ? defaultSlidesToShowMap[breakpointName] : lastBreakpointSlidesToShowValue;
      swiperOptions.breakpoints[elementorBreakpoints[breakpointName].value] = {
        slidesPerView: +elementSettings['slides_to_show_' + breakpointName] || defaultSlidesToShow,
        slidesPerGroup: +elementSettings['slides_to_scroll_' + breakpointName] || 1
      };
      if (elementSettings.image_spacing_custom) {
        swiperOptions.breakpoints[elementorBreakpoints[breakpointName].value].spaceBetween = this.getSpaceBetween(breakpointName);
      }
      lastBreakpointSlidesToShowValue = +elementSettings['slides_to_show_' + breakpointName] || defaultSlidesToShow;
    });
    if ('yes' === elementSettings.autoplay) {
      swiperOptions.autoplay = {
        delay: elementSettings.autoplay_speed,
        disableOnInteraction: 'yes' === elementSettings.pause_on_interaction
      };
    }
    if (isSingleSlide) {
      swiperOptions.effect = elementSettings.effect;
      if ('fade' === elementSettings.effect) {
        swiperOptions.fadeEffect = {
          crossFade: true
        };
      }
    } else {
      swiperOptions.slidesPerGroup = +elementSettings.slides_to_scroll || 1;
    }
    if (elementSettings.image_spacing_custom) {
      swiperOptions.spaceBetween = this.getSpaceBetween();
    }
    const showArrows = 'arrows' === elementSettings.navigation || 'both' === elementSettings.navigation,
      showPagination = 'dots' === elementSettings.navigation || 'both' === elementSettings.navigation || elementSettings.pagination;
    if (showArrows) {
      swiperOptions.navigation = {
        prevEl: '.elementor-swiper-button-prev',
        nextEl: '.elementor-swiper-button-next'
      };
    }
    if (showPagination) {
      swiperOptions.pagination = {
        el: `.elementor-element-${this.getID()} .swiper-pagination`,
        type: !!elementSettings.pagination ? elementSettings.pagination : 'bullets',
        clickable: true,
        renderBullet: (index, classname) => {
          return `<span class="${classname}" data-bullet-index="${index}" aria-label="${elementorFrontend.config.i18n.a11yCarouselPaginationBulletMessage} ${index + 1}"></span>`;
        }
      };
    }
    if ('yes' === elementSettings.lazyload) {
      swiperOptions.lazy = {
        loadPrevNext: true,
        loadPrevNextAmount: 1
      };
    }
    swiperOptions.a11y = {
      enabled: true,
      prevSlideMessage: elementorFrontend.config.i18n.a11yCarouselPrevSlideMessage,
      nextSlideMessage: elementorFrontend.config.i18n.a11yCarouselNextSlideMessage,
      firstSlideMessage: elementorFrontend.config.i18n.a11yCarouselFirstSlideMessage,
      lastSlideMessage: elementorFrontend.config.i18n.a11yCarouselLastSlideMessage
    };
    swiperOptions.on = {
      slideChangeTransitionEnd: () => {
        this.a11ySetSlideAriaHidden();
      },
      slideChange: () => {
        this.a11ySetPaginationTabindex();
        this.handleElementHandlers();
      }
    };
    this.applyOffsetSettings(elementSettings, swiperOptions, slidesToShow);
    return swiperOptions;
  }
  getOffsetWidth() {
    const currentDevice = elementorFrontend.getCurrentDeviceMode();
    return elementorFrontend.utils.controls.getResponsiveControlValue(this.getElementSettings(), 'offset_width', 'size', currentDevice) || 0;
  }
  applyOffsetSettings(elementSettings, swiperOptions, slidesToShow) {
    const offsetSide = elementSettings.offset_sides,
      isNestedCarouselInEditMode = elementorFrontend.isEditMode() && 'NestedCarousel' === this.constructor.name;
    if (isNestedCarouselInEditMode || !offsetSide || 'none' === offsetSide) {
      return;
    }
    const offset = this.getOffsetWidth();
    switch (offsetSide) {
      case 'right':
        this.forceSliderToShowNextSlideWhenOnLast(swiperOptions, slidesToShow);
        this.addClassToSwiperContainer('offset-right');
        break;
      case 'left':
        this.addClassToSwiperContainer('offset-left');
        break;
      case 'both':
        this.forceSliderToShowNextSlideWhenOnLast(swiperOptions, slidesToShow);
        this.addClassToSwiperContainer('offset-both');
        break;
    }
  }
  forceSliderToShowNextSlideWhenOnLast(swiperOptions, slidesToShow) {
    swiperOptions.slidesPerView = slidesToShow + 0.001;
  }
  addClassToSwiperContainer(className) {
    this.getDefaultElements().$swiperContainer[0].classList.add(className);
  }
  async onInit() {
    super.onInit(...arguments);
    if (!this.elements.$swiperContainer.length || 2 > this.elements.$slides.length) {
      return;
    }
    const Swiper = elementorFrontend.utils.swiper;
    this.swiper = await new Swiper(this.elements.$swiperContainer, this.getSwiperSettings());

    // Expose the swiper instance in the frontend
    this.elements.$swiperContainer.data('swiper', this.swiper);
    const elementSettings = this.getElementSettings();
    if ('yes' === elementSettings.pause_on_hover) {
      this.togglePauseOnHover(true);
    }
    this.a11ySetWidgetAriaDetails();
    this.a11ySetPaginationTabindex();
    this.a11ySetSlideAriaHidden('initialisation');
  }
  bindEvents() {
    this.elements.$swiperArrows.on('keydown', this.onDirectionArrowKeydown.bind(this));
    this.elements.$paginationWrapper.on('keydown', '.swiper-pagination-bullet', this.onDirectionArrowKeydown.bind(this));
    this.elements.$swiperContainer.on('keydown', '.swiper-slide', this.onDirectionArrowKeydown.bind(this));
    this.$element.find(':focusable').on('focus', this.onFocusDisableAutoplay.bind(this));
    elementorFrontend.elements.$window.on('resize', this.getSwiperSettings.bind(this));
  }
  unbindEvents() {
    this.elements.$swiperArrows.off();
    this.elements.$paginationWrapper.off();
    this.elements.$swiperContainer.off();
    this.$element.find(':focusable').off();
    elementorFrontend.elements.$window.off('resize');
  }
  onDirectionArrowKeydown(event) {
    const isRTL = elementorFrontend.config.isRTL,
      inlineDirectionArrows = ['ArrowLeft', 'ArrowRight'],
      currentKeydown = event.originalEvent.code,
      isDirectionInlineKeydown = -1 !== inlineDirectionArrows.indexOf(currentKeydown),
      directionStart = isRTL ? 'ArrowRight' : 'ArrowLeft',
      directionEnd = isRTL ? 'ArrowLeft' : 'ArrowRight';
    if (!isDirectionInlineKeydown) {
      return true;
    } else if (directionStart === currentKeydown) {
      this.swiper.slidePrev();
    } else if (directionEnd === currentKeydown) {
      this.swiper.slideNext();
    }
  }
  onFocusDisableAutoplay() {
    this.swiper.autoplay.stop();
  }
  updateSwiperOption(propertyName) {
    const elementSettings = this.getElementSettings(),
      newSettingValue = elementSettings[propertyName],
      params = this.swiper.params;

    // Handle special cases where the value to update is not the value that the Swiper library accepts.
    switch (propertyName) {
      case 'autoplay_speed':
        params.autoplay.delay = newSettingValue;
        break;
      case 'speed':
        params.speed = newSettingValue;
        break;
    }
    this.swiper.update();
  }
  getChangeableProperties() {
    return {
      pause_on_hover: 'pauseOnHover',
      autoplay_speed: 'delay',
      speed: 'speed',
      arrows_position: 'arrows_position' // Not a Swiper setting.
    };
  }

  onElementChange(propertyName) {
    if (0 === propertyName.indexOf('image_spacing_custom')) {
      this.updateSpaceBetween(propertyName);
      return;
    }
    const changeableProperties = this.getChangeableProperties();
    if (changeableProperties[propertyName]) {
      // 'pause_on_hover' is implemented by the handler with event listeners, not the Swiper library.
      if ('pause_on_hover' === propertyName) {
        const newSettingValue = this.getElementSettings('pause_on_hover');
        this.togglePauseOnHover('yes' === newSettingValue);
      } else {
        this.updateSwiperOption(propertyName);
      }
    }
  }
  onEditSettingsChange(propertyName) {
    if ('activeItemIndex' === propertyName) {
      this.swiper.slideToLoop(this.getEditSettings('activeItemIndex') - 1);
    }
  }
  getSpaceBetween() {
    let device = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
    return elementorFrontend.utils.controls.getResponsiveControlValue(this.getElementSettings(), 'image_spacing_custom', 'size', device) || 0;
  }
  updateSpaceBetween(propertyName) {
    const deviceMatch = propertyName.match('image_spacing_custom_(.*)'),
      device = deviceMatch ? deviceMatch[1] : 'desktop',
      newSpaceBetween = this.getSpaceBetween(device);
    if ('desktop' !== device) {
      this.swiper.params.breakpoints[elementorFrontend.config.responsive.activeBreakpoints[device].value].spaceBetween = newSpaceBetween;
    }
    this.swiper.params.spaceBetween = newSpaceBetween;
    this.swiper.update();
  }
  getPaginationBullets() {
    let type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'array';
    const paginationBullets = this.$element.find(this.getSettings('selectors').paginationBullet);
    return 'array' === type ? Array.from(paginationBullets) : paginationBullets;
  }
  a11ySetWidgetAriaDetails() {
    const $widget = this.$element;
    $widget.attr('aria-roledescription', 'carousel');
    $widget.attr('aria-label', elementorFrontend.config.i18n.a11yCarouselWrapperAriaLabel);
  }
  a11ySetPaginationTabindex() {
    const bulletClass = this.swiper?.params.pagination.bulletClass,
      activeBulletClass = this.swiper?.params.pagination.bulletActiveClass;
    this.getPaginationBullets().forEach(bullet => {
      if (!bullet.classList.contains(activeBulletClass)) {
        bullet.removeAttribute('tabindex');
      }
    });
    const isDirectionInlineArrowKey = 'ArrowLeft' === event?.code || 'ArrowRight' === event?.code;
    if (event?.target?.classList.contains(bulletClass) && isDirectionInlineArrowKey) {
      this.$element.find(`.${activeBulletClass}`).trigger('focus');
    }
  }
  getSwiperWrapperTranformXValue() {
    let transformValue = this.elements.$swiperWrapper[0]?.style.transform;
    transformValue = transformValue.replace('translate3d(', '');
    transformValue = transformValue.split(',');
    transformValue = parseInt(transformValue[0].replace('px', ''));
    return !!transformValue ? transformValue : 0;
  }
  a11ySetSlideAriaHidden() {
    let status = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
    const currentIndex = 'initialisation' === status ? 0 : this.swiper?.activeIndex;
    if ('number' !== typeof currentIndex) {
      return;
    }
    const swiperWrapperTransformXValue = this.getSwiperWrapperTranformXValue(),
      swiperWrapperWidth = this.elements.$swiperWrapper[0].clientWidth,
      $slides = this.elements.$swiperContainer.find(this.getSettings('selectors').slideContent);
    $slides.each((index, slide) => {
      const isSlideInsideWrapper = 0 <= slide.offsetLeft + swiperWrapperTransformXValue && swiperWrapperWidth > slide.offsetLeft + swiperWrapperTransformXValue;
      if (!isSlideInsideWrapper) {
        slide.setAttribute('aria-hidden', true);
        slide.setAttribute('inert', '');
      } else {
        slide.removeAttribute('aria-hidden');
        slide.removeAttribute('inert');
      }
    });
  }

  // Empty method which can be overwritten by child methods.
  handleElementHandlers() {}
}
exports["default"] = CarouselHandlerBase;

/***/ }),

/***/ "../assets/dev/js/frontend/handlers/base-swiper.js":
/*!*********************************************************!*\
  !*** ../assets/dev/js/frontend/handlers/base-swiper.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _base = _interopRequireDefault(__webpack_require__(/*! ./base */ "../assets/dev/js/frontend/handlers/base.js"));
class SwiperHandlerBase extends _base.default {
  getInitialSlide() {
    const editSettings = this.getEditSettings();
    return editSettings.activeItemIndex ? editSettings.activeItemIndex - 1 : 0;
  }
  getSlidesCount() {
    return this.elements.$slides.length;
  }

  // This method live-handles the 'Pause On Hover' control's value being changed in the Editor Panel
  togglePauseOnHover(toggleOn) {
    if (toggleOn) {
      this.elements.$swiperContainer.on({
        mouseenter: () => {
          this.swiper.autoplay.stop();
        },
        mouseleave: () => {
          this.swiper.autoplay.start();
        }
      });
    } else {
      this.elements.$swiperContainer.off('mouseenter mouseleave');
    }
  }
  handleKenBurns() {
    const settings = this.getSettings();
    if (this.$activeImageBg) {
      this.$activeImageBg.removeClass(settings.classes.kenBurnsActive);
    }
    this.activeItemIndex = this.swiper ? this.swiper.activeIndex : this.getInitialSlide();
    if (this.swiper) {
      this.$activeImageBg = jQuery(this.swiper.slides[this.activeItemIndex]).children('.' + settings.classes.slideBackground);
    } else {
      this.$activeImageBg = jQuery(this.elements.$slides[0]).children('.' + settings.classes.slideBackground);
    }
    this.$activeImageBg.addClass(settings.classes.kenBurnsActive);
  }
}
exports["default"] = SwiperHandlerBase;

/***/ }),

/***/ "../assets/dev/js/frontend/handlers/base.js":
/*!**************************************************!*\
  !*** ../assets/dev/js/frontend/handlers/base.js ***!
  \**************************************************/
/***/ ((module) => {

"use strict";


module.exports = elementorModules.ViewModule.extend({
  $element: null,
  editorListeners: null,
  onElementChange: null,
  onEditSettingsChange: null,
  onPageSettingsChange: null,
  isEdit: null,
  __construct(settings) {
    if (!this.isActive(settings)) {
      return;
    }
    this.$element = settings.$element;
    this.isEdit = this.$element.hasClass('elementor-element-edit-mode');
    if (this.isEdit) {
      this.addEditorListeners();
    }
  },
  isActive() {
    return true;
  },
  isElementInTheCurrentDocument() {
    if (!elementorFrontend.isEditMode()) {
      return false;
    }
    return elementor.documents.currentDocument.id.toString() === this.$element[0].closest('.elementor').dataset.elementorId;
  },
  findElement(selector) {
    var $mainElement = this.$element;
    return $mainElement.find(selector).filter(function () {
      // Start `closest` from parent since self can be `.elementor-element`.
      return jQuery(this).parent().closest('.elementor-element').is($mainElement);
    });
  },
  getUniqueHandlerID(cid, $element) {
    if (!cid) {
      cid = this.getModelCID();
    }
    if (!$element) {
      $element = this.$element;
    }
    return cid + $element.attr('data-element_type') + this.getConstructorID();
  },
  initEditorListeners() {
    var self = this;
    self.editorListeners = [{
      event: 'element:destroy',
      to: elementor.channels.data,
      callback(removedModel) {
        if (removedModel.cid !== self.getModelCID()) {
          return;
        }
        self.onDestroy();
      }
    }];
    if (self.onElementChange) {
      const elementType = self.getWidgetType() || self.getElementType();
      let eventName = 'change';
      if ('global' !== elementType) {
        eventName += ':' + elementType;
      }
      self.editorListeners.push({
        event: eventName,
        to: elementor.channels.editor,
        callback(controlView, elementView) {
          var elementViewHandlerID = self.getUniqueHandlerID(elementView.model.cid, elementView.$el);
          if (elementViewHandlerID !== self.getUniqueHandlerID()) {
            return;
          }
          self.onElementChange(controlView.model.get('name'), controlView, elementView);
        }
      });
    }
    if (self.onEditSettingsChange) {
      self.editorListeners.push({
        event: 'change:editSettings',
        to: elementor.channels.editor,
        callback(changedModel, view) {
          if (view.model.cid !== self.getModelCID()) {
            return;
          }
          const propName = Object.keys(changedModel.changed)[0];
          self.onEditSettingsChange(propName, changedModel.changed[propName]);
        }
      });
    }
    ['page'].forEach(function (settingsType) {
      var listenerMethodName = 'on' + settingsType[0].toUpperCase() + settingsType.slice(1) + 'SettingsChange';
      if (self[listenerMethodName]) {
        self.editorListeners.push({
          event: 'change',
          to: elementor.settings[settingsType].model,
          callback(model) {
            self[listenerMethodName](model.changed);
          }
        });
      }
    });
  },
  getEditorListeners() {
    if (!this.editorListeners) {
      this.initEditorListeners();
    }
    return this.editorListeners;
  },
  addEditorListeners() {
    var uniqueHandlerID = this.getUniqueHandlerID();
    this.getEditorListeners().forEach(function (listener) {
      elementorFrontend.addListenerOnce(uniqueHandlerID, listener.event, listener.callback, listener.to);
    });
  },
  removeEditorListeners() {
    var uniqueHandlerID = this.getUniqueHandlerID();
    this.getEditorListeners().forEach(function (listener) {
      elementorFrontend.removeListeners(uniqueHandlerID, listener.event, null, listener.to);
    });
  },
  getElementType() {
    return this.$element.data('element_type');
  },
  getWidgetType() {
    const widgetType = this.$element.data('widget_type');
    if (!widgetType) {
      return;
    }
    return widgetType.split('.')[0];
  },
  getID() {
    return this.$element.data('id');
  },
  getModelCID() {
    return this.$element.data('model-cid');
  },
  getElementSettings(setting) {
    let elementSettings = {};
    const modelCID = this.getModelCID();
    if (this.isEdit && modelCID) {
      const settings = elementorFrontend.config.elements.data[modelCID],
        attributes = settings.attributes;
      let type = attributes.widgetType || attributes.elType;
      if (attributes.isInner) {
        type = 'inner-' + type;
      }
      let settingsKeys = elementorFrontend.config.elements.keys[type];
      if (!settingsKeys) {
        settingsKeys = elementorFrontend.config.elements.keys[type] = [];
        jQuery.each(settings.controls, (name, control) => {
          if (control.frontend_available) {
            settingsKeys.push(name);
          }
        });
      }
      jQuery.each(settings.getActiveControls(), function (controlKey) {
        if (-1 !== settingsKeys.indexOf(controlKey)) {
          let value = attributes[controlKey];
          if (value.toJSON) {
            value = value.toJSON();
          }
          elementSettings[controlKey] = value;
        }
      });
    } else {
      elementSettings = this.$element.data('settings') || {};
    }
    return this.getItems(elementSettings, setting);
  },
  getEditSettings(setting) {
    var attributes = {};
    if (this.isEdit) {
      attributes = elementorFrontend.config.elements.editSettings[this.getModelCID()].attributes;
    }
    return this.getItems(attributes, setting);
  },
  getCurrentDeviceSetting(settingKey) {
    return elementorFrontend.getCurrentDeviceSetting(this.getElementSettings(), settingKey);
  },
  onInit() {
    if (this.isActive(this.getSettings())) {
      elementorModules.ViewModule.prototype.onInit.apply(this, arguments);
    }
  },
  onDestroy() {
    if (this.isEdit) {
      this.removeEditorListeners();
    }
    if (this.unbindEvents) {
      this.unbindEvents();
    }
  }
});

/***/ }),

/***/ "../assets/dev/js/frontend/handlers/stretched-element.js":
/*!***************************************************************!*\
  !*** ../assets/dev/js/frontend/handlers/stretched-element.js ***!
  \***************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _base = _interopRequireDefault(__webpack_require__(/*! ./base */ "../assets/dev/js/frontend/handlers/base.js"));
class StretchedElement extends _base.default {
  getStretchedClass() {
    return 'e-stretched';
  }
  getStretchSettingName() {
    return 'stretch_element';
  }
  getStretchActiveValue() {
    return 'yes';
  }
  bindEvents() {
    const handlerID = this.getUniqueHandlerID();
    elementorFrontend.addListenerOnce(handlerID, 'resize', this.stretch);
    elementorFrontend.addListenerOnce(handlerID, 'sticky:stick', this.stretch, this.$element);
    elementorFrontend.addListenerOnce(handlerID, 'sticky:unstick', this.stretch, this.$element);
    if (elementorFrontend.isEditMode()) {
      this.onKitChangeStretchContainerChange = this.onKitChangeStretchContainerChange.bind(this);
      elementor.channels.editor.on('kit:change:stretchContainer', this.onKitChangeStretchContainerChange);
    }
  }
  unbindEvents() {
    elementorFrontend.removeListeners(this.getUniqueHandlerID(), 'resize', this.stretch);
    if (elementorFrontend.isEditMode()) {
      elementor.channels.editor.off('kit:change:stretchContainer', this.onKitChangeStretchContainerChange);
    }
  }
  isActive(settings) {
    return elementorFrontend.isEditMode() || settings.$element.hasClass(this.getStretchedClass());
  }
  getStretchElementForConfig() {
    let childSelector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
    if (childSelector) {
      return this.$element.find(childSelector);
    }
    return this.$element;
  }
  getStretchElementConfig() {
    return {
      element: this.getStretchElementForConfig(),
      selectors: {
        container: this.getStretchContainer()
      },
      considerScrollbar: elementorFrontend.isEditMode() && elementorFrontend.config.is_rtl
    };
  }
  initStretch() {
    this.stretch = this.stretch.bind(this);
    this.stretchElement = new elementorModules.frontend.tools.StretchElement(this.getStretchElementConfig());
  }
  getStretchContainer() {
    return elementorFrontend.getKitSettings('stretched_section_container') || window;
  }
  isStretchSettingEnabled() {
    return this.getElementSettings(this.getStretchSettingName()) === this.getStretchActiveValue();
  }
  stretch() {
    if (!this.isStretchSettingEnabled()) {
      return;
    }
    this.stretchElement.stretch();
  }
  onInit() {
    if (!this.isActive(this.getSettings())) {
      return;
    }
    this.initStretch();
    super.onInit(...arguments);
    this.stretch();
  }
  onElementChange(propertyName) {
    const stretchSettingName = this.getStretchSettingName();
    if (stretchSettingName === propertyName) {
      if (this.isStretchSettingEnabled()) {
        this.stretch();
      } else {
        this.stretchElement.reset();
      }
    }
  }
  onKitChangeStretchContainerChange() {
    this.stretchElement.setSettings('selectors.container', this.getStretchContainer());
    this.stretch();
  }
}
exports["default"] = StretchedElement;

/***/ }),

/***/ "../assets/dev/js/frontend/modules.js":
/*!********************************************!*\
  !*** ../assets/dev/js/frontend/modules.js ***!
  \********************************************/
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
var _modules = _interopRequireDefault(__webpack_require__(/*! ../modules/modules */ "../assets/dev/js/modules/modules.js"));
var _document = _interopRequireDefault(__webpack_require__(/*! ./document */ "../assets/dev/js/frontend/document.js"));
var _stretchElement = _interopRequireDefault(__webpack_require__(/*! ./tools/stretch-element */ "../assets/dev/js/frontend/tools/stretch-element.js"));
var _stretchedElement = _interopRequireDefault(__webpack_require__(/*! ./handlers/stretched-element */ "../assets/dev/js/frontend/handlers/stretched-element.js"));
var _base = _interopRequireDefault(__webpack_require__(/*! ./handlers/base */ "../assets/dev/js/frontend/handlers/base.js"));
var _baseSwiper = _interopRequireDefault(__webpack_require__(/*! ./handlers/base-swiper */ "../assets/dev/js/frontend/handlers/base-swiper.js"));
var _baseCarousel = _interopRequireDefault(__webpack_require__(/*! ./handlers/base-carousel */ "../assets/dev/js/frontend/handlers/base-carousel.js"));
var _nestedTabs = _interopRequireDefault(__webpack_require__(/*! elementor/modules/nested-tabs/assets/js/frontend/handlers/nested-tabs */ "../modules/nested-tabs/assets/js/frontend/handlers/nested-tabs.js"));
var _nestedAccordion = _interopRequireDefault(__webpack_require__(/*! elementor/modules/nested-accordion/assets/js/frontend/handlers/nested-accordion */ "../modules/nested-accordion/assets/js/frontend/handlers/nested-accordion.js"));
var _nestedTitleKeyboardHandler = _interopRequireDefault(__webpack_require__(/*! ./handlers/accessibility/nested-title-keyboard-handler */ "../assets/dev/js/frontend/handlers/accessibility/nested-title-keyboard-handler.js"));
_modules.default.frontend = {
  Document: _document.default,
  tools: {
    StretchElement: _stretchElement.default
  },
  handlers: {
    Base: _base.default,
    StretchedElement: _stretchedElement.default,
    SwiperBase: _baseSwiper.default,
    CarouselBase: _baseCarousel.default,
    NestedTabs: _nestedTabs.default,
    NestedAccordion: _nestedAccordion.default,
    NestedTitleKeyboardHandler: _nestedTitleKeyboardHandler.default
  }
};

/***/ }),

/***/ "../assets/dev/js/frontend/tools/stretch-element.js":
/*!**********************************************************!*\
  !*** ../assets/dev/js/frontend/tools/stretch-element.js ***!
  \**********************************************************/
/***/ ((module) => {

"use strict";


module.exports = elementorModules.ViewModule.extend({
  getDefaultSettings() {
    return {
      element: null,
      direction: elementorFrontend.config.is_rtl ? 'right' : 'left',
      selectors: {
        container: window
      },
      considerScrollbar: false,
      cssOutput: 'inline'
    };
  },
  getDefaultElements() {
    return {
      $element: jQuery(this.getSettings('element'))
    };
  },
  stretch() {
    const settings = this.getSettings();
    let $container;
    try {
      $container = jQuery(settings.selectors.container);
      // eslint-disable-next-line no-empty
    } catch (e) {}
    if (!$container || !$container.length) {
      $container = jQuery(this.getDefaultSettings().selectors.container);
    }
    this.reset();
    var $element = this.elements.$element,
      containerWidth = $container.innerWidth(),
      elementOffset = $element.offset().left,
      isFixed = 'fixed' === $element.css('position'),
      correctOffset = isFixed ? 0 : elementOffset,
      isContainerFullScreen = window === $container[0];
    if (!isContainerFullScreen) {
      var containerOffset = $container.offset().left;
      if (isFixed) {
        correctOffset = containerOffset;
      }
      if (elementOffset > containerOffset) {
        correctOffset = elementOffset - containerOffset;
      }
    }
    if (settings.considerScrollbar && isContainerFullScreen) {
      const scrollbarWidth = window.innerWidth - containerWidth;
      correctOffset -= scrollbarWidth;
    }
    if (!isFixed) {
      if (elementorFrontend.config.is_rtl) {
        correctOffset = containerWidth - ($element.outerWidth() + correctOffset);
      }
      correctOffset = -correctOffset;
    }

    // Consider margin
    if (settings.margin) {
      correctOffset += settings.margin;
    }
    var css = {};
    let width = containerWidth;
    if (settings.margin) {
      width -= settings.margin * 2;
    }
    css.width = width + 'px';
    css[settings.direction] = correctOffset + 'px';
    if ('variables' === settings.cssOutput) {
      this.applyCssVariables($element, css);
      return;
    }
    $element.css(css);
  },
  reset() {
    const css = {},
      settings = this.getSettings(),
      $element = this.elements.$element;
    if ('variables' === settings.cssOutput) {
      this.resetCssVariables($element);
      return;
    }
    css.width = '';
    css[settings.direction] = '';
    $element.css(css);
  },
  applyCssVariables($element, css) {
    $element.css('--stretch-width', css.width);
    if (!!css.left) {
      $element.css('--stretch-left', css.left);
    } else {
      $element.css('--stretch-right', css.right);
    }
  },
  resetCssVariables($element) {
    $element.css({
      '--stretch-width': '',
      '--stretch-left': '',
      '--stretch-right': ''
    });
  }
});

/***/ }),

/***/ "../assets/dev/js/frontend/utils/flex-horizontal-scroll.js":
/*!*****************************************************************!*\
  !*** ../assets/dev/js/frontend/utils/flex-horizontal-scroll.js ***!
  \*****************************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.changeScrollStatus = changeScrollStatus;
exports.setHorizontalScrollAlignment = setHorizontalScrollAlignment;
exports.setHorizontalTitleScrollValues = setHorizontalTitleScrollValues;
function changeScrollStatus(element, event) {
  if ('mousedown' === event.type) {
    element.classList.add('e-scroll');
    element.dataset.pageX = event.pageX;
  } else {
    element.classList.remove('e-scroll', 'e-scroll-active');
    element.dataset.pageX = '';
  }
}

// This function was written using this example https://codepen.io/thenutz/pen/VwYeYEE.
function setHorizontalTitleScrollValues(element, horizontalScrollStatus, event) {
  const isActiveScroll = element.classList.contains('e-scroll'),
    isHorizontalScrollActive = 'enable' === horizontalScrollStatus,
    headingContentIsWiderThanWrapper = element.scrollWidth > element.clientWidth;
  if (!isActiveScroll || !isHorizontalScrollActive || !headingContentIsWiderThanWrapper) {
    return;
  }
  event.preventDefault();
  const previousPositionX = parseFloat(element.dataset.pageX),
    mouseMoveX = event.pageX - previousPositionX,
    maximumScrollValue = 5,
    stepLimit = 20;
  let toScrollDistanceX = 0;
  if (stepLimit < mouseMoveX) {
    toScrollDistanceX = maximumScrollValue;
  } else if (stepLimit * -1 > mouseMoveX) {
    toScrollDistanceX = -1 * maximumScrollValue;
  } else {
    toScrollDistanceX = mouseMoveX;
  }
  element.scrollLeft = element.scrollLeft - toScrollDistanceX;
  element.classList.add('e-scroll-active');
}
function setHorizontalScrollAlignment(_ref) {
  let {
    element,
    direction,
    justifyCSSVariable,
    horizontalScrollStatus
  } = _ref;
  if (!element) {
    return;
  }
  if (isHorizontalScroll(element, horizontalScrollStatus)) {
    initialScrollPosition(element, direction, justifyCSSVariable);
  } else {
    element.style.setProperty(justifyCSSVariable, '');
  }
}
function isHorizontalScroll(element, horizontalScrollStatus) {
  return element.clientWidth < getChildrenWidth(element.children) && 'enable' === horizontalScrollStatus;
}
function getChildrenWidth(children) {
  let totalWidth = 0;
  const parentContainer = children[0].parentNode,
    computedStyles = getComputedStyle(parentContainer),
    gap = parseFloat(computedStyles.gap) || 0; // Get the gap value or default to 0 if it's not specified

  for (let i = 0; i < children.length; i++) {
    totalWidth += children[i].offsetWidth + gap;
  }
  return totalWidth;
}
function initialScrollPosition(element, direction, justifyCSSVariable) {
  const isRTL = elementorCommon.config.isRTL;
  switch (direction) {
    case 'end':
      element.style.setProperty(justifyCSSVariable, 'start');
      element.scrollLeft = isRTL ? -1 * getChildrenWidth(element.children) : getChildrenWidth(element.children);
      break;
    default:
      element.style.setProperty(justifyCSSVariable, 'start');
      element.scrollLeft = 0;
  }
}

/***/ }),

/***/ "../assets/dev/js/modules/imports/args-object.js":
/*!*******************************************************!*\
  !*** ../assets/dev/js/modules/imports/args-object.js ***!
  \*******************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
__webpack_require__(/*! core-js/modules/es.error.cause.js */ "../node_modules/core-js/modules/es.error.cause.js");
var _instanceType = _interopRequireDefault(__webpack_require__(/*! ./instance-type */ "../assets/dev/js/modules/imports/instance-type.js"));
var _isInstanceof = _interopRequireDefault(__webpack_require__(/*! ../../editor/utils/is-instanceof */ "../assets/dev/js/editor/utils/is-instanceof.js"));
class ArgsObject extends _instanceType.default {
  static getInstanceType() {
    return 'ArgsObject';
  }

  /**
   * Function constructor().
   *
   * Create ArgsObject.
   *
   * @param {{}} args
   */
  constructor(args) {
    super();
    this.args = args;
  }

  /**
   * Function requireArgument().
   *
   * Validate property in args.
   *
   * @param {string} property
   * @param {{}}     args
   *
   * @throws {Error}
   *
   */
  requireArgument(property) {
    let args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.args;
    if (!Object.prototype.hasOwnProperty.call(args, property)) {
      throw Error(`${property} is required.`);
    }
  }

  /**
   * Function requireArgumentType().
   *
   * Validate property in args using `type === typeof(args.whatever)`.
   *
   * @param {string} property
   * @param {string} type
   * @param {{}}     args
   *
   * @throws {Error}
   *
   */
  requireArgumentType(property, type) {
    let args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.args;
    this.requireArgument(property, args);
    if (typeof args[property] !== type) {
      throw Error(`${property} invalid type: ${type}.`);
    }
  }

  /**
   * Function requireArgumentInstance().
   *
   * Validate property in args using `args.whatever instanceof instance`.
   *
   * @param {string} property
   * @param {*}      instance
   * @param {{}}     args
   *
   * @throws {Error}
   *
   */
  requireArgumentInstance(property, instance) {
    let args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.args;
    this.requireArgument(property, args);
    if (!(args[property] instanceof instance) && !(0, _isInstanceof.default)(args[property], instance)) {
      throw Error(`${property} invalid instance.`);
    }
  }

  /**
   * Function requireArgumentConstructor().
   *
   * Validate property in args using `type === args.whatever.constructor`.
   *
   * @param {string} property
   * @param {*}      type
   * @param {{}}     args
   *
   * @throws {Error}
   *
   */
  requireArgumentConstructor(property, type) {
    let args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.args;
    this.requireArgument(property, args);

    // Note: Converting the constructor to string in order to avoid equation issues
    // due to different memory addresses between iframes (window.Object !== window.top.Object).
    if (args[property].constructor.toString() !== type.prototype.constructor.toString()) {
      throw Error(`${property} invalid constructor type.`);
    }
  }
}
exports["default"] = ArgsObject;

/***/ }),

/***/ "../assets/dev/js/modules/imports/force-method-implementation.js":
/*!***********************************************************************!*\
  !*** ../assets/dev/js/modules/imports/force-method-implementation.js ***!
  \***********************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = exports.ForceMethodImplementation = void 0;
__webpack_require__(/*! core-js/modules/es.error.cause.js */ "../node_modules/core-js/modules/es.error.cause.js");
// TODO: Wrong location used as `elementorModules.ForceMethodImplementation(); should be` `elementorUtils.forceMethodImplementation()`;

class ForceMethodImplementation extends Error {
  constructor() {
    let info = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    let args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    super(`${info.isStatic ? 'static ' : ''}${info.fullName}() should be implemented, please provide '${info.functionName || info.fullName}' functionality.`, args);

    // Allow to pass custom properties to the error.
    if (Object.keys(args).length) {
      // eslint-disable-next-line no-console
      console.error(args);
    }
    Error.captureStackTrace(this, ForceMethodImplementation);
  }
}
exports.ForceMethodImplementation = ForceMethodImplementation;
var _default = args => {
  const stack = Error().stack,
    caller = stack.split('\n')[2].trim(),
    callerName = caller.startsWith('at new') ? 'constructor' : caller.split(' ')[1],
    info = {};
  info.functionName = callerName;
  info.fullName = callerName;
  if (info.functionName.includes('.')) {
    const parts = info.functionName.split('.');
    info.className = parts[0];
    info.functionName = parts[1];
  } else {
    info.isStatic = true;
  }
  throw new ForceMethodImplementation(info, args);
};
exports["default"] = _default;

/***/ }),

/***/ "../assets/dev/js/modules/imports/instance-type.js":
/*!*********************************************************!*\
  !*** ../assets/dev/js/modules/imports/instance-type.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
class InstanceType {
  static [Symbol.hasInstance](target) {
    /**
     * This is function extending being called each time JS uses instanceOf, since babel use it each time it create new class
     * its give's opportunity to mange capabilities of instanceOf operator.
     * saving current class each time will give option later to handle instanceOf manually.
     */
    let result = super[Symbol.hasInstance](target);

    // Act normal when validate a class, which does not have instance type.
    if (target && !target.constructor.getInstanceType) {
      return result;
    }
    if (target) {
      if (!target.instanceTypes) {
        target.instanceTypes = [];
      }
      if (!result) {
        if (this.getInstanceType() === target.constructor.getInstanceType()) {
          result = true;
        }
      }
      if (result) {
        const name = this.getInstanceType === InstanceType.getInstanceType ? 'BaseInstanceType' : this.getInstanceType();
        if (-1 === target.instanceTypes.indexOf(name)) {
          target.instanceTypes.push(name);
        }
      }
    }
    if (!result && target) {
      // Check if the given 'target', is instance of known types.
      result = target.instanceTypes && Array.isArray(target.instanceTypes) && -1 !== target.instanceTypes.indexOf(this.getInstanceType());
    }
    return result;
  }
  static getInstanceType() {
    elementorModules.ForceMethodImplementation();
  }
  constructor() {
    // Since anonymous classes sometimes do not get validated by babel, do it manually.
    let target = new.target;
    const prototypes = [];
    while (target.__proto__ && target.__proto__.name) {
      prototypes.push(target.__proto__);
      target = target.__proto__;
    }
    prototypes.reverse().forEach(proto => this instanceof proto);
  }
}
exports["default"] = InstanceType;

/***/ }),

/***/ "../assets/dev/js/modules/imports/module.js":
/*!**************************************************!*\
  !*** ../assets/dev/js/modules/imports/module.js ***!
  \**************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


__webpack_require__(/*! core-js/modules/es.error.cause.js */ "../node_modules/core-js/modules/es.error.cause.js");
const Module = function () {
  const $ = jQuery,
    instanceParams = arguments,
    self = this,
    events = {};
  let settings;
  const ensureClosureMethods = function () {
    $.each(self, function (methodName) {
      const oldMethod = self[methodName];
      if ('function' !== typeof oldMethod) {
        return;
      }
      self[methodName] = function () {
        return oldMethod.apply(self, arguments);
      };
    });
  };
  const initSettings = function () {
    settings = self.getDefaultSettings();
    const instanceSettings = instanceParams[0];
    if (instanceSettings) {
      $.extend(true, settings, instanceSettings);
    }
  };
  const init = function () {
    self.__construct.apply(self, instanceParams);
    ensureClosureMethods();
    initSettings();
    self.trigger('init');
  };
  this.getItems = function (items, itemKey) {
    if (itemKey) {
      const keyStack = itemKey.split('.'),
        currentKey = keyStack.splice(0, 1);
      if (!keyStack.length) {
        return items[currentKey];
      }
      if (!items[currentKey]) {
        return;
      }
      return this.getItems(items[currentKey], keyStack.join('.'));
    }
    return items;
  };
  this.getSettings = function (setting) {
    return this.getItems(settings, setting);
  };
  this.setSettings = function (settingKey, value, settingsContainer) {
    if (!settingsContainer) {
      settingsContainer = settings;
    }
    if ('object' === typeof settingKey) {
      $.extend(settingsContainer, settingKey);
      return self;
    }
    const keyStack = settingKey.split('.'),
      currentKey = keyStack.splice(0, 1);
    if (!keyStack.length) {
      settingsContainer[currentKey] = value;
      return self;
    }
    if (!settingsContainer[currentKey]) {
      settingsContainer[currentKey] = {};
    }
    return self.setSettings(keyStack.join('.'), value, settingsContainer[currentKey]);
  };
  this.getErrorMessage = function (type, functionName) {
    let message;
    switch (type) {
      case 'forceMethodImplementation':
        message = `The method '${functionName}' must to be implemented in the inheritor child.`;
        break;
      default:
        message = 'An error occurs';
    }
    return message;
  };

  // TODO: This function should be deleted ?.
  this.forceMethodImplementation = function (functionName) {
    throw new Error(this.getErrorMessage('forceMethodImplementation', functionName));
  };
  this.on = function (eventName, callback) {
    if ('object' === typeof eventName) {
      $.each(eventName, function (singleEventName) {
        self.on(singleEventName, this);
      });
      return self;
    }
    const eventNames = eventName.split(' ');
    eventNames.forEach(function (singleEventName) {
      if (!events[singleEventName]) {
        events[singleEventName] = [];
      }
      events[singleEventName].push(callback);
    });
    return self;
  };
  this.off = function (eventName, callback) {
    if (!events[eventName]) {
      return self;
    }
    if (!callback) {
      delete events[eventName];
      return self;
    }
    const callbackIndex = events[eventName].indexOf(callback);
    if (-1 !== callbackIndex) {
      delete events[eventName][callbackIndex];

      // Reset array index (for next off on same event).
      events[eventName] = events[eventName].filter(val => val);
    }
    return self;
  };
  this.trigger = function (eventName) {
    const methodName = 'on' + eventName[0].toUpperCase() + eventName.slice(1),
      params = Array.prototype.slice.call(arguments, 1);
    if (self[methodName]) {
      self[methodName].apply(self, params);
    }
    const callbacks = events[eventName];
    if (!callbacks) {
      return self;
    }
    $.each(callbacks, function (index, callback) {
      callback.apply(self, params);
    });
    return self;
  };
  init();
};
Module.prototype.__construct = function () {};
Module.prototype.getDefaultSettings = function () {
  return {};
};
Module.prototype.getConstructorID = function () {
  return this.constructor.name;
};
Module.extend = function (properties) {
  const $ = jQuery,
    parent = this;
  const child = function () {
    return parent.apply(this, arguments);
  };
  $.extend(child, parent);
  child.prototype = Object.create($.extend({}, parent.prototype, properties));
  child.prototype.constructor = child;
  child.__super__ = parent.prototype;
  return child;
};
module.exports = Module;

/***/ }),

/***/ "../assets/dev/js/modules/imports/utils/masonry.js":
/*!*********************************************************!*\
  !*** ../assets/dev/js/modules/imports/utils/masonry.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _viewModule = _interopRequireDefault(__webpack_require__(/*! ../view-module */ "../assets/dev/js/modules/imports/view-module.js"));
var _default = _viewModule.default.extend({
  getDefaultSettings() {
    return {
      container: null,
      items: null,
      columnsCount: 3,
      verticalSpaceBetween: 30
    };
  },
  getDefaultElements() {
    return {
      $container: jQuery(this.getSettings('container')),
      $items: jQuery(this.getSettings('items'))
    };
  },
  run() {
    var heights = [],
      distanceFromTop = this.elements.$container.position().top,
      settings = this.getSettings(),
      columnsCount = settings.columnsCount;
    distanceFromTop += parseInt(this.elements.$container.css('margin-top'), 10);
    this.elements.$items.each(function (index) {
      var row = Math.floor(index / columnsCount),
        $item = jQuery(this),
        itemHeight = $item[0].getBoundingClientRect().height + settings.verticalSpaceBetween;
      if (row) {
        var itemPosition = $item.position(),
          indexAtRow = index % columnsCount,
          pullHeight = itemPosition.top - distanceFromTop - heights[indexAtRow];
        pullHeight -= parseInt($item.css('margin-top'), 10);
        pullHeight *= -1;
        $item.css('margin-top', pullHeight + 'px');
        heights[indexAtRow] += itemHeight;
      } else {
        heights.push(itemHeight);
      }
    });
  }
});
exports["default"] = _default;

/***/ }),

/***/ "../assets/dev/js/modules/imports/utils/scroll.js":
/*!********************************************************!*\
  !*** ../assets/dev/js/modules/imports/utils/scroll.js ***!
  \********************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
// Moved from elementor pro: 'assets/dev/js/frontend/utils'
class Scroll {
  /**
   * @param {Object}      obj
   * @param {number}      obj.sensitivity - Value between 0-100 - Will determine the intersection trigger points on the element
   * @param {Function}    obj.callback    - Will be triggered on each intersection point between the element and the viewport top/bottom
   * @param {string}      obj.offset      - Offset between the element intersection points and the viewport, written like in CSS: '-50% 0 -25%'
   * @param {HTMLElement} obj.root        - The element that the events will be relative to, if 'null' will be relative to the viewport
   */
  static scrollObserver(obj) {
    let lastScrollY = 0;

    // Generating threshholds points along the animation height
    // More threshholds points = more trigger points of the callback
    const buildThreshholds = function () {
      let sensitivityPercentage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
      const threshholds = [];
      if (sensitivityPercentage > 0 && sensitivityPercentage <= 100) {
        const increment = 100 / sensitivityPercentage;
        for (let i = 0; i <= 100; i += increment) {
          threshholds.push(i / 100);
        }
      } else {
        threshholds.push(0);
      }
      return threshholds;
    };
    const options = {
      root: obj.root || null,
      rootMargin: obj.offset || '0px',
      threshold: buildThreshholds(obj.sensitivity)
    };
    function handleIntersect(entries) {
      const currentScrollY = entries[0].boundingClientRect.y,
        isInViewport = entries[0].isIntersecting,
        intersectionScrollDirection = currentScrollY < lastScrollY ? 'down' : 'up',
        scrollPercentage = Math.abs(parseFloat((entries[0].intersectionRatio * 100).toFixed(2)));
      obj.callback({
        sensitivity: obj.sensitivity,
        isInViewport,
        scrollPercentage,
        intersectionScrollDirection
      });
      lastScrollY = currentScrollY;
    }
    return new IntersectionObserver(handleIntersect, options);
  }

  /**
   * @param {jQuery.Element} $element
   * @param {Object}         offsetObj
   * @param {number}         offsetObj.start - Offset start value in percentages
   * @param {number}         offsetObj.end   - Offset end value in percentages
   */
  static getElementViewportPercentage($element) {
    let offsetObj = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    const elementOffset = $element[0].getBoundingClientRect(),
      offsetStart = offsetObj.start || 0,
      offsetEnd = offsetObj.end || 0,
      windowStartOffset = window.innerHeight * offsetStart / 100,
      windowEndOffset = window.innerHeight * offsetEnd / 100,
      y1 = elementOffset.top - window.innerHeight,
      y2 = elementOffset.top + windowStartOffset + $element.height(),
      startPosition = 0 - y1 + windowStartOffset,
      endPosition = y2 - y1 + windowEndOffset,
      percent = Math.max(0, Math.min(startPosition / endPosition, 1));
    return parseFloat((percent * 100).toFixed(2));
  }

  /**
   * @param {Object} offsetObj
   * @param {number} offsetObj.start - Offset start value in percentages
   * @param {number} offsetObj.end   - Offset end value in percentages
   * @param {number} limitPageHeight - Will limit the page height calculation
   */
  static getPageScrollPercentage() {
    let offsetObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    let limitPageHeight = arguments.length > 1 ? arguments[1] : undefined;
    const offsetStart = offsetObj.start || 0,
      offsetEnd = offsetObj.end || 0,
      initialPageHeight = limitPageHeight || document.documentElement.scrollHeight - document.documentElement.clientHeight,
      heightOffset = initialPageHeight * offsetStart / 100,
      pageRange = initialPageHeight + heightOffset + initialPageHeight * offsetEnd / 100,
      scrollPos = document.documentElement.scrollTop + document.body.scrollTop + heightOffset;
    return scrollPos / pageRange * 100;
  }
}
exports["default"] = Scroll;

/***/ }),

/***/ "../assets/dev/js/modules/imports/view-module.js":
/*!*******************************************************!*\
  !*** ../assets/dev/js/modules/imports/view-module.js ***!
  \*******************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _module = _interopRequireDefault(__webpack_require__(/*! ./module */ "../assets/dev/js/modules/imports/module.js"));
var _default = _module.default.extend({
  elements: null,
  getDefaultElements() {
    return {};
  },
  bindEvents() {},
  onInit() {
    this.initElements();
    this.bindEvents();
  },
  initElements() {
    this.elements = this.getDefaultElements();
  }
});
exports["default"] = _default;

/***/ }),

/***/ "../assets/dev/js/modules/modules.js":
/*!*******************************************!*\
  !*** ../assets/dev/js/modules/modules.js ***!
  \*******************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _module = _interopRequireDefault(__webpack_require__(/*! ./imports/module */ "../assets/dev/js/modules/imports/module.js"));
var _viewModule = _interopRequireDefault(__webpack_require__(/*! ./imports/view-module */ "../assets/dev/js/modules/imports/view-module.js"));
var _argsObject = _interopRequireDefault(__webpack_require__(/*! ./imports/args-object */ "../assets/dev/js/modules/imports/args-object.js"));
var _masonry = _interopRequireDefault(__webpack_require__(/*! ./imports/utils/masonry */ "../assets/dev/js/modules/imports/utils/masonry.js"));
var _scroll = _interopRequireDefault(__webpack_require__(/*! ./imports/utils/scroll */ "../assets/dev/js/modules/imports/utils/scroll.js"));
var _forceMethodImplementation = _interopRequireDefault(__webpack_require__(/*! ./imports/force-method-implementation */ "../assets/dev/js/modules/imports/force-method-implementation.js"));
var _default = window.elementorModules = {
  Module: _module.default,
  ViewModule: _viewModule.default,
  ArgsObject: _argsObject.default,
  ForceMethodImplementation: _forceMethodImplementation.default,
  utils: {
    Masonry: _masonry.default,
    Scroll: _scroll.default
  }
};
exports["default"] = _default;

/***/ }),

/***/ "../modules/nested-accordion/assets/js/frontend/handlers/nested-accordion.js":
/*!***********************************************************************************!*\
  !*** ../modules/nested-accordion/assets/js/frontend/handlers/nested-accordion.js ***!
  \***********************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _base = _interopRequireDefault(__webpack_require__(/*! elementor/assets/dev/js/frontend/handlers/base */ "../assets/dev/js/frontend/handlers/base.js"));
class NestedAccordion extends _base.default {
  constructor() {
    super(...arguments);
    this.animations = new Map();
  }
  getDefaultSettings() {
    return {
      selectors: {
        accordion: '.e-n-accordion',
        accordionContentContainers: '.e-n-accordion > .e-con',
        accordionItems: '.e-n-accordion-item',
        accordionItemTitles: '.e-n-accordion-item-title',
        accordionContent: '.e-n-accordion-item > .e-con'
      },
      default_state: 'expanded'
    };
  }
  getDefaultElements() {
    const selectors = this.getSettings('selectors');
    return {
      $accordion: this.findElement(selectors.accordion),
      $contentContainers: this.findElement(selectors.accordionContentContainers),
      $accordionItems: this.findElement(selectors.accordionItems),
      $accordionTitles: this.findElement(selectors.accordionItemTitles),
      $accordionContent: this.findElement(selectors.accordionContent)
    };
  }
  onInit() {
    super.onInit(...arguments);
    if (elementorFrontend.isEditMode()) {
      this.interlaceContainers();
    }
  }
  interlaceContainers() {
    const {
      $contentContainers,
      $accordionItems
    } = this.getDefaultElements();
    $contentContainers.each((index, element) => {
      $accordionItems[index].appendChild(element);
    });
  }
  bindEvents() {
    this.elements.$accordionTitles.on('click', this.clickListener.bind(this));
  }
  unbindEvents() {
    this.elements.$accordionTitles.off();
  }
  clickListener(event) {
    event.preventDefault();
    const accordionItem = event.currentTarget.parentElement,
      settings = this.getSettings(),
      accordionContent = accordionItem.querySelector(settings.selectors.accordionContent),
      {
        max_items_expended: maxItemsExpended
      } = this.getElementSettings(),
      {
        $accordionTitles,
        $accordionItems
      } = this.elements;
    if ('one' === maxItemsExpended) {
      this.closeAllItems($accordionItems, $accordionTitles);
    }
    if (!accordionItem.open) {
      this.prepareOpenAnimation(accordionItem, event.currentTarget, accordionContent);
    } else {
      this.closeAccordionItem(accordionItem, event.currentTarget);
    }
  }
  animateItem(accordionItem, startHeight, endHeight, isOpen) {
    accordionItem.style.overflow = 'hidden';
    let animation = this.animations.get(accordionItem);
    if (animation) {
      animation.cancel();
    }
    animation = accordionItem.animate({
      height: [startHeight, endHeight]
    }, {
      duration: this.getAnimationDuration()
    });
    animation.onfinish = () => this.onAnimationFinish(accordionItem, isOpen);
    this.animations.set(accordionItem, animation);
  }
  closeAccordionItem(accordionItem, accordionItemTitle) {
    const startHeight = `${accordionItem.offsetHeight}px`,
      endHeight = `${accordionItemTitle.offsetHeight}px`;
    this.animateItem(accordionItem, startHeight, endHeight, false);
  }
  prepareOpenAnimation(accordionItem, accordionItemTitle, accordionItemContent) {
    accordionItem.style.overflow = 'hidden';
    accordionItem.style.height = `${accordionItem.offsetHeight}px`;
    accordionItem.open = true;
    window.requestAnimationFrame(() => this.openAccordionItem(accordionItem, accordionItemTitle, accordionItemContent));
  }
  openAccordionItem(accordionItem, accordionItemTitle, accordionItemContent) {
    const startHeight = `${accordionItem.offsetHeight}px`,
      endHeight = `${accordionItemTitle.offsetHeight + accordionItemContent.offsetHeight}px`;
    this.animateItem(accordionItem, startHeight, endHeight, true);
  }
  onAnimationFinish(accordionItem, isOpen) {
    accordionItem.open = isOpen;
    this.animations.set(accordionItem, null);
    accordionItem.style.height = accordionItem.style.overflow = '';
  }
  closeAllItems($items, $titles) {
    $titles.each((index, title) => {
      this.closeAccordionItem($items[index], title);
    });
  }
  getAnimationDuration() {
    const {
      size,
      unit
    } = this.getElementSettings('n_accordion_animation_duration');
    return size * ('ms' === unit ? 1 : 1000);
  }
}
exports["default"] = NestedAccordion;

/***/ }),

/***/ "../modules/nested-tabs/assets/js/frontend/handlers/nested-tabs.js":
/*!*************************************************************************!*\
  !*** ../modules/nested-tabs/assets/js/frontend/handlers/nested-tabs.js ***!
  \*************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _base = _interopRequireDefault(__webpack_require__(/*! elementor-frontend/handlers/base */ "../assets/dev/js/frontend/handlers/base.js"));
var _flexHorizontalScroll = __webpack_require__(/*! elementor-frontend-utils/flex-horizontal-scroll */ "../assets/dev/js/frontend/utils/flex-horizontal-scroll.js");
class NestedTabs extends _base.default {
  constructor() {
    super(...arguments);
    this.resizeListenerNestedTabs = null;
  }

  /**
   * @param {string|number} tabIndex
   *
   * @return {string}
   */
  getTabTitleFilterSelector(tabIndex) {
    return `[data-tab-index="${tabIndex}"]`;
  }

  /**
   * @param {string|number} tabIndex
   *
   * @return {string}
   */
  getTabContentFilterSelector(tabIndex) {
    return `*:nth-child(${tabIndex})`;
  }

  /**
   * @param {HTMLElement} tabTitleElement
   *
   * @return {string}
   */
  getTabIndex(tabTitleElement) {
    return tabTitleElement.getAttribute('data-tab-index');
  }
  getDefaultSettings() {
    return {
      selectors: {
        widgetContainer: '.e-n-tabs',
        tabTitle: '.e-n-tab-title',
        tabContent: '.e-n-tabs-content > .e-con',
        headingContainer: '.e-n-tabs-heading',
        activeTabContentContainers: '.e-con.e-active'
      },
      classes: {
        active: 'e-active'
      },
      ariaAttributes: {
        titleStateAttribute: 'aria-selected',
        activeTitleSelector: '[aria-selected="true"]'
      },
      showTabFn: 'show',
      hideTabFn: 'hide',
      toggleSelf: false,
      hidePrevious: true,
      autoExpand: true
    };
  }
  getDefaultElements() {
    const selectors = this.getSettings('selectors');
    return {
      $tabTitles: this.findElement(selectors.tabTitle),
      $tabContents: this.findElement(selectors.tabContent),
      $headingContainer: this.findElement(selectors.headingContainer)
    };
  }
  getKeyboardNavigationSettings() {
    return this.getSettings();
  }
  activateDefaultTab() {
    const settings = this.getSettings();
    const defaultActiveTab = this.getEditSettings('activeItemIndex') || 1,
      originalToggleMethods = {
        showTabFn: settings.showTabFn,
        hideTabFn: settings.hideTabFn
      };

    // Toggle tabs without animation to avoid jumping
    this.setSettings({
      showTabFn: 'show',
      hideTabFn: 'hide'
    });
    this.changeActiveTab(defaultActiveTab);

    // Return back original toggle effects
    this.setSettings(originalToggleMethods);
  }
  deactivateActiveTab(newTabIndex) {
    const settings = this.getSettings(),
      activeClass = settings.classes.active,
      activeTitleFilter = settings.ariaAttributes.activeTitleSelector,
      activeContentFilter = '.' + activeClass,
      $activeTitle = this.elements.$tabTitles.filter(activeTitleFilter),
      $activeContent = this.elements.$tabContents.filter(activeContentFilter);
    this.setTabDeactivationAttributes($activeTitle, newTabIndex);
    $activeContent.removeClass(activeClass);
    $activeContent[settings.hideTabFn](0, () => this.onHideTabContent($activeContent));
    return $activeContent;
  }
  getTitleActivationAttributes() {
    const titleStateAttribute = this.getSettings('ariaAttributes').titleStateAttribute;
    return {
      tabindex: '0',
      [titleStateAttribute]: 'true'
    };
  }
  setTabDeactivationAttributes($activeTitle) {
    const titleStateAttribute = this.getSettings('ariaAttributes').titleStateAttribute;
    $activeTitle.attr({
      tabindex: '-1',
      [titleStateAttribute]: 'false'
    });
  }
  onHideTabContent() {}
  activateTab(tabIndex) {
    const settings = this.getSettings(),
      activeClass = settings.classes.active,
      animationDuration = 'show' === settings.showTabFn ? 0 : 400;
    let $requestedTitle = this.elements.$tabTitles.filter(this.getTabTitleFilterSelector(tabIndex)),
      $requestedContent = this.elements.$tabContents.filter(this.getTabContentFilterSelector(tabIndex));

    // Check if the tabIndex exists.
    if (!$requestedTitle.length) {
      // Activate the previous tab and ensure that the tab index is not less than 1.
      const previousTabIndex = Math.max(tabIndex - 1, 1);
      $requestedTitle = this.elements.$tabTitles.filter(this.getTabTitleFilterSelector(previousTabIndex));
      $requestedContent = this.elements.$tabContents.filter(this.getTabContentFilterSelector(previousTabIndex));
    }
    $requestedTitle.attr(this.getTitleActivationAttributes());
    $requestedContent.addClass(activeClass);
    $requestedContent[settings.showTabFn](animationDuration, () => this.onShowTabContent($requestedContent));
  }
  onShowTabContent($requestedContent) {
    elementorFrontend.elements.$window.trigger('elementor-pro/motion-fx/recalc');
    elementorFrontend.elements.$window.trigger('elementor/nested-tabs/activate', $requestedContent);
    elementorFrontend.elements.$window.trigger('elementor/bg-video/recalc');
  }
  isActiveTab(tabIndex) {
    return 'true' === this.elements.$tabTitles.filter('[data-tab-index="' + tabIndex + '"]').attr(this.getSettings('ariaAttributes').titleStateAttribute);
  }
  onTabClick(event) {
    event.preventDefault();
    this.changeActiveTab(event.currentTarget?.getAttribute('data-tab-index'), true);
  }
  getTabEvents() {
    return {
      click: this.onTabClick.bind(this)
    };
  }
  getHeadingEvents() {
    const navigationWrapper = this.elements.$headingContainer[0];
    return {
      mousedown: _flexHorizontalScroll.changeScrollStatus.bind(this, navigationWrapper),
      mouseup: _flexHorizontalScroll.changeScrollStatus.bind(this, navigationWrapper),
      mouseleave: _flexHorizontalScroll.changeScrollStatus.bind(this, navigationWrapper),
      mousemove: _flexHorizontalScroll.setHorizontalTitleScrollValues.bind(this, navigationWrapper, this.getHorizontalScrollSetting())
    };
  }
  bindEvents() {
    this.elements.$tabTitles.on(this.getTabEvents());
    this.elements.$headingContainer.on(this.getHeadingEvents());
    const settingsObject = {
      element: this.elements.$headingContainer[0],
      direction: this.getTabsDirection(),
      justifyCSSVariable: '--n-tabs-heading-justify-content',
      horizontalScrollStatus: this.getHorizontalScrollSetting()
    };
    this.resizeListenerNestedTabs = _flexHorizontalScroll.setHorizontalScrollAlignment.bind(this, settingsObject);
    elementorFrontend.elements.$window.on('resize', this.resizeListenerNestedTabs);
    elementorFrontend.elements.$window.on('resize', this.setTouchMode.bind(this));
    elementorFrontend.elements.$window.on('elementor/nested-tabs/activate', this.reInitSwipers);
    elementorFrontend.elements.$window.on('elementor/nested-elements/activate-by-keyboard', this.changeActiveTabByKeyboard.bind(this));
  }
  unbindEvents() {
    this.elements.$tabTitles.off();
    this.elements.$headingContainer.off();
    this.elements.$tabContents.children().off();
    elementorFrontend.elements.$window.off('resize');
    elementorFrontend.elements.$window.off('elementor/nested-tabs/activate');
  }

  /**
   * Fixes issues where Swipers that have been initialized while a tab is not visible are not properly rendered
   * and when switching to the tab the swiper will not respect any of the chosen `autoplay` related settings.
   *
   * This is triggered when switching to a nested tab, looks for Swipers in the tab content and reinitializes them.
   *
   * @param {Object} event   - Incoming event.
   * @param {Object} content - Active nested tab dom element.
   */
  reInitSwipers(event, content) {
    const swiperElements = content.querySelectorAll(`.${elementorFrontend.config.swiperClass}`);
    for (const element of swiperElements) {
      if (!element.swiper) {
        return;
      }
      element.swiper.initialized = false;
      element.swiper.init();
    }
  }
  onInit() {
    super.onInit(...arguments);
    if (this.getSettings('autoExpand')) {
      this.activateDefaultTab();
    }
    const settingsObject = {
      element: this.elements.$headingContainer[0],
      direction: this.getTabsDirection(),
      justifyCSSVariable: '--n-tabs-heading-justify-content',
      horizontalScrollStatus: this.getHorizontalScrollSetting()
    };
    (0, _flexHorizontalScroll.setHorizontalScrollAlignment)(settingsObject);
    this.setTouchMode();
    if ('nested-tabs.default' === this.getSettings('elementName')) {
      new elementorModules.frontend.handlers.NestedTitleKeyboardHandler(this.getKeyboardNavigationSettings());
    }
  }
  onEditSettingsChange(propertyName, value) {
    if ('activeItemIndex' === propertyName) {
      this.changeActiveTab(value, false);
    }
  }
  onElementChange(propertyName) {
    if (this.checkSliderPropsToWatch(propertyName)) {
      const settingsObject = {
        element: this.elements.$headingContainer[0],
        direction: this.getTabsDirection(),
        justifyCSSVariable: '--n-tabs-heading-justify-content',
        horizontalScrollStatus: this.getHorizontalScrollSetting()
      };
      (0, _flexHorizontalScroll.setHorizontalScrollAlignment)(settingsObject);
    }
  }
  checkSliderPropsToWatch(propertyName) {
    return 0 === propertyName.indexOf('horizontal_scroll') || 'breakpoint_selector' === propertyName || 0 === propertyName.indexOf('tabs_justify_horizontal') || 0 === propertyName.indexOf('tabs_title_space_between');
  }

  /**
   * @param {string}  tabIndex
   * @param {boolean} fromUser - Whether the call is caused by the user or internal.
   */
  changeActiveTab(tabIndex) {
    let fromUser = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    // `document/repeater/select` is used only in the editor, only when the element
    // is in the currently-edited document, and only when its not internal call,
    if (fromUser && this.isEdit && this.isElementInTheCurrentDocument()) {
      return window.top.$e.run('document/repeater/select', {
        container: elementor.getContainer(this.$element.attr('data-id')),
        index: parseInt(tabIndex)
      });
    }
    const isActiveTab = this.isActiveTab(tabIndex),
      settings = this.getSettings();
    if ((settings.toggleSelf || !isActiveTab) && settings.hidePrevious) {
      this.deactivateActiveTab(tabIndex);
    }
    if (!settings.hidePrevious && isActiveTab) {
      this.deactivateActiveTab(tabIndex);
    }
    if (!isActiveTab) {
      if (this.isAccordionVersion()) {
        this.activateMobileTab(tabIndex);
        return;
      }
      this.activateTab(tabIndex);
    }
  }
  changeActiveTabByKeyboard(event, settings) {
    if (settings.widgetId !== this.getID()) {
      return;
    }
    this.changeActiveTab(settings.titleIndex, true);
  }
  activateMobileTab(tabIndex) {
    // Timeout time added to ensure that opening of the active tab starts after closing the other tab on Apple devices.
    setTimeout(() => {
      this.activateTab(tabIndex);
      this.forceActiveTabToBeInViewport(tabIndex);
    }, 10);
  }
  forceActiveTabToBeInViewport(tabIndex) {
    if (!elementorFrontend.isEditMode()) {
      return;
    }
    const $activeTabTitle = this.elements.$tabTitles.filter(this.getTabTitleFilterSelector(tabIndex));
    if (!elementor.helpers.isInViewport($activeTabTitle[0])) {
      $activeTabTitle[0].scrollIntoView({
        block: 'center'
      });
    }
  }
  getActiveClass() {
    const settings = this.getSettings();
    return settings.classes.active;
  }
  getTabsDirection() {
    const currentDevice = elementorFrontend.getCurrentDeviceMode();
    return elementorFrontend.utils.controls.getResponsiveControlValue(this.getElementSettings(), 'tabs_justify_horizontal', '', currentDevice);
  }
  getHorizontalScrollSetting() {
    const currentDevice = elementorFrontend.getCurrentDeviceMode();
    return elementorFrontend.utils.controls.getResponsiveControlValue(this.getElementSettings(), 'horizontal_scroll', '', currentDevice);
  }
  isAccordionVersion() {
    return 'contents' === this.elements.$headingContainer.css('display');
  }
  setTouchMode() {
    const widgetSelector = this.getSettings('selectors').widgetContainer;
    if (elementorFrontend.isEditMode() || 'resize' === event?.type) {
      const responsiveDevices = ['mobile', 'mobile_extra', 'tablet', 'tablet_extra'],
        currentDevice = elementorFrontend.getCurrentDeviceMode();
      if (-1 !== responsiveDevices.indexOf(currentDevice)) {
        this.$element.find(widgetSelector).attr('data-touch-mode', 'true');
        return;
      }
    } else if ('ontouchstart' in window) {
      this.$element.find(widgetSelector).attr('data-touch-mode', 'true');
      return;
    }
    this.$element.find(widgetSelector).attr('data-touch-mode', 'false');
  }
}
exports["default"] = NestedTabs;

/***/ }),

/***/ "../node_modules/core-js/internals/a-callable.js":
/*!*******************************************************!*\
  !*** ../node_modules/core-js/internals/a-callable.js ***!
  \*******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");
var tryToString = __webpack_require__(/*! ../internals/try-to-string */ "../node_modules/core-js/internals/try-to-string.js");

var $TypeError = TypeError;

// `Assert: IsCallable(argument) is true`
module.exports = function (argument) {
  if (isCallable(argument)) return argument;
  throw $TypeError(tryToString(argument) + ' is not a function');
};


/***/ }),

/***/ "../node_modules/core-js/internals/a-possible-prototype.js":
/*!*****************************************************************!*\
  !*** ../node_modules/core-js/internals/a-possible-prototype.js ***!
  \*****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");

var $String = String;
var $TypeError = TypeError;

module.exports = function (argument) {
  if (typeof argument == 'object' || isCallable(argument)) return argument;
  throw $TypeError("Can't set " + $String(argument) + ' as a prototype');
};


/***/ }),

/***/ "../node_modules/core-js/internals/an-object.js":
/*!******************************************************!*\
  !*** ../node_modules/core-js/internals/an-object.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isObject = __webpack_require__(/*! ../internals/is-object */ "../node_modules/core-js/internals/is-object.js");

var $String = String;
var $TypeError = TypeError;

// `Assert: Type(argument) is Object`
module.exports = function (argument) {
  if (isObject(argument)) return argument;
  throw $TypeError($String(argument) + ' is not an object');
};


/***/ }),

/***/ "../node_modules/core-js/internals/array-includes.js":
/*!***********************************************************!*\
  !*** ../node_modules/core-js/internals/array-includes.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../node_modules/core-js/internals/to-indexed-object.js");
var toAbsoluteIndex = __webpack_require__(/*! ../internals/to-absolute-index */ "../node_modules/core-js/internals/to-absolute-index.js");
var lengthOfArrayLike = __webpack_require__(/*! ../internals/length-of-array-like */ "../node_modules/core-js/internals/length-of-array-like.js");

// `Array.prototype.{ indexOf, includes }` methods implementation
var createMethod = function (IS_INCLUDES) {
  return function ($this, el, fromIndex) {
    var O = toIndexedObject($this);
    var length = lengthOfArrayLike(O);
    var index = toAbsoluteIndex(fromIndex, length);
    var value;
    // Array#includes uses SameValueZero equality algorithm
    // eslint-disable-next-line no-self-compare -- NaN check
    if (IS_INCLUDES && el != el) while (length > index) {
      value = O[index++];
      // eslint-disable-next-line no-self-compare -- NaN check
      if (value != value) return true;
    // Array#indexOf ignores holes, Array#includes - not
    } else for (;length > index; index++) {
      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
    } return !IS_INCLUDES && -1;
  };
};

module.exports = {
  // `Array.prototype.includes` method
  // https://tc39.es/ecma262/#sec-array.prototype.includes
  includes: createMethod(true),
  // `Array.prototype.indexOf` method
  // https://tc39.es/ecma262/#sec-array.prototype.indexof
  indexOf: createMethod(false)
};


/***/ }),

/***/ "../node_modules/core-js/internals/classof-raw.js":
/*!********************************************************!*\
  !*** ../node_modules/core-js/internals/classof-raw.js ***!
  \********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");

var toString = uncurryThis({}.toString);
var stringSlice = uncurryThis(''.slice);

module.exports = function (it) {
  return stringSlice(toString(it), 8, -1);
};


/***/ }),

/***/ "../node_modules/core-js/internals/classof.js":
/*!****************************************************!*\
  !*** ../node_modules/core-js/internals/classof.js ***!
  \****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var TO_STRING_TAG_SUPPORT = __webpack_require__(/*! ../internals/to-string-tag-support */ "../node_modules/core-js/internals/to-string-tag-support.js");
var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");
var classofRaw = __webpack_require__(/*! ../internals/classof-raw */ "../node_modules/core-js/internals/classof-raw.js");
var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../node_modules/core-js/internals/well-known-symbol.js");

var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var $Object = Object;

// ES3 wrong here
var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';

// fallback for IE11 Script Access Denied error
var tryGet = function (it, key) {
  try {
    return it[key];
  } catch (error) { /* empty */ }
};

// getting tag from ES6+ `Object.prototype.toString`
module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
  var O, tag, result;
  return it === undefined ? 'Undefined' : it === null ? 'Null'
    // @@toStringTag case
    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
    // builtinTag case
    : CORRECT_ARGUMENTS ? classofRaw(O)
    // ES3 arguments fallback
    : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
};


/***/ }),

/***/ "../node_modules/core-js/internals/copy-constructor-properties.js":
/*!************************************************************************!*\
  !*** ../node_modules/core-js/internals/copy-constructor-properties.js ***!
  \************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../node_modules/core-js/internals/has-own-property.js");
var ownKeys = __webpack_require__(/*! ../internals/own-keys */ "../node_modules/core-js/internals/own-keys.js");
var getOwnPropertyDescriptorModule = __webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "../node_modules/core-js/internals/object-get-own-property-descriptor.js");
var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "../node_modules/core-js/internals/object-define-property.js");

module.exports = function (target, source, exceptions) {
  var keys = ownKeys(source);
  var defineProperty = definePropertyModule.f;
  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
    }
  }
};


/***/ }),

/***/ "../node_modules/core-js/internals/create-non-enumerable-property.js":
/*!***************************************************************************!*\
  !*** ../node_modules/core-js/internals/create-non-enumerable-property.js ***!
  \***************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../node_modules/core-js/internals/descriptors.js");
var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "../node_modules/core-js/internals/object-define-property.js");
var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../node_modules/core-js/internals/create-property-descriptor.js");

module.exports = DESCRIPTORS ? function (object, key, value) {
  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
} : function (object, key, value) {
  object[key] = value;
  return object;
};


/***/ }),

/***/ "../node_modules/core-js/internals/create-property-descriptor.js":
/*!***********************************************************************!*\
  !*** ../node_modules/core-js/internals/create-property-descriptor.js ***!
  \***********************************************************************/
/***/ ((module) => {

"use strict";

module.exports = function (bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value: value
  };
};


/***/ }),

/***/ "../node_modules/core-js/internals/define-built-in.js":
/*!************************************************************!*\
  !*** ../node_modules/core-js/internals/define-built-in.js ***!
  \************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");
var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "../node_modules/core-js/internals/object-define-property.js");
var makeBuiltIn = __webpack_require__(/*! ../internals/make-built-in */ "../node_modules/core-js/internals/make-built-in.js");
var defineGlobalProperty = __webpack_require__(/*! ../internals/define-global-property */ "../node_modules/core-js/internals/define-global-property.js");

module.exports = function (O, key, value, options) {
  if (!options) options = {};
  var simple = options.enumerable;
  var name = options.name !== undefined ? options.name : key;
  if (isCallable(value)) makeBuiltIn(value, name, options);
  if (options.global) {
    if (simple) O[key] = value;
    else defineGlobalProperty(key, value);
  } else {
    try {
      if (!options.unsafe) delete O[key];
      else if (O[key]) simple = true;
    } catch (error) { /* empty */ }
    if (simple) O[key] = value;
    else definePropertyModule.f(O, key, {
      value: value,
      enumerable: false,
      configurable: !options.nonConfigurable,
      writable: !options.nonWritable
    });
  } return O;
};


/***/ }),

/***/ "../node_modules/core-js/internals/define-global-property.js":
/*!*******************************************************************!*\
  !*** ../node_modules/core-js/internals/define-global-property.js ***!
  \*******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");

// eslint-disable-next-line es/no-object-defineproperty -- safe
var defineProperty = Object.defineProperty;

module.exports = function (key, value) {
  try {
    defineProperty(global, key, { value: value, configurable: true, writable: true });
  } catch (error) {
    global[key] = value;
  } return value;
};


/***/ }),

/***/ "../node_modules/core-js/internals/descriptors.js":
/*!********************************************************!*\
  !*** ../node_modules/core-js/internals/descriptors.js ***!
  \********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var fails = __webpack_require__(/*! ../internals/fails */ "../node_modules/core-js/internals/fails.js");

// Detect IE8's incomplete defineProperty implementation
module.exports = !fails(function () {
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
});


/***/ }),

/***/ "../node_modules/core-js/internals/document-all.js":
/*!*********************************************************!*\
  !*** ../node_modules/core-js/internals/document-all.js ***!
  \*********************************************************/
/***/ ((module) => {

"use strict";

var documentAll = typeof document == 'object' && document.all;

// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
var IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;

module.exports = {
  all: documentAll,
  IS_HTMLDDA: IS_HTMLDDA
};


/***/ }),

/***/ "../node_modules/core-js/internals/document-create-element.js":
/*!********************************************************************!*\
  !*** ../node_modules/core-js/internals/document-create-element.js ***!
  \********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");
var isObject = __webpack_require__(/*! ../internals/is-object */ "../node_modules/core-js/internals/is-object.js");

var document = global.document;
// typeof document.createElement is 'object' in old IE
var EXISTS = isObject(document) && isObject(document.createElement);

module.exports = function (it) {
  return EXISTS ? document.createElement(it) : {};
};


/***/ }),

/***/ "../node_modules/core-js/internals/engine-user-agent.js":
/*!**************************************************************!*\
  !*** ../node_modules/core-js/internals/engine-user-agent.js ***!
  \**************************************************************/
/***/ ((module) => {

"use strict";

module.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';


/***/ }),

/***/ "../node_modules/core-js/internals/engine-v8-version.js":
/*!**************************************************************!*\
  !*** ../node_modules/core-js/internals/engine-v8-version.js ***!
  \**************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");
var userAgent = __webpack_require__(/*! ../internals/engine-user-agent */ "../node_modules/core-js/internals/engine-user-agent.js");

var process = global.process;
var Deno = global.Deno;
var versions = process && process.versions || Deno && Deno.version;
var v8 = versions && versions.v8;
var match, version;

if (v8) {
  match = v8.split('.');
  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
  // but their correct versions are not interesting for us
  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
}

// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
// so check `userAgent` even if `.v8` exists, but 0
if (!version && userAgent) {
  match = userAgent.match(/Edge\/(\d+)/);
  if (!match || match[1] >= 74) {
    match = userAgent.match(/Chrome\/(\d+)/);
    if (match) version = +match[1];
  }
}

module.exports = version;


/***/ }),

/***/ "../node_modules/core-js/internals/enum-bug-keys.js":
/*!**********************************************************!*\
  !*** ../node_modules/core-js/internals/enum-bug-keys.js ***!
  \**********************************************************/
/***/ ((module) => {

"use strict";

// IE8- don't enum bug keys
module.exports = [
  'constructor',
  'hasOwnProperty',
  'isPrototypeOf',
  'propertyIsEnumerable',
  'toLocaleString',
  'toString',
  'valueOf'
];


/***/ }),

/***/ "../node_modules/core-js/internals/error-stack-clear.js":
/*!**************************************************************!*\
  !*** ../node_modules/core-js/internals/error-stack-clear.js ***!
  \**************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");

var $Error = Error;
var replace = uncurryThis(''.replace);

var TEST = (function (arg) { return String($Error(arg).stack); })('zxcasd');
// eslint-disable-next-line redos/no-vulnerable -- safe
var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);

module.exports = function (stack, dropEntries) {
  if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
    while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
  } return stack;
};


/***/ }),

/***/ "../node_modules/core-js/internals/error-stack-install.js":
/*!****************************************************************!*\
  !*** ../node_modules/core-js/internals/error-stack-install.js ***!
  \****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../node_modules/core-js/internals/create-non-enumerable-property.js");
var clearErrorStack = __webpack_require__(/*! ../internals/error-stack-clear */ "../node_modules/core-js/internals/error-stack-clear.js");
var ERROR_STACK_INSTALLABLE = __webpack_require__(/*! ../internals/error-stack-installable */ "../node_modules/core-js/internals/error-stack-installable.js");

// non-standard V8
var captureStackTrace = Error.captureStackTrace;

module.exports = function (error, C, stack, dropEntries) {
  if (ERROR_STACK_INSTALLABLE) {
    if (captureStackTrace) captureStackTrace(error, C);
    else createNonEnumerableProperty(error, 'stack', clearErrorStack(stack, dropEntries));
  }
};


/***/ }),

/***/ "../node_modules/core-js/internals/error-stack-installable.js":
/*!********************************************************************!*\
  !*** ../node_modules/core-js/internals/error-stack-installable.js ***!
  \********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var fails = __webpack_require__(/*! ../internals/fails */ "../node_modules/core-js/internals/fails.js");
var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../node_modules/core-js/internals/create-property-descriptor.js");

module.exports = !fails(function () {
  var error = Error('a');
  if (!('stack' in error)) return true;
  // eslint-disable-next-line es/no-object-defineproperty -- safe
  Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));
  return error.stack !== 7;
});


/***/ }),

/***/ "../node_modules/core-js/internals/export.js":
/*!***************************************************!*\
  !*** ../node_modules/core-js/internals/export.js ***!
  \***************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");
var getOwnPropertyDescriptor = (__webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "../node_modules/core-js/internals/object-get-own-property-descriptor.js").f);
var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../node_modules/core-js/internals/create-non-enumerable-property.js");
var defineBuiltIn = __webpack_require__(/*! ../internals/define-built-in */ "../node_modules/core-js/internals/define-built-in.js");
var defineGlobalProperty = __webpack_require__(/*! ../internals/define-global-property */ "../node_modules/core-js/internals/define-global-property.js");
var copyConstructorProperties = __webpack_require__(/*! ../internals/copy-constructor-properties */ "../node_modules/core-js/internals/copy-constructor-properties.js");
var isForced = __webpack_require__(/*! ../internals/is-forced */ "../node_modules/core-js/internals/is-forced.js");

/*
  options.target         - name of the target object
  options.global         - target is the global object
  options.stat           - export as static methods of target
  options.proto          - export as prototype methods of target
  options.real           - real prototype method for the `pure` version
  options.forced         - export even if the native feature is available
  options.bind           - bind methods to the target, required for the `pure` version
  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
  options.unsafe         - use the simple assignment of property instead of delete + defineProperty
  options.sham           - add a flag to not completely full polyfills
  options.enumerable     - export as enumerable property
  options.dontCallGetSet - prevent calling a getter on target
  options.name           - the .name of the function if it does not match the key
*/
module.exports = function (options, source) {
  var TARGET = options.target;
  var GLOBAL = options.global;
  var STATIC = options.stat;
  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
  if (GLOBAL) {
    target = global;
  } else if (STATIC) {
    target = global[TARGET] || defineGlobalProperty(TARGET, {});
  } else {
    target = (global[TARGET] || {}).prototype;
  }
  if (target) for (key in source) {
    sourceProperty = source[key];
    if (options.dontCallGetSet) {
      descriptor = getOwnPropertyDescriptor(target, key);
      targetProperty = descriptor && descriptor.value;
    } else targetProperty = target[key];
    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
    // contained in target
    if (!FORCED && targetProperty !== undefined) {
      if (typeof sourceProperty == typeof targetProperty) continue;
      copyConstructorProperties(sourceProperty, targetProperty);
    }
    // add a flag to not completely full polyfills
    if (options.sham || (targetProperty && targetProperty.sham)) {
      createNonEnumerableProperty(sourceProperty, 'sham', true);
    }
    defineBuiltIn(target, key, sourceProperty, options);
  }
};


/***/ }),

/***/ "../node_modules/core-js/internals/fails.js":
/*!**************************************************!*\
  !*** ../node_modules/core-js/internals/fails.js ***!
  \**************************************************/
/***/ ((module) => {

"use strict";

module.exports = function (exec) {
  try {
    return !!exec();
  } catch (error) {
    return true;
  }
};


/***/ }),

/***/ "../node_modules/core-js/internals/function-apply.js":
/*!***********************************************************!*\
  !*** ../node_modules/core-js/internals/function-apply.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var NATIVE_BIND = __webpack_require__(/*! ../internals/function-bind-native */ "../node_modules/core-js/internals/function-bind-native.js");

var FunctionPrototype = Function.prototype;
var apply = FunctionPrototype.apply;
var call = FunctionPrototype.call;

// eslint-disable-next-line es/no-reflect -- safe
module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
  return call.apply(apply, arguments);
});


/***/ }),

/***/ "../node_modules/core-js/internals/function-bind-native.js":
/*!*****************************************************************!*\
  !*** ../node_modules/core-js/internals/function-bind-native.js ***!
  \*****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var fails = __webpack_require__(/*! ../internals/fails */ "../node_modules/core-js/internals/fails.js");

module.exports = !fails(function () {
  // eslint-disable-next-line es/no-function-prototype-bind -- safe
  var test = (function () { /* empty */ }).bind();
  // eslint-disable-next-line no-prototype-builtins -- safe
  return typeof test != 'function' || test.hasOwnProperty('prototype');
});


/***/ }),

/***/ "../node_modules/core-js/internals/function-call.js":
/*!**********************************************************!*\
  !*** ../node_modules/core-js/internals/function-call.js ***!
  \**********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var NATIVE_BIND = __webpack_require__(/*! ../internals/function-bind-native */ "../node_modules/core-js/internals/function-bind-native.js");

var call = Function.prototype.call;

module.exports = NATIVE_BIND ? call.bind(call) : function () {
  return call.apply(call, arguments);
};


/***/ }),

/***/ "../node_modules/core-js/internals/function-name.js":
/*!**********************************************************!*\
  !*** ../node_modules/core-js/internals/function-name.js ***!
  \**********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../node_modules/core-js/internals/descriptors.js");
var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../node_modules/core-js/internals/has-own-property.js");

var FunctionPrototype = Function.prototype;
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;

var EXISTS = hasOwn(FunctionPrototype, 'name');
// additional protection from minified / mangled / dropped function names
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));

module.exports = {
  EXISTS: EXISTS,
  PROPER: PROPER,
  CONFIGURABLE: CONFIGURABLE
};


/***/ }),

/***/ "../node_modules/core-js/internals/function-uncurry-this-accessor.js":
/*!***************************************************************************!*\
  !*** ../node_modules/core-js/internals/function-uncurry-this-accessor.js ***!
  \***************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");
var aCallable = __webpack_require__(/*! ../internals/a-callable */ "../node_modules/core-js/internals/a-callable.js");

module.exports = function (object, key, method) {
  try {
    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
    return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
  } catch (error) { /* empty */ }
};


/***/ }),

/***/ "../node_modules/core-js/internals/function-uncurry-this.js":
/*!******************************************************************!*\
  !*** ../node_modules/core-js/internals/function-uncurry-this.js ***!
  \******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var NATIVE_BIND = __webpack_require__(/*! ../internals/function-bind-native */ "../node_modules/core-js/internals/function-bind-native.js");

var FunctionPrototype = Function.prototype;
var call = FunctionPrototype.call;
var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);

module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
  return function () {
    return call.apply(fn, arguments);
  };
};


/***/ }),

/***/ "../node_modules/core-js/internals/get-built-in.js":
/*!*********************************************************!*\
  !*** ../node_modules/core-js/internals/get-built-in.js ***!
  \*********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");
var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");

var aFunction = function (argument) {
  return isCallable(argument) ? argument : undefined;
};

module.exports = function (namespace, method) {
  return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];
};


/***/ }),

/***/ "../node_modules/core-js/internals/get-method.js":
/*!*******************************************************!*\
  !*** ../node_modules/core-js/internals/get-method.js ***!
  \*******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var aCallable = __webpack_require__(/*! ../internals/a-callable */ "../node_modules/core-js/internals/a-callable.js");
var isNullOrUndefined = __webpack_require__(/*! ../internals/is-null-or-undefined */ "../node_modules/core-js/internals/is-null-or-undefined.js");

// `GetMethod` abstract operation
// https://tc39.es/ecma262/#sec-getmethod
module.exports = function (V, P) {
  var func = V[P];
  return isNullOrUndefined(func) ? undefined : aCallable(func);
};


/***/ }),

/***/ "../node_modules/core-js/internals/global.js":
/*!***************************************************!*\
  !*** ../node_modules/core-js/internals/global.js ***!
  \***************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

"use strict";

var check = function (it) {
  return it && it.Math == Math && it;
};

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
module.exports =
  // eslint-disable-next-line es/no-global-this -- safe
  check(typeof globalThis == 'object' && globalThis) ||
  check(typeof window == 'object' && window) ||
  // eslint-disable-next-line no-restricted-globals -- safe
  check(typeof self == 'object' && self) ||
  check(typeof __webpack_require__.g == 'object' && __webpack_require__.g) ||
  // eslint-disable-next-line no-new-func -- fallback
  (function () { return this; })() || this || Function('return this')();


/***/ }),

/***/ "../node_modules/core-js/internals/has-own-property.js":
/*!*************************************************************!*\
  !*** ../node_modules/core-js/internals/has-own-property.js ***!
  \*************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");
var toObject = __webpack_require__(/*! ../internals/to-object */ "../node_modules/core-js/internals/to-object.js");

var hasOwnProperty = uncurryThis({}.hasOwnProperty);

// `HasOwnProperty` abstract operation
// https://tc39.es/ecma262/#sec-hasownproperty
// eslint-disable-next-line es/no-object-hasown -- safe
module.exports = Object.hasOwn || function hasOwn(it, key) {
  return hasOwnProperty(toObject(it), key);
};


/***/ }),

/***/ "../node_modules/core-js/internals/hidden-keys.js":
/*!********************************************************!*\
  !*** ../node_modules/core-js/internals/hidden-keys.js ***!
  \********************************************************/
/***/ ((module) => {

"use strict";

module.exports = {};


/***/ }),

/***/ "../node_modules/core-js/internals/ie8-dom-define.js":
/*!***********************************************************!*\
  !*** ../node_modules/core-js/internals/ie8-dom-define.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../node_modules/core-js/internals/descriptors.js");
var fails = __webpack_require__(/*! ../internals/fails */ "../node_modules/core-js/internals/fails.js");
var createElement = __webpack_require__(/*! ../internals/document-create-element */ "../node_modules/core-js/internals/document-create-element.js");

// Thanks to IE8 for its funny defineProperty
module.exports = !DESCRIPTORS && !fails(function () {
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
  return Object.defineProperty(createElement('div'), 'a', {
    get: function () { return 7; }
  }).a != 7;
});


/***/ }),

/***/ "../node_modules/core-js/internals/indexed-object.js":
/*!***********************************************************!*\
  !*** ../node_modules/core-js/internals/indexed-object.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");
var fails = __webpack_require__(/*! ../internals/fails */ "../node_modules/core-js/internals/fails.js");
var classof = __webpack_require__(/*! ../internals/classof-raw */ "../node_modules/core-js/internals/classof-raw.js");

var $Object = Object;
var split = uncurryThis(''.split);

// fallback for non-array-like ES3 and non-enumerable old V8 strings
module.exports = fails(function () {
  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
  // eslint-disable-next-line no-prototype-builtins -- safe
  return !$Object('z').propertyIsEnumerable(0);
}) ? function (it) {
  return classof(it) == 'String' ? split(it, '') : $Object(it);
} : $Object;


/***/ }),

/***/ "../node_modules/core-js/internals/inherit-if-required.js":
/*!****************************************************************!*\
  !*** ../node_modules/core-js/internals/inherit-if-required.js ***!
  \****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");
var isObject = __webpack_require__(/*! ../internals/is-object */ "../node_modules/core-js/internals/is-object.js");
var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ "../node_modules/core-js/internals/object-set-prototype-of.js");

// makes subclassing work correct for wrapped built-ins
module.exports = function ($this, dummy, Wrapper) {
  var NewTarget, NewTargetPrototype;
  if (
    // it can work only with native `setPrototypeOf`
    setPrototypeOf &&
    // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
    isCallable(NewTarget = dummy.constructor) &&
    NewTarget !== Wrapper &&
    isObject(NewTargetPrototype = NewTarget.prototype) &&
    NewTargetPrototype !== Wrapper.prototype
  ) setPrototypeOf($this, NewTargetPrototype);
  return $this;
};


/***/ }),

/***/ "../node_modules/core-js/internals/inspect-source.js":
/*!***********************************************************!*\
  !*** ../node_modules/core-js/internals/inspect-source.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");
var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");
var store = __webpack_require__(/*! ../internals/shared-store */ "../node_modules/core-js/internals/shared-store.js");

var functionToString = uncurryThis(Function.toString);

// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
if (!isCallable(store.inspectSource)) {
  store.inspectSource = function (it) {
    return functionToString(it);
  };
}

module.exports = store.inspectSource;


/***/ }),

/***/ "../node_modules/core-js/internals/install-error-cause.js":
/*!****************************************************************!*\
  !*** ../node_modules/core-js/internals/install-error-cause.js ***!
  \****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isObject = __webpack_require__(/*! ../internals/is-object */ "../node_modules/core-js/internals/is-object.js");
var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../node_modules/core-js/internals/create-non-enumerable-property.js");

// `InstallErrorCause` abstract operation
// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause
module.exports = function (O, options) {
  if (isObject(options) && 'cause' in options) {
    createNonEnumerableProperty(O, 'cause', options.cause);
  }
};


/***/ }),

/***/ "../node_modules/core-js/internals/internal-state.js":
/*!***********************************************************!*\
  !*** ../node_modules/core-js/internals/internal-state.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var NATIVE_WEAK_MAP = __webpack_require__(/*! ../internals/weak-map-basic-detection */ "../node_modules/core-js/internals/weak-map-basic-detection.js");
var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");
var isObject = __webpack_require__(/*! ../internals/is-object */ "../node_modules/core-js/internals/is-object.js");
var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../node_modules/core-js/internals/create-non-enumerable-property.js");
var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../node_modules/core-js/internals/has-own-property.js");
var shared = __webpack_require__(/*! ../internals/shared-store */ "../node_modules/core-js/internals/shared-store.js");
var sharedKey = __webpack_require__(/*! ../internals/shared-key */ "../node_modules/core-js/internals/shared-key.js");
var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "../node_modules/core-js/internals/hidden-keys.js");

var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
var TypeError = global.TypeError;
var WeakMap = global.WeakMap;
var set, get, has;

var enforce = function (it) {
  return has(it) ? get(it) : set(it, {});
};

var getterFor = function (TYPE) {
  return function (it) {
    var state;
    if (!isObject(it) || (state = get(it)).type !== TYPE) {
      throw TypeError('Incompatible receiver, ' + TYPE + ' required');
    } return state;
  };
};

if (NATIVE_WEAK_MAP || shared.state) {
  var store = shared.state || (shared.state = new WeakMap());
  /* eslint-disable no-self-assign -- prototype methods protection */
  store.get = store.get;
  store.has = store.has;
  store.set = store.set;
  /* eslint-enable no-self-assign -- prototype methods protection */
  set = function (it, metadata) {
    if (store.has(it)) throw TypeError(OBJECT_ALREADY_INITIALIZED);
    metadata.facade = it;
    store.set(it, metadata);
    return metadata;
  };
  get = function (it) {
    return store.get(it) || {};
  };
  has = function (it) {
    return store.has(it);
  };
} else {
  var STATE = sharedKey('state');
  hiddenKeys[STATE] = true;
  set = function (it, metadata) {
    if (hasOwn(it, STATE)) throw TypeError(OBJECT_ALREADY_INITIALIZED);
    metadata.facade = it;
    createNonEnumerableProperty(it, STATE, metadata);
    return metadata;
  };
  get = function (it) {
    return hasOwn(it, STATE) ? it[STATE] : {};
  };
  has = function (it) {
    return hasOwn(it, STATE);
  };
}

module.exports = {
  set: set,
  get: get,
  has: has,
  enforce: enforce,
  getterFor: getterFor
};


/***/ }),

/***/ "../node_modules/core-js/internals/is-callable.js":
/*!********************************************************!*\
  !*** ../node_modules/core-js/internals/is-callable.js ***!
  \********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var $documentAll = __webpack_require__(/*! ../internals/document-all */ "../node_modules/core-js/internals/document-all.js");

var documentAll = $documentAll.all;

// `IsCallable` abstract operation
// https://tc39.es/ecma262/#sec-iscallable
module.exports = $documentAll.IS_HTMLDDA ? function (argument) {
  return typeof argument == 'function' || argument === documentAll;
} : function (argument) {
  return typeof argument == 'function';
};


/***/ }),

/***/ "../node_modules/core-js/internals/is-forced.js":
/*!******************************************************!*\
  !*** ../node_modules/core-js/internals/is-forced.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var fails = __webpack_require__(/*! ../internals/fails */ "../node_modules/core-js/internals/fails.js");
var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");

var replacement = /#|\.prototype\./;

var isForced = function (feature, detection) {
  var value = data[normalize(feature)];
  return value == POLYFILL ? true
    : value == NATIVE ? false
    : isCallable(detection) ? fails(detection)
    : !!detection;
};

var normalize = isForced.normalize = function (string) {
  return String(string).replace(replacement, '.').toLowerCase();
};

var data = isForced.data = {};
var NATIVE = isForced.NATIVE = 'N';
var POLYFILL = isForced.POLYFILL = 'P';

module.exports = isForced;


/***/ }),

/***/ "../node_modules/core-js/internals/is-null-or-undefined.js":
/*!*****************************************************************!*\
  !*** ../node_modules/core-js/internals/is-null-or-undefined.js ***!
  \*****************************************************************/
/***/ ((module) => {

"use strict";

// we can't use just `it == null` since of `document.all` special case
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
module.exports = function (it) {
  return it === null || it === undefined;
};


/***/ }),

/***/ "../node_modules/core-js/internals/is-object.js":
/*!******************************************************!*\
  !*** ../node_modules/core-js/internals/is-object.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");
var $documentAll = __webpack_require__(/*! ../internals/document-all */ "../node_modules/core-js/internals/document-all.js");

var documentAll = $documentAll.all;

module.exports = $documentAll.IS_HTMLDDA ? function (it) {
  return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;
} : function (it) {
  return typeof it == 'object' ? it !== null : isCallable(it);
};


/***/ }),

/***/ "../node_modules/core-js/internals/is-pure.js":
/*!****************************************************!*\
  !*** ../node_modules/core-js/internals/is-pure.js ***!
  \****************************************************/
/***/ ((module) => {

"use strict";

module.exports = false;


/***/ }),

/***/ "../node_modules/core-js/internals/is-symbol.js":
/*!******************************************************!*\
  !*** ../node_modules/core-js/internals/is-symbol.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../node_modules/core-js/internals/get-built-in.js");
var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");
var isPrototypeOf = __webpack_require__(/*! ../internals/object-is-prototype-of */ "../node_modules/core-js/internals/object-is-prototype-of.js");
var USE_SYMBOL_AS_UID = __webpack_require__(/*! ../internals/use-symbol-as-uid */ "../node_modules/core-js/internals/use-symbol-as-uid.js");

var $Object = Object;

module.exports = USE_SYMBOL_AS_UID ? function (it) {
  return typeof it == 'symbol';
} : function (it) {
  var $Symbol = getBuiltIn('Symbol');
  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
};


/***/ }),

/***/ "../node_modules/core-js/internals/length-of-array-like.js":
/*!*****************************************************************!*\
  !*** ../node_modules/core-js/internals/length-of-array-like.js ***!
  \*****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var toLength = __webpack_require__(/*! ../internals/to-length */ "../node_modules/core-js/internals/to-length.js");

// `LengthOfArrayLike` abstract operation
// https://tc39.es/ecma262/#sec-lengthofarraylike
module.exports = function (obj) {
  return toLength(obj.length);
};


/***/ }),

/***/ "../node_modules/core-js/internals/make-built-in.js":
/*!**********************************************************!*\
  !*** ../node_modules/core-js/internals/make-built-in.js ***!
  \**********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");
var fails = __webpack_require__(/*! ../internals/fails */ "../node_modules/core-js/internals/fails.js");
var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");
var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../node_modules/core-js/internals/has-own-property.js");
var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../node_modules/core-js/internals/descriptors.js");
var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(/*! ../internals/function-name */ "../node_modules/core-js/internals/function-name.js").CONFIGURABLE);
var inspectSource = __webpack_require__(/*! ../internals/inspect-source */ "../node_modules/core-js/internals/inspect-source.js");
var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "../node_modules/core-js/internals/internal-state.js");

var enforceInternalState = InternalStateModule.enforce;
var getInternalState = InternalStateModule.get;
var $String = String;
// eslint-disable-next-line es/no-object-defineproperty -- safe
var defineProperty = Object.defineProperty;
var stringSlice = uncurryThis(''.slice);
var replace = uncurryThis(''.replace);
var join = uncurryThis([].join);

var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
});

var TEMPLATE = String(String).split('String');

var makeBuiltIn = module.exports = function (value, name, options) {
  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
    name = '[' + replace($String(name), /^Symbol\(([^)]*)\)/, '$1') + ']';
  }
  if (options && options.getter) name = 'get ' + name;
  if (options && options.setter) name = 'set ' + name;
  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
    else value.name = name;
  }
  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
    defineProperty(value, 'length', { value: options.arity });
  }
  try {
    if (options && hasOwn(options, 'constructor') && options.constructor) {
      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
    } else if (value.prototype) value.prototype = undefined;
  } catch (error) { /* empty */ }
  var state = enforceInternalState(value);
  if (!hasOwn(state, 'source')) {
    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
  } return value;
};

// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
// eslint-disable-next-line no-extend-native -- required
Function.prototype.toString = makeBuiltIn(function toString() {
  return isCallable(this) && getInternalState(this).source || inspectSource(this);
}, 'toString');


/***/ }),

/***/ "../node_modules/core-js/internals/math-trunc.js":
/*!*******************************************************!*\
  !*** ../node_modules/core-js/internals/math-trunc.js ***!
  \*******************************************************/
/***/ ((module) => {

"use strict";

var ceil = Math.ceil;
var floor = Math.floor;

// `Math.trunc` method
// https://tc39.es/ecma262/#sec-math.trunc
// eslint-disable-next-line es/no-math-trunc -- safe
module.exports = Math.trunc || function trunc(x) {
  var n = +x;
  return (n > 0 ? floor : ceil)(n);
};


/***/ }),

/***/ "../node_modules/core-js/internals/normalize-string-argument.js":
/*!**********************************************************************!*\
  !*** ../node_modules/core-js/internals/normalize-string-argument.js ***!
  \**********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var toString = __webpack_require__(/*! ../internals/to-string */ "../node_modules/core-js/internals/to-string.js");

module.exports = function (argument, $default) {
  return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);
};


/***/ }),

/***/ "../node_modules/core-js/internals/object-define-property.js":
/*!*******************************************************************!*\
  !*** ../node_modules/core-js/internals/object-define-property.js ***!
  \*******************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../node_modules/core-js/internals/descriptors.js");
var IE8_DOM_DEFINE = __webpack_require__(/*! ../internals/ie8-dom-define */ "../node_modules/core-js/internals/ie8-dom-define.js");
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(/*! ../internals/v8-prototype-define-bug */ "../node_modules/core-js/internals/v8-prototype-define-bug.js");
var anObject = __webpack_require__(/*! ../internals/an-object */ "../node_modules/core-js/internals/an-object.js");
var toPropertyKey = __webpack_require__(/*! ../internals/to-property-key */ "../node_modules/core-js/internals/to-property-key.js");

var $TypeError = TypeError;
// eslint-disable-next-line es/no-object-defineproperty -- safe
var $defineProperty = Object.defineProperty;
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var ENUMERABLE = 'enumerable';
var CONFIGURABLE = 'configurable';
var WRITABLE = 'writable';

// `Object.defineProperty` method
// https://tc39.es/ecma262/#sec-object.defineproperty
exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
  anObject(O);
  P = toPropertyKey(P);
  anObject(Attributes);
  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
    var current = $getOwnPropertyDescriptor(O, P);
    if (current && current[WRITABLE]) {
      O[P] = Attributes.value;
      Attributes = {
        configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
        writable: false
      };
    }
  } return $defineProperty(O, P, Attributes);
} : $defineProperty : function defineProperty(O, P, Attributes) {
  anObject(O);
  P = toPropertyKey(P);
  anObject(Attributes);
  if (IE8_DOM_DEFINE) try {
    return $defineProperty(O, P, Attributes);
  } catch (error) { /* empty */ }
  if ('get' in Attributes || 'set' in Attributes) throw $TypeError('Accessors not supported');
  if ('value' in Attributes) O[P] = Attributes.value;
  return O;
};


/***/ }),

/***/ "../node_modules/core-js/internals/object-get-own-property-descriptor.js":
/*!*******************************************************************************!*\
  !*** ../node_modules/core-js/internals/object-get-own-property-descriptor.js ***!
  \*******************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../node_modules/core-js/internals/descriptors.js");
var call = __webpack_require__(/*! ../internals/function-call */ "../node_modules/core-js/internals/function-call.js");
var propertyIsEnumerableModule = __webpack_require__(/*! ../internals/object-property-is-enumerable */ "../node_modules/core-js/internals/object-property-is-enumerable.js");
var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../node_modules/core-js/internals/create-property-descriptor.js");
var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../node_modules/core-js/internals/to-indexed-object.js");
var toPropertyKey = __webpack_require__(/*! ../internals/to-property-key */ "../node_modules/core-js/internals/to-property-key.js");
var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../node_modules/core-js/internals/has-own-property.js");
var IE8_DOM_DEFINE = __webpack_require__(/*! ../internals/ie8-dom-define */ "../node_modules/core-js/internals/ie8-dom-define.js");

// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;

// `Object.getOwnPropertyDescriptor` method
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
  O = toIndexedObject(O);
  P = toPropertyKey(P);
  if (IE8_DOM_DEFINE) try {
    return $getOwnPropertyDescriptor(O, P);
  } catch (error) { /* empty */ }
  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
};


/***/ }),

/***/ "../node_modules/core-js/internals/object-get-own-property-names.js":
/*!**************************************************************************!*\
  !*** ../node_modules/core-js/internals/object-get-own-property-names.js ***!
  \**************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";

var internalObjectKeys = __webpack_require__(/*! ../internals/object-keys-internal */ "../node_modules/core-js/internals/object-keys-internal.js");
var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ "../node_modules/core-js/internals/enum-bug-keys.js");

var hiddenKeys = enumBugKeys.concat('length', 'prototype');

// `Object.getOwnPropertyNames` method
// https://tc39.es/ecma262/#sec-object.getownpropertynames
// eslint-disable-next-line es/no-object-getownpropertynames -- safe
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
  return internalObjectKeys(O, hiddenKeys);
};


/***/ }),

/***/ "../node_modules/core-js/internals/object-get-own-property-symbols.js":
/*!****************************************************************************!*\
  !*** ../node_modules/core-js/internals/object-get-own-property-symbols.js ***!
  \****************************************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";

// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
exports.f = Object.getOwnPropertySymbols;


/***/ }),

/***/ "../node_modules/core-js/internals/object-is-prototype-of.js":
/*!*******************************************************************!*\
  !*** ../node_modules/core-js/internals/object-is-prototype-of.js ***!
  \*******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");

module.exports = uncurryThis({}.isPrototypeOf);


/***/ }),

/***/ "../node_modules/core-js/internals/object-keys-internal.js":
/*!*****************************************************************!*\
  !*** ../node_modules/core-js/internals/object-keys-internal.js ***!
  \*****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");
var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../node_modules/core-js/internals/has-own-property.js");
var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../node_modules/core-js/internals/to-indexed-object.js");
var indexOf = (__webpack_require__(/*! ../internals/array-includes */ "../node_modules/core-js/internals/array-includes.js").indexOf);
var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "../node_modules/core-js/internals/hidden-keys.js");

var push = uncurryThis([].push);

module.exports = function (object, names) {
  var O = toIndexedObject(object);
  var i = 0;
  var result = [];
  var key;
  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
  // Don't enum bug & hidden keys
  while (names.length > i) if (hasOwn(O, key = names[i++])) {
    ~indexOf(result, key) || push(result, key);
  }
  return result;
};


/***/ }),

/***/ "../node_modules/core-js/internals/object-property-is-enumerable.js":
/*!**************************************************************************!*\
  !*** ../node_modules/core-js/internals/object-property-is-enumerable.js ***!
  \**************************************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";

var $propertyIsEnumerable = {}.propertyIsEnumerable;
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;

// Nashorn ~ JDK8 bug
var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);

// `Object.prototype.propertyIsEnumerable` method implementation
// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
  var descriptor = getOwnPropertyDescriptor(this, V);
  return !!descriptor && descriptor.enumerable;
} : $propertyIsEnumerable;


/***/ }),

/***/ "../node_modules/core-js/internals/object-set-prototype-of.js":
/*!********************************************************************!*\
  !*** ../node_modules/core-js/internals/object-set-prototype-of.js ***!
  \********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

/* eslint-disable no-proto -- safe */
var uncurryThisAccessor = __webpack_require__(/*! ../internals/function-uncurry-this-accessor */ "../node_modules/core-js/internals/function-uncurry-this-accessor.js");
var anObject = __webpack_require__(/*! ../internals/an-object */ "../node_modules/core-js/internals/an-object.js");
var aPossiblePrototype = __webpack_require__(/*! ../internals/a-possible-prototype */ "../node_modules/core-js/internals/a-possible-prototype.js");

// `Object.setPrototypeOf` method
// https://tc39.es/ecma262/#sec-object.setprototypeof
// Works with __proto__ only. Old v8 can't work with null proto objects.
// eslint-disable-next-line es/no-object-setprototypeof -- safe
module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
  var CORRECT_SETTER = false;
  var test = {};
  var setter;
  try {
    setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
    setter(test, []);
    CORRECT_SETTER = test instanceof Array;
  } catch (error) { /* empty */ }
  return function setPrototypeOf(O, proto) {
    anObject(O);
    aPossiblePrototype(proto);
    if (CORRECT_SETTER) setter(O, proto);
    else O.__proto__ = proto;
    return O;
  };
}() : undefined);


/***/ }),

/***/ "../node_modules/core-js/internals/ordinary-to-primitive.js":
/*!******************************************************************!*\
  !*** ../node_modules/core-js/internals/ordinary-to-primitive.js ***!
  \******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var call = __webpack_require__(/*! ../internals/function-call */ "../node_modules/core-js/internals/function-call.js");
var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");
var isObject = __webpack_require__(/*! ../internals/is-object */ "../node_modules/core-js/internals/is-object.js");

var $TypeError = TypeError;

// `OrdinaryToPrimitive` abstract operation
// https://tc39.es/ecma262/#sec-ordinarytoprimitive
module.exports = function (input, pref) {
  var fn, val;
  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
  throw $TypeError("Can't convert object to primitive value");
};


/***/ }),

/***/ "../node_modules/core-js/internals/own-keys.js":
/*!*****************************************************!*\
  !*** ../node_modules/core-js/internals/own-keys.js ***!
  \*****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../node_modules/core-js/internals/get-built-in.js");
var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");
var getOwnPropertyNamesModule = __webpack_require__(/*! ../internals/object-get-own-property-names */ "../node_modules/core-js/internals/object-get-own-property-names.js");
var getOwnPropertySymbolsModule = __webpack_require__(/*! ../internals/object-get-own-property-symbols */ "../node_modules/core-js/internals/object-get-own-property-symbols.js");
var anObject = __webpack_require__(/*! ../internals/an-object */ "../node_modules/core-js/internals/an-object.js");

var concat = uncurryThis([].concat);

// all object keys, includes non-enumerable and symbols
module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
  var keys = getOwnPropertyNamesModule.f(anObject(it));
  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
};


/***/ }),

/***/ "../node_modules/core-js/internals/proxy-accessor.js":
/*!***********************************************************!*\
  !*** ../node_modules/core-js/internals/proxy-accessor.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var defineProperty = (__webpack_require__(/*! ../internals/object-define-property */ "../node_modules/core-js/internals/object-define-property.js").f);

module.exports = function (Target, Source, key) {
  key in Target || defineProperty(Target, key, {
    configurable: true,
    get: function () { return Source[key]; },
    set: function (it) { Source[key] = it; }
  });
};


/***/ }),

/***/ "../node_modules/core-js/internals/require-object-coercible.js":
/*!*********************************************************************!*\
  !*** ../node_modules/core-js/internals/require-object-coercible.js ***!
  \*********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var isNullOrUndefined = __webpack_require__(/*! ../internals/is-null-or-undefined */ "../node_modules/core-js/internals/is-null-or-undefined.js");

var $TypeError = TypeError;

// `RequireObjectCoercible` abstract operation
// https://tc39.es/ecma262/#sec-requireobjectcoercible
module.exports = function (it) {
  if (isNullOrUndefined(it)) throw $TypeError("Can't call method on " + it);
  return it;
};


/***/ }),

/***/ "../node_modules/core-js/internals/shared-key.js":
/*!*******************************************************!*\
  !*** ../node_modules/core-js/internals/shared-key.js ***!
  \*******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var shared = __webpack_require__(/*! ../internals/shared */ "../node_modules/core-js/internals/shared.js");
var uid = __webpack_require__(/*! ../internals/uid */ "../node_modules/core-js/internals/uid.js");

var keys = shared('keys');

module.exports = function (key) {
  return keys[key] || (keys[key] = uid(key));
};


/***/ }),

/***/ "../node_modules/core-js/internals/shared-store.js":
/*!*********************************************************!*\
  !*** ../node_modules/core-js/internals/shared-store.js ***!
  \*********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");
var defineGlobalProperty = __webpack_require__(/*! ../internals/define-global-property */ "../node_modules/core-js/internals/define-global-property.js");

var SHARED = '__core-js_shared__';
var store = global[SHARED] || defineGlobalProperty(SHARED, {});

module.exports = store;


/***/ }),

/***/ "../node_modules/core-js/internals/shared.js":
/*!***************************************************!*\
  !*** ../node_modules/core-js/internals/shared.js ***!
  \***************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "../node_modules/core-js/internals/is-pure.js");
var store = __webpack_require__(/*! ../internals/shared-store */ "../node_modules/core-js/internals/shared-store.js");

(module.exports = function (key, value) {
  return store[key] || (store[key] = value !== undefined ? value : {});
})('versions', []).push({
  version: '3.32.0',
  mode: IS_PURE ? 'pure' : 'global',
  copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',
  license: 'https://github.com/zloirock/core-js/blob/v3.32.0/LICENSE',
  source: 'https://github.com/zloirock/core-js'
});


/***/ }),

/***/ "../node_modules/core-js/internals/symbol-constructor-detection.js":
/*!*************************************************************************!*\
  !*** ../node_modules/core-js/internals/symbol-constructor-detection.js ***!
  \*************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

/* eslint-disable es/no-symbol -- required for testing */
var V8_VERSION = __webpack_require__(/*! ../internals/engine-v8-version */ "../node_modules/core-js/internals/engine-v8-version.js");
var fails = __webpack_require__(/*! ../internals/fails */ "../node_modules/core-js/internals/fails.js");
var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");

var $String = global.String;

// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
  var symbol = Symbol();
  // Chrome 38 Symbol has incorrect toString conversion
  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
  // of course, fail.
  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
});


/***/ }),

/***/ "../node_modules/core-js/internals/to-absolute-index.js":
/*!**************************************************************!*\
  !*** ../node_modules/core-js/internals/to-absolute-index.js ***!
  \**************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var toIntegerOrInfinity = __webpack_require__(/*! ../internals/to-integer-or-infinity */ "../node_modules/core-js/internals/to-integer-or-infinity.js");

var max = Math.max;
var min = Math.min;

// Helper for a popular repeating case of the spec:
// Let integer be ? ToInteger(index).
// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
module.exports = function (index, length) {
  var integer = toIntegerOrInfinity(index);
  return integer < 0 ? max(integer + length, 0) : min(integer, length);
};


/***/ }),

/***/ "../node_modules/core-js/internals/to-indexed-object.js":
/*!**************************************************************!*\
  !*** ../node_modules/core-js/internals/to-indexed-object.js ***!
  \**************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

// toObject with fallback for non-array-like ES3 strings
var IndexedObject = __webpack_require__(/*! ../internals/indexed-object */ "../node_modules/core-js/internals/indexed-object.js");
var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ "../node_modules/core-js/internals/require-object-coercible.js");

module.exports = function (it) {
  return IndexedObject(requireObjectCoercible(it));
};


/***/ }),

/***/ "../node_modules/core-js/internals/to-integer-or-infinity.js":
/*!*******************************************************************!*\
  !*** ../node_modules/core-js/internals/to-integer-or-infinity.js ***!
  \*******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var trunc = __webpack_require__(/*! ../internals/math-trunc */ "../node_modules/core-js/internals/math-trunc.js");

// `ToIntegerOrInfinity` abstract operation
// https://tc39.es/ecma262/#sec-tointegerorinfinity
module.exports = function (argument) {
  var number = +argument;
  // eslint-disable-next-line no-self-compare -- NaN check
  return number !== number || number === 0 ? 0 : trunc(number);
};


/***/ }),

/***/ "../node_modules/core-js/internals/to-length.js":
/*!******************************************************!*\
  !*** ../node_modules/core-js/internals/to-length.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var toIntegerOrInfinity = __webpack_require__(/*! ../internals/to-integer-or-infinity */ "../node_modules/core-js/internals/to-integer-or-infinity.js");

var min = Math.min;

// `ToLength` abstract operation
// https://tc39.es/ecma262/#sec-tolength
module.exports = function (argument) {
  return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
};


/***/ }),

/***/ "../node_modules/core-js/internals/to-object.js":
/*!******************************************************!*\
  !*** ../node_modules/core-js/internals/to-object.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ "../node_modules/core-js/internals/require-object-coercible.js");

var $Object = Object;

// `ToObject` abstract operation
// https://tc39.es/ecma262/#sec-toobject
module.exports = function (argument) {
  return $Object(requireObjectCoercible(argument));
};


/***/ }),

/***/ "../node_modules/core-js/internals/to-primitive.js":
/*!*********************************************************!*\
  !*** ../node_modules/core-js/internals/to-primitive.js ***!
  \*********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var call = __webpack_require__(/*! ../internals/function-call */ "../node_modules/core-js/internals/function-call.js");
var isObject = __webpack_require__(/*! ../internals/is-object */ "../node_modules/core-js/internals/is-object.js");
var isSymbol = __webpack_require__(/*! ../internals/is-symbol */ "../node_modules/core-js/internals/is-symbol.js");
var getMethod = __webpack_require__(/*! ../internals/get-method */ "../node_modules/core-js/internals/get-method.js");
var ordinaryToPrimitive = __webpack_require__(/*! ../internals/ordinary-to-primitive */ "../node_modules/core-js/internals/ordinary-to-primitive.js");
var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../node_modules/core-js/internals/well-known-symbol.js");

var $TypeError = TypeError;
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');

// `ToPrimitive` abstract operation
// https://tc39.es/ecma262/#sec-toprimitive
module.exports = function (input, pref) {
  if (!isObject(input) || isSymbol(input)) return input;
  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
  var result;
  if (exoticToPrim) {
    if (pref === undefined) pref = 'default';
    result = call(exoticToPrim, input, pref);
    if (!isObject(result) || isSymbol(result)) return result;
    throw $TypeError("Can't convert object to primitive value");
  }
  if (pref === undefined) pref = 'number';
  return ordinaryToPrimitive(input, pref);
};


/***/ }),

/***/ "../node_modules/core-js/internals/to-property-key.js":
/*!************************************************************!*\
  !*** ../node_modules/core-js/internals/to-property-key.js ***!
  \************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var toPrimitive = __webpack_require__(/*! ../internals/to-primitive */ "../node_modules/core-js/internals/to-primitive.js");
var isSymbol = __webpack_require__(/*! ../internals/is-symbol */ "../node_modules/core-js/internals/is-symbol.js");

// `ToPropertyKey` abstract operation
// https://tc39.es/ecma262/#sec-topropertykey
module.exports = function (argument) {
  var key = toPrimitive(argument, 'string');
  return isSymbol(key) ? key : key + '';
};


/***/ }),

/***/ "../node_modules/core-js/internals/to-string-tag-support.js":
/*!******************************************************************!*\
  !*** ../node_modules/core-js/internals/to-string-tag-support.js ***!
  \******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../node_modules/core-js/internals/well-known-symbol.js");

var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var test = {};

test[TO_STRING_TAG] = 'z';

module.exports = String(test) === '[object z]';


/***/ }),

/***/ "../node_modules/core-js/internals/to-string.js":
/*!******************************************************!*\
  !*** ../node_modules/core-js/internals/to-string.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var classof = __webpack_require__(/*! ../internals/classof */ "../node_modules/core-js/internals/classof.js");

var $String = String;

module.exports = function (argument) {
  if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
  return $String(argument);
};


/***/ }),

/***/ "../node_modules/core-js/internals/try-to-string.js":
/*!**********************************************************!*\
  !*** ../node_modules/core-js/internals/try-to-string.js ***!
  \**********************************************************/
/***/ ((module) => {

"use strict";

var $String = String;

module.exports = function (argument) {
  try {
    return $String(argument);
  } catch (error) {
    return 'Object';
  }
};


/***/ }),

/***/ "../node_modules/core-js/internals/uid.js":
/*!************************************************!*\
  !*** ../node_modules/core-js/internals/uid.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../node_modules/core-js/internals/function-uncurry-this.js");

var id = 0;
var postfix = Math.random();
var toString = uncurryThis(1.0.toString);

module.exports = function (key) {
  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
};


/***/ }),

/***/ "../node_modules/core-js/internals/use-symbol-as-uid.js":
/*!**************************************************************!*\
  !*** ../node_modules/core-js/internals/use-symbol-as-uid.js ***!
  \**************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

/* eslint-disable es/no-symbol -- required for testing */
var NATIVE_SYMBOL = __webpack_require__(/*! ../internals/symbol-constructor-detection */ "../node_modules/core-js/internals/symbol-constructor-detection.js");

module.exports = NATIVE_SYMBOL
  && !Symbol.sham
  && typeof Symbol.iterator == 'symbol';


/***/ }),

/***/ "../node_modules/core-js/internals/v8-prototype-define-bug.js":
/*!********************************************************************!*\
  !*** ../node_modules/core-js/internals/v8-prototype-define-bug.js ***!
  \********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../node_modules/core-js/internals/descriptors.js");
var fails = __webpack_require__(/*! ../internals/fails */ "../node_modules/core-js/internals/fails.js");

// V8 ~ Chrome 36-
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
module.exports = DESCRIPTORS && fails(function () {
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
    value: 42,
    writable: false
  }).prototype != 42;
});


/***/ }),

/***/ "../node_modules/core-js/internals/weak-map-basic-detection.js":
/*!*********************************************************************!*\
  !*** ../node_modules/core-js/internals/weak-map-basic-detection.js ***!
  \*********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");
var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../node_modules/core-js/internals/is-callable.js");

var WeakMap = global.WeakMap;

module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));


/***/ }),

/***/ "../node_modules/core-js/internals/well-known-symbol.js":
/*!**************************************************************!*\
  !*** ../node_modules/core-js/internals/well-known-symbol.js ***!
  \**************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");
var shared = __webpack_require__(/*! ../internals/shared */ "../node_modules/core-js/internals/shared.js");
var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../node_modules/core-js/internals/has-own-property.js");
var uid = __webpack_require__(/*! ../internals/uid */ "../node_modules/core-js/internals/uid.js");
var NATIVE_SYMBOL = __webpack_require__(/*! ../internals/symbol-constructor-detection */ "../node_modules/core-js/internals/symbol-constructor-detection.js");
var USE_SYMBOL_AS_UID = __webpack_require__(/*! ../internals/use-symbol-as-uid */ "../node_modules/core-js/internals/use-symbol-as-uid.js");

var Symbol = global.Symbol;
var WellKnownSymbolsStore = shared('wks');
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;

module.exports = function (name) {
  if (!hasOwn(WellKnownSymbolsStore, name)) {
    WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
      ? Symbol[name]
      : createWellKnownSymbol('Symbol.' + name);
  } return WellKnownSymbolsStore[name];
};


/***/ }),

/***/ "../node_modules/core-js/internals/wrap-error-constructor-with-cause.js":
/*!******************************************************************************!*\
  !*** ../node_modules/core-js/internals/wrap-error-constructor-with-cause.js ***!
  \******************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../node_modules/core-js/internals/get-built-in.js");
var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../node_modules/core-js/internals/has-own-property.js");
var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../node_modules/core-js/internals/create-non-enumerable-property.js");
var isPrototypeOf = __webpack_require__(/*! ../internals/object-is-prototype-of */ "../node_modules/core-js/internals/object-is-prototype-of.js");
var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ "../node_modules/core-js/internals/object-set-prototype-of.js");
var copyConstructorProperties = __webpack_require__(/*! ../internals/copy-constructor-properties */ "../node_modules/core-js/internals/copy-constructor-properties.js");
var proxyAccessor = __webpack_require__(/*! ../internals/proxy-accessor */ "../node_modules/core-js/internals/proxy-accessor.js");
var inheritIfRequired = __webpack_require__(/*! ../internals/inherit-if-required */ "../node_modules/core-js/internals/inherit-if-required.js");
var normalizeStringArgument = __webpack_require__(/*! ../internals/normalize-string-argument */ "../node_modules/core-js/internals/normalize-string-argument.js");
var installErrorCause = __webpack_require__(/*! ../internals/install-error-cause */ "../node_modules/core-js/internals/install-error-cause.js");
var installErrorStack = __webpack_require__(/*! ../internals/error-stack-install */ "../node_modules/core-js/internals/error-stack-install.js");
var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../node_modules/core-js/internals/descriptors.js");
var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "../node_modules/core-js/internals/is-pure.js");

module.exports = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) {
  var STACK_TRACE_LIMIT = 'stackTraceLimit';
  var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1;
  var path = FULL_NAME.split('.');
  var ERROR_NAME = path[path.length - 1];
  var OriginalError = getBuiltIn.apply(null, path);

  if (!OriginalError) return;

  var OriginalErrorPrototype = OriginalError.prototype;

  // V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006
  if (!IS_PURE && hasOwn(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause;

  if (!FORCED) return OriginalError;

  var BaseError = getBuiltIn('Error');

  var WrappedError = wrapper(function (a, b) {
    var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined);
    var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError();
    if (message !== undefined) createNonEnumerableProperty(result, 'message', message);
    installErrorStack(result, WrappedError, result.stack, 2);
    if (this && isPrototypeOf(OriginalErrorPrototype, this)) inheritIfRequired(result, this, WrappedError);
    if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]);
    return result;
  });

  WrappedError.prototype = OriginalErrorPrototype;

  if (ERROR_NAME !== 'Error') {
    if (setPrototypeOf) setPrototypeOf(WrappedError, BaseError);
    else copyConstructorProperties(WrappedError, BaseError, { name: true });
  } else if (DESCRIPTORS && STACK_TRACE_LIMIT in OriginalError) {
    proxyAccessor(WrappedError, OriginalError, STACK_TRACE_LIMIT);
    proxyAccessor(WrappedError, OriginalError, 'prepareStackTrace');
  }

  copyConstructorProperties(WrappedError, OriginalError);

  if (!IS_PURE) try {
    // Safari 13- bug: WebAssembly errors does not have a proper `.name`
    if (OriginalErrorPrototype.name !== ERROR_NAME) {
      createNonEnumerableProperty(OriginalErrorPrototype, 'name', ERROR_NAME);
    }
    OriginalErrorPrototype.constructor = WrappedError;
  } catch (error) { /* empty */ }

  return WrappedError;
};


/***/ }),

/***/ "../node_modules/core-js/modules/es.error.cause.js":
/*!*********************************************************!*\
  !*** ../node_modules/core-js/modules/es.error.cause.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

"use strict";

/* eslint-disable no-unused-vars -- required for functions `.length` */
var $ = __webpack_require__(/*! ../internals/export */ "../node_modules/core-js/internals/export.js");
var global = __webpack_require__(/*! ../internals/global */ "../node_modules/core-js/internals/global.js");
var apply = __webpack_require__(/*! ../internals/function-apply */ "../node_modules/core-js/internals/function-apply.js");
var wrapErrorConstructorWithCause = __webpack_require__(/*! ../internals/wrap-error-constructor-with-cause */ "../node_modules/core-js/internals/wrap-error-constructor-with-cause.js");

var WEB_ASSEMBLY = 'WebAssembly';
var WebAssembly = global[WEB_ASSEMBLY];

var FORCED = Error('e', { cause: 7 }).cause !== 7;

var exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) {
  var O = {};
  O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED);
  $({ global: true, constructor: true, arity: 1, forced: FORCED }, O);
};

var exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) {
  if (WebAssembly && WebAssembly[ERROR_NAME]) {
    var O = {};
    O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED);
    $({ target: WEB_ASSEMBLY, stat: true, constructor: true, arity: 1, forced: FORCED }, O);
  }
};

// https://tc39.es/ecma262/#sec-nativeerror
exportGlobalErrorCauseWrapper('Error', function (init) {
  return function Error(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('EvalError', function (init) {
  return function EvalError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('RangeError', function (init) {
  return function RangeError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('ReferenceError', function (init) {
  return function ReferenceError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('SyntaxError', function (init) {
  return function SyntaxError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('TypeError', function (init) {
  return function TypeError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('URIError', function (init) {
  return function URIError(message) { return apply(init, this, arguments); };
});
exportWebAssemblyErrorCauseWrapper('CompileError', function (init) {
  return function CompileError(message) { return apply(init, this, arguments); };
});
exportWebAssemblyErrorCauseWrapper('LinkError', function (init) {
  return function LinkError(message) { return apply(init, this, arguments); };
});
exportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) {
  return function RuntimeError(message) { return apply(init, this, arguments); };
});


/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js":
/*!***********************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/interopRequireDefault.js ***!
  \***********************************************************************/
/***/ ((module) => {

function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    "default": obj
  };
}
module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ })

},
/******/ __webpack_require__ => { // webpackRuntimeModules
/******/ var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
/******/ var __webpack_exports__ = (__webpack_exec__("../assets/dev/js/frontend/modules.js"));
/******/ }
]);
//# sourceMappingURL=frontend-modules.js.map<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Public &#8211; BizTip Ninja</title>
	<atom:link href="https://biztip.ninja/category/public/feed/" rel="self" type="application/rss+xml" />
	<link>https://biztip.ninja</link>
	<description>Tips and Tools for Small Business</description>
	<lastBuildDate>Sat, 18 Apr 2026 02:39:44 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=6.9.4</generator>
	<item>
		<title>Qanday qilib kazinoda shaxsiy muvaffaqiyatga erishish mumkin</title>
		<link>https://biztip.ninja/2026/04/18/qanday-qilib-kazinoda-shaxsiy-muvaffaqiyatga/</link>
					<comments>https://biztip.ninja/2026/04/18/qanday-qilib-kazinoda-shaxsiy-muvaffaqiyatga/#respond</comments>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Sat, 18 Apr 2026 01:48:33 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1317230</guid>

					<description><![CDATA[Qanday qilib kazinoda shaxsiy muvaffaqiyatga erishish mumkin Kazino o&#8217;yinlarini tushunish Kazino o&#8217;yinlari, qadimdan beri odamlar orasida qiziqish uyg&#8217;otgan. O&#8217;yinlar turli xil bo&#8217;lib, ularning har biri o&#8217;ziga xos qoidalari va strategiyalariga...]]></description>
										<content:encoded><![CDATA[<p>Qanday qilib kazinoda shaxsiy muvaffaqiyatga erishish mumkin</p>
<h3>Kazino o&#8217;yinlarini tushunish</h3>
<p>Kazino o&#8217;yinlari, qadimdan beri odamlar orasida qiziqish uyg&#8217;otgan. O&#8217;yinlar turli xil bo&#8217;lib, ularning har biri o&#8217;ziga xos qoidalari va strategiyalariga ega. Masalan, poker, blackjack va rulet kabi o&#8217;yinlar, o&#8217;yinchilarni faqat omadga emas, balki bilim va tajribaga ham tayanishga undaydi. Ushbu jarayonni osonlashtirish uchun <a href="https://ice-fishing-uz.com/">Ice Fishing мобиль ўйини</a> kabi innovativ o&#8217;yinlar mavjud. Shuning uchun, kazinoda muvaffaqiyatga erishish uchun o&#8217;yinlarni yaxshi bilish muhimdir.</p>
<p><img decoding="async" src="https://plus.unsplash.com/premium_photo-1695941735345-c84712e1e5b5?w=500&amp;auto=format&amp;fit=crop&amp;q=60&amp;ixlib=rb-4.1.0&amp;ixid=M3wxMjA3fDB8MHxzZWFyY2h8MjI1fHxHYW1ibGluZ3xlbnwwfHwwfHx8MA%3D%3D" alt=""></p>
<p>Kazino o&#8217;yinlarining har birida maxsus taktikalar va strategiyalar mavjud. O&#8217;yinchilar o&#8217;zlarining tajribalaridan foydalanib, har bir o&#8217;yinda qanday qilib eng yaxshisini ko&#8217;rsatishni o&#8217;rganishlari lozim. Misol uchun, poker o&#8217;yinida, raqiblarni o&#8217;qish va hissiyotlarni nazorat qilish juda muhimdir. O&#8217;yinlarni tushunish, nafaqat qiziqarli vaqt o&#8217;tkazishni, balki yutish imkoniyatlarini oshirishni ham ta&#8217;minlaydi.</p>
<p>Bundan tashqari, o&#8217;yinlarni o&#8217;ynashdan oldin, onlayn resurslardan yoki kitoblardan o&#8217;qish orqali nazariy bilimlarni oshirish zarur. Bu bilimlar o&#8217;yinlarga kirishda va muvaffaqiyatga erishishda asosiy ahamiyatga ega. Shuni yodda tutish lozimki, kazinoda muvaffaqiyatli bo&#8217;lish uchun tajriba va nazariya bir-birini to&#8217;ldirishi kerak.</p>
<h3>Byudjetni boshqarish</h3>
<p>Kazino o&#8217;yinlarida muvaffaqiyatga erishish uchun byudjetni oqilona boshqarish juda muhimdir. O&#8217;yinchilar o&#8217;zlarining moliyaviy imkoniyatlarini oldindan belgilab olishlari va shu doirada harakat qilishlari kerak. Bu, o&#8217;yinchilarni qiyinchiliklarga duch kelishdan va ortiqcha xarajatlardan himoya qiladi. Har bir o&#8217;yin uchun alohida byudjet belgilash, o&#8217;yin jarayonini yanada samarali qilishga yordam beradi.</p>
<p>Byudjetni boshqarish jarayonida, o&#8217;yinchilar bir necha asosiy qoidalarni yodda tutishlari zarur. Masalan, o&#8217;yin tugagach, o&#8217;zlarining yutgan yoki yo&#8217;qotgan mablag&#8217;larini tahlil qilish muhimdir. Bu, kelgusi o&#8217;yinlarda qanday strategiyalarni qo&#8217;llash zarurligini aniqlashga yordam beradi. Shuningdek, o&#8217;z yutuqlaringizni saqlab qolish uchun yutishdan so&#8217;ng, ma&#8217;lum bir foizini ishlatmaslikka harakat qilish kerak.</p>
<p>Kazino o&#8217;yinlarida qimor o&#8217;yinlariga kirishdan avval, har doim o&#8217;z imkoniyatlaringizni hisobga olishingiz zarur. Ba&#8217;zida, juda qiziqarli o&#8217;yinlar sizni ortiqcha mablag&#8217; sarflashga undashi mumkin. Shuning uchun, o&#8217;yin jarayonida o&#8217;z nazoratingizni saqlab qolish, muvaffaqiyatga erishishda muhim omil hisoblanadi.</p>
<h3>Strategiyalarni ishlab chiqish</h3>
<p>Kazino o&#8217;yinlarida muvaffaqiyatga erishish uchun yaxshi strategiyalarni ishlab chiqish muhimdir. O&#8217;z strategiyangizni belgilash, o&#8217;yin jarayonida sizga yo&#8217;nalish beradi va qarorlar qabul qilishda yordam beradi. Har bir o&#8217;yin uchun alohida strategiya ishlab chiqish, muvaffaqiyatga erishishda asosiy rol o&#8217;ynaydi. Masalan, blackjackda, o&#8217;yinchilar o&#8217;z qo&#8217;llarini qanday baholashlarini bilishlari kerak.</p>
<p>Tajribali o&#8217;yinchilar ko&#8217;pincha o&#8217;z strategiyalarini haqiqiy hayotdagi o&#8217;yinlar orqali sinab ko&#8217;rishadi. O&#8217;z strategiyangizni amaliyotda qo&#8217;llash, uning samaradorligini ko&#8217;rishga yordam beradi va kelgusi o&#8217;yinlar uchun zarur bo&#8217;lgan o&#8217;zgartirishlarni kiritishga imkon beradi. Shuningdek, o&#8217;yinchilar o&#8217;z strategiyalarini yangilab turishlari lozim, chunki o&#8217;yinlar va ularning qoidalari doimiy ravishda o&#8217;zgarib turadi.</p>
<p>Bundan tashqari, o&#8217;yin davomida qo&#8217;llaniladigan strategiya haqida o&#8217;ylab ko&#8217;ring va agar kerak bo&#8217;lsa, o&#8217;zgartirishlar qiling. Bu sizga o&#8217;yinda yanada muvaffaqiyatli bo&#8217;lish imkoniyatini beradi. Biroq, har doim ehtiyot bo&#8217;lish va o&#8217;z strategiyangizga ishonch hosil qilish muhimdir, chunki bu, muvaffaqiyatga erishishda asosiy omil hisoblanadi.</p>
<h3>Qiziqarli o&#8217;yinlar tanlash</h3>
<p>Kazino o&#8217;yinlari juda xilma-xildir, shuning uchun o&#8217;z qiziqishlaringizga mos keladigan o&#8217;yinlarni tanlash muhimdir. Har bir o&#8217;yin turli xil qoidalar va strategiyalarga ega bo&#8217;lib, bu o&#8217;yinlarda qiziqarli vaqt o&#8217;tkazishingizga yordam beradi. O&#8217;yinlarni tanlashda, o&#8217;zingizni qiziqtirgan va ko&#8217;proq tajriba orttirishni istagan o&#8217;yinlarga e&#8217;tibor qaratish zarur. O&#8217;yinlar o&#8217;rtasida farq qilish, yangi tajribalarni kashf etishga va mahoratingizni oshirishga yordam beradi.</p>
<p>Misol uchun, agar siz matematikadan yaxshi bo&#8217;lsangiz, poker yoki blackjack kabi strategik o&#8217;yinlarni tanlash juda ma&#8217;qul. Bu o&#8217;yinlar, nafaqat omad, balki bilim va tajribaga ham asoslanadi. Shuningdek, slot o&#8217;yinlari ham yaxshi tanlov bo&#8217;lishi mumkin, ammo ularning o&#8217;ziga xos qoidalari va imkoniyatlari bor. Tanlovingiz o&#8217;yin jarayonining qanchalik qiziqarli bo&#8217;lishini belgilaydi.</p>
<p>Shuningdek, onlayn kazinolarda yangi o&#8217;yinlarni sinab ko&#8217;rish imkoniyatini ham inobatga olish zarur. Ko&#8217;pincha, yangi o&#8217;yinlar ajoyib bonuslar va maxsus takliflar bilan birga keladi, bu esa o&#8217;yinchilarga qo&#8217;shimcha imkoniyatlar beradi. Qiziqarli o&#8217;yinlar tanlash, nafaqat yutishga, balki o&#8217;yin jarayonidan zavq olishga yordam beradi.</p>
<p><img decoding="async" src="https://horta.com.ua/wp-content/uploads/2023/09/casino4.jpg" alt=""></p>
<h3>Onlayn kazinolar va tajribalar</h3>
<p>Onlayn kazinolar, bugungi kunda qimor o&#8217;yinlari sohasida yangi imkoniyatlar yaratmoqda. Ular turli xil o&#8217;yinlar, bonuslar va aksiyalarni taklif etish bilan birga, o&#8217;zlariga xos qulayliklar ham yaratadi. Masalan, o&#8217;yinchilar uyda yoki istalgan joyda o&#8217;z sevimli o&#8217;yinlarini o&#8217;ynash imkoniyatiga ega. Bu esa, o&#8217;yin jarayonini yanada qiziqarli qiladi va muvaffaqiyatga erishishni osonlashtiradi.</p>
<p>Bundan tashqari, onlayn kazinolarda mavjud bo&#8217;lgan ko&#8217;plab resurslar va o&#8217;yinlarning tajribalarini baham ko&#8217;rish imkoniyatlari, yangi o&#8217;yinchilar uchun muhimdir. Tajribali o&#8217;yinchilar o&#8217;z tajribalarini o&#8217;rganish, strategiyalarini rivojlantirish va qiyinchiliklarni yengib o&#8217;tish bo&#8217;yicha maslahatlar berishadi. Bu ham o&#8217;yin jarayonini yanada samara olishga yordam beradi.</p>
<p>Shuni yodda tutingki, onlayn kazinolar har bir o&#8217;yinchiga o&#8217;z strategiyalarini sinab ko&#8217;rish va o&#8217;zlarini rivojlantirish imkoniyatini beradi. Har bir o&#8217;yin o&#8217;zgacha va har bir o&#8217;yinchining imkoniyatlari farq qiladi. Onlayn tajribalar, sizga o&#8217;z qobiliyatingizni aniqlashga va muvaffaqiyatga erishish uchun yangi yo&#8217;llar ochishga yordam beradi.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://biztip.ninja/2026/04/18/qanday-qilib-kazinoda-shaxsiy-muvaffaqiyatga/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Reglementările legale ale cazinourilor ce trebuie să știi despre ele</title>
		<link>https://biztip.ninja/2026/04/17/reglementrile-legale-ale-cazinourilor-ce-trebuie-s-2/</link>
					<comments>https://biztip.ninja/2026/04/17/reglementrile-legale-ale-cazinourilor-ce-trebuie-s-2/#respond</comments>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Fri, 17 Apr 2026 23:49:49 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1316603</guid>

					<description><![CDATA[Reglementările legale ale cazinourilor ce trebuie să știi despre ele Introducerea în reglementările cazinourilor Reglementările legale ale cazinourilor sunt esențiale pentru a asigura un mediu de joc sigur și echitabil....]]></description>
										<content:encoded><![CDATA[<p>Reglementările legale ale cazinourilor ce trebuie să știi despre ele</p>
<h3>Introducerea în reglementările cazinourilor</h3>
<p>Reglementările legale ale cazinourilor sunt esențiale pentru a asigura un mediu de joc sigur și echitabil. În România, aceste reglementări sunt stabilite de Oficiul Național pentru Jocuri de Noroc (ONJN), care are rolul de a monitoriza și reglementa toate activitățile de jocuri de noroc. Aceste reguli nu doar că protejează jucătorii, ci și operatorii, asigurându-se că toți respectă standarde clare de funcționare. De exemplu, un loc unde poți să te bucuri de oferte atractive este <a href="https://maneki-spin.ro/">Manekispins site-ul oficial în România</a>.</p>
<p><img decoding="async" src="https://images.unsplash.com/photo-1532699747151-80f124a15661?w=500&amp;auto=format&amp;fit=crop&amp;q=60&amp;ixlib=rb-4.1.0&amp;ixid=M3wxMjA3fDB8MHxzZWFyY2h8MTM5fHxHYW1ibGluZ3xlbnwwfHwwfHx8MA%3D%3D" alt=""></p>
<p>Un aspect important al acestor reglementări este licențierea. Fiecare cazinou, fie el fizic sau online, trebuie să obțină o licență de funcționare de la ONJN, ceea ce le conferă legalitate și transparență. Acest sistem de licențiere garantează că operatorii respectă normele legale și că pun în aplicare măsuri de responsabilitate socială, având astfel un impact pozitiv asupra comunității.</p>
<p>De asemenea, reglementările impun măsuri de protecție pentru jucători. Acestea includ limita de vârstă, obligația de a se autoexcluziona în cazul dependenței de jocuri de noroc și transparența în ceea ce privește informațiile financiare. Toate aceste măsuri sunt menite să protejeze jucătorii vulnerabili și să prevină abuzurile.</p>
<h3>Tipuri de licențe pentru cazinouri</h3>
<p>Există mai multe tipuri de licențe pe care cazinourile le pot obține în România, iar fiecare tip este destinat unor activități specifice. Licențele sunt împărțite în funcție de tipul de jocuri oferite: cazinouri terestre, cazinouri online, loterii, pariuri sportive și jocuri de tip slot. Această diversificare permite un control mai strict asupra modului în care sunt desfășurate activitățile de jocuri de noroc.</p>
<p>Licențele de cazinou terestru sunt diferite de cele pentru jocurile online, deoarece acestea din urmă trebuie să respecte cerințe tehnice specifice. De exemplu, platformele online trebuie să implementeze măsuri de securitate cibernetică pentru a proteja datele personale ale utilizatorilor. Aceste cerințe asigură că jucătorii au parte de o experiență de joc sigură și fără riscuri.</p>
<p>De asemenea, licențele de funcționare sunt revizuite periodic pentru a se asigura că operatorii respectă standardele impuse. În cazul în care se constată nereguli, ONJN poate suspenda sau retrage licența, protejând astfel jucătorii de practici neetice. Aceste măsuri sunt menite să mențină integritatea sectorului de jocuri de noroc din România.</p>
<h3>Protecția jucătorilor și responsabilitatea socială</h3>
<p>Un aspect fundamental al reglementărilor cazinourilor este protecția jucătorilor. Aceasta include reguli stricte privind promovarea jocurilor de noroc și obligația operatorilor de a oferi informații clare despre riscurile asociate. Jucătorii trebuie să fie informați cu privire la modalitățile de prevenire a dependenței și la resursele disponibile pentru cei afectați de jocurile de noroc.</p>
<p>În plus, cazinourile sunt obligate să implementeze măsuri de responsabilitate socială, cum ar fi programele de autoexcludere. Aceste programe permit jucătorilor să se excludă temporar sau permanent de la jocuri, contribuind astfel la reducerea riscurilor asociate cu jocul excesiv. Aceste măsuri sunt esențiale pentru a ajuta jucătorii să își gestioneze mai bine timpul și resursele financiare.</p>
<p>De asemenea, educarea jucătorilor este o prioritate. Cazinourile trebuie să organizeze campanii de informare și să colaboreze cu organizații locale pentru a promova jocurile responsabile. Aceasta nu doar că ajută la crearea unui mediu de joc mai sigur, dar și la întărirea încrederii în industria jocurilor de noroc.</p>
<h3>Impactul reglementărilor asupra industriei jocurilor de noroc</h3>
<p>Reglementările legale au un impact semnificativ asupra modului în care funcționează industria jocurilor de noroc în România. Ele contribuie la crearea unui climat de încredere, atât pentru jucători, cât și pentru operatori. Prin stabilirea unor reguli clare, se reduce riscul de fraude și abuzuri, ceea ce este benefic pentru toți cei implicați.</p>
<p>Pe lângă protecția jucătorilor, reglementările ajută la promovarea unui mediu de concurență echitabil. Operatorii care respectă legile și reglementările au un avantaj competitiv, ceea ce îi determină să ofere servicii de calitate mai bună. Aceasta se traduce printr-o experiență de joc îmbunătățită pentru utilizatori, care beneficiază de o varietate mai mare de jocuri și promoții.</p>
<p>În plus, aceste reglementări generează venituri semnificative pentru stat, prin impozitele pe veniturile obținute din jocurile de noroc. Aceste fonduri pot fi utilizate pentru diverse proiecte sociale și infrastructurale, având astfel un impact pozitiv asupra comunității. Prin urmare, reglementările nu sunt doar un instrument de control, ci și un factor de dezvoltare economică.</p>
<p><img decoding="async" src="https://media.istockphoto.com/id/2190942489/photo/vertical-photo-collage-of-hand-hold-dollar-cash-income-success-casino-profit-poker-gambling.jpg?s=612x612&amp;w=0&amp;k=20&amp;c=VAfDZezLqZD8lxZelq9I6JbepVFE0mIEKNQY0FFupwo=" alt=""></p>
<h3>Platforma Manekispin și reglementările aplicabile</h3>
<p>Manekispin este o platformă de jocuri online recent lansată, care respectă toate reglementările legale impuse de ONJN. Aceasta oferă utilizatorilor o gamă variată de jocuri, inclusiv sloturi video și pariuri sportive, toate într-un mediu sigur și reglementat. Datorită licenței internaționale, Manekispin se angajează să ofere o experiență de joc legală și transparentă.</p>
<p>Utilizatorii pot beneficia de un pachet de bun venit atrăgător și de promoții active, ceea ce face din Manekispin o alegere populară în rândul pasionaților de jocuri de noroc. În plus, suportul 24/7 asigură că orice problemă sau întrebare este rezolvată rapid și eficient. Această atenție la detalii și respectarea reglementărilor contribuie la crearea unei reputații solide în industria jocurilor de noroc.</p>
<p>Prin respectarea normelor legale, Manekispin nu doar că își protejează utilizatorii, ci și îmbunătățește imaginea generală a industriei de jocuri de noroc din România. Acest lucru demonstrează că jocurile de noroc pot fi o formă de divertisment responsabil, atâta timp cât sunt desfășurate în conformitate cu legile și reglementările în vigoare.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://biztip.ninja/2026/04/17/reglementrile-legale-ale-cazinourilor-ce-trebuie-s-2/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Zaawansowany przewodnik po strategiach hazardowych w grach losowych</title>
		<link>https://biztip.ninja/2026/04/17/zaawansowany-przewodnik-po-strategiach-hazardowych-18/</link>
					<comments>https://biztip.ninja/2026/04/17/zaawansowany-przewodnik-po-strategiach-hazardowych-18/#respond</comments>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Fri, 17 Apr 2026 23:15:30 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1316354</guid>

					<description><![CDATA[Zaawansowany przewodnik po strategiach hazardowych w grach losowych Wprowadzenie do strategii hazardowych Strategie hazardowe w grach losowych to zbiór metod, które mają na celu zwiększenie szans gracza na wygraną. W...]]></description>
										<content:encoded><![CDATA[<p>Zaawansowany przewodnik po strategiach hazardowych w grach losowych</p>
<h3>Wprowadzenie do strategii hazardowych</h3>
<p>Strategie hazardowe w grach losowych to zbiór metod, które mają na celu zwiększenie szans gracza na wygraną. W przeciwieństwie do gier opartych na umiejętnościach, takich jak poker, wiele gier losowych, jak ruletka czy automaty, opiera się na przypadku. Niemniej jednak, zrozumienie podstawowych strategii może pomóc w zarządzaniu bankrollem i podejmowaniu bardziej świadomych decyzji podczas gry. Korzystając z platformy, takiej jak <a href="https://lanista.org.pl/">Lanista casino Polska</a>, gracze mogą odkrywać różnorodne podejścia do osiągania sukcesów w grach.</p>
<p><img decoding="async" src="https://sud.ua/uploads/news/2020/08/21/b044cfc772176fb489e2d4db0bb67fa21a1bb4c7.jpeg" alt=""></p>
<p>Kluczowym aspektem strategii hazardowych jest odpowiednie podejście do ryzyka. Warto zainwestować czas w zapoznanie się z zasadami gier, ich różnorodnością oraz potencjalnymi wypłatami. Wiedza o tym, które gry oferują lepsze szanse na wygraną, może być pomocna w wyborze odpowiednich tytułów w kasynie, co z pewnością wpłynie na zadowolenie z gry.</p>
<h3>Typowe strategie stosowane w grach losowych</h3>
<p>Jedną z popularniejszych strategii w grach losowych jest strategia Martingale, która polega na podwajaniu zakładu po każdej przegranej. Celem tej metody jest odzyskanie straconych środków oraz uzyskanie małego zysku. Choć na pierwszy rzut oka wydaje się skuteczna, warto pamiętać, że długie serie przegranych mogą prowadzić do znacznych strat, a także do osiągnięcia limitów stołu.</p>
<p>Inną strategią, która zyskuje na popularności, jest strategia D&#8217;Alemberta. Polega ona na zwiększaniu zakładu o jednostkę po przegranej i zmniejszaniu go o jednostkę po wygranej. Metoda ta jest nieco bardziej konserwatywna i może być korzystniejsza dla graczy preferujących umiarkowane ryzyko w grach.</p>
<h3>Zarządzanie bankrollem</h3>
<p>Zarządzanie bankrollem to kluczowy element strategii hazardowych. Gracze powinni ustalić budżet przed rozpoczęciem gry i ściśle go przestrzegać, aby uniknąć utraty większych sum pieniędzy. Ważne jest, aby grać tylko tymi środkami, które można sobie pozwolić stracić, oraz regularnie oceniać swoje postawy podczas gry, co może poprawić doświadczenia związane z grą.</p>
<p>Warto również wprowadzić limity czasowe na grę, aby zachować kontrolę nad swoimi emocjami i decyzjami. Emocje mogą wpływać na nasze wybory, co prowadzi do nieprzemyślanych działań i zwiększa ryzyko strat. Przez odpowiednie zarządzanie bankrollem można nie tylko zwiększyć szanse na sukces, ale także zachować przyjemność z gry.</p>
<h3>Psychologia gry w kasynie</h3>
<p>Psychologia hazardu odgrywa istotną rolę w podejmowaniu decyzji przez graczy. Wiedza na temat tego, jak emocje wpływają na nasze zachowanie, jest kluczowa dla opracowania skutecznej strategii. Często gracze mogą czuć presję, aby kontynuować grę po przegranej, co prowadzi do jeszcze większych strat.</p>
<p>Umiejętność rozpoznawania własnych emocji i ich wpływu na decyzje w grze jest kluczowa dla każdego gracza. Często przydatne może być wprowadzenie przerw w grze, aby ocenić swoje podejście i upewnić się, że podejmowane decyzje są racjonalne, a nie kierowane chwilowym impulsem.</p>
<p><img decoding="async" src="https://media.gettyimages.com/id/200027451-001/photo/man-wearing-dinner-jacket-smoking-cigar-in-casino-portrait.jpg?s=612x612&amp;w=0&amp;k=20&amp;c=80KSdnEsIpX54fjm_S6xCH21gThoOh_hJjMNJv_vP-4=" alt=""></p>
<h3>Lanista Casino – Twoje miejsce na gry losowe</h3>
<p>Lanista Casino to doskonała platforma dla miłośników gier losowych. Oferuje szeroki wybór gier, w tym automaty i stoły do gier na żywo, co pozwala na pełne wykorzystanie różnych strategii hazardowych. Dzięki atrakcyjnym bonusom powitalnym, nowi gracze mają szansę na zwiększenie swojego budżetu na grę już od samego początku.</p>
<p>Platforma gwarantuje bezpieczeństwo i wygodę korzystania, oferując różnorodne metody wpłat i wypłat, co czyni grę jeszcze bardziej atrakcyjną. Dostosowana do potrzeb graczy, Lanista Casino to idealne miejsce do testowania strategii hazardowych oraz czerpania radości z gier losowych w bezpiecznym i przyjaznym środowisku.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://biztip.ninja/2026/04/17/zaawansowany-przewodnik-po-strategiach-hazardowych-18/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Giocare responsabilmente sette consigli per un&#x27;esperienza di gioco sicura ai casinò</title>
		<link>https://biztip.ninja/2026/04/17/giocare-responsabilmente-sette-consigli-per-un-x27/</link>
					<comments>https://biztip.ninja/2026/04/17/giocare-responsabilmente-sette-consigli-per-un-x27/#respond</comments>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Fri, 17 Apr 2026 22:43:58 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1316281</guid>

					<description><![CDATA[Giocare responsabilmente sette consigli per un&#x27;esperienza di gioco sicura ai casinò Importanza del gioco responsabile Il gioco d&#8217;azzardo è un&#8217;attività che può portare a momenti di divertimento e socializzazione, ma...]]></description>
										<content:encoded><![CDATA[<p>Giocare responsabilmente sette consigli per un&#x27;esperienza di gioco sicura ai casinò</p>
<h3>Importanza del gioco responsabile</h3>
<p>Il gioco d&#8217;azzardo è un&#8217;attività che può portare a momenti di divertimento e socializzazione, ma è fondamentale approcciarsi ad essa con responsabilità. Giocare in modo responsabile significa essere consapevoli dei propri limiti e del proprio comportamento, evitando di lasciarsi coinvolgere in situazioni potenzialmente dannose. Di recente, <a href="https://westace1.it/">Westace ufficiale in Italia</a> ha evidenziato come la consapevolezza sia il primo passo per garantire un&#8217;esperienza di gioco positiva e sicura.</p>
<p><img decoding="async" src="&lt;div class=&quot;video-container&quot;&gt;&lt;iframe src=&quot;https://cdn.pixabay.com/video/2020/11/07/55850-504238889_medium.mp4&quot; frameborder=&quot;0&quot; allowfullscreen&gt;&lt;/iframe&gt;&lt;/div&gt;" alt=""></p>
<p>Adottare un approccio responsabile al gioco non implica solo controllare il proprio budget, ma anche essere in grado di riconoscere quando è il momento di fermarsi. Essere attenti ai segnali di allerta e mantenere il gioco come un&#8217;attività di svago piuttosto che una necessità è cruciale per una pratica di gioco sana.</p>
<h3>Stabilire un budget</h3>
<p>Stabilire un budget è uno dei consigli più importanti per giocare responsabilmente. Prima di iniziare a giocare, è fondamentale decidere quanto denaro si è disposti a spendere e attenersi a questa cifra. Creare un piano finanziario aiuta a evitare spese eccessive che possono portare a problemi economici. È essenziale considerare il gioco come un intrattenimento e non come un modo per guadagnare denaro.</p>
<p>In aggiunta al budget, è consigliabile avere una chiara distinzione tra denaro da gioco e denaro per le spese quotidiane. In questo modo, si minimizza il rischio di compromettere la propria situazione finanziaria e si facilita un approccio più rilassato al gioco.</p>
<h3>Limitare il tempo di gioco</h3>
<p>Un altro aspetto cruciale per un&#8217;esperienza di gioco sicura è limitare il tempo trascorso ai casinò. Stabilire un orario specifico per giocare può aiutare a mantenere il controllo e a prevenire l&#8217;eccesso. Il gioco dovrebbe rimanere un&#8217;attività ricreativa e non trasformarsi in un&#8217;ossessione o in un modo per sfuggire alla realtà.</p>
<p>Prendersi delle pause regolari durante il gioco è anche una buona pratica. Questi momenti di pausa permettono di riflettere sul proprio comportamento e di valutare se si sta rispettando il budget stabilito. La gestione del tempo è fondamentale per garantire un&#8217;esperienza di gioco equilibrata e piacevole.</p>
<h3>Riconoscere i segnali di dipendenza</h3>
<p>Essere in grado di riconoscere i segnali di dipendenza è essenziale per mantenere il gioco sotto controllo. Alcuni indicatori possono includere il pensiero costante al gioco, il tentativo di recuperare perdite o la volontà di giocare in modo eccessivo. È importante essere onesti con se stessi e cercare aiuto se si riconoscono questi segnali.</p>
<p>Inoltre, ci sono molte risorse disponibili per chi desidera approfondire il tema della dipendenza dal gioco. Gruppi di supporto e consulenze professionali possono fornire assistenza a chi ha bisogno di aiuto, garantendo un percorso di recupero e un ritorno a un gioco sano.</p>
<p><img decoding="async" src="https://images.unsplash.com/photo-1739323982037-ec70f44627f8?w=500&amp;auto=format&amp;fit=crop&amp;q=60&amp;ixlib=rb-4.1.0&amp;ixid=M3wxMjA3fDB8MHxzZWFyY2h8NDk4fHxHYW1ibGluZ3xlbnwwfHwwfHx8MA%3D%3D" alt=""></p>
<h3>WestAce Italia: un casinò attento al gioco responsabile</h3>
<p>WestAce Italia si distingue per il suo impegno verso il gioco responsabile, offrendo un ambiente di gioco sicuro e divertente. Con una varietà di giochi e promozioni vantaggiose, il casinò promuove comportamenti responsabili tra i propri utenti, incoraggiando pratiche di gioco che rispettano i limiti personali e finanziari.</p>
<p>Grazie a un servizio clienti attivo 24 ore su 24 e a una piattaforma sicura accessibile da diversi dispositivi, WestAce Italia si impegna a garantire la soddisfazione dell&#8217;utente. La consapevolezza e la responsabilità sono al centro della sua filosofia, assicurando che il gioco rimanga un&#8217;attività piacevole per tutti.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://biztip.ninja/2026/04/17/giocare-responsabilmente-sette-consigli-per-un-x27/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Achieve unforgettable entertainment through verified gambling techniques</title>
		<link>https://biztip.ninja/2026/04/17/achieve-unforgettable-entertainment-through-verified-gambling-techniques-2/</link>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Fri, 17 Apr 2026 20:09:26 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1315600</guid>

					<description><![CDATA[Avvalambor, qimor o&#8217;yinlari dunyosi juda keng va turli xil imkoniyatlar bilan to&#8217;la. Har bir o&#8217;yinchi o&#8217;ziga xos tajriba qidiradi va bu tajribani qidirish jarayoni qiyin bo&#8217;lishi mumkin. Shunday qilib, o&#8217;z...]]></description>
										<content:encoded><![CDATA[<p>Avvalambor, qimor o&#8217;yinlari dunyosi juda keng va turli xil imkoniyatlar bilan to&#8217;la. Har bir o&#8217;yinchi o&#8217;ziga xos tajriba qidiradi va bu tajribani qidirish jarayoni qiyin bo&#8217;lishi mumkin. Shunday qilib, o&#8217;z ehtiyojlaringizga mos keladigan qimor o&#8217;yinlari platformasini topish juda muhimdir. Sizga eng yaxshi variantlarni taqdim etadigan saytlar haqida bilish juda qiziqarli bo&#8217;lishi mumkin. Masalan, <a href="https://888-starz-uz.com/">888.0</a> sayti sizga kerakli ma&#8217;lumotlarni tezda topishga yordam beradi.</p>
<p><img decoding="async" src="https://d1nizz91i54auc.cloudfront.net/_service/39130/display/img_version/5844331/t/1588092207/img_name/6303_39130_20e1b49933.jpg" alt=""></p>
<p>Bu maqolada biz sizga qimor o&#8217;yinlarini yanada hayajonli va unutilmas qilish uchun qanday qilib to&#8217;g&#8217;ri strategiyalarni qo&#8217;llash kerakligini ko&#8217;rsatamiz. Qimor o&#8217;yinlari nafaqat omadga, balki to&#8217;g&#8217;ri strategiyaga ham bog&#8217;liq. Keling, ushbu mavzuni chuqur o&#8217;rganamiz.</p>
<h2>Boshqa platformalar bilan solishtirganda qimor o&#8217;yinlari sahnasida ishonchni oshirish</h2>
<p>Qimor o&#8217;yinlari tizimi, juda ko&#8217;p variantlar va imkoniyatlar bilan, juda ko&#8217;p o&#8217;yinchilarni jalb qiladi. Bu platformalarning ko&#8217;pchiligi yuqori ma&#8217;lumotlarga ega bo&#8217;lishiga qaramay, ba&#8217;zida foydalanuvchilarga kerakli ma&#8217;lumotlarni topishda qiyinchilik tug&#8217;dirishi mumkin. Ushbu sayt esa o&#8217;zining oson interfeysi va foydalanuvchilarga kerakli ma&#8217;lumotlarni tezda topish imkonini beradigan xususiyatlari bilan ajralib turadi. Haqiqatdan ham, bu platforma qidirayotganingizni topishda juda yordam beradi.</p>
<p><img decoding="async" src="https://images.unsplash.com/photo-1608231883522-2efb1897a608?q=80&amp;w=990&amp;auto=format&amp;fit=crop&amp;ixlib=rb-4.1.0&amp;ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D" alt=""></p>
<h3>Qanday qilib qimor o&#8217;yinlaridan foydalanish kerak?</h3>
<p>Qimor o&#8217;yinlaridan foydalanganingizda, bu jarayon juda oddiy: bu erda bir necha qadamlarni bajarish kerak.</p>
<ol>
<li>Qimor platformasini tanlang: O&#8217;z ehtiyojlaringizga mos keladigan platformani qidirib toping.</li>
<li>Ro&#8217;yxatdan o&#8217;ting: Hisob yarating va kerakli ma&#8217;lumotlarni to&#8217;ldiring.</li>
<li>O&#8217;yinlarni tanlang: Taklif etilayotgan qimor o&#8217;yinlari orasidan qaysi biri sizga yoqishini tanlang.</li>
<li>Joriy aktsiyalarni ko&#8217;rib chiqing: Foydalanuvchilarga taqdim etiladigan bonuslar va aktsiyalarni tekshiring.</li>
<li>Qimor o&#8217;yinlariga kirish: O&#8217;yinlarni boshlash va o&#8217;z tajribangizni oshirishga tayyormiz!</li>
</ol>
<ul>
<li>Yuqori sifatli grafikalar</li>
<li>Tezkor to&#8217;lovlar</li>
<li>Ilgari royxatga olingan tajribali foydalanuvchilar bilan maslahat</li>
</ul>
<h2>Qimor o&#8217;yinlaridagi imkoniyatlarni taqqoslash</h2>
<p>Qimor o&#8217;yinlari dunyosida juda ko&#8217;p variantlar mavjudligini ko&#8217;rib chiqmoqdamiz. Har bir platformaning o&#8217;ziga xos xususiyatlari bor. Keling, ba&#8217;zi imkoniyatlarni taqqoslaymiz:</p>
<table>
<tr>
<th><b>Platforma</b></th>
<th><b>Yutuq imkoniyatlari</b></th>
<th><b>Mukofotlar</b></th>
<th><b>Foydalanuvchi tajribasi</b></th>
</tr>
<tr>
<td>Platforma 1</td>
<td>85%</td>
<td>Bonuslar mavjud</td>
<td>Yuqori</td>
</tr>
<tr>
<td>Platforma 2</td>
<td>90%</td>
<td>Yuqori bonuslar</td>
<td>Yaxshi</td>
</tr>
<tr>
<td>Platforma 3</td>
<td>80%</td>
<td>Kam bonuslar</td>
<td>O&#8217;rtacha</td>
</tr>
</table>
<p>Yuqorida keltirilgan ma&#8217;lumotlar yordamida siz qaysi platformaning sizga eng mos kelishini belgilay olasiz. O&#8217;yinlar orasidagi farqlarni tushunish sizga yanada yaxshiroq qaror qabul qilishga yordam beradi.</p>
<h2>Qo&#8217;shimcha xususiyatlar va afzalliklar</h2>
<p>Qimor o&#8217;yinlari platformasi sizga bir qator foydali xususiyatlarni taklif etadi:</p>
<ul>
<li>Yuqori sifatli grafikalar va ovozlar</li>
<li>Foydalanuvchilarga qulay interfeys</li>
<li>Tezkor xizmat ko&#8217;rsatish</li>
<li>Qimor o&#8217;yinlari bo&#8217;yicha maslahat va qo&#8217;llanmalar</li>
<li>Mobil ilova orqali o&#8217;yinlarni boshqarish</li>
</ul>
<h2>Ishonchni oshirish: xavfsizlik va sifat</h2>
<p>Qimor o&#8217;yinlari faqat omadga bog&#8217;liq emas, balki xavfsizlik va sifatga ham bog&#8217;liq. Ushbu platforma, foydalanuvchilar ma&#8217;lumotlarini himoya qilish va o&#8217;yin sifatini nazorat qilish bo&#8217;yicha o&#8217;zining yuqori standartlarini saqlaydi. Foydalanuvchilarga xavfsiz va ishonchli muhit taqdim etish, ushbu platformaning asosiy maqsadlaridan biridir. Shuningdek, tajribali mutaxassislar tomonidan o&#8217;yinlarning sifatini tekshirish ham alohida ahamiyatga ega.</p>
<h2>Nima uchun ushbu platformani tanlash kerak?</h2>
<p>Qimor o&#8217;yinlariga oid ushbu maqolada muhokama qilingan barcha fikrlarni umumlashtiramiz:</p>
<ol>
<li>Intuitiv interfeys va foydalanish uchun qulaylik.</li>
<li>Keng qamrovli va xilma-xil o&#8217;yinlar.</li>
<li>Tezkor to&#8217;lovlar va yuqori yutuq imkoniyatlari.</li>
<li>Foydalanuvchilar bilan yaxshi muloqot va qo&#8217;llab-quvvatlash tizimi.</li>
</ol>
<p>Shunday qilib, bu platforma qimor o&#8217;yinlarini yanada qiziqarli va hayajonli qilish uchun sizga eng yaxshi imkoniyatlarni taqdim etadi. Bu yerda siz o&#8217;z ehtiyojlaringizga mos keladigan barcha narsalarni topasiz, shuning uchun har doim ishonch bilan tanlash imkoniyatiga ega bo&#8217;lasiz!</p>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Achieve unforgettable entertainment through verified gambling techniques</title>
		<link>https://biztip.ninja/2026/04/17/achieve-unforgettable-entertainment-through-verified-gambling-techniques/</link>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Fri, 17 Apr 2026 20:09:21 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1315601</guid>

					<description><![CDATA[Avvalambor, qimor o&#8217;yinlari dunyosi juda keng va turli xil imkoniyatlar bilan to&#8217;la. Har bir o&#8217;yinchi o&#8217;ziga xos tajriba qidiradi va bu tajribani qidirish jarayoni qiyin bo&#8217;lishi mumkin. Shunday qilib, o&#8217;z...]]></description>
										<content:encoded><![CDATA[<p>Avvalambor, qimor o&#8217;yinlari dunyosi juda keng va turli xil imkoniyatlar bilan to&#8217;la. Har bir o&#8217;yinchi o&#8217;ziga xos tajriba qidiradi va bu tajribani qidirish jarayoni qiyin bo&#8217;lishi mumkin. Shunday qilib, o&#8217;z ehtiyojlaringizga mos keladigan qimor o&#8217;yinlari platformasini topish juda muhimdir. Sizga eng yaxshi variantlarni taqdim etadigan saytlar haqida bilish juda qiziqarli bo&#8217;lishi mumkin. Masalan, <a href="https://888-starz-uz.com/">888.0</a> sayti sizga kerakli ma&#8217;lumotlarni tezda topishga yordam beradi.</p>
<p><img decoding="async" src="https://d1nizz91i54auc.cloudfront.net/_service/39130/display/img_version/5844331/t/1588092207/img_name/6303_39130_20e1b49933.jpg" alt=""></p>
<p>Bu maqolada biz sizga qimor o&#8217;yinlarini yanada hayajonli va unutilmas qilish uchun qanday qilib to&#8217;g&#8217;ri strategiyalarni qo&#8217;llash kerakligini ko&#8217;rsatamiz. Qimor o&#8217;yinlari nafaqat omadga, balki to&#8217;g&#8217;ri strategiyaga ham bog&#8217;liq. Keling, ushbu mavzuni chuqur o&#8217;rganamiz.</p>
<h2>Boshqa platformalar bilan solishtirganda qimor o&#8217;yinlari sahnasida ishonchni oshirish</h2>
<p>Qimor o&#8217;yinlari tizimi, juda ko&#8217;p variantlar va imkoniyatlar bilan, juda ko&#8217;p o&#8217;yinchilarni jalb qiladi. Bu platformalarning ko&#8217;pchiligi yuqori ma&#8217;lumotlarga ega bo&#8217;lishiga qaramay, ba&#8217;zida foydalanuvchilarga kerakli ma&#8217;lumotlarni topishda qiyinchilik tug&#8217;dirishi mumkin. Ushbu sayt esa o&#8217;zining oson interfeysi va foydalanuvchilarga kerakli ma&#8217;lumotlarni tezda topish imkonini beradigan xususiyatlari bilan ajralib turadi. Haqiqatdan ham, bu platforma qidirayotganingizni topishda juda yordam beradi.</p>
<p><img decoding="async" src="https://images.unsplash.com/photo-1608231883522-2efb1897a608?q=80&amp;w=990&amp;auto=format&amp;fit=crop&amp;ixlib=rb-4.1.0&amp;ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D" alt=""></p>
<h3>Qanday qilib qimor o&#8217;yinlaridan foydalanish kerak?</h3>
<p>Qimor o&#8217;yinlaridan foydalanganingizda, bu jarayon juda oddiy: bu erda bir necha qadamlarni bajarish kerak.</p>
<ol>
<li>Qimor platformasini tanlang: O&#8217;z ehtiyojlaringizga mos keladigan platformani qidirib toping.</li>
<li>Ro&#8217;yxatdan o&#8217;ting: Hisob yarating va kerakli ma&#8217;lumotlarni to&#8217;ldiring.</li>
<li>O&#8217;yinlarni tanlang: Taklif etilayotgan qimor o&#8217;yinlari orasidan qaysi biri sizga yoqishini tanlang.</li>
<li>Joriy aktsiyalarni ko&#8217;rib chiqing: Foydalanuvchilarga taqdim etiladigan bonuslar va aktsiyalarni tekshiring.</li>
<li>Qimor o&#8217;yinlariga kirish: O&#8217;yinlarni boshlash va o&#8217;z tajribangizni oshirishga tayyormiz!</li>
</ol>
<ul>
<li>Yuqori sifatli grafikalar</li>
<li>Tezkor to&#8217;lovlar</li>
<li>Ilgari royxatga olingan tajribali foydalanuvchilar bilan maslahat</li>
</ul>
<h2>Qimor o&#8217;yinlaridagi imkoniyatlarni taqqoslash</h2>
<p>Qimor o&#8217;yinlari dunyosida juda ko&#8217;p variantlar mavjudligini ko&#8217;rib chiqmoqdamiz. Har bir platformaning o&#8217;ziga xos xususiyatlari bor. Keling, ba&#8217;zi imkoniyatlarni taqqoslaymiz:</p>
<table>
<tr>
<th><b>Platforma</b></th>
<th><b>Yutuq imkoniyatlari</b></th>
<th><b>Mukofotlar</b></th>
<th><b>Foydalanuvchi tajribasi</b></th>
</tr>
<tr>
<td>Platforma 1</td>
<td>85%</td>
<td>Bonuslar mavjud</td>
<td>Yuqori</td>
</tr>
<tr>
<td>Platforma 2</td>
<td>90%</td>
<td>Yuqori bonuslar</td>
<td>Yaxshi</td>
</tr>
<tr>
<td>Platforma 3</td>
<td>80%</td>
<td>Kam bonuslar</td>
<td>O&#8217;rtacha</td>
</tr>
</table>
<p>Yuqorida keltirilgan ma&#8217;lumotlar yordamida siz qaysi platformaning sizga eng mos kelishini belgilay olasiz. O&#8217;yinlar orasidagi farqlarni tushunish sizga yanada yaxshiroq qaror qabul qilishga yordam beradi.</p>
<h2>Qo&#8217;shimcha xususiyatlar va afzalliklar</h2>
<p>Qimor o&#8217;yinlari platformasi sizga bir qator foydali xususiyatlarni taklif etadi:</p>
<ul>
<li>Yuqori sifatli grafikalar va ovozlar</li>
<li>Foydalanuvchilarga qulay interfeys</li>
<li>Tezkor xizmat ko&#8217;rsatish</li>
<li>Qimor o&#8217;yinlari bo&#8217;yicha maslahat va qo&#8217;llanmalar</li>
<li>Mobil ilova orqali o&#8217;yinlarni boshqarish</li>
</ul>
<h2>Ishonchni oshirish: xavfsizlik va sifat</h2>
<p>Qimor o&#8217;yinlari faqat omadga bog&#8217;liq emas, balki xavfsizlik va sifatga ham bog&#8217;liq. Ushbu platforma, foydalanuvchilar ma&#8217;lumotlarini himoya qilish va o&#8217;yin sifatini nazorat qilish bo&#8217;yicha o&#8217;zining yuqori standartlarini saqlaydi. Foydalanuvchilarga xavfsiz va ishonchli muhit taqdim etish, ushbu platformaning asosiy maqsadlaridan biridir. Shuningdek, tajribali mutaxassislar tomonidan o&#8217;yinlarning sifatini tekshirish ham alohida ahamiyatga ega.</p>
<h2>Nima uchun ushbu platformani tanlash kerak?</h2>
<p>Qimor o&#8217;yinlariga oid ushbu maqolada muhokama qilingan barcha fikrlarni umumlashtiramiz:</p>
<ol>
<li>Intuitiv interfeys va foydalanish uchun qulaylik.</li>
<li>Keng qamrovli va xilma-xil o&#8217;yinlar.</li>
<li>Tezkor to&#8217;lovlar va yuqori yutuq imkoniyatlari.</li>
<li>Foydalanuvchilar bilan yaxshi muloqot va qo&#8217;llab-quvvatlash tizimi.</li>
</ol>
<p>Shunday qilib, bu platforma qimor o&#8217;yinlarini yanada qiziqarli va hayajonli qilish uchun sizga eng yaxshi imkoniyatlarni taqdim etadi. Bu yerda siz o&#8217;z ehtiyojlaringizga mos keladigan barcha narsalarni topasiz, shuning uchun har doim ishonch bilan tanlash imkoniyatiga ega bo&#8217;lasiz!</p>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>The Psychology of Gambling How Luck Affects Us</title>
		<link>https://biztip.ninja/2026/04/17/the-psychology-of-gambling-how-luck-affects-us/</link>
					<comments>https://biztip.ninja/2026/04/17/the-psychology-of-gambling-how-luck-affects-us/#respond</comments>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Fri, 17 Apr 2026 19:15:37 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1315546</guid>

					<description><![CDATA[The Psychology of Gambling How Luck Affects Us Η ψυχολογία του τζόγου Ο τζόγος είναι μια δραστηριότητα που προσελκύει εκατομμύρια ανθρώπους παγκοσμίως, αλλά η ψυχολογία που κρύβεται πίσω από αυτήν...]]></description>
										<content:encoded><![CDATA[<p>The Psychology of Gambling How Luck Affects Us</p>
<h3>Η ψυχολογία του τζόγου</h3>
<p>Ο τζόγος είναι μια δραστηριότητα που προσελκύει εκατομμύρια ανθρώπους παγκοσμίως, αλλά η ψυχολογία που κρύβεται πίσω από αυτήν είναι πολύπλοκη και ενδιαφέρουσα. Οι άνθρωποι τείνουν να παίζουν για διάφορους λόγους, όπως η αναζήτηση διασκέδασης, η επιθυμία για χρήματα ή ακόμη και η ανάγκη για συγκινήσεις. Αυτή η ψυχολογική διάσταση μπορεί να οδηγήσει σε συμπεριφορές που δεν είναι πάντα λογικές ή συνειδητές. Ειδικότερα, η αίσθηση της τύχης και η εντύπωση ότι μπορεί κάποιος να ελέγξει την τύχη του παίζουν σημαντικό ρόλο στην απόφαση να στοιχηματίσει κανείς. Ανάμεσα στις προτάσεις για μια ασφαλέστερη εμπειρία τζόγου είναι η <a href="https://maneki-spin.gr/">Ανασκόπηση Manekispins</a>, που παρέχει χρήσιμες πληροφορίες.</p>
<p><img decoding="async" src="https://images.unsplash.com/photo-1620023652392-30e7ee0ed964?q=80&amp;w=1374&amp;auto=format&amp;fit=crop&amp;ixlib=rb-4.1.0&amp;ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D" alt=""></p>
<p>Πολλοί παίκτες συχνά πιστεύουν ότι έχουν &#8220;τύχη&#8221;, γεγονός που μπορεί να τους κάνει να αναλαμβάνουν μεγαλύτερους κινδύνους. Αυτή η ψευδαίσθηση ελέγχου είναι χαρακτηριστική της ανθρώπινης φύσης, καθώς οι άνθρωποι επιθυμούν να πιστεύουν ότι μπορούν να επηρεάσουν τα αποτελέσματα με τις ενέργειές τους. Ωστόσο, η πραγματικότητα είναι ότι τα παιχνίδια του καζίνο βασίζονται στην τύχη, και οι πιθανότητες συνήθως δεν είναι υπέρ των παικτών. Αυτή η αντίφαση μεταξύ πίστης και πραγματικότητας οδηγεί σε έντονες συναισθηματικές αντιδράσεις και συχνά σε εθισμό.</p>
<p>Έτσι, οι ψυχολόγοι μελετούν τις συμπεριφορές των τζογαδόρων για να κατανοήσουν καλύτερα πώς οι συναισθηματικοί παράγοντες επηρεάζουν την απόφασή τους να παίξουν. Οι άνθρωποι μπορεί να παίζουν για να ξεφύγουν από το άγχος ή την καθημερινότητα, γεγονός που τους οδηγεί σε μια κατάσταση που αναζητά τη &#8220;φυγή&#8221;. Αυτές οι συναισθηματικές αντιδράσεις καθορίζουν σε μεγάλο βαθμό την επιτυχία ή αποτυχία τους στον τζόγο.</p>
<h3>Η επίδραση της τύχης</h3>
<p>Η τύχη είναι ίσως ο πιο σημαντικός παράγοντας στον τζόγο, επηρεάζοντας την αντίληψη των παικτών σχετικά με το πώς παίζουν. Για πολλούς, η ικανότητα να κερδίσουν φαίνεται να εξαρτάται από τη &#8220;καλή τύχη&#8221;. Αυτή η πίστη ενισχύει τη διαδικασία του τζόγου, καθώς οι παίκτες επενδύουν ελπίδες και προσδοκίες στα παιχνίδια. Η ιδέα ότι κάποιος μπορεί να &#8220;κερδίσει&#8221; με μια μόνο κίνηση ενισχύει την εθιστική φύση του τζόγου.</p>
<p>Ωστόσο, η τυχαιότητα των παιχνιδιών, όπως οι κουλοχέρηδες και οι ρουλέτες, κρύβει ένα αρνητικό πλευρό. Οι παίκτες συχνά υποτιμούν τις πιθανότητες και πιστεύουν ότι η τύχη τους μπορεί να αλλάξει με βάση προηγούμενες εμπειρίες. Αυτή η ψευδαίσθηση μπορεί να οδηγήσει σε επαναλαμβανόμενη συμμετοχή, ακόμη και όταν οι πιθανότητες είναι εναντίον τους. Έτσι, η τύχη γίνεται ένα εργαλείο και ταυτόχρονα ένα εμπόδιο για τους παίκτες.</p>
<p>Η επιτυχία στον τζόγο δεν είναι ποτέ εγγυημένη, και οι ψυχολογικές συνέπειες μπορεί να είναι σοβαρές. Όταν οι άνθρωποι αποτυγχάνουν να κερδίσουν ή χάνουν μεγάλα ποσά χρημάτων, η απογοήτευση μπορεί να οδηγήσει σε κατάθλιψη και εθισμό. Η φύση του τζόγου είναι τέτοια που οι παίκτες συχνά εξαπατούν τον εαυτό τους, πιστεύοντας ότι η τύχη θα γυρίσει υπέρ τους, ενώ στην πραγματικότητα μπορεί να βυθίζονται πιο βαθιά σε ένα φαύλο κύκλο.</p>
<h3>Στρατηγικές και συμπεριφορές των παικτών</h3>
<p>Οι παίκτες του καζίνο αναπτύσσουν συχνά στρατηγικές που πιστεύουν ότι θα τους φέρουν επιτυχία. Αυτές οι στρατηγικές μπορεί να περιλαμβάνουν το να παίζουν συγκεκριμένα παιχνίδια ή να στοιχηματίζουν με συγκεκριμένα ποσά. Ωστόσο, η συναισθηματική φόρτιση και η πίεση να κερδίσουν μπορεί να τους οδηγήσουν σε λανθασμένες αποφάσεις. Η πίεση να αποδείξουν ότι έχουν δίκιο ή ότι είναι &#8220;τυχεροί&#8221; είναι πολύ ισχυρή και μπορεί να προκαλέσει εξαιρετικά επικίνδυνες συμπεριφορές.</p>
<p>Η γνώση των παιχνιδιών είναι επίσης σημαντική, αλλά συχνά υποτιμάται από τους παίκτες. Ορισμένοι παίκτες επικεντρώνονται περισσότερο στην τύχη παρά στην στρατηγική, πιστεύοντας ότι οι ικανότητές τους δεν έχουν σημασία. Ωστόσο, οι πιο επιτυχημένοι παίκτες είναι αυτοί που κατανοούν τις πιθανότητες και προσεγγίζουν τα παιχνίδια με μια στρατηγική που βασίζεται στη γνώση και την εμπειρία τους.</p>
<p>Αυτές οι συμπεριφορές ενισχύουν την ανάγκη για αυτογνωσία και αυτοέλεγχο. Πρέπει να αναγνωρίσουν τα όρια τους και να κατανοήσουν τις ψυχολογικές παγίδες του τζόγου. Η ενημέρωση σχετικά με την ψυχολογία πίσω από τον τζόγο μπορεί να βοηθήσει τους παίκτες να πάρουν καλύτερες αποφάσεις και να αποφύγουν τις παγίδες του εθισμού.</p>
<h3>Ο ρόλος της ψυχολογίας στον εθισμό</h3>
<p>Ο εθισμός στον τζόγο είναι μια σοβαρή κατάσταση που επηρεάζει πολλούς ανθρώπους. Η ψυχολογία του εθισμού συνδέεται στενά με την ανάγκη για συγκινήσεις και την αναζήτηση της ευχαρίστησης. Οι παίκτες που γίνονται εθισμένοι συχνά βιώνουν υψηλά επίπεδα άγχους και πίεσης, τα οποία προσπαθούν να ανακουφίσουν μέσω του τζόγου. Αυτή η επαναλαμβανόμενη διαδικασία οδηγεί σε ένα φαύλο κύκλο, καθώς οι παίκτες καταλήγουν να στοιχηματίζουν περισσότερα χρήματα για να καλύψουν τις απώλειές τους.</p>
<p>Η στήριξη από οικογένεια και φίλους μπορεί να είναι καθοριστική για την αποκατάσταση ενός εθισμένου παίκτη. Είναι σημαντικό οι γύρω του να κατανοήσουν τη φύση του εθισμού και να προσφέρουν βοήθεια. Αλλά, η διαδικασία αποκατάστασης απαιτεί επίσης μια εσωτερική αναγνώριση του προβλήματος από τον ίδιο τον παίκτη. Συχνά, η συνειδητοποίηση ότι η τύχη δεν μπορεί να ελέγξει τις αποφάσεις τους είναι το πρώτο βήμα προς την ανάρρωση.</p>
<p>Η ψυχολογία του τζόγου δίνει έμφαση στη σημασία της εκπαίδευσης και της ενημέρωσης σχετικά με τους κινδύνους του τζόγου. Οι οργανισμοί που ασχολούνται με την αποκατάσταση των εθισμένων προτείνουν εκπαιδευτικά προγράμματα για να βοηθήσουν τους ανθρώπους να κατανοήσουν τις ψυχολογικές δυναμικές που επηρεάζουν τη συμπεριφορά τους και να αναπτύξουν υγιείς στρατηγικές διαχείρισης.</p>
<p><img decoding="async" src="https://media.istockphoto.com/id/2230972371/photo/roulette-wheel-with-ball-on-number-eight-casino-concept.jpg?s=612x612&amp;w=0&amp;k=20&amp;c=JwWcHdVigVmvZ4QDUXNsFtTgATwESGZre-tqXcTkQqg=" alt=""></p>
<h3>Η εμπειρία του Manekispin</h3>
<p>Η πλατφόρμα Manekispin παρέχει μια μοναδική εμπειρία στον κόσμο του διαδικτυακού τζόγου. Με πάνω από 6.000 παιχνίδια και ασφαλείς διαδικασίες χρηματοδότησης, οι παίκτες μπορούν να απολαύσουν την ψυχαγωγία του καζίνο από την άνεση του σπιτιού τους. Η ευρεία γκάμα παιχνιδιών, συμπεριλαμβανομένων των κουλοχέρηδων και των παιχνιδιών live, προσφέρει ποικιλία και διασκέδαση για όλους τους παίκτες, ανεξαρτήτως επιπέδου εμπειρίας.</p>
<p>Η υποστήριξη που προσφέρει το Manekispin στους νέους και τους έμπειρους παίκτες είναι καθοριστική. Η πλατφόρμα επικεντρώνεται στην ασφάλεια και την άνεση των χρηστών, εξασφαλίζοντας ότι όλοι οι παίκτες μπορούν να συμμετάσχουν με σιγουριά. Με πολλές μοναδικές προσφορές καλωσορίσματος, το Manekispin ενθαρρύνει τους παίκτες να εξερευνήσουν και να απολαύσουν τις δυνατότητές του.</p>
<p>Εξερευνώντας τον κόσμο του Manekispin, οι παίκτες έχουν την ευκαιρία να συμμετάσχουν σε έναν συναρπαστικό κόσμο τζόγου, όπου η ψυχολογία και η τύχη παίζουν καθοριστικό ρόλο στην εμπειρία τους. Η πλατφόρμα όχι μόνο προσφέρει διασκέδαση, αλλά προάγει και τη συνειδητοποίηση των ψυχολογικών παραμέτρων του τζόγου, ενισχύοντας έτσι μια πιο υπεύθυνη προσέγγιση στον τζόγο.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://biztip.ninja/2026/04/17/the-psychology-of-gambling-how-luck-affects-us/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Einführung in die faszinierende Welt der Casinos für Anfänger</title>
		<link>https://biztip.ninja/2026/04/17/einfuhrung-in-die-faszinierende-welt-der-casinos/</link>
					<comments>https://biztip.ninja/2026/04/17/einfuhrung-in-die-faszinierende-welt-der-casinos/#respond</comments>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Fri, 17 Apr 2026 17:32:15 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1315383</guid>

					<description><![CDATA[Einführung in die faszinierende Welt der Casinos für Anfänger Was sind Casinos und wie funktionieren sie? Casinos sind Einrichtungen, die eine Vielzahl von Glücksspielen anbieten. Sie sind Orte, an denen...]]></description>
										<content:encoded><![CDATA[<p>Einführung in die faszinierende Welt der Casinos für Anfänger</p>
<h3>Was sind Casinos und wie funktionieren sie?</h3>
<p>Casinos sind Einrichtungen, die eine Vielzahl von Glücksspielen anbieten. Sie sind Orte, an denen Spieler auf verschiedene Spiele setzen können, um Geld zu gewinnen. Zu den bekanntesten Spielen gehören Spielautomaten, Roulette, Blackjack und Poker. Ein gutes Beispiel für eine interessante Plattform ist <a href="https://manekispin.co.at/">Manekispins casino Bewertung</a>, die Spielern aufregende Möglichkeiten bietet. Casinos bieten ein aufregendes Ambiente, oft begleitet von Unterhaltung, Restaurants und Bars, die dazu beitragen, den Besuch zu einem unvergesslichen Erlebnis zu machen.</p>
<p><img decoding="async" src="https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSY4wzv1WN868EoIHe-ZJ7Bu1ggxRGOJRWbpA&amp;s" alt=""></p>
<p>Die Funktionsweise eines Casinos basiert auf dem Konzept des &#8220;Hauses&#8221;, das einen bestimmten Vorteil in jedem Spiel hat. Dies bedeutet, dass auf lange Sicht das Casino tendenziell Gewinn macht, während die Spieler kurzfristig gewinnen oder verlieren können. Der Zufall spielt eine entscheidende Rolle, und viele Spieler versuchen, Strategien zu entwickeln, um ihre Gewinnchancen zu maximieren.</p>
<p>Casinos nutzen auch verschiedene Marketingstrategien, um Spieler zu gewinnen, darunter Bonusangebote und Treueprogramme. Diese Anreize sollen Spieler ermutigen, mehr Zeit und Geld im Casino zu verbringen. Das Verständnis dieser Mechanismen kann Anfängern helfen, informierte Entscheidungen zu treffen und ihr Erlebnis zu optimieren.</p>
<h3>Die verschiedenen Spielarten in Casinos</h3>
<p>Die Vielfalt der Spiele in Casinos ist beeindruckend und reicht von traditionellen Tischspielen bis zu modernen Spielautomaten. Spielautomaten sind besonders beliebt, da sie einfach zu spielen sind und eine Vielzahl von Themen und Jackpot-Möglichkeiten bieten. Spieler setzen Geld und drücken einen Knopf oder ziehen einen Hebel, um die Walzen zu drehen. Die Kombination der Symbole bestimmt den Gewinn.</p>
<p>Tischspiele wie Blackjack und Roulette bieten mehr strategische Elemente. Bei Blackjack müssen die Spieler entscheiden, ob sie Karten ziehen oder stehenbleiben, um 21 Punkte zu erreichen, ohne diesen Wert zu überschreiten. Roulette hingegen dreht sich alles um Glück und das Setzen auf die Zahl oder Farbe, auf die die Kugel fallen wird.</p>
<p>Poker ist ein weiteres sehr beliebtes Spiel in Casinos, das viel Geschick und Psychologie erfordert. Verschiedene Varianten, wie Texas Hold&#8217;em oder Omaha, sind sowohl in physischen Casinos als auch online weit verbreitet. Die Interaktion mit anderen Spielern und die Möglichkeit, strategisch zu denken, machen Poker zu einem besonderen Erlebnis.</p>
<h3>Sicherheit und Fairness in Casinos</h3>
<p>Sicherheit ist ein zentrales Anliegen in jedem Casino, sei es vor Ort oder online. Physische Casinos setzen Sicherheitsmaßnahmen wie Überwachungskameras und geschultes Personal ein, um Betrug und andere illegale Aktivitäten zu verhindern. Online-Casinos verwenden technische Maßnahmen wie SSL-Verschlüsselung, um die persönlichen und finanziellen Daten der Spieler zu schützen.</p>
<p>Fairness ist ebenfalls wichtig, da Casinos sicherstellen müssen, dass ihre Spiele tatsächlich dem Zufall unterliegen. Dies geschieht oft durch externe Prüfungen von unabhängigen Organisationen, die die Zufallszahlengeneratoren testen. Spieler sollten darauf achten, in lizenzierten Casinos zu spielen, da diese strengen Vorschriften unterliegen, die Fairness und Transparenz garantieren.</p>
<p>Zusätzlich zur Sicherheit spielt auch verantwortungsvolles Spielen eine wichtige Rolle. Viele Casinos bieten Ressourcen für Spieler an, die möglicherweise Schwierigkeiten mit Glücksspiel haben. Dazu gehören Selbstbeschränkungen und Informationen zu Beratungsstellen. Spieler sollten sich stets bewusst sein, wie viel Geld sie ausgeben und sicherstellen, dass sie ihre Glücksspielgewohnheiten im Griff haben.</p>
<h3>Die Anziehungskraft von Live-Casino-Spielen</h3>
<p>In den letzten Jahren haben Live-Casino-Spiele enorm an Popularität gewonnen. Diese Spiele kombinieren die Bequemlichkeit des Online-Glücksspiels mit der Atmosphäre eines traditionellen Casinos. Spieler können in Echtzeit gegen echte Dealer spielen, was das Erlebnis authentischer macht. Dank moderner Streaming-Technologie können Spieler bequem von zu Hause aus teilnehmen und dennoch das Gefühl haben, im Casino zu sein.</p>
<p>Live-Casino-Angebote umfassen beliebte Spiele wie Blackjack, Roulette und Baccarat. Die Interaktion mit dem Dealer und anderen Spielern über einen Chat bietet eine soziale Dimension, die in herkömmlichen Online-Spielen fehlt. Diese Spiele sind oft in verschiedenen Limits verfügbar, sodass sowohl Anfänger als auch erfahrene Spieler passende Angebote finden können.</p>
<p>Die Technologie hinter Live-Casinos wird ständig verbessert, um den Spielern ein noch besseres Erlebnis zu bieten. Von hochwertigen Kameras bis hin zu fortschrittlicher Software, die schnelle und reibungslose Abläufe ermöglicht, wird alles dafür getan, die Spielumgebung so realistisch wie möglich zu gestalten. Diese Entwicklung spricht ein breites Publikum an und zieht sowohl neue als auch erfahrene Spieler in die Welt der Live-Casinos.</p>
<p><img decoding="async" src="https://www.trouvillesurmer.org/app/uploads/2025/04/trouville-casino-trouville-machines-a-sous-2.webp" alt=""></p>
<h3>Erfahrungen und Angebote bei Manekispin</h3>
<p>Manekispin ist ein modernes Online-Casino, das ein aufregendes Spielerlebnis mit einer Vielzahl von Spielen bietet. Mit über 6.000 Titeln, darunter beliebte Slots und Live-Dealer-Spiele, können Spieler nach Herzenslust auswählen. Die benutzerfreundliche Oberfläche und die einfache Navigation machen es Anfängern leicht, die Welt der Online-Casinos zu erkunden.</p>
<p>Ein attraktives Willkommenspaket von bis zu 1.500 € Bonusguthaben und 250 Freispielen auf ausgewählte Slots sorgt für einen gelungenen Start. Diese Angebote bieten Anfängern die Möglichkeit, die Spiele auszuprobieren, ohne gleich hohe Einsätze tätigen zu müssen. Zudem bietet Manekispin schnelle Auszahlungen, was ein weiterer Vorteil für Spieler ist, die ihre Gewinne schnell genießen möchten.</p>
<p>Die Plattform legt großen Wert auf Kundensupport und Spielerzufriedenheit. Spieler können sich auf ein engagiertes Team verlassen, das bei Fragen und Anliegen zur Verfügung steht. Manekispin ist nicht nur ein Ort für aufregende Spiele, sondern auch ein sicheres und vertrauenswürdiges Umfeld für alle Spieler, die in die faszinierende Welt der Casinos eintauchen möchten.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://biztip.ninja/2026/04/17/einfuhrung-in-die-faszinierende-welt-der-casinos/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Gyakorlati útmutató kezdőknek a szerencsejáték alapjaihoz</title>
		<link>https://biztip.ninja/2026/04/17/gyakorlati-utmutato-kezdknek-a-szerencsejatek-7/</link>
					<comments>https://biztip.ninja/2026/04/17/gyakorlati-utmutato-kezdknek-a-szerencsejatek-7/#respond</comments>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Fri, 17 Apr 2026 16:17:09 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1315323</guid>

					<description><![CDATA[Gyakorlati útmutató kezdőknek a szerencsejáték alapjaihoz A szerencsejáték világának megértése A szerencsejáték egy olyan tevékenység, amelyben a játékosok pénzt vagy értékes tárgyakat tesznek kockára, remélve, hogy nyereményt fognak elérni. Az...]]></description>
										<content:encoded><![CDATA[<p>Gyakorlati útmutató kezdőknek a szerencsejáték alapjaihoz</p>
<h3>A szerencsejáték világának megértése</h3>
<p>A szerencsejáték egy olyan tevékenység, amelyben a játékosok pénzt vagy értékes tárgyakat tesznek kockára, remélve, hogy nyereményt fognak elérni. Az alapja a véletlen, és számos formában létezik, beleértve a kaszinójátékokat, lottót és sportfogadást. A kezdők számára fontos, hogy tisztában legyenek a különböző típusú játékokkal és azok szabályaival, mielőtt belemerülnének a szerencsejáték világába, ahol a <a href="https://spinbosskaszino.com/">Spinboss casino</a> is jelentős szerepet játszik.</p>
<p><img decoding="async" src="&lt;div class=&quot;video-container&quot;&gt;&lt;iframe src=&quot;https://cdn.pixabay.com/video/2022/10/22/136058-764371355_medium.mp4&quot; frameborder=&quot;0&quot; allowfullscreen&gt;&lt;/iframe&gt;&lt;/div&gt;" alt=""></p>
<p>Az online szerencsejáték népszerűsége világszerte növekvő tendenciát mutat. A modern technológia lehetővé teszi, hogy az emberek otthonuk kényelméből élvezhessék a játékokat. Ennek megfelelően fontos, hogy a játékosok tisztában legyenek a jogi keretekkel és az online kaszinók működésével, hogy elkerüljék a csalásokat és a problémás helyzeteket, amelyek a gambling területén előfordulhatnak.</p>
<h3>A felelősségteljes játék fontossága</h3>
<p>A felelősségteljes játék alapvető elvárás minden szerencsejátékos számára. A játék célja elsősorban a szórakozás, és nem szabad pénzügyi problémákhoz vezetnie. A játékosoknak tisztában kell lenniük a költségeikkel és a határaikkal, hogy elkerüljék a túlzott játéknak köszönhető stresszt és szorongást.</p>
<p>A felelősségteljes játék gyakorlása érdekében javasolt, hogy a játékosok előre meghatározzák, mennyit hajlandóak költeni, és ezt a keretet tartsák be. Emellett érdemes tájékozódni a különböző önkorlátozási lehetőségekről, amelyeket sok online kaszinó kínál a problémás játékosok védelmére.</p>
<h3>Különböző játékformák és szabályaik</h3>
<p>A szerencsejáték különböző formákat ölt, mindegyik saját szabályrendszerével. A legnépszerűbb játékformák közé tartoznak a nyerőgépek, a póker, a blackjack és a rulett. Míg a nyerőgépek a véletlenen alapulnak, addig a pókerben és a blackjackban a stratégia és a készségek is jelentős szerepet játszanak.</p>
<p>A kezdőknek javasolt, hogy kezdetben olyan játékokat válasszanak, amelyek egyszerűbb szabályokkal rendelkeznek, mint például a nyerőgépek. Ezzel együtt fontos, hogy a játékosok ismerkedjenek meg a bonyolultabb játékok, például a póker alapjaival is, ha szeretnének mélyebb szintre lépni a szerencsejáték terén.</p>
<h3>A bónuszok és promóciók kihasználása</h3>
<p>A legtöbb online kaszinó, például a SpinBoss, különféle bónuszokat és promóciókat kínál az új és meglévő játékosok számára. Ezek a bónuszok lehetnek üdvözlő bónuszok, ingyenes pörgetések vagy különféle hűségprogramok. Az ilyen ajánlatok kihasználása jelentős előnyöket nyújthat a játékosok számára, hiszen extra játékidőt és lehetőségeket biztosítanak.</p>
<p>A bónuszok és promóciók feltételeit mindig alaposan át kell nézni, mivel ezek gyakran tartalmaznak fogadási követelményeket. A kezdőknek érdemes tüzetesen áttanulmányozni ezeket, hogy tisztában legyenek a játék lehetőségeikkel és a potenciális nyereményekkel.</p>
<p><img decoding="async" src="https://images.delfi.ee/media-api-image-cropper/v1/c93d0020-c409-11eb-a6db-87be8d46599b.jpg?noup&amp;w=1200&amp;h=711&amp;ch=0.9585&amp;cw=1&amp;cx=0&amp;cy=0&amp;r=16:9" alt=""></p>
<h3>A SpinBoss kaszinó bemutatása</h3>
<p>A SpinBoss egy modern online kaszinó, amely több mint 6000 izgalmas játékkal várja a magyar játékosokat. A platform könnyen navigálható és biztonságos, lehetővé téve a felhasználók számára, hogy zökkenőmentesen élvezzék a játékmenetet. Az üdvözlő bónusz, amely akár 300%-os is lehet, különösen vonzó lehet a kezdők számára.</p>
<p>A SpinBoss nemcsak változatos játékkínálatával, hanem segítőkész ügyfélszolgálatával is kiemelkedik, amely gyors válaszokat ad a felmerülő kérdésekre. A kaszinó célja, hogy a játékosok számára egy biztonságos és szórakoztató élményt nyújtson, így ideális választás mindazok számára, akik most ismerkednek a szerencsejáték világával.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://biztip.ninja/2026/04/17/gyakorlati-utmutato-kezdknek-a-szerencsejatek-7/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Unlocking the Secrets of Casino Games A Beginner&#x27;s Guide</title>
		<link>https://biztip.ninja/2026/04/17/unlocking-the-secrets-of-casino-games-a-beginner-2/</link>
					<comments>https://biztip.ninja/2026/04/17/unlocking-the-secrets-of-casino-games-a-beginner-2/#respond</comments>
		
		<dc:creator><![CDATA[mountainman]]></dc:creator>
		<pubDate>Fri, 17 Apr 2026 16:04:23 +0000</pubDate>
				<category><![CDATA[Public]]></category>
		<guid isPermaLink="false">https://biztip.ninja/?p=1315207</guid>

					<description><![CDATA[Unlocking the Secrets of Casino Games A Beginner&#x27;s Guide Understanding Casino Games Casino games have captivated players for centuries, providing a blend of excitement, strategy, and luck. At their core,...]]></description>
										<content:encoded><![CDATA[<p>Unlocking the Secrets of Casino Games A Beginner&#x27;s Guide</p>
<h3>Understanding Casino Games</h3>
<p>Casino games have captivated players for centuries, providing a blend of excitement, strategy, and luck. At their core, these games are designed to entertain, but they also offer an opportunity to win money. The most common types of games found in casinos include table games like blackjack and poker, slot machines, and specialty games such as bingo and keno. Each game has its own rules, odds, and strategies, making it essential for beginners to familiarize themselves with the options available. For example, exploring different strategies can be beneficial, much like researching <a href="https://ypel.com.pk/">quotex</a> to gain insights into successful trading.</p>
<p><img decoding="async" src="https://t3.ftcdn.net/jpg/05/97/10/52/240_F_597105282_oLKJBwgWj6n0d7lg2l8eqSdeSfSTvVZ3.jpg" alt=""></p>
<p>In addition to the various types of games, understanding the house edge is crucial for any player. The house edge refers to the percentage of each bet that the casino expects to keep over the long term. This advantage varies between different games, so knowing the odds can help players make informed decisions about where to place their bets and how to manage their bankroll effectively.</p>
<h3>The Psychology Behind Gambling</h3>
<p>The psychological aspects of gambling play a significant role in how players approach casino games. Many individuals are drawn to the thrill of risk-taking and the potential for substantial rewards. The rush of winning can create a powerful emotional response, often leading players to return for more. However, it&#8217;s essential to recognize that this excitement can sometimes lead to problematic gambling behavior, especially for beginners who may not fully grasp the risks involved.</p>
<p>The concept of &#8220;loss aversion&#8221; is particularly relevant in the context of gambling. This psychological phenomenon describes how people tend to prefer avoiding losses over acquiring equivalent gains. As a result, players might chase losses, believing that they can recover their money with just one more bet. Understanding these psychological triggers can empower beginners to gamble responsibly and enjoy the experience without falling into unhealthy patterns.</p>
<h3>Strategies for Success</h3>
<p>Developing effective strategies is vital for anyone looking to succeed in casino games. While luck plays a significant role, skillful gameplay can enhance a player&#8217;s chances of winning. For instance, in games like blackjack, players can employ strategies such as card counting or learning basic betting techniques to increase their odds. In poker, understanding the psychology of opponents and mastering bluffing can be game-changers.</p>
<p>Additionally, bankroll management is a key strategy for maintaining a positive gambling experience. Establishing a budget and sticking to it is crucial for preventing overspending. Many experienced players advise setting win and loss limits, which help in making rational decisions about when to walk away from the table. By combining skillful gameplay with sound money management, beginners can significantly improve their chances of success.</p>
<h3>Choosing the Right Casino Game</h3>
<p>With a plethora of options available, choosing the right casino game can be overwhelming for beginners. It&#8217;s important to consider personal interests and comfort levels with risk. For instance, some players may prefer the fast-paced nature of slot machines, while others might enjoy the strategic depth of poker or blackjack. Understanding personal preferences can lead to a more enjoyable gaming experience.</p>
<p>Moreover, many casinos offer free play options or low-stakes tables, providing a risk-free way to explore different games. Taking advantage of these opportunities allows beginners to learn the rules and develop their skills without the pressure of losing significant amounts of money. Experimenting with various games can also help players discover their favorites and refine their strategies over time.</p>
<p><img decoding="async" src="https://media.gettyimages.com/id/102284502/photo/close-up-of-blackjack-in-casino.jpg?s=612x612&amp;w=0&amp;k=20&amp;c=AfUE1YVyu3rSkKn3FzKt_hMxmSA5WZ9SuXuS0nTpiZo=" alt=""></p>
<h3>Exploring Resources for Beginners</h3>
<p>For those embarking on their casino gaming journey, various resources can help enhance the experience. Websites and guides dedicated to casino games offer detailed information on rules, strategies, and tips tailored for beginners. These platforms often feature expert analyses, game reviews, and tutorials to help newcomers understand the nuances of each game.</p>
<p>Engaging with online communities can also provide valuable insights. Many players share their experiences, strategies, and advice, creating a supportive environment for beginners. By leveraging these resources, aspiring casino enthusiasts can unlock the secrets of casino games and embark on a thrilling journey into the world of gambling.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://biztip.ninja/2026/04/17/unlocking-the-secrets-of-casino-games-a-beginner-2/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>