4 месяцев назад · 744683614e
--- a/add.js
+++ b/add.js
@@ -1,23 +1,16 @@
 
				 
			
 
				-
			
 
				 <html>
			
 
				-
			
 
				-<body>
			
 
				-
			
 
				-  <script>
			
 
				-    // 创建一个h1元素
			
 
				-    var h1Element = document.createElement("h1");
			
 
				-
			
 
				-    // 设置h1元素的文本内容
			
 
				-    h1Element.textContent = "火元素";
			
 
				-
			
 
				-    // 设置h1元素的颜色为红色
			
 
				-    h1Element.style.color = "red";
			
 
				-
			
 
				-    // 将h1元素添加到body元素中（你也可以选择添加到其他合适的父元素里）
			
 
				-    document.body.appendChild(h1Element);
			
 
				-  </script>
			
 
				-
			
 
				-</body>
			
 
				-
			
 
				+  <head>
			
 
				+    <meta charset="utf-8" />
			
 
				+    <title>ECharts</title>
			
 
				+   
			
 
				+    <script src="echarts.js"></script>
			
 
				+  </head>
			
 
				+  <body>
			
 
				+    
			
 
				+    <div id="main" style="width: 600px;height:400px;"></div>
			
 
				+    <script type="text/javascript">
			
 
				+     
			
 
				+    </script>
			
 
				+  </body>
			
 
				 </html>
			
--- a/node_modules/.package-lock.json
+++ b/node_modules/.package-lock.json
@@ -14,6 +14,25 @@
 
				         "zrender": "5.6.0"
			
 
				       }
			
 
				     },
			
 
				+    "node_modules/swiper": {
			
 
				+      "version": "11.1.15",
			
 
				+      "resolved": "https://registry.npmmirror.com/swiper/-/swiper-11.1.15.tgz",
			
 
				+      "integrity": "sha512-IzWeU34WwC7gbhjKsjkImTuCRf+lRbO6cnxMGs88iVNKDwV+xQpBCJxZ4bNH6gSrIbbyVJ1kuGzo3JTtz//CBw==",
			
 
				+      "funding": [
			
 
				+        {
			
 
				+          "type": "patreon",
			
 
				+          "url": "https://www.patreon.com/swiperjs"
			
 
				+        },
			
 
				+        {
			
 
				+          "type": "open_collective",
			
 
				+          "url": "http://opencollective.com/swiper"
			
 
				+        }
			
 
				+      ],
			
 
				+      "license": "MIT",
			
 
				+      "engines": {
			
 
				+        "node": ">= 4.7.0"
			
 
				+      }
			
 
				+    },
			
 
				     "node_modules/tslib": {
			
 
				       "version": "2.3.0",
			
 
				       "resolved": "https://registry.npmmirror.com/tslib/-/tslib-2.3.0.tgz",
			
--- a/node_modules/swiper/LICENSE
+++ b/node_modules/swiper/LICENSE
@@ -0,0 +1,20 @@
 
				+The MIT License (MIT)
			
 
				+
			
 
				+Copyright (c) 2019 Vladimir Kharlampidi
			
 
				+
			
 
				+Permission is hereby granted, free of charge, to any person obtaining a copy of
			
 
				+this software and associated documentation files (the "Software"), to deal in
			
 
				+the Software without restriction, including without limitation the rights to
			
 
				+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
			
 
				+the Software, and to permit persons to whom the Software is furnished to do so,
			
 
				+subject to the following conditions:
			
 
				+
			
 
				+The above copyright notice and this permission notice shall be included in all
			
 
				+copies or substantial portions of the Software.
			
 
				+
			
 
				+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
			
 
				+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
			
 
				+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
			
 
				+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
			
 
				+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
			
 
				+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
			
--- a/node_modules/swiper/README.md
+++ b/node_modules/swiper/README.md
@@ -0,0 +1,11 @@
 
				+Swiper
			
 
				+==========
			
 
				+
			
 
				+Swiper - is the free and most modern mobile touch slider with hardware accelerated transitions and amazing native behavior. It is intended to be used in mobile websites, mobile web apps, and mobile native/hybrid apps.
			
 
				+
			
 
				+Swiper is not compatible with all platforms, it is a modern touch slider which is focused only on modern apps/platforms to bring the best experience and simplicity.
			
 
				+
			
 
				+# Getting Started
			
 
				+  * [Getting Started Guide](https://swiperjs.com/get-started/)
			
 
				+  * [API](https://swiperjs.com/swiper-api/)
			
 
				+  * [Demos](https://swiperjs.com/demos/)
			
--- a/node_modules/swiper/modules/a11y-element.css
+++ b/node_modules/swiper/modules/a11y-element.css
@@ -0,0 +1,9 @@
 
				+/* a11y */
			
 
				+.swiper .swiper-notification {
			
 
				+  position: absolute;
			
 
				+  left: 0;
			
 
				+  top: 0;
			
 
				+  pointer-events: none;
			
 
				+  opacity: 0;
			
 
				+  z-index: -1000;
			
 
				+}
			
--- a/node_modules/swiper/modules/a11y-element.min.css
+++ b/node_modules/swiper/modules/a11y-element.min.css
@@ -0,0 +1 @@
 
				+.swiper .swiper-notification{position:absolute;left:0;top:0;pointer-events:none;opacity:0;z-index:-1000}
			
--- a/node_modules/swiper/modules/a11y.css
+++ b/node_modules/swiper/modules/a11y.css
@@ -0,0 +1,9 @@
 
				+/* a11y */
			
 
				+.swiper .swiper-notification {
			
 
				+  position: absolute;
			
 
				+  left: 0;
			
 
				+  top: 0;
			
 
				+  pointer-events: none;
			
 
				+  opacity: 0;
			
 
				+  z-index: -1000;
			
 
				+}
			
--- a/node_modules/swiper/modules/a11y.less
+++ b/node_modules/swiper/modules/a11y.less
@@ -0,0 +1,9 @@
 
				+/* a11y */
			
 
				+.swiper .swiper-notification {
			
 
				+  position: absolute;
			
 
				+  left: 0;
			
 
				+  top: 0;
			
 
				+  pointer-events: none;
			
 
				+  opacity: 0;
			
 
				+  z-index: -1000;
			
 
				+}
			
--- a/node_modules/swiper/modules/a11y.min.css
+++ b/node_modules/swiper/modules/a11y.min.css
@@ -0,0 +1 @@
 
				+.swiper .swiper-notification{position:absolute;left:0;top:0;pointer-events:none;opacity:0;z-index:-1000}
			
--- a/node_modules/swiper/modules/a11y.min.mjs
+++ b/node_modules/swiper/modules/a11y.min.mjs
--- a/node_modules/swiper/modules/a11y.min.mjs.map
+++ b/node_modules/swiper/modules/a11y.min.mjs.map
--- a/node_modules/swiper/modules/a11y.mjs
+++ b/node_modules/swiper/modules/a11y.mjs
@@ -0,0 +1,378 @@
 
				+import { g as getDocument } from '../shared/ssr-window.esm.mjs';
			
 
				+import { c as classesToSelector } from '../shared/classes-to-selector.mjs';
			
 
				+import { c as createElement, h as elementIndex, m as makeElementsArray } from '../shared/utils.mjs';
			
 
				+
			
 
				+function A11y(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    on
			
 
				+  } = _ref;
			
 
				+  extendParams({
			
 
				+    a11y: {
			
 
				+      enabled: true,
			
 
				+      notificationClass: 'swiper-notification',
			
 
				+      prevSlideMessage: 'Previous slide',
			
 
				+      nextSlideMessage: 'Next slide',
			
 
				+      firstSlideMessage: 'This is the first slide',
			
 
				+      lastSlideMessage: 'This is the last slide',
			
 
				+      paginationBulletMessage: 'Go to slide {{index}}',
			
 
				+      slideLabelMessage: '{{index}} / {{slidesLength}}',
			
 
				+      containerMessage: null,
			
 
				+      containerRoleDescriptionMessage: null,
			
 
				+      containerRole: null,
			
 
				+      itemRoleDescriptionMessage: null,
			
 
				+      slideRole: 'group',
			
 
				+      id: null,
			
 
				+      scrollOnFocus: true
			
 
				+    }
			
 
				+  });
			
 
				+  swiper.a11y = {
			
 
				+    clicked: false
			
 
				+  };
			
 
				+  let liveRegion = null;
			
 
				+  let preventFocusHandler;
			
 
				+  let focusTargetSlideEl;
			
 
				+  let visibilityChangedTimestamp = new Date().getTime();
			
 
				+  function notify(message) {
			
 
				+    const notification = liveRegion;
			
 
				+    if (notification.length === 0) return;
			
 
				+    notification.innerHTML = '';
			
 
				+    notification.innerHTML = message;
			
 
				+  }
			
 
				+  function getRandomNumber(size) {
			
 
				+    if (size === void 0) {
			
 
				+      size = 16;
			
 
				+    }
			
 
				+    const randomChar = () => Math.round(16 * Math.random()).toString(16);
			
 
				+    return 'x'.repeat(size).replace(/x/g, randomChar);
			
 
				+  }
			
 
				+  function makeElFocusable(el) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('tabIndex', '0');
			
 
				+    });
			
 
				+  }
			
 
				+  function makeElNotFocusable(el) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('tabIndex', '-1');
			
 
				+    });
			
 
				+  }
			
 
				+  function addElRole(el, role) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('role', role);
			
 
				+    });
			
 
				+  }
			
 
				+  function addElRoleDescription(el, description) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('aria-roledescription', description);
			
 
				+    });
			
 
				+  }
			
 
				+  function addElControls(el, controls) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('aria-controls', controls);
			
 
				+    });
			
 
				+  }
			
 
				+  function addElLabel(el, label) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('aria-label', label);
			
 
				+    });
			
 
				+  }
			
 
				+  function addElId(el, id) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('id', id);
			
 
				+    });
			
 
				+  }
			
 
				+  function addElLive(el, live) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('aria-live', live);
			
 
				+    });
			
 
				+  }
			
 
				+  function disableEl(el) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('aria-disabled', true);
			
 
				+    });
			
 
				+  }
			
 
				+  function enableEl(el) {
			
 
				+    el = makeElementsArray(el);
			
 
				+    el.forEach(subEl => {
			
 
				+      subEl.setAttribute('aria-disabled', false);
			
 
				+    });
			
 
				+  }
			
 
				+  function onEnterOrSpaceKey(e) {
			
 
				+    if (e.keyCode !== 13 && e.keyCode !== 32) return;
			
 
				+    const params = swiper.params.a11y;
			
 
				+    const targetEl = e.target;
			
 
				+    if (swiper.pagination && swiper.pagination.el && (targetEl === swiper.pagination.el || swiper.pagination.el.contains(e.target))) {
			
 
				+      if (!e.target.matches(classesToSelector(swiper.params.pagination.bulletClass))) return;
			
 
				+    }
			
 
				+    if (swiper.navigation && swiper.navigation.prevEl && swiper.navigation.nextEl) {
			
 
				+      const prevEls = makeElementsArray(swiper.navigation.prevEl);
			
 
				+      const nextEls = makeElementsArray(swiper.navigation.nextEl);
			
 
				+      if (nextEls.includes(targetEl)) {
			
 
				+        if (!(swiper.isEnd && !swiper.params.loop)) {
			
 
				+          swiper.slideNext();
			
 
				+        }
			
 
				+        if (swiper.isEnd) {
			
 
				+          notify(params.lastSlideMessage);
			
 
				+        } else {
			
 
				+          notify(params.nextSlideMessage);
			
 
				+        }
			
 
				+      }
			
 
				+      if (prevEls.includes(targetEl)) {
			
 
				+        if (!(swiper.isBeginning && !swiper.params.loop)) {
			
 
				+          swiper.slidePrev();
			
 
				+        }
			
 
				+        if (swiper.isBeginning) {
			
 
				+          notify(params.firstSlideMessage);
			
 
				+        } else {
			
 
				+          notify(params.prevSlideMessage);
			
 
				+        }
			
 
				+      }
			
 
				+    }
			
 
				+    if (swiper.pagination && targetEl.matches(classesToSelector(swiper.params.pagination.bulletClass))) {
			
 
				+      targetEl.click();
			
 
				+    }
			
 
				+  }
			
 
				+  function updateNavigation() {
			
 
				+    if (swiper.params.loop || swiper.params.rewind || !swiper.navigation) return;
			
 
				+    const {
			
 
				+      nextEl,
			
 
				+      prevEl
			
 
				+    } = swiper.navigation;
			
 
				+    if (prevEl) {
			
 
				+      if (swiper.isBeginning) {
			
 
				+        disableEl(prevEl);
			
 
				+        makeElNotFocusable(prevEl);
			
 
				+      } else {
			
 
				+        enableEl(prevEl);
			
 
				+        makeElFocusable(prevEl);
			
 
				+      }
			
 
				+    }
			
 
				+    if (nextEl) {
			
 
				+      if (swiper.isEnd) {
			
 
				+        disableEl(nextEl);
			
 
				+        makeElNotFocusable(nextEl);
			
 
				+      } else {
			
 
				+        enableEl(nextEl);
			
 
				+        makeElFocusable(nextEl);
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+  function hasPagination() {
			
 
				+    return swiper.pagination && swiper.pagination.bullets && swiper.pagination.bullets.length;
			
 
				+  }
			
 
				+  function hasClickablePagination() {
			
 
				+    return hasPagination() && swiper.params.pagination.clickable;
			
 
				+  }
			
 
				+  function updatePagination() {
			
 
				+    const params = swiper.params.a11y;
			
 
				+    if (!hasPagination()) return;
			
 
				+    swiper.pagination.bullets.forEach(bulletEl => {
			
 
				+      if (swiper.params.pagination.clickable) {
			
 
				+        makeElFocusable(bulletEl);
			
 
				+        if (!swiper.params.pagination.renderBullet) {
			
 
				+          addElRole(bulletEl, 'button');
			
 
				+          addElLabel(bulletEl, params.paginationBulletMessage.replace(/\{\{index\}\}/, elementIndex(bulletEl) + 1));
			
 
				+        }
			
 
				+      }
			
 
				+      if (bulletEl.matches(classesToSelector(swiper.params.pagination.bulletActiveClass))) {
			
 
				+        bulletEl.setAttribute('aria-current', 'true');
			
 
				+      } else {
			
 
				+        bulletEl.removeAttribute('aria-current');
			
 
				+      }
			
 
				+    });
			
 
				+  }
			
 
				+  const initNavEl = (el, wrapperId, message) => {
			
 
				+    makeElFocusable(el);
			
 
				+    if (el.tagName !== 'BUTTON') {
			
 
				+      addElRole(el, 'button');
			
 
				+      el.addEventListener('keydown', onEnterOrSpaceKey);
			
 
				+    }
			
 
				+    addElLabel(el, message);
			
 
				+    addElControls(el, wrapperId);
			
 
				+  };
			
 
				+  const handlePointerDown = e => {
			
 
				+    if (focusTargetSlideEl && focusTargetSlideEl !== e.target && !focusTargetSlideEl.contains(e.target)) {
			
 
				+      preventFocusHandler = true;
			
 
				+    }
			
 
				+    swiper.a11y.clicked = true;
			
 
				+  };
			
 
				+  const handlePointerUp = () => {
			
 
				+    preventFocusHandler = false;
			
 
				+    requestAnimationFrame(() => {
			
 
				+      requestAnimationFrame(() => {
			
 
				+        if (!swiper.destroyed) {
			
 
				+          swiper.a11y.clicked = false;
			
 
				+        }
			
 
				+      });
			
 
				+    });
			
 
				+  };
			
 
				+  const onVisibilityChange = e => {
			
 
				+    visibilityChangedTimestamp = new Date().getTime();
			
 
				+  };
			
 
				+  const handleFocus = e => {
			
 
				+    if (swiper.a11y.clicked || !swiper.params.a11y.scrollOnFocus) return;
			
 
				+    if (new Date().getTime() - visibilityChangedTimestamp < 100) return;
			
 
				+    const slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);
			
 
				+    if (!slideEl || !swiper.slides.includes(slideEl)) return;
			
 
				+    focusTargetSlideEl = slideEl;
			
 
				+    const isActive = swiper.slides.indexOf(slideEl) === swiper.activeIndex;
			
 
				+    const isVisible = swiper.params.watchSlidesProgress && swiper.visibleSlides && swiper.visibleSlides.includes(slideEl);
			
 
				+    if (isActive || isVisible) return;
			
 
				+    if (e.sourceCapabilities && e.sourceCapabilities.firesTouchEvents) return;
			
 
				+    if (swiper.isHorizontal()) {
			
 
				+      swiper.el.scrollLeft = 0;
			
 
				+    } else {
			
 
				+      swiper.el.scrollTop = 0;
			
 
				+    }
			
 
				+    requestAnimationFrame(() => {
			
 
				+      if (preventFocusHandler) return;
			
 
				+      if (swiper.params.loop) {
			
 
				+        swiper.slideToLoop(parseInt(slideEl.getAttribute('data-swiper-slide-index')), 0);
			
 
				+      } else {
			
 
				+        swiper.slideTo(swiper.slides.indexOf(slideEl), 0);
			
 
				+      }
			
 
				+      preventFocusHandler = false;
			
 
				+    });
			
 
				+  };
			
 
				+  const initSlides = () => {
			
 
				+    const params = swiper.params.a11y;
			
 
				+    if (params.itemRoleDescriptionMessage) {
			
 
				+      addElRoleDescription(swiper.slides, params.itemRoleDescriptionMessage);
			
 
				+    }
			
 
				+    if (params.slideRole) {
			
 
				+      addElRole(swiper.slides, params.slideRole);
			
 
				+    }
			
 
				+    const slidesLength = swiper.slides.length;
			
 
				+    if (params.slideLabelMessage) {
			
 
				+      swiper.slides.forEach((slideEl, index) => {
			
 
				+        const slideIndex = swiper.params.loop ? parseInt(slideEl.getAttribute('data-swiper-slide-index'), 10) : index;
			
 
				+        const ariaLabelMessage = params.slideLabelMessage.replace(/\{\{index\}\}/, slideIndex + 1).replace(/\{\{slidesLength\}\}/, slidesLength);
			
 
				+        addElLabel(slideEl, ariaLabelMessage);
			
 
				+      });
			
 
				+    }
			
 
				+  };
			
 
				+  const init = () => {
			
 
				+    const params = swiper.params.a11y;
			
 
				+    swiper.el.append(liveRegion);
			
 
				+
			
 
				+    // Container
			
 
				+    const containerEl = swiper.el;
			
 
				+    if (params.containerRoleDescriptionMessage) {
			
 
				+      addElRoleDescription(containerEl, params.containerRoleDescriptionMessage);
			
 
				+    }
			
 
				+    if (params.containerMessage) {
			
 
				+      addElLabel(containerEl, params.containerMessage);
			
 
				+    }
			
 
				+    if (params.containerRole) {
			
 
				+      addElRole(containerEl, params.containerRole);
			
 
				+    }
			
 
				+
			
 
				+    // Wrapper
			
 
				+    const wrapperEl = swiper.wrapperEl;
			
 
				+    const wrapperId = params.id || wrapperEl.getAttribute('id') || `swiper-wrapper-${getRandomNumber(16)}`;
			
 
				+    const live = swiper.params.autoplay && swiper.params.autoplay.enabled ? 'off' : 'polite';
			
 
				+    addElId(wrapperEl, wrapperId);
			
 
				+    addElLive(wrapperEl, live);
			
 
				+
			
 
				+    // Slide
			
 
				+    initSlides();
			
 
				+
			
 
				+    // Navigation
			
 
				+    let {
			
 
				+      nextEl,
			
 
				+      prevEl
			
 
				+    } = swiper.navigation ? swiper.navigation : {};
			
 
				+    nextEl = makeElementsArray(nextEl);
			
 
				+    prevEl = makeElementsArray(prevEl);
			
 
				+    if (nextEl) {
			
 
				+      nextEl.forEach(el => initNavEl(el, wrapperId, params.nextSlideMessage));
			
 
				+    }
			
 
				+    if (prevEl) {
			
 
				+      prevEl.forEach(el => initNavEl(el, wrapperId, params.prevSlideMessage));
			
 
				+    }
			
 
				+
			
 
				+    // Pagination
			
 
				+    if (hasClickablePagination()) {
			
 
				+      const paginationEl = makeElementsArray(swiper.pagination.el);
			
 
				+      paginationEl.forEach(el => {
			
 
				+        el.addEventListener('keydown', onEnterOrSpaceKey);
			
 
				+      });
			
 
				+    }
			
 
				+
			
 
				+    // Tab focus
			
 
				+    const document = getDocument();
			
 
				+    document.addEventListener('visibilitychange', onVisibilityChange);
			
 
				+    swiper.el.addEventListener('focus', handleFocus, true);
			
 
				+    swiper.el.addEventListener('focus', handleFocus, true);
			
 
				+    swiper.el.addEventListener('pointerdown', handlePointerDown, true);
			
 
				+    swiper.el.addEventListener('pointerup', handlePointerUp, true);
			
 
				+  };
			
 
				+  function destroy() {
			
 
				+    if (liveRegion) liveRegion.remove();
			
 
				+    let {
			
 
				+      nextEl,
			
 
				+      prevEl
			
 
				+    } = swiper.navigation ? swiper.navigation : {};
			
 
				+    nextEl = makeElementsArray(nextEl);
			
 
				+    prevEl = makeElementsArray(prevEl);
			
 
				+    if (nextEl) {
			
 
				+      nextEl.forEach(el => el.removeEventListener('keydown', onEnterOrSpaceKey));
			
 
				+    }
			
 
				+    if (prevEl) {
			
 
				+      prevEl.forEach(el => el.removeEventListener('keydown', onEnterOrSpaceKey));
			
 
				+    }
			
 
				+
			
 
				+    // Pagination
			
 
				+    if (hasClickablePagination()) {
			
 
				+      const paginationEl = makeElementsArray(swiper.pagination.el);
			
 
				+      paginationEl.forEach(el => {
			
 
				+        el.removeEventListener('keydown', onEnterOrSpaceKey);
			
 
				+      });
			
 
				+    }
			
 
				+    const document = getDocument();
			
 
				+    document.removeEventListener('visibilitychange', onVisibilityChange);
			
 
				+    // Tab focus
			
 
				+    if (swiper.el && typeof swiper.el !== 'string') {
			
 
				+      swiper.el.removeEventListener('focus', handleFocus, true);
			
 
				+      swiper.el.removeEventListener('pointerdown', handlePointerDown, true);
			
 
				+      swiper.el.removeEventListener('pointerup', handlePointerUp, true);
			
 
				+    }
			
 
				+  }
			
 
				+  on('beforeInit', () => {
			
 
				+    liveRegion = createElement('span', swiper.params.a11y.notificationClass);
			
 
				+    liveRegion.setAttribute('aria-live', 'assertive');
			
 
				+    liveRegion.setAttribute('aria-atomic', 'true');
			
 
				+  });
			
 
				+  on('afterInit', () => {
			
 
				+    if (!swiper.params.a11y.enabled) return;
			
 
				+    init();
			
 
				+  });
			
 
				+  on('slidesLengthChange snapGridLengthChange slidesGridLengthChange', () => {
			
 
				+    if (!swiper.params.a11y.enabled) return;
			
 
				+    initSlides();
			
 
				+  });
			
 
				+  on('fromEdge toEdge afterInit lock unlock', () => {
			
 
				+    if (!swiper.params.a11y.enabled) return;
			
 
				+    updateNavigation();
			
 
				+  });
			
 
				+  on('paginationUpdate', () => {
			
 
				+    if (!swiper.params.a11y.enabled) return;
			
 
				+    updatePagination();
			
 
				+  });
			
 
				+  on('destroy', () => {
			
 
				+    if (!swiper.params.a11y.enabled) return;
			
 
				+    destroy();
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { A11y as default };
			
--- a/node_modules/swiper/modules/a11y.scss
+++ b/node_modules/swiper/modules/a11y.scss
@@ -0,0 +1,9 @@
 
				+/* a11y */
			
 
				+.swiper .swiper-notification {
			
 
				+  position: absolute;
			
 
				+  left: 0;
			
 
				+  top: 0;
			
 
				+  pointer-events: none;
			
 
				+  opacity: 0;
			
 
				+  z-index: -1000;
			
 
				+}
			
--- a/node_modules/swiper/modules/autoplay-element.css
+++ b/node_modules/swiper/modules/autoplay-element.css
--- a/node_modules/swiper/modules/autoplay-element.min.css
+++ b/node_modules/swiper/modules/autoplay-element.min.css
--- a/node_modules/swiper/modules/autoplay.css
+++ b/node_modules/swiper/modules/autoplay.css
--- a/node_modules/swiper/modules/autoplay.less
+++ b/node_modules/swiper/modules/autoplay.less
--- a/node_modules/swiper/modules/autoplay.min.css
+++ b/node_modules/swiper/modules/autoplay.min.css
--- a/node_modules/swiper/modules/autoplay.min.mjs
+++ b/node_modules/swiper/modules/autoplay.min.mjs
--- a/node_modules/swiper/modules/autoplay.min.mjs.map
+++ b/node_modules/swiper/modules/autoplay.min.mjs.map
--- a/node_modules/swiper/modules/autoplay.mjs
+++ b/node_modules/swiper/modules/autoplay.mjs
@@ -0,0 +1,304 @@
 
				+import { g as getDocument } from '../shared/ssr-window.esm.mjs';
			
 
				+
			
 
				+/* eslint no-underscore-dangle: "off" */
			
 
				+/* eslint no-use-before-define: "off" */
			
 
				+function Autoplay(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    on,
			
 
				+    emit,
			
 
				+    params
			
 
				+  } = _ref;
			
 
				+  swiper.autoplay = {
			
 
				+    running: false,
			
 
				+    paused: false,
			
 
				+    timeLeft: 0
			
 
				+  };
			
 
				+  extendParams({
			
 
				+    autoplay: {
			
 
				+      enabled: false,
			
 
				+      delay: 3000,
			
 
				+      waitForTransition: true,
			
 
				+      disableOnInteraction: false,
			
 
				+      stopOnLastSlide: false,
			
 
				+      reverseDirection: false,
			
 
				+      pauseOnMouseEnter: false
			
 
				+    }
			
 
				+  });
			
 
				+  let timeout;
			
 
				+  let raf;
			
 
				+  let autoplayDelayTotal = params && params.autoplay ? params.autoplay.delay : 3000;
			
 
				+  let autoplayDelayCurrent = params && params.autoplay ? params.autoplay.delay : 3000;
			
 
				+  let autoplayTimeLeft;
			
 
				+  let autoplayStartTime = new Date().getTime();
			
 
				+  let wasPaused;
			
 
				+  let isTouched;
			
 
				+  let pausedByTouch;
			
 
				+  let touchStartTimeout;
			
 
				+  let slideChanged;
			
 
				+  let pausedByInteraction;
			
 
				+  let pausedByPointerEnter;
			
 
				+  function onTransitionEnd(e) {
			
 
				+    if (!swiper || swiper.destroyed || !swiper.wrapperEl) return;
			
 
				+    if (e.target !== swiper.wrapperEl) return;
			
 
				+    swiper.wrapperEl.removeEventListener('transitionend', onTransitionEnd);
			
 
				+    if (pausedByPointerEnter || e.detail && e.detail.bySwiperTouchMove) {
			
 
				+      return;
			
 
				+    }
			
 
				+    resume();
			
 
				+  }
			
 
				+  const calcTimeLeft = () => {
			
 
				+    if (swiper.destroyed || !swiper.autoplay.running) return;
			
 
				+    if (swiper.autoplay.paused) {
			
 
				+      wasPaused = true;
			
 
				+    } else if (wasPaused) {
			
 
				+      autoplayDelayCurrent = autoplayTimeLeft;
			
 
				+      wasPaused = false;
			
 
				+    }
			
 
				+    const timeLeft = swiper.autoplay.paused ? autoplayTimeLeft : autoplayStartTime + autoplayDelayCurrent - new Date().getTime();
			
 
				+    swiper.autoplay.timeLeft = timeLeft;
			
 
				+    emit('autoplayTimeLeft', timeLeft, timeLeft / autoplayDelayTotal);
			
 
				+    raf = requestAnimationFrame(() => {
			
 
				+      calcTimeLeft();
			
 
				+    });
			
 
				+  };
			
 
				+  const getSlideDelay = () => {
			
 
				+    let activeSlideEl;
			
 
				+    if (swiper.virtual && swiper.params.virtual.enabled) {
			
 
				+      activeSlideEl = swiper.slides.filter(slideEl => slideEl.classList.contains('swiper-slide-active'))[0];
			
 
				+    } else {
			
 
				+      activeSlideEl = swiper.slides[swiper.activeIndex];
			
 
				+    }
			
 
				+    if (!activeSlideEl) return undefined;
			
 
				+    const currentSlideDelay = parseInt(activeSlideEl.getAttribute('data-swiper-autoplay'), 10);
			
 
				+    return currentSlideDelay;
			
 
				+  };
			
 
				+  const run = delayForce => {
			
 
				+    if (swiper.destroyed || !swiper.autoplay.running) return;
			
 
				+    cancelAnimationFrame(raf);
			
 
				+    calcTimeLeft();
			
 
				+    let delay = typeof delayForce === 'undefined' ? swiper.params.autoplay.delay : delayForce;
			
 
				+    autoplayDelayTotal = swiper.params.autoplay.delay;
			
 
				+    autoplayDelayCurrent = swiper.params.autoplay.delay;
			
 
				+    const currentSlideDelay = getSlideDelay();
			
 
				+    if (!Number.isNaN(currentSlideDelay) && currentSlideDelay > 0 && typeof delayForce === 'undefined') {
			
 
				+      delay = currentSlideDelay;
			
 
				+      autoplayDelayTotal = currentSlideDelay;
			
 
				+      autoplayDelayCurrent = currentSlideDelay;
			
 
				+    }
			
 
				+    autoplayTimeLeft = delay;
			
 
				+    const speed = swiper.params.speed;
			
 
				+    const proceed = () => {
			
 
				+      if (!swiper || swiper.destroyed) return;
			
 
				+      if (swiper.params.autoplay.reverseDirection) {
			
 
				+        if (!swiper.isBeginning || swiper.params.loop || swiper.params.rewind) {
			
 
				+          swiper.slidePrev(speed, true, true);
			
 
				+          emit('autoplay');
			
 
				+        } else if (!swiper.params.autoplay.stopOnLastSlide) {
			
 
				+          swiper.slideTo(swiper.slides.length - 1, speed, true, true);
			
 
				+          emit('autoplay');
			
 
				+        }
			
 
				+      } else {
			
 
				+        if (!swiper.isEnd || swiper.params.loop || swiper.params.rewind) {
			
 
				+          swiper.slideNext(speed, true, true);
			
 
				+          emit('autoplay');
			
 
				+        } else if (!swiper.params.autoplay.stopOnLastSlide) {
			
 
				+          swiper.slideTo(0, speed, true, true);
			
 
				+          emit('autoplay');
			
 
				+        }
			
 
				+      }
			
 
				+      if (swiper.params.cssMode) {
			
 
				+        autoplayStartTime = new Date().getTime();
			
 
				+        requestAnimationFrame(() => {
			
 
				+          run();
			
 
				+        });
			
 
				+      }
			
 
				+    };
			
 
				+    if (delay > 0) {
			
 
				+      clearTimeout(timeout);
			
 
				+      timeout = setTimeout(() => {
			
 
				+        proceed();
			
 
				+      }, delay);
			
 
				+    } else {
			
 
				+      requestAnimationFrame(() => {
			
 
				+        proceed();
			
 
				+      });
			
 
				+    }
			
 
				+
			
 
				+    // eslint-disable-next-line
			
 
				+    return delay;
			
 
				+  };
			
 
				+  const start = () => {
			
 
				+    autoplayStartTime = new Date().getTime();
			
 
				+    swiper.autoplay.running = true;
			
 
				+    run();
			
 
				+    emit('autoplayStart');
			
 
				+  };
			
 
				+  const stop = () => {
			
 
				+    swiper.autoplay.running = false;
			
 
				+    clearTimeout(timeout);
			
 
				+    cancelAnimationFrame(raf);
			
 
				+    emit('autoplayStop');
			
 
				+  };
			
 
				+  const pause = (internal, reset) => {
			
 
				+    if (swiper.destroyed || !swiper.autoplay.running) return;
			
 
				+    clearTimeout(timeout);
			
 
				+    if (!internal) {
			
 
				+      pausedByInteraction = true;
			
 
				+    }
			
 
				+    const proceed = () => {
			
 
				+      emit('autoplayPause');
			
 
				+      if (swiper.params.autoplay.waitForTransition) {
			
 
				+        swiper.wrapperEl.addEventListener('transitionend', onTransitionEnd);
			
 
				+      } else {
			
 
				+        resume();
			
 
				+      }
			
 
				+    };
			
 
				+    swiper.autoplay.paused = true;
			
 
				+    if (reset) {
			
 
				+      if (slideChanged) {
			
 
				+        autoplayTimeLeft = swiper.params.autoplay.delay;
			
 
				+      }
			
 
				+      slideChanged = false;
			
 
				+      proceed();
			
 
				+      return;
			
 
				+    }
			
 
				+    const delay = autoplayTimeLeft || swiper.params.autoplay.delay;
			
 
				+    autoplayTimeLeft = delay - (new Date().getTime() - autoplayStartTime);
			
 
				+    if (swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop) return;
			
 
				+    if (autoplayTimeLeft < 0) autoplayTimeLeft = 0;
			
 
				+    proceed();
			
 
				+  };
			
 
				+  const resume = () => {
			
 
				+    if (swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop || swiper.destroyed || !swiper.autoplay.running) return;
			
 
				+    autoplayStartTime = new Date().getTime();
			
 
				+    if (pausedByInteraction) {
			
 
				+      pausedByInteraction = false;
			
 
				+      run(autoplayTimeLeft);
			
 
				+    } else {
			
 
				+      run();
			
 
				+    }
			
 
				+    swiper.autoplay.paused = false;
			
 
				+    emit('autoplayResume');
			
 
				+  };
			
 
				+  const onVisibilityChange = () => {
			
 
				+    if (swiper.destroyed || !swiper.autoplay.running) return;
			
 
				+    const document = getDocument();
			
 
				+    if (document.visibilityState === 'hidden') {
			
 
				+      pausedByInteraction = true;
			
 
				+      pause(true);
			
 
				+    }
			
 
				+    if (document.visibilityState === 'visible') {
			
 
				+      resume();
			
 
				+    }
			
 
				+  };
			
 
				+  const onPointerEnter = e => {
			
 
				+    if (e.pointerType !== 'mouse') return;
			
 
				+    pausedByInteraction = true;
			
 
				+    pausedByPointerEnter = true;
			
 
				+    if (swiper.animating || swiper.autoplay.paused) return;
			
 
				+    pause(true);
			
 
				+  };
			
 
				+  const onPointerLeave = e => {
			
 
				+    if (e.pointerType !== 'mouse') return;
			
 
				+    pausedByPointerEnter = false;
			
 
				+    if (swiper.autoplay.paused) {
			
 
				+      resume();
			
 
				+    }
			
 
				+  };
			
 
				+  const attachMouseEvents = () => {
			
 
				+    if (swiper.params.autoplay.pauseOnMouseEnter) {
			
 
				+      swiper.el.addEventListener('pointerenter', onPointerEnter);
			
 
				+      swiper.el.addEventListener('pointerleave', onPointerLeave);
			
 
				+    }
			
 
				+  };
			
 
				+  const detachMouseEvents = () => {
			
 
				+    if (swiper.el && typeof swiper.el !== 'string') {
			
 
				+      swiper.el.removeEventListener('pointerenter', onPointerEnter);
			
 
				+      swiper.el.removeEventListener('pointerleave', onPointerLeave);
			
 
				+    }
			
 
				+  };
			
 
				+  const attachDocumentEvents = () => {
			
 
				+    const document = getDocument();
			
 
				+    document.addEventListener('visibilitychange', onVisibilityChange);
			
 
				+  };
			
 
				+  const detachDocumentEvents = () => {
			
 
				+    const document = getDocument();
			
 
				+    document.removeEventListener('visibilitychange', onVisibilityChange);
			
 
				+  };
			
 
				+  on('init', () => {
			
 
				+    if (swiper.params.autoplay.enabled) {
			
 
				+      attachMouseEvents();
			
 
				+      attachDocumentEvents();
			
 
				+      start();
			
 
				+    }
			
 
				+  });
			
 
				+  on('destroy', () => {
			
 
				+    detachMouseEvents();
			
 
				+    detachDocumentEvents();
			
 
				+    if (swiper.autoplay.running) {
			
 
				+      stop();
			
 
				+    }
			
 
				+  });
			
 
				+  on('_freeModeStaticRelease', () => {
			
 
				+    if (pausedByTouch || pausedByInteraction) {
			
 
				+      resume();
			
 
				+    }
			
 
				+  });
			
 
				+  on('_freeModeNoMomentumRelease', () => {
			
 
				+    if (!swiper.params.autoplay.disableOnInteraction) {
			
 
				+      pause(true, true);
			
 
				+    } else {
			
 
				+      stop();
			
 
				+    }
			
 
				+  });
			
 
				+  on('beforeTransitionStart', (_s, speed, internal) => {
			
 
				+    if (swiper.destroyed || !swiper.autoplay.running) return;
			
 
				+    if (internal || !swiper.params.autoplay.disableOnInteraction) {
			
 
				+      pause(true, true);
			
 
				+    } else {
			
 
				+      stop();
			
 
				+    }
			
 
				+  });
			
 
				+  on('sliderFirstMove', () => {
			
 
				+    if (swiper.destroyed || !swiper.autoplay.running) return;
			
 
				+    if (swiper.params.autoplay.disableOnInteraction) {
			
 
				+      stop();
			
 
				+      return;
			
 
				+    }
			
 
				+    isTouched = true;
			
 
				+    pausedByTouch = false;
			
 
				+    pausedByInteraction = false;
			
 
				+    touchStartTimeout = setTimeout(() => {
			
 
				+      pausedByInteraction = true;
			
 
				+      pausedByTouch = true;
			
 
				+      pause(true);
			
 
				+    }, 200);
			
 
				+  });
			
 
				+  on('touchEnd', () => {
			
 
				+    if (swiper.destroyed || !swiper.autoplay.running || !isTouched) return;
			
 
				+    clearTimeout(touchStartTimeout);
			
 
				+    clearTimeout(timeout);
			
 
				+    if (swiper.params.autoplay.disableOnInteraction) {
			
 
				+      pausedByTouch = false;
			
 
				+      isTouched = false;
			
 
				+      return;
			
 
				+    }
			
 
				+    if (pausedByTouch && swiper.params.cssMode) resume();
			
 
				+    pausedByTouch = false;
			
 
				+    isTouched = false;
			
 
				+  });
			
 
				+  on('slideChange', () => {
			
 
				+    if (swiper.destroyed || !swiper.autoplay.running) return;
			
 
				+    slideChanged = true;
			
 
				+  });
			
 
				+  Object.assign(swiper.autoplay, {
			
 
				+    start,
			
 
				+    stop,
			
 
				+    pause,
			
 
				+    resume
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { Autoplay as default };
			
--- a/node_modules/swiper/modules/autoplay.scss
+++ b/node_modules/swiper/modules/autoplay.scss
--- a/node_modules/swiper/modules/controller-element.css
+++ b/node_modules/swiper/modules/controller-element.css
--- a/node_modules/swiper/modules/controller-element.min.css
+++ b/node_modules/swiper/modules/controller-element.min.css
--- a/node_modules/swiper/modules/controller.css
+++ b/node_modules/swiper/modules/controller.css
--- a/node_modules/swiper/modules/controller.less
+++ b/node_modules/swiper/modules/controller.less
--- a/node_modules/swiper/modules/controller.min.css
+++ b/node_modules/swiper/modules/controller.min.css
--- a/node_modules/swiper/modules/controller.min.mjs
+++ b/node_modules/swiper/modules/controller.min.mjs
--- a/node_modules/swiper/modules/controller.min.mjs.map
+++ b/node_modules/swiper/modules/controller.min.mjs.map
--- a/node_modules/swiper/modules/controller.mjs
+++ b/node_modules/swiper/modules/controller.mjs
@@ -0,0 +1,191 @@
 
				+import { n as nextTick, k as elementTransitionEnd } from '../shared/utils.mjs';
			
 
				+
			
 
				+/* eslint no-bitwise: ["error", { "allow": [">>"] }] */
			
 
				+function Controller(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    on
			
 
				+  } = _ref;
			
 
				+  extendParams({
			
 
				+    controller: {
			
 
				+      control: undefined,
			
 
				+      inverse: false,
			
 
				+      by: 'slide' // or 'container'
			
 
				+    }
			
 
				+  });
			
 
				+
			
 
				+  swiper.controller = {
			
 
				+    control: undefined
			
 
				+  };
			
 
				+  function LinearSpline(x, y) {
			
 
				+    const binarySearch = function search() {
			
 
				+      let maxIndex;
			
 
				+      let minIndex;
			
 
				+      let guess;
			
 
				+      return (array, val) => {
			
 
				+        minIndex = -1;
			
 
				+        maxIndex = array.length;
			
 
				+        while (maxIndex - minIndex > 1) {
			
 
				+          guess = maxIndex + minIndex >> 1;
			
 
				+          if (array[guess] <= val) {
			
 
				+            minIndex = guess;
			
 
				+          } else {
			
 
				+            maxIndex = guess;
			
 
				+          }
			
 
				+        }
			
 
				+        return maxIndex;
			
 
				+      };
			
 
				+    }();
			
 
				+    this.x = x;
			
 
				+    this.y = y;
			
 
				+    this.lastIndex = x.length - 1;
			
 
				+    // Given an x value (x2), return the expected y2 value:
			
 
				+    // (x1,y1) is the known point before given value,
			
 
				+    // (x3,y3) is the known point after given value.
			
 
				+    let i1;
			
 
				+    let i3;
			
 
				+    this.interpolate = function interpolate(x2) {
			
 
				+      if (!x2) return 0;
			
 
				+
			
 
				+      // Get the indexes of x1 and x3 (the array indexes before and after given x2):
			
 
				+      i3 = binarySearch(this.x, x2);
			
 
				+      i1 = i3 - 1;
			
 
				+
			
 
				+      // We have our indexes i1 & i3, so we can calculate already:
			
 
				+      // y2 := ((x2−x1) × (y3−y1)) ÷ (x3−x1) + y1
			
 
				+      return (x2 - this.x[i1]) * (this.y[i3] - this.y[i1]) / (this.x[i3] - this.x[i1]) + this.y[i1];
			
 
				+    };
			
 
				+    return this;
			
 
				+  }
			
 
				+  function getInterpolateFunction(c) {
			
 
				+    swiper.controller.spline = swiper.params.loop ? new LinearSpline(swiper.slidesGrid, c.slidesGrid) : new LinearSpline(swiper.snapGrid, c.snapGrid);
			
 
				+  }
			
 
				+  function setTranslate(_t, byController) {
			
 
				+    const controlled = swiper.controller.control;
			
 
				+    let multiplier;
			
 
				+    let controlledTranslate;
			
 
				+    const Swiper = swiper.constructor;
			
 
				+    function setControlledTranslate(c) {
			
 
				+      if (c.destroyed) return;
			
 
				+
			
 
				+      // this will create an Interpolate function based on the snapGrids
			
 
				+      // x is the Grid of the scrolled scroller and y will be the controlled scroller
			
 
				+      // it makes sense to create this only once and recall it for the interpolation
			
 
				+      // the function does a lot of value caching for performance
			
 
				+      const translate = swiper.rtlTranslate ? -swiper.translate : swiper.translate;
			
 
				+      if (swiper.params.controller.by === 'slide') {
			
 
				+        getInterpolateFunction(c);
			
 
				+        // i am not sure why the values have to be multiplicated this way, tried to invert the snapGrid
			
 
				+        // but it did not work out
			
 
				+        controlledTranslate = -swiper.controller.spline.interpolate(-translate);
			
 
				+      }
			
 
				+      if (!controlledTranslate || swiper.params.controller.by === 'container') {
			
 
				+        multiplier = (c.maxTranslate() - c.minTranslate()) / (swiper.maxTranslate() - swiper.minTranslate());
			
 
				+        if (Number.isNaN(multiplier) || !Number.isFinite(multiplier)) {
			
 
				+          multiplier = 1;
			
 
				+        }
			
 
				+        controlledTranslate = (translate - swiper.minTranslate()) * multiplier + c.minTranslate();
			
 
				+      }
			
 
				+      if (swiper.params.controller.inverse) {
			
 
				+        controlledTranslate = c.maxTranslate() - controlledTranslate;
			
 
				+      }
			
 
				+      c.updateProgress(controlledTranslate);
			
 
				+      c.setTranslate(controlledTranslate, swiper);
			
 
				+      c.updateActiveIndex();
			
 
				+      c.updateSlidesClasses();
			
 
				+    }
			
 
				+    if (Array.isArray(controlled)) {
			
 
				+      for (let i = 0; i < controlled.length; i += 1) {
			
 
				+        if (controlled[i] !== byController && controlled[i] instanceof Swiper) {
			
 
				+          setControlledTranslate(controlled[i]);
			
 
				+        }
			
 
				+      }
			
 
				+    } else if (controlled instanceof Swiper && byController !== controlled) {
			
 
				+      setControlledTranslate(controlled);
			
 
				+    }
			
 
				+  }
			
 
				+  function setTransition(duration, byController) {
			
 
				+    const Swiper = swiper.constructor;
			
 
				+    const controlled = swiper.controller.control;
			
 
				+    let i;
			
 
				+    function setControlledTransition(c) {
			
 
				+      if (c.destroyed) return;
			
 
				+      c.setTransition(duration, swiper);
			
 
				+      if (duration !== 0) {
			
 
				+        c.transitionStart();
			
 
				+        if (c.params.autoHeight) {
			
 
				+          nextTick(() => {
			
 
				+            c.updateAutoHeight();
			
 
				+          });
			
 
				+        }
			
 
				+        elementTransitionEnd(c.wrapperEl, () => {
			
 
				+          if (!controlled) return;
			
 
				+          c.transitionEnd();
			
 
				+        });
			
 
				+      }
			
 
				+    }
			
 
				+    if (Array.isArray(controlled)) {
			
 
				+      for (i = 0; i < controlled.length; i += 1) {
			
 
				+        if (controlled[i] !== byController && controlled[i] instanceof Swiper) {
			
 
				+          setControlledTransition(controlled[i]);
			
 
				+        }
			
 
				+      }
			
 
				+    } else if (controlled instanceof Swiper && byController !== controlled) {
			
 
				+      setControlledTransition(controlled);
			
 
				+    }
			
 
				+  }
			
 
				+  function removeSpline() {
			
 
				+    if (!swiper.controller.control) return;
			
 
				+    if (swiper.controller.spline) {
			
 
				+      swiper.controller.spline = undefined;
			
 
				+      delete swiper.controller.spline;
			
 
				+    }
			
 
				+  }
			
 
				+  on('beforeInit', () => {
			
 
				+    if (typeof window !== 'undefined' && (
			
 
				+    // eslint-disable-line
			
 
				+    typeof swiper.params.controller.control === 'string' || swiper.params.controller.control instanceof HTMLElement)) {
			
 
				+      const controlElements = typeof swiper.params.controller.control === 'string' ? [...document.querySelectorAll(swiper.params.controller.control)] : [swiper.params.controller.control];
			
 
				+      controlElements.forEach(controlElement => {
			
 
				+        if (!swiper.controller.control) swiper.controller.control = [];
			
 
				+        if (controlElement && controlElement.swiper) {
			
 
				+          swiper.controller.control.push(controlElement.swiper);
			
 
				+        } else if (controlElement) {
			
 
				+          const eventName = `${swiper.params.eventsPrefix}init`;
			
 
				+          const onControllerSwiper = e => {
			
 
				+            swiper.controller.control.push(e.detail[0]);
			
 
				+            swiper.update();
			
 
				+            controlElement.removeEventListener(eventName, onControllerSwiper);
			
 
				+          };
			
 
				+          controlElement.addEventListener(eventName, onControllerSwiper);
			
 
				+        }
			
 
				+      });
			
 
				+      return;
			
 
				+    }
			
 
				+    swiper.controller.control = swiper.params.controller.control;
			
 
				+  });
			
 
				+  on('update', () => {
			
 
				+    removeSpline();
			
 
				+  });
			
 
				+  on('resize', () => {
			
 
				+    removeSpline();
			
 
				+  });
			
 
				+  on('observerUpdate', () => {
			
 
				+    removeSpline();
			
 
				+  });
			
 
				+  on('setTranslate', (_s, translate, byController) => {
			
 
				+    if (!swiper.controller.control || swiper.controller.control.destroyed) return;
			
 
				+    swiper.controller.setTranslate(translate, byController);
			
 
				+  });
			
 
				+  on('setTransition', (_s, duration, byController) => {
			
 
				+    if (!swiper.controller.control || swiper.controller.control.destroyed) return;
			
 
				+    swiper.controller.setTransition(duration, byController);
			
 
				+  });
			
 
				+  Object.assign(swiper.controller, {
			
 
				+    setTranslate,
			
 
				+    setTransition
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { Controller as default };
			
--- a/node_modules/swiper/modules/controller.scss
+++ b/node_modules/swiper/modules/controller.scss
--- a/node_modules/swiper/modules/effect-cards-element.css
+++ b/node_modules/swiper/modules/effect-cards-element.css
@@ -0,0 +1,9 @@
 
				+.swiper.swiper-cards {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-cards ::slotted(swiper-slide) {
			
 
				+  transform-origin: center bottom;
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+  overflow: hidden;
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-cards-element.min.css
+++ b/node_modules/swiper/modules/effect-cards-element.min.css
@@ -0,0 +1 @@
 
				+.swiper.swiper-cards{overflow:visible}.swiper-cards ::slotted(swiper-slide){transform-origin:center bottom;-webkit-backface-visibility:hidden;backface-visibility:hidden;overflow:hidden}
			
--- a/node_modules/swiper/modules/effect-cards.css
+++ b/node_modules/swiper/modules/effect-cards.css
@@ -0,0 +1,9 @@
 
				+.swiper.swiper-cards {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-cards .swiper-slide {
			
 
				+  transform-origin: center bottom;
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+  overflow: hidden;
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-cards.less
+++ b/node_modules/swiper/modules/effect-cards.less
@@ -0,0 +1,10 @@
 
				+.swiper.swiper-cards {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-cards {
			
 
				+  .swiper-slide {
			
 
				+    transform-origin: center bottom;
			
 
				+    backface-visibility: hidden;
			
 
				+    overflow: hidden;
			
 
				+  }
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-cards.min.css
+++ b/node_modules/swiper/modules/effect-cards.min.css
@@ -0,0 +1 @@
 
				+.swiper.swiper-cards{overflow:visible}.swiper-cards .swiper-slide{transform-origin:center bottom;-webkit-backface-visibility:hidden;backface-visibility:hidden;overflow:hidden}
			
--- a/node_modules/swiper/modules/effect-cards.min.mjs
+++ b/node_modules/swiper/modules/effect-cards.min.mjs
--- a/node_modules/swiper/modules/effect-cards.min.mjs.map
+++ b/node_modules/swiper/modules/effect-cards.min.mjs.map
--- a/node_modules/swiper/modules/effect-cards.mjs
+++ b/node_modules/swiper/modules/effect-cards.mjs
@@ -0,0 +1,125 @@
 
				+import { c as createShadow } from '../shared/create-shadow.mjs';
			
 
				+import { e as effectInit } from '../shared/effect-init.mjs';
			
 
				+import { e as effectTarget } from '../shared/effect-target.mjs';
			
 
				+import { e as effectVirtualTransitionEnd } from '../shared/effect-virtual-transition-end.mjs';
			
 
				+import { g as getSlideTransformEl } from '../shared/utils.mjs';
			
 
				+
			
 
				+function EffectCards(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    on
			
 
				+  } = _ref;
			
 
				+  extendParams({
			
 
				+    cardsEffect: {
			
 
				+      slideShadows: true,
			
 
				+      rotate: true,
			
 
				+      perSlideRotate: 2,
			
 
				+      perSlideOffset: 8
			
 
				+    }
			
 
				+  });
			
 
				+  const setTranslate = () => {
			
 
				+    const {
			
 
				+      slides,
			
 
				+      activeIndex,
			
 
				+      rtlTranslate: rtl
			
 
				+    } = swiper;
			
 
				+    const params = swiper.params.cardsEffect;
			
 
				+    const {
			
 
				+      startTranslate,
			
 
				+      isTouched
			
 
				+    } = swiper.touchEventsData;
			
 
				+    const currentTranslate = rtl ? -swiper.translate : swiper.translate;
			
 
				+    for (let i = 0; i < slides.length; i += 1) {
			
 
				+      const slideEl = slides[i];
			
 
				+      const slideProgress = slideEl.progress;
			
 
				+      const progress = Math.min(Math.max(slideProgress, -4), 4);
			
 
				+      let offset = slideEl.swiperSlideOffset;
			
 
				+      if (swiper.params.centeredSlides && !swiper.params.cssMode) {
			
 
				+        swiper.wrapperEl.style.transform = `translateX(${swiper.minTranslate()}px)`;
			
 
				+      }
			
 
				+      if (swiper.params.centeredSlides && swiper.params.cssMode) {
			
 
				+        offset -= slides[0].swiperSlideOffset;
			
 
				+      }
			
 
				+      let tX = swiper.params.cssMode ? -offset - swiper.translate : -offset;
			
 
				+      let tY = 0;
			
 
				+      const tZ = -100 * Math.abs(progress);
			
 
				+      let scale = 1;
			
 
				+      let rotate = -params.perSlideRotate * progress;
			
 
				+      let tXAdd = params.perSlideOffset - Math.abs(progress) * 0.75;
			
 
				+      const slideIndex = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.from + i : i;
			
 
				+      const isSwipeToNext = (slideIndex === activeIndex || slideIndex === activeIndex - 1) && progress > 0 && progress < 1 && (isTouched || swiper.params.cssMode) && currentTranslate < startTranslate;
			
 
				+      const isSwipeToPrev = (slideIndex === activeIndex || slideIndex === activeIndex + 1) && progress < 0 && progress > -1 && (isTouched || swiper.params.cssMode) && currentTranslate > startTranslate;
			
 
				+      if (isSwipeToNext || isSwipeToPrev) {
			
 
				+        const subProgress = (1 - Math.abs((Math.abs(progress) - 0.5) / 0.5)) ** 0.5;
			
 
				+        rotate += -28 * progress * subProgress;
			
 
				+        scale += -0.5 * subProgress;
			
 
				+        tXAdd += 96 * subProgress;
			
 
				+        tY = `${-25 * subProgress * Math.abs(progress)}%`;
			
 
				+      }
			
 
				+      if (progress < 0) {
			
 
				+        // next
			
 
				+        tX = `calc(${tX}px ${rtl ? '-' : '+'} (${tXAdd * Math.abs(progress)}%))`;
			
 
				+      } else if (progress > 0) {
			
 
				+        // prev
			
 
				+        tX = `calc(${tX}px ${rtl ? '-' : '+'} (-${tXAdd * Math.abs(progress)}%))`;
			
 
				+      } else {
			
 
				+        tX = `${tX}px`;
			
 
				+      }
			
 
				+      if (!swiper.isHorizontal()) {
			
 
				+        const prevY = tY;
			
 
				+        tY = tX;
			
 
				+        tX = prevY;
			
 
				+      }
			
 
				+      const scaleString = progress < 0 ? `${1 + (1 - scale) * progress}` : `${1 - (1 - scale) * progress}`;
			
 
				+
			
 
				+      /* eslint-disable */
			
 
				+      const transform = `
			
 
				+        translate3d(${tX}, ${tY}, ${tZ}px)
			
 
				+        rotateZ(${params.rotate ? rtl ? -rotate : rotate : 0}deg)
			
 
				+        scale(${scaleString})
			
 
				+      `;
			
 
				+      /* eslint-enable */
			
 
				+
			
 
				+      if (params.slideShadows) {
			
 
				+        // Set shadows
			
 
				+        let shadowEl = slideEl.querySelector('.swiper-slide-shadow');
			
 
				+        if (!shadowEl) {
			
 
				+          shadowEl = createShadow('cards', slideEl);
			
 
				+        }
			
 
				+        if (shadowEl) shadowEl.style.opacity = Math.min(Math.max((Math.abs(progress) - 0.5) / 0.5, 0), 1);
			
 
				+      }
			
 
				+      slideEl.style.zIndex = -Math.abs(Math.round(slideProgress)) + slides.length;
			
 
				+      const targetEl = effectTarget(params, slideEl);
			
 
				+      targetEl.style.transform = transform;
			
 
				+    }
			
 
				+  };
			
 
				+  const setTransition = duration => {
			
 
				+    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
			
 
				+    transformElements.forEach(el => {
			
 
				+      el.style.transitionDuration = `${duration}ms`;
			
 
				+      el.querySelectorAll('.swiper-slide-shadow').forEach(shadowEl => {
			
 
				+        shadowEl.style.transitionDuration = `${duration}ms`;
			
 
				+      });
			
 
				+    });
			
 
				+    effectVirtualTransitionEnd({
			
 
				+      swiper,
			
 
				+      duration,
			
 
				+      transformElements
			
 
				+    });
			
 
				+  };
			
 
				+  effectInit({
			
 
				+    effect: 'cards',
			
 
				+    swiper,
			
 
				+    on,
			
 
				+    setTranslate,
			
 
				+    setTransition,
			
 
				+    perspective: () => true,
			
 
				+    overwriteParams: () => ({
			
 
				+      watchSlidesProgress: true,
			
 
				+      virtualTranslate: !swiper.params.cssMode
			
 
				+    })
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { EffectCards as default };
			
--- a/node_modules/swiper/modules/effect-cards.scss
+++ b/node_modules/swiper/modules/effect-cards.scss
@@ -0,0 +1,10 @@
 
				+.swiper.swiper-cards {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-cards {
			
 
				+  .swiper-slide {
			
 
				+    transform-origin: center bottom;
			
 
				+    backface-visibility: hidden;
			
 
				+    overflow: hidden;
			
 
				+  }
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-coverflow-element.css
+++ b/node_modules/swiper/modules/effect-coverflow-element.css
--- a/node_modules/swiper/modules/effect-coverflow-element.min.css
+++ b/node_modules/swiper/modules/effect-coverflow-element.min.css
--- a/node_modules/swiper/modules/effect-coverflow.css
+++ b/node_modules/swiper/modules/effect-coverflow.css
--- a/node_modules/swiper/modules/effect-coverflow.less
+++ b/node_modules/swiper/modules/effect-coverflow.less
@@ -0,0 +1,2 @@
 
				+.swiper-coverflow {
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-coverflow.min.css
+++ b/node_modules/swiper/modules/effect-coverflow.min.css
--- a/node_modules/swiper/modules/effect-coverflow.min.mjs
+++ b/node_modules/swiper/modules/effect-coverflow.min.mjs
--- a/node_modules/swiper/modules/effect-coverflow.min.mjs.map
+++ b/node_modules/swiper/modules/effect-coverflow.min.mjs.map
--- a/node_modules/swiper/modules/effect-coverflow.mjs
+++ b/node_modules/swiper/modules/effect-coverflow.mjs
@@ -0,0 +1,104 @@
 
				+import { c as createShadow } from '../shared/create-shadow.mjs';
			
 
				+import { e as effectInit } from '../shared/effect-init.mjs';
			
 
				+import { e as effectTarget } from '../shared/effect-target.mjs';
			
 
				+import { g as getSlideTransformEl, o as getRotateFix } from '../shared/utils.mjs';
			
 
				+
			
 
				+function EffectCoverflow(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    on
			
 
				+  } = _ref;
			
 
				+  extendParams({
			
 
				+    coverflowEffect: {
			
 
				+      rotate: 50,
			
 
				+      stretch: 0,
			
 
				+      depth: 100,
			
 
				+      scale: 1,
			
 
				+      modifier: 1,
			
 
				+      slideShadows: true
			
 
				+    }
			
 
				+  });
			
 
				+  const setTranslate = () => {
			
 
				+    const {
			
 
				+      width: swiperWidth,
			
 
				+      height: swiperHeight,
			
 
				+      slides,
			
 
				+      slidesSizesGrid
			
 
				+    } = swiper;
			
 
				+    const params = swiper.params.coverflowEffect;
			
 
				+    const isHorizontal = swiper.isHorizontal();
			
 
				+    const transform = swiper.translate;
			
 
				+    const center = isHorizontal ? -transform + swiperWidth / 2 : -transform + swiperHeight / 2;
			
 
				+    const rotate = isHorizontal ? params.rotate : -params.rotate;
			
 
				+    const translate = params.depth;
			
 
				+    const r = getRotateFix(swiper);
			
 
				+    // Each slide offset from center
			
 
				+    for (let i = 0, length = slides.length; i < length; i += 1) {
			
 
				+      const slideEl = slides[i];
			
 
				+      const slideSize = slidesSizesGrid[i];
			
 
				+      const slideOffset = slideEl.swiperSlideOffset;
			
 
				+      const centerOffset = (center - slideOffset - slideSize / 2) / slideSize;
			
 
				+      const offsetMultiplier = typeof params.modifier === 'function' ? params.modifier(centerOffset) : centerOffset * params.modifier;
			
 
				+      let rotateY = isHorizontal ? rotate * offsetMultiplier : 0;
			
 
				+      let rotateX = isHorizontal ? 0 : rotate * offsetMultiplier;
			
 
				+      // var rotateZ = 0
			
 
				+      let translateZ = -translate * Math.abs(offsetMultiplier);
			
 
				+      let stretch = params.stretch;
			
 
				+      // Allow percentage to make a relative stretch for responsive sliders
			
 
				+      if (typeof stretch === 'string' && stretch.indexOf('%') !== -1) {
			
 
				+        stretch = parseFloat(params.stretch) / 100 * slideSize;
			
 
				+      }
			
 
				+      let translateY = isHorizontal ? 0 : stretch * offsetMultiplier;
			
 
				+      let translateX = isHorizontal ? stretch * offsetMultiplier : 0;
			
 
				+      let scale = 1 - (1 - params.scale) * Math.abs(offsetMultiplier);
			
 
				+
			
 
				+      // Fix for ultra small values
			
 
				+      if (Math.abs(translateX) < 0.001) translateX = 0;
			
 
				+      if (Math.abs(translateY) < 0.001) translateY = 0;
			
 
				+      if (Math.abs(translateZ) < 0.001) translateZ = 0;
			
 
				+      if (Math.abs(rotateY) < 0.001) rotateY = 0;
			
 
				+      if (Math.abs(rotateX) < 0.001) rotateX = 0;
			
 
				+      if (Math.abs(scale) < 0.001) scale = 0;
			
 
				+      const slideTransform = `translate3d(${translateX}px,${translateY}px,${translateZ}px)  rotateX(${r(rotateX)}deg) rotateY(${r(rotateY)}deg) scale(${scale})`;
			
 
				+      const targetEl = effectTarget(params, slideEl);
			
 
				+      targetEl.style.transform = slideTransform;
			
 
				+      slideEl.style.zIndex = -Math.abs(Math.round(offsetMultiplier)) + 1;
			
 
				+      if (params.slideShadows) {
			
 
				+        // Set shadows
			
 
				+        let shadowBeforeEl = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-left') : slideEl.querySelector('.swiper-slide-shadow-top');
			
 
				+        let shadowAfterEl = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-right') : slideEl.querySelector('.swiper-slide-shadow-bottom');
			
 
				+        if (!shadowBeforeEl) {
			
 
				+          shadowBeforeEl = createShadow('coverflow', slideEl, isHorizontal ? 'left' : 'top');
			
 
				+        }
			
 
				+        if (!shadowAfterEl) {
			
 
				+          shadowAfterEl = createShadow('coverflow', slideEl, isHorizontal ? 'right' : 'bottom');
			
 
				+        }
			
 
				+        if (shadowBeforeEl) shadowBeforeEl.style.opacity = offsetMultiplier > 0 ? offsetMultiplier : 0;
			
 
				+        if (shadowAfterEl) shadowAfterEl.style.opacity = -offsetMultiplier > 0 ? -offsetMultiplier : 0;
			
 
				+      }
			
 
				+    }
			
 
				+  };
			
 
				+  const setTransition = duration => {
			
 
				+    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
			
 
				+    transformElements.forEach(el => {
			
 
				+      el.style.transitionDuration = `${duration}ms`;
			
 
				+      el.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(shadowEl => {
			
 
				+        shadowEl.style.transitionDuration = `${duration}ms`;
			
 
				+      });
			
 
				+    });
			
 
				+  };
			
 
				+  effectInit({
			
 
				+    effect: 'coverflow',
			
 
				+    swiper,
			
 
				+    on,
			
 
				+    setTranslate,
			
 
				+    setTransition,
			
 
				+    perspective: () => true,
			
 
				+    overwriteParams: () => ({
			
 
				+      watchSlidesProgress: true
			
 
				+    })
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { EffectCoverflow as default };
			
--- a/node_modules/swiper/modules/effect-coverflow.scss
+++ b/node_modules/swiper/modules/effect-coverflow.scss
@@ -0,0 +1,2 @@
 
				+.swiper-coverflow {
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-creative-element.css
+++ b/node_modules/swiper/modules/effect-creative-element.css
@@ -0,0 +1,6 @@
 
				+.swiper-creative ::slotted(swiper-slide) {
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+  overflow: hidden;
			
 
				+  transition-property: transform, opacity, height;
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-creative-element.min.css
+++ b/node_modules/swiper/modules/effect-creative-element.min.css
@@ -0,0 +1 @@
 
				+.swiper-creative ::slotted(swiper-slide){-webkit-backface-visibility:hidden;backface-visibility:hidden;overflow:hidden;transition-property:transform,opacity,height}
			
--- a/node_modules/swiper/modules/effect-creative.css
+++ b/node_modules/swiper/modules/effect-creative.css
@@ -0,0 +1,6 @@
 
				+.swiper-creative .swiper-slide {
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+  overflow: hidden;
			
 
				+  transition-property: transform, opacity, height;
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-creative.less
+++ b/node_modules/swiper/modules/effect-creative.less
@@ -0,0 +1,7 @@
 
				+.swiper-creative {
			
 
				+  .swiper-slide {
			
 
				+    backface-visibility: hidden;
			
 
				+    overflow: hidden;
			
 
				+    transition-property: transform, opacity, height;
			
 
				+  }
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-creative.min.css
+++ b/node_modules/swiper/modules/effect-creative.min.css
@@ -0,0 +1 @@
 
				+.swiper-creative .swiper-slide{-webkit-backface-visibility:hidden;backface-visibility:hidden;overflow:hidden;transition-property:transform,opacity,height}
			
--- a/node_modules/swiper/modules/effect-creative.min.mjs
+++ b/node_modules/swiper/modules/effect-creative.min.mjs
--- a/node_modules/swiper/modules/effect-creative.min.mjs.map
+++ b/node_modules/swiper/modules/effect-creative.min.mjs.map
--- a/node_modules/swiper/modules/effect-creative.mjs
+++ b/node_modules/swiper/modules/effect-creative.mjs
@@ -0,0 +1,146 @@
 
				+import { c as createShadow } from '../shared/create-shadow.mjs';
			
 
				+import { e as effectInit } from '../shared/effect-init.mjs';
			
 
				+import { e as effectTarget } from '../shared/effect-target.mjs';
			
 
				+import { e as effectVirtualTransitionEnd } from '../shared/effect-virtual-transition-end.mjs';
			
 
				+import { g as getSlideTransformEl, o as getRotateFix } from '../shared/utils.mjs';
			
 
				+
			
 
				+function EffectCreative(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    on
			
 
				+  } = _ref;
			
 
				+  extendParams({
			
 
				+    creativeEffect: {
			
 
				+      limitProgress: 1,
			
 
				+      shadowPerProgress: false,
			
 
				+      progressMultiplier: 1,
			
 
				+      perspective: true,
			
 
				+      prev: {
			
 
				+        translate: [0, 0, 0],
			
 
				+        rotate: [0, 0, 0],
			
 
				+        opacity: 1,
			
 
				+        scale: 1
			
 
				+      },
			
 
				+      next: {
			
 
				+        translate: [0, 0, 0],
			
 
				+        rotate: [0, 0, 0],
			
 
				+        opacity: 1,
			
 
				+        scale: 1
			
 
				+      }
			
 
				+    }
			
 
				+  });
			
 
				+  const getTranslateValue = value => {
			
 
				+    if (typeof value === 'string') return value;
			
 
				+    return `${value}px`;
			
 
				+  };
			
 
				+  const setTranslate = () => {
			
 
				+    const {
			
 
				+      slides,
			
 
				+      wrapperEl,
			
 
				+      slidesSizesGrid
			
 
				+    } = swiper;
			
 
				+    const params = swiper.params.creativeEffect;
			
 
				+    const {
			
 
				+      progressMultiplier: multiplier
			
 
				+    } = params;
			
 
				+    const isCenteredSlides = swiper.params.centeredSlides;
			
 
				+    const rotateFix = getRotateFix(swiper);
			
 
				+    if (isCenteredSlides) {
			
 
				+      const margin = slidesSizesGrid[0] / 2 - swiper.params.slidesOffsetBefore || 0;
			
 
				+      wrapperEl.style.transform = `translateX(calc(50% - ${margin}px))`;
			
 
				+    }
			
 
				+    for (let i = 0; i < slides.length; i += 1) {
			
 
				+      const slideEl = slides[i];
			
 
				+      const slideProgress = slideEl.progress;
			
 
				+      const progress = Math.min(Math.max(slideEl.progress, -params.limitProgress), params.limitProgress);
			
 
				+      let originalProgress = progress;
			
 
				+      if (!isCenteredSlides) {
			
 
				+        originalProgress = Math.min(Math.max(slideEl.originalProgress, -params.limitProgress), params.limitProgress);
			
 
				+      }
			
 
				+      const offset = slideEl.swiperSlideOffset;
			
 
				+      const t = [swiper.params.cssMode ? -offset - swiper.translate : -offset, 0, 0];
			
 
				+      const r = [0, 0, 0];
			
 
				+      let custom = false;
			
 
				+      if (!swiper.isHorizontal()) {
			
 
				+        t[1] = t[0];
			
 
				+        t[0] = 0;
			
 
				+      }
			
 
				+      let data = {
			
 
				+        translate: [0, 0, 0],
			
 
				+        rotate: [0, 0, 0],
			
 
				+        scale: 1,
			
 
				+        opacity: 1
			
 
				+      };
			
 
				+      if (progress < 0) {
			
 
				+        data = params.next;
			
 
				+        custom = true;
			
 
				+      } else if (progress > 0) {
			
 
				+        data = params.prev;
			
 
				+        custom = true;
			
 
				+      }
			
 
				+      // set translate
			
 
				+      t.forEach((value, index) => {
			
 
				+        t[index] = `calc(${value}px + (${getTranslateValue(data.translate[index])} * ${Math.abs(progress * multiplier)}))`;
			
 
				+      });
			
 
				+      // set rotates
			
 
				+      r.forEach((value, index) => {
			
 
				+        let val = data.rotate[index] * Math.abs(progress * multiplier);
			
 
				+        r[index] = val;
			
 
				+      });
			
 
				+      slideEl.style.zIndex = -Math.abs(Math.round(slideProgress)) + slides.length;
			
 
				+      const translateString = t.join(', ');
			
 
				+      const rotateString = `rotateX(${rotateFix(r[0])}deg) rotateY(${rotateFix(r[1])}deg) rotateZ(${rotateFix(r[2])}deg)`;
			
 
				+      const scaleString = originalProgress < 0 ? `scale(${1 + (1 - data.scale) * originalProgress * multiplier})` : `scale(${1 - (1 - data.scale) * originalProgress * multiplier})`;
			
 
				+      const opacityString = originalProgress < 0 ? 1 + (1 - data.opacity) * originalProgress * multiplier : 1 - (1 - data.opacity) * originalProgress * multiplier;
			
 
				+      const transform = `translate3d(${translateString}) ${rotateString} ${scaleString}`;
			
 
				+
			
 
				+      // Set shadows
			
 
				+      if (custom && data.shadow || !custom) {
			
 
				+        let shadowEl = slideEl.querySelector('.swiper-slide-shadow');
			
 
				+        if (!shadowEl && data.shadow) {
			
 
				+          shadowEl = createShadow('creative', slideEl);
			
 
				+        }
			
 
				+        if (shadowEl) {
			
 
				+          const shadowOpacity = params.shadowPerProgress ? progress * (1 / params.limitProgress) : progress;
			
 
				+          shadowEl.style.opacity = Math.min(Math.max(Math.abs(shadowOpacity), 0), 1);
			
 
				+        }
			
 
				+      }
			
 
				+      const targetEl = effectTarget(params, slideEl);
			
 
				+      targetEl.style.transform = transform;
			
 
				+      targetEl.style.opacity = opacityString;
			
 
				+      if (data.origin) {
			
 
				+        targetEl.style.transformOrigin = data.origin;
			
 
				+      }
			
 
				+    }
			
 
				+  };
			
 
				+  const setTransition = duration => {
			
 
				+    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
			
 
				+    transformElements.forEach(el => {
			
 
				+      el.style.transitionDuration = `${duration}ms`;
			
 
				+      el.querySelectorAll('.swiper-slide-shadow').forEach(shadowEl => {
			
 
				+        shadowEl.style.transitionDuration = `${duration}ms`;
			
 
				+      });
			
 
				+    });
			
 
				+    effectVirtualTransitionEnd({
			
 
				+      swiper,
			
 
				+      duration,
			
 
				+      transformElements,
			
 
				+      allSlides: true
			
 
				+    });
			
 
				+  };
			
 
				+  effectInit({
			
 
				+    effect: 'creative',
			
 
				+    swiper,
			
 
				+    on,
			
 
				+    setTranslate,
			
 
				+    setTransition,
			
 
				+    perspective: () => swiper.params.creativeEffect.perspective,
			
 
				+    overwriteParams: () => ({
			
 
				+      watchSlidesProgress: true,
			
 
				+      virtualTranslate: !swiper.params.cssMode
			
 
				+    })
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { EffectCreative as default };
			
--- a/node_modules/swiper/modules/effect-creative.scss
+++ b/node_modules/swiper/modules/effect-creative.scss
@@ -0,0 +1,7 @@
 
				+.swiper-creative {
			
 
				+  .swiper-slide {
			
 
				+    backface-visibility: hidden;
			
 
				+    overflow: hidden;
			
 
				+    transition-property: transform, opacity, height;
			
 
				+  }
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-cube-element.css
+++ b/node_modules/swiper/modules/effect-cube-element.css
@@ -0,0 +1,53 @@
 
				+.swiper.swiper-cube {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-cube ::slotted(swiper-slide) {
			
 
				+  pointer-events: none;
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+  z-index: 1;
			
 
				+  visibility: hidden;
			
 
				+  transform-origin: 0 0;
			
 
				+  width: 100%;
			
 
				+  height: 100%;
			
 
				+}
			
 
				+.swiper-cube ::slotted(swiper-slide) ::slotted(swiper-slide) {
			
 
				+  pointer-events: none;
			
 
				+}
			
 
				+.swiper-cube.swiper-rtl ::slotted(swiper-slide) {
			
 
				+  transform-origin: 100% 0;
			
 
				+}
			
 
				+.swiper-cube ::slotted(.swiper-slide-active),
			
 
				+.swiper-cube ::slotted(.swiper-slide-active) ::slotted(.swiper-slide-active) {
			
 
				+  pointer-events: auto;
			
 
				+}
			
 
				+.swiper-cube ::slotted(.swiper-slide-active),
			
 
				+.swiper-cube ::slotted(.swiper-slide-next),
			
 
				+.swiper-cube ::slotted(.swiper-slide-prev) {
			
 
				+  pointer-events: auto;
			
 
				+  visibility: visible;
			
 
				+}
			
 
				+.swiper-cube .swiper-cube-shadow {
			
 
				+  position: absolute;
			
 
				+  left: 0;
			
 
				+  bottom: 0px;
			
 
				+  width: 100%;
			
 
				+  height: 100%;
			
 
				+  opacity: 0.6;
			
 
				+  z-index: 0;
			
 
				+}
			
 
				+.swiper-cube .swiper-cube-shadow:before {
			
 
				+  content: '';
			
 
				+  background: #000;
			
 
				+  position: absolute;
			
 
				+  left: 0;
			
 
				+  top: 0;
			
 
				+  bottom: 0;
			
 
				+  right: 0;
			
 
				+  filter: blur(50px);
			
 
				+}
			
 
				+.swiper-cube ::slotted(.swiper-slide-next) + ::slotted(swiper-slide) {
			
 
				+  pointer-events: auto;
			
 
				+  visibility: visible;
			
 
				+}
			
 
				+/* Cube slide shadows start *//* Cube slide shadows end */
			
--- a/node_modules/swiper/modules/effect-cube-element.min.css
+++ b/node_modules/swiper/modules/effect-cube-element.min.css
@@ -0,0 +1 @@
 
				+.swiper.swiper-cube{overflow:visible}.swiper-cube ::slotted(swiper-slide){pointer-events:none;-webkit-backface-visibility:hidden;backface-visibility:hidden;z-index:1;visibility:hidden;transform-origin:0 0;width:100%;height:100%}.swiper-cube ::slotted(swiper-slide) ::slotted(swiper-slide){pointer-events:none}.swiper-cube.swiper-rtl ::slotted(swiper-slide){transform-origin:100% 0}.swiper-cube ::slotted(.swiper-slide-active),.swiper-cube ::slotted(.swiper-slide-active) ::slotted(.swiper-slide-active){pointer-events:auto}.swiper-cube ::slotted(.swiper-slide-active),.swiper-cube ::slotted(.swiper-slide-next),.swiper-cube ::slotted(.swiper-slide-prev){pointer-events:auto;visibility:visible}.swiper-cube .swiper-cube-shadow{position:absolute;left:0;bottom:0px;width:100%;height:100%;opacity:.6;z-index:0}.swiper-cube .swiper-cube-shadow:before{content:'';background:#000;position:absolute;left:0;top:0;bottom:0;right:0;filter:blur(50px)}.swiper-cube ::slotted(.swiper-slide-next)+::slotted(swiper-slide){pointer-events:auto;visibility:visible}
			
--- a/node_modules/swiper/modules/effect-cube.css
+++ b/node_modules/swiper/modules/effect-cube.css
@@ -0,0 +1,62 @@
 
				+.swiper.swiper-cube {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-cube .swiper-slide {
			
 
				+  pointer-events: none;
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+  z-index: 1;
			
 
				+  visibility: hidden;
			
 
				+  transform-origin: 0 0;
			
 
				+  width: 100%;
			
 
				+  height: 100%;
			
 
				+}
			
 
				+.swiper-cube .swiper-slide .swiper-slide {
			
 
				+  pointer-events: none;
			
 
				+}
			
 
				+.swiper-cube.swiper-rtl .swiper-slide {
			
 
				+  transform-origin: 100% 0;
			
 
				+}
			
 
				+.swiper-cube .swiper-slide-active,
			
 
				+.swiper-cube .swiper-slide-active .swiper-slide-active {
			
 
				+  pointer-events: auto;
			
 
				+}
			
 
				+.swiper-cube .swiper-slide-active,
			
 
				+.swiper-cube .swiper-slide-next,
			
 
				+.swiper-cube .swiper-slide-prev {
			
 
				+  pointer-events: auto;
			
 
				+  visibility: visible;
			
 
				+}
			
 
				+.swiper-cube .swiper-cube-shadow {
			
 
				+  position: absolute;
			
 
				+  left: 0;
			
 
				+  bottom: 0px;
			
 
				+  width: 100%;
			
 
				+  height: 100%;
			
 
				+  opacity: 0.6;
			
 
				+  z-index: 0;
			
 
				+}
			
 
				+.swiper-cube .swiper-cube-shadow:before {
			
 
				+  content: '';
			
 
				+  background: #000;
			
 
				+  position: absolute;
			
 
				+  left: 0;
			
 
				+  top: 0;
			
 
				+  bottom: 0;
			
 
				+  right: 0;
			
 
				+  filter: blur(50px);
			
 
				+}
			
 
				+.swiper-cube .swiper-slide-next + .swiper-slide {
			
 
				+  pointer-events: auto;
			
 
				+  visibility: visible;
			
 
				+}
			
 
				+/* Cube slide shadows start */
			
 
				+.swiper-cube .swiper-slide-shadow-cube.swiper-slide-shadow-top,
			
 
				+.swiper-cube .swiper-slide-shadow-cube.swiper-slide-shadow-bottom,
			
 
				+.swiper-cube .swiper-slide-shadow-cube.swiper-slide-shadow-left,
			
 
				+.swiper-cube .swiper-slide-shadow-cube.swiper-slide-shadow-right {
			
 
				+  z-index: 0;
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+}
			
 
				+/* Cube slide shadows end */
			
--- a/node_modules/swiper/modules/effect-cube.less
+++ b/node_modules/swiper/modules/effect-cube.less
@@ -0,0 +1,71 @@
 
				+.swiper.swiper-cube {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-cube {
			
 
				+  .swiper-slide {
			
 
				+    pointer-events: none;
			
 
				+    backface-visibility: hidden;
			
 
				+    z-index: 1;
			
 
				+    visibility: hidden;
			
 
				+    transform-origin: 0 0;
			
 
				+    width: 100%;
			
 
				+    height: 100%;
			
 
				+    .swiper-slide {
			
 
				+      pointer-events: none;
			
 
				+    }
			
 
				+  }
			
 
				+  &.swiper-rtl .swiper-slide {
			
 
				+    transform-origin: 100% 0;
			
 
				+  }
			
 
				+  .swiper-slide-active {
			
 
				+    &,
			
 
				+    & .swiper-slide-active {
			
 
				+      pointer-events: auto;
			
 
				+    }
			
 
				+  }
			
 
				+  .swiper-slide-active,
			
 
				+  .swiper-slide-next,
			
 
				+  .swiper-slide-prev {
			
 
				+    pointer-events: auto;
			
 
				+    visibility: visible;
			
 
				+  }
			
 
				+
			
 
				+  .swiper-cube-shadow {
			
 
				+    position: absolute;
			
 
				+    left: 0;
			
 
				+    bottom: 0px;
			
 
				+    width: 100%;
			
 
				+    height: 100%;
			
 
				+    opacity: 0.6;
			
 
				+    z-index: 0;
			
 
				+
			
 
				+    &:before {
			
 
				+      content: '';
			
 
				+      background: #000;
			
 
				+      position: absolute;
			
 
				+      left: 0;
			
 
				+      top: 0;
			
 
				+      bottom: 0;
			
 
				+      right: 0;
			
 
				+      -webkit-filter: blur(50px);
			
 
				+      filter: blur(50px);
			
 
				+    }
			
 
				+  }
			
 
				+}
			
 
				+.swiper-cube {
			
 
				+  .swiper-slide-next + .swiper-slide {
			
 
				+    pointer-events: auto;
			
 
				+    visibility: visible;
			
 
				+  }
			
 
				+}
			
 
				+/* Cube slide shadows start */
			
 
				+.swiper-cube {
			
 
				+  .swiper-slide-shadow-cube.swiper-slide-shadow-top,
			
 
				+  .swiper-slide-shadow-cube.swiper-slide-shadow-bottom,
			
 
				+  .swiper-slide-shadow-cube.swiper-slide-shadow-left,
			
 
				+  .swiper-slide-shadow-cube.swiper-slide-shadow-right {
			
 
				+    z-index: 0;
			
 
				+    backface-visibility: hidden;
			
 
				+  }
			
 
				+}
			
 
				+/* Cube slide shadows end */
			
--- a/node_modules/swiper/modules/effect-cube.min.css
+++ b/node_modules/swiper/modules/effect-cube.min.css
@@ -0,0 +1 @@
 
				+.swiper.swiper-cube{overflow:visible}.swiper-cube .swiper-slide{pointer-events:none;-webkit-backface-visibility:hidden;backface-visibility:hidden;z-index:1;visibility:hidden;transform-origin:0 0;width:100%;height:100%}.swiper-cube .swiper-slide .swiper-slide{pointer-events:none}.swiper-cube.swiper-rtl .swiper-slide{transform-origin:100% 0}.swiper-cube .swiper-slide-active,.swiper-cube .swiper-slide-active .swiper-slide-active{pointer-events:auto}.swiper-cube .swiper-slide-active,.swiper-cube .swiper-slide-next,.swiper-cube .swiper-slide-prev{pointer-events:auto;visibility:visible}.swiper-cube .swiper-cube-shadow{position:absolute;left:0;bottom:0px;width:100%;height:100%;opacity:.6;z-index:0}.swiper-cube .swiper-cube-shadow:before{content:'';background:#000;position:absolute;left:0;top:0;bottom:0;right:0;filter:blur(50px)}.swiper-cube .swiper-slide-next+.swiper-slide{pointer-events:auto;visibility:visible}.swiper-cube .swiper-slide-shadow-cube.swiper-slide-shadow-bottom,.swiper-cube .swiper-slide-shadow-cube.swiper-slide-shadow-left,.swiper-cube .swiper-slide-shadow-cube.swiper-slide-shadow-right,.swiper-cube .swiper-slide-shadow-cube.swiper-slide-shadow-top{z-index:0;-webkit-backface-visibility:hidden;backface-visibility:hidden}
			
--- a/node_modules/swiper/modules/effect-cube.min.mjs
+++ b/node_modules/swiper/modules/effect-cube.min.mjs
--- a/node_modules/swiper/modules/effect-cube.min.mjs.map
+++ b/node_modules/swiper/modules/effect-cube.min.mjs.map
--- a/node_modules/swiper/modules/effect-cube.mjs
+++ b/node_modules/swiper/modules/effect-cube.mjs
@@ -0,0 +1,174 @@
 
				+import { e as effectInit } from '../shared/effect-init.mjs';
			
 
				+import { c as createElement, o as getRotateFix } from '../shared/utils.mjs';
			
 
				+
			
 
				+function EffectCube(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    on
			
 
				+  } = _ref;
			
 
				+  extendParams({
			
 
				+    cubeEffect: {
			
 
				+      slideShadows: true,
			
 
				+      shadow: true,
			
 
				+      shadowOffset: 20,
			
 
				+      shadowScale: 0.94
			
 
				+    }
			
 
				+  });
			
 
				+  const createSlideShadows = (slideEl, progress, isHorizontal) => {
			
 
				+    let shadowBefore = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-left') : slideEl.querySelector('.swiper-slide-shadow-top');
			
 
				+    let shadowAfter = isHorizontal ? slideEl.querySelector('.swiper-slide-shadow-right') : slideEl.querySelector('.swiper-slide-shadow-bottom');
			
 
				+    if (!shadowBefore) {
			
 
				+      shadowBefore = createElement('div', `swiper-slide-shadow-cube swiper-slide-shadow-${isHorizontal ? 'left' : 'top'}`.split(' '));
			
 
				+      slideEl.append(shadowBefore);
			
 
				+    }
			
 
				+    if (!shadowAfter) {
			
 
				+      shadowAfter = createElement('div', `swiper-slide-shadow-cube swiper-slide-shadow-${isHorizontal ? 'right' : 'bottom'}`.split(' '));
			
 
				+      slideEl.append(shadowAfter);
			
 
				+    }
			
 
				+    if (shadowBefore) shadowBefore.style.opacity = Math.max(-progress, 0);
			
 
				+    if (shadowAfter) shadowAfter.style.opacity = Math.max(progress, 0);
			
 
				+  };
			
 
				+  const recreateShadows = () => {
			
 
				+    // create new ones
			
 
				+    const isHorizontal = swiper.isHorizontal();
			
 
				+    swiper.slides.forEach(slideEl => {
			
 
				+      const progress = Math.max(Math.min(slideEl.progress, 1), -1);
			
 
				+      createSlideShadows(slideEl, progress, isHorizontal);
			
 
				+    });
			
 
				+  };
			
 
				+  const setTranslate = () => {
			
 
				+    const {
			
 
				+      el,
			
 
				+      wrapperEl,
			
 
				+      slides,
			
 
				+      width: swiperWidth,
			
 
				+      height: swiperHeight,
			
 
				+      rtlTranslate: rtl,
			
 
				+      size: swiperSize,
			
 
				+      browser
			
 
				+    } = swiper;
			
 
				+    const r = getRotateFix(swiper);
			
 
				+    const params = swiper.params.cubeEffect;
			
 
				+    const isHorizontal = swiper.isHorizontal();
			
 
				+    const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
			
 
				+    let wrapperRotate = 0;
			
 
				+    let cubeShadowEl;
			
 
				+    if (params.shadow) {
			
 
				+      if (isHorizontal) {
			
 
				+        cubeShadowEl = swiper.wrapperEl.querySelector('.swiper-cube-shadow');
			
 
				+        if (!cubeShadowEl) {
			
 
				+          cubeShadowEl = createElement('div', 'swiper-cube-shadow');
			
 
				+          swiper.wrapperEl.append(cubeShadowEl);
			
 
				+        }
			
 
				+        cubeShadowEl.style.height = `${swiperWidth}px`;
			
 
				+      } else {
			
 
				+        cubeShadowEl = el.querySelector('.swiper-cube-shadow');
			
 
				+        if (!cubeShadowEl) {
			
 
				+          cubeShadowEl = createElement('div', 'swiper-cube-shadow');
			
 
				+          el.append(cubeShadowEl);
			
 
				+        }
			
 
				+      }
			
 
				+    }
			
 
				+    for (let i = 0; i < slides.length; i += 1) {
			
 
				+      const slideEl = slides[i];
			
 
				+      let slideIndex = i;
			
 
				+      if (isVirtual) {
			
 
				+        slideIndex = parseInt(slideEl.getAttribute('data-swiper-slide-index'), 10);
			
 
				+      }
			
 
				+      let slideAngle = slideIndex * 90;
			
 
				+      let round = Math.floor(slideAngle / 360);
			
 
				+      if (rtl) {
			
 
				+        slideAngle = -slideAngle;
			
 
				+        round = Math.floor(-slideAngle / 360);
			
 
				+      }
			
 
				+      const progress = Math.max(Math.min(slideEl.progress, 1), -1);
			
 
				+      let tx = 0;
			
 
				+      let ty = 0;
			
 
				+      let tz = 0;
			
 
				+      if (slideIndex % 4 === 0) {
			
 
				+        tx = -round * 4 * swiperSize;
			
 
				+        tz = 0;
			
 
				+      } else if ((slideIndex - 1) % 4 === 0) {
			
 
				+        tx = 0;
			
 
				+        tz = -round * 4 * swiperSize;
			
 
				+      } else if ((slideIndex - 2) % 4 === 0) {
			
 
				+        tx = swiperSize + round * 4 * swiperSize;
			
 
				+        tz = swiperSize;
			
 
				+      } else if ((slideIndex - 3) % 4 === 0) {
			
 
				+        tx = -swiperSize;
			
 
				+        tz = 3 * swiperSize + swiperSize * 4 * round;
			
 
				+      }
			
 
				+      if (rtl) {
			
 
				+        tx = -tx;
			
 
				+      }
			
 
				+      if (!isHorizontal) {
			
 
				+        ty = tx;
			
 
				+        tx = 0;
			
 
				+      }
			
 
				+      const transform = `rotateX(${r(isHorizontal ? 0 : -slideAngle)}deg) rotateY(${r(isHorizontal ? slideAngle : 0)}deg) translate3d(${tx}px, ${ty}px, ${tz}px)`;
			
 
				+      if (progress <= 1 && progress > -1) {
			
 
				+        wrapperRotate = slideIndex * 90 + progress * 90;
			
 
				+        if (rtl) wrapperRotate = -slideIndex * 90 - progress * 90;
			
 
				+      }
			
 
				+      slideEl.style.transform = transform;
			
 
				+      if (params.slideShadows) {
			
 
				+        createSlideShadows(slideEl, progress, isHorizontal);
			
 
				+      }
			
 
				+    }
			
 
				+    wrapperEl.style.transformOrigin = `50% 50% -${swiperSize / 2}px`;
			
 
				+    wrapperEl.style['-webkit-transform-origin'] = `50% 50% -${swiperSize / 2}px`;
			
 
				+    if (params.shadow) {
			
 
				+      if (isHorizontal) {
			
 
				+        cubeShadowEl.style.transform = `translate3d(0px, ${swiperWidth / 2 + params.shadowOffset}px, ${-swiperWidth / 2}px) rotateX(89.99deg) rotateZ(0deg) scale(${params.shadowScale})`;
			
 
				+      } else {
			
 
				+        const shadowAngle = Math.abs(wrapperRotate) - Math.floor(Math.abs(wrapperRotate) / 90) * 90;
			
 
				+        const multiplier = 1.5 - (Math.sin(shadowAngle * 2 * Math.PI / 360) / 2 + Math.cos(shadowAngle * 2 * Math.PI / 360) / 2);
			
 
				+        const scale1 = params.shadowScale;
			
 
				+        const scale2 = params.shadowScale / multiplier;
			
 
				+        const offset = params.shadowOffset;
			
 
				+        cubeShadowEl.style.transform = `scale3d(${scale1}, 1, ${scale2}) translate3d(0px, ${swiperHeight / 2 + offset}px, ${-swiperHeight / 2 / scale2}px) rotateX(-89.99deg)`;
			
 
				+      }
			
 
				+    }
			
 
				+    const zFactor = (browser.isSafari || browser.isWebView) && browser.needPerspectiveFix ? -swiperSize / 2 : 0;
			
 
				+    wrapperEl.style.transform = `translate3d(0px,0,${zFactor}px) rotateX(${r(swiper.isHorizontal() ? 0 : wrapperRotate)}deg) rotateY(${r(swiper.isHorizontal() ? -wrapperRotate : 0)}deg)`;
			
 
				+    wrapperEl.style.setProperty('--swiper-cube-translate-z', `${zFactor}px`);
			
 
				+  };
			
 
				+  const setTransition = duration => {
			
 
				+    const {
			
 
				+      el,
			
 
				+      slides
			
 
				+    } = swiper;
			
 
				+    slides.forEach(slideEl => {
			
 
				+      slideEl.style.transitionDuration = `${duration}ms`;
			
 
				+      slideEl.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(subEl => {
			
 
				+        subEl.style.transitionDuration = `${duration}ms`;
			
 
				+      });
			
 
				+    });
			
 
				+    if (swiper.params.cubeEffect.shadow && !swiper.isHorizontal()) {
			
 
				+      const shadowEl = el.querySelector('.swiper-cube-shadow');
			
 
				+      if (shadowEl) shadowEl.style.transitionDuration = `${duration}ms`;
			
 
				+    }
			
 
				+  };
			
 
				+  effectInit({
			
 
				+    effect: 'cube',
			
 
				+    swiper,
			
 
				+    on,
			
 
				+    setTranslate,
			
 
				+    setTransition,
			
 
				+    recreateShadows,
			
 
				+    getEffectParams: () => swiper.params.cubeEffect,
			
 
				+    perspective: () => true,
			
 
				+    overwriteParams: () => ({
			
 
				+      slidesPerView: 1,
			
 
				+      slidesPerGroup: 1,
			
 
				+      watchSlidesProgress: true,
			
 
				+      resistanceRatio: 0,
			
 
				+      spaceBetween: 0,
			
 
				+      centeredSlides: false,
			
 
				+      virtualTranslate: true
			
 
				+    })
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { EffectCube as default };
			
--- a/node_modules/swiper/modules/effect-cube.scss
+++ b/node_modules/swiper/modules/effect-cube.scss
@@ -0,0 +1,71 @@
 
				+.swiper.swiper-cube {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-cube {
			
 
				+  .swiper-slide {
			
 
				+    pointer-events: none;
			
 
				+    backface-visibility: hidden;
			
 
				+    z-index: 1;
			
 
				+    visibility: hidden;
			
 
				+    transform-origin: 0 0;
			
 
				+    width: 100%;
			
 
				+    height: 100%;
			
 
				+    .swiper-slide {
			
 
				+      pointer-events: none;
			
 
				+    }
			
 
				+  }
			
 
				+  &.swiper-rtl .swiper-slide {
			
 
				+    transform-origin: 100% 0;
			
 
				+  }
			
 
				+  .swiper-slide-active {
			
 
				+    &,
			
 
				+    & .swiper-slide-active {
			
 
				+      pointer-events: auto;
			
 
				+    }
			
 
				+  }
			
 
				+  .swiper-slide-active,
			
 
				+  .swiper-slide-next,
			
 
				+  .swiper-slide-prev {
			
 
				+    pointer-events: auto;
			
 
				+    visibility: visible;
			
 
				+  }
			
 
				+
			
 
				+  .swiper-cube-shadow {
			
 
				+    position: absolute;
			
 
				+    left: 0;
			
 
				+    bottom: 0px;
			
 
				+    width: 100%;
			
 
				+    height: 100%;
			
 
				+    opacity: 0.6;
			
 
				+    z-index: 0;
			
 
				+
			
 
				+    &:before {
			
 
				+      content: '';
			
 
				+      background: #000;
			
 
				+      position: absolute;
			
 
				+      left: 0;
			
 
				+      top: 0;
			
 
				+      bottom: 0;
			
 
				+      right: 0;
			
 
				+      -webkit-filter: blur(50px);
			
 
				+      filter: blur(50px);
			
 
				+    }
			
 
				+  }
			
 
				+}
			
 
				+.swiper-cube {
			
 
				+  .swiper-slide-next + .swiper-slide {
			
 
				+    pointer-events: auto;
			
 
				+    visibility: visible;
			
 
				+  }
			
 
				+}
			
 
				+/* Cube slide shadows start */
			
 
				+.swiper-cube {
			
 
				+  .swiper-slide-shadow-cube.swiper-slide-shadow-top,
			
 
				+  .swiper-slide-shadow-cube.swiper-slide-shadow-bottom,
			
 
				+  .swiper-slide-shadow-cube.swiper-slide-shadow-left,
			
 
				+  .swiper-slide-shadow-cube.swiper-slide-shadow-right {
			
 
				+    z-index: 0;
			
 
				+    backface-visibility: hidden;
			
 
				+  }
			
 
				+}
			
 
				+/* Cube slide shadows end */
			
--- a/node_modules/swiper/modules/effect-fade-element.css
+++ b/node_modules/swiper/modules/effect-fade-element.css
@@ -0,0 +1,16 @@
 
				+.swiper-fade.swiper-free-mode ::slotted(swiper-slide) {
			
 
				+  transition-timing-function: ease-out;
			
 
				+}
			
 
				+.swiper-fade ::slotted(swiper-slide) {
			
 
				+  pointer-events: none;
			
 
				+  transition-property: opacity;
			
 
				+}
			
 
				+.swiper-fade ::slotted(swiper-slide) ::slotted(swiper-slide) {
			
 
				+  pointer-events: none;
			
 
				+}
			
 
				+.swiper-fade ::slotted(.swiper-slide-active) {
			
 
				+  pointer-events: auto;
			
 
				+}
			
 
				+.swiper-fade ::slotted(.swiper-slide-active) ::slotted(.swiper-slide-active) {
			
 
				+  pointer-events: auto;
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-fade-element.min.css
+++ b/node_modules/swiper/modules/effect-fade-element.min.css
@@ -0,0 +1 @@
 
				+.swiper-fade.swiper-free-mode ::slotted(swiper-slide){transition-timing-function:ease-out}.swiper-fade ::slotted(swiper-slide){pointer-events:none;transition-property:opacity}.swiper-fade ::slotted(swiper-slide) ::slotted(swiper-slide){pointer-events:none}.swiper-fade ::slotted(.swiper-slide-active){pointer-events:auto}.swiper-fade ::slotted(.swiper-slide-active) ::slotted(.swiper-slide-active){pointer-events:auto}
			
--- a/node_modules/swiper/modules/effect-fade.css
+++ b/node_modules/swiper/modules/effect-fade.css
@@ -0,0 +1,16 @@
 
				+.swiper-fade.swiper-free-mode .swiper-slide {
			
 
				+  transition-timing-function: ease-out;
			
 
				+}
			
 
				+.swiper-fade .swiper-slide {
			
 
				+  pointer-events: none;
			
 
				+  transition-property: opacity;
			
 
				+}
			
 
				+.swiper-fade .swiper-slide .swiper-slide {
			
 
				+  pointer-events: none;
			
 
				+}
			
 
				+.swiper-fade .swiper-slide-active {
			
 
				+  pointer-events: auto;
			
 
				+}
			
 
				+.swiper-fade .swiper-slide-active .swiper-slide-active {
			
 
				+  pointer-events: auto;
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-fade.less
+++ b/node_modules/swiper/modules/effect-fade.less
@@ -0,0 +1,20 @@
 
				+.swiper-fade {
			
 
				+  &.swiper-free-mode {
			
 
				+    .swiper-slide {
			
 
				+      transition-timing-function: ease-out;
			
 
				+    }
			
 
				+  }
			
 
				+  .swiper-slide {
			
 
				+    pointer-events: none;
			
 
				+    transition-property: opacity;
			
 
				+    .swiper-slide {
			
 
				+      pointer-events: none;
			
 
				+    }
			
 
				+  }
			
 
				+  .swiper-slide-active {
			
 
				+    pointer-events: auto;
			
 
				+    & .swiper-slide-active {
			
 
				+      pointer-events: auto;
			
 
				+    }
			
 
				+  }
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-fade.min.css
+++ b/node_modules/swiper/modules/effect-fade.min.css
@@ -0,0 +1 @@
 
				+.swiper-fade.swiper-free-mode .swiper-slide{transition-timing-function:ease-out}.swiper-fade .swiper-slide{pointer-events:none;transition-property:opacity}.swiper-fade .swiper-slide .swiper-slide{pointer-events:none}.swiper-fade .swiper-slide-active{pointer-events:auto}.swiper-fade .swiper-slide-active .swiper-slide-active{pointer-events:auto}
			
--- a/node_modules/swiper/modules/effect-fade.min.mjs
+++ b/node_modules/swiper/modules/effect-fade.min.mjs
@@ -0,0 +1,2 @@
 
				+import{e as effectInit}from"../shared/effect-init.min.mjs";import{e as effectTarget}from"../shared/effect-target.min.mjs";import{e as effectVirtualTransitionEnd}from"../shared/effect-virtual-transition-end.min.mjs";import{g as getSlideTransformEl}from"../shared/utils.min.mjs";function EffectFade(e){let{swiper:t,extendParams:s,on:a}=e;s({fadeEffect:{crossFade:!1}});effectInit({effect:"fade",swiper:t,on:a,setTranslate:()=>{const{slides:e}=t,s=t.params.fadeEffect;for(let a=0;a<e.length;a+=1){const e=t.slides[a];let r=-e.swiperSlideOffset;t.params.virtualTranslate||(r-=t.translate);let i=0;t.isHorizontal()||(i=r,r=0);const f=t.params.fadeEffect.crossFade?Math.max(1-Math.abs(e.progress),0):1+Math.min(Math.max(e.progress,-1),0),n=effectTarget(s,e);n.style.opacity=f,n.style.transform=`translate3d(${r}px, ${i}px, 0px)`}},setTransition:e=>{const s=t.slides.map((e=>getSlideTransformEl(e)));s.forEach((t=>{t.style.transitionDuration=`${e}ms`})),effectVirtualTransitionEnd({swiper:t,duration:e,transformElements:s,allSlides:!0})},overwriteParams:()=>({slidesPerView:1,slidesPerGroup:1,watchSlidesProgress:!0,spaceBetween:0,virtualTranslate:!t.params.cssMode})})}export{EffectFade as default};
			
 
				+//# sourceMappingURL=effect-fade.min.mjs.map
			
--- a/node_modules/swiper/modules/effect-fade.min.mjs.map
+++ b/node_modules/swiper/modules/effect-fade.min.mjs.map
@@ -0,0 +1 @@
 
				+{"version":3,"file":"effect-fade.mjs.mjs","names":["effectInit","effectTarget","effectVirtualTransitionEnd","getSlideTransformEl","EffectFade","_ref","swiper","extendParams","on","fadeEffect","crossFade","effect","setTranslate","slides","params","i","length","slideEl","tx","swiperSlideOffset","virtualTranslate","translate","ty","isHorizontal","slideOpacity","Math","max","abs","progress","min","targetEl","style","opacity","transform","setTransition","duration","transformElements","map","forEach","el","transitionDuration","allSlides","overwriteParams","slidesPerView","slidesPerGroup","watchSlidesProgress","spaceBetween","cssMode"],"sources":["0"],"mappings":"YAAcA,eAAkB,4CAClBC,iBAAoB,8CACpBC,+BAAkC,8DAClCC,wBAA2B,0BAEzC,SAASC,WAAWC,GAClB,IAAIC,OACFA,EAAMC,aACNA,EAAYC,GACZA,GACEH,EACJE,EAAa,CACXE,WAAY,CACVC,WAAW,KAoCfV,WAAW,CACTW,OAAQ,OACRL,SACAE,KACAI,aArCmB,KACnB,MAAMC,OACJA,GACEP,EACEQ,EAASR,EAAOQ,OAAOL,WAC7B,IAAK,IAAIM,EAAI,EAAGA,EAAIF,EAAOG,OAAQD,GAAK,EAAG,CACzC,MAAME,EAAUX,EAAOO,OAAOE,GAE9B,IAAIG,GADWD,EAAQE,kBAElBb,EAAOQ,OAAOM,mBAAkBF,GAAMZ,EAAOe,WAClD,IAAIC,EAAK,EACJhB,EAAOiB,iBACVD,EAAKJ,EACLA,EAAK,GAEP,MAAMM,EAAelB,EAAOQ,OAAOL,WAAWC,UAAYe,KAAKC,IAAI,EAAID,KAAKE,IAAIV,EAAQW,UAAW,GAAK,EAAIH,KAAKI,IAAIJ,KAAKC,IAAIT,EAAQW,UAAW,GAAI,GAC/IE,EAAW7B,aAAaa,EAAQG,GACtCa,EAASC,MAAMC,QAAUR,EACzBM,EAASC,MAAME,UAAY,eAAef,QAASI,WACrD,GAmBAY,cAjBoBC,IACpB,MAAMC,EAAoB9B,EAAOO,OAAOwB,KAAIpB,GAAWd,oBAAoBc,KAC3EmB,EAAkBE,SAAQC,IACxBA,EAAGR,MAAMS,mBAAqB,GAAGL,KAAY,IAE/CjC,2BAA2B,CACzBI,SACA6B,WACAC,oBACAK,WAAW,GACX,EAQFC,gBAAiB,KAAM,CACrBC,cAAe,EACfC,eAAgB,EAChBC,qBAAqB,EACrBC,aAAc,EACd1B,kBAAmBd,EAAOQ,OAAOiC,WAGvC,QAES3C"}
			
--- a/node_modules/swiper/modules/effect-fade.mjs
+++ b/node_modules/swiper/modules/effect-fade.mjs
@@ -0,0 +1,66 @@
 
				+import { e as effectInit } from '../shared/effect-init.mjs';
			
 
				+import { e as effectTarget } from '../shared/effect-target.mjs';
			
 
				+import { e as effectVirtualTransitionEnd } from '../shared/effect-virtual-transition-end.mjs';
			
 
				+import { g as getSlideTransformEl } from '../shared/utils.mjs';
			
 
				+
			
 
				+function EffectFade(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    on
			
 
				+  } = _ref;
			
 
				+  extendParams({
			
 
				+    fadeEffect: {
			
 
				+      crossFade: false
			
 
				+    }
			
 
				+  });
			
 
				+  const setTranslate = () => {
			
 
				+    const {
			
 
				+      slides
			
 
				+    } = swiper;
			
 
				+    const params = swiper.params.fadeEffect;
			
 
				+    for (let i = 0; i < slides.length; i += 1) {
			
 
				+      const slideEl = swiper.slides[i];
			
 
				+      const offset = slideEl.swiperSlideOffset;
			
 
				+      let tx = -offset;
			
 
				+      if (!swiper.params.virtualTranslate) tx -= swiper.translate;
			
 
				+      let ty = 0;
			
 
				+      if (!swiper.isHorizontal()) {
			
 
				+        ty = tx;
			
 
				+        tx = 0;
			
 
				+      }
			
 
				+      const slideOpacity = swiper.params.fadeEffect.crossFade ? Math.max(1 - Math.abs(slideEl.progress), 0) : 1 + Math.min(Math.max(slideEl.progress, -1), 0);
			
 
				+      const targetEl = effectTarget(params, slideEl);
			
 
				+      targetEl.style.opacity = slideOpacity;
			
 
				+      targetEl.style.transform = `translate3d(${tx}px, ${ty}px, 0px)`;
			
 
				+    }
			
 
				+  };
			
 
				+  const setTransition = duration => {
			
 
				+    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
			
 
				+    transformElements.forEach(el => {
			
 
				+      el.style.transitionDuration = `${duration}ms`;
			
 
				+    });
			
 
				+    effectVirtualTransitionEnd({
			
 
				+      swiper,
			
 
				+      duration,
			
 
				+      transformElements,
			
 
				+      allSlides: true
			
 
				+    });
			
 
				+  };
			
 
				+  effectInit({
			
 
				+    effect: 'fade',
			
 
				+    swiper,
			
 
				+    on,
			
 
				+    setTranslate,
			
 
				+    setTransition,
			
 
				+    overwriteParams: () => ({
			
 
				+      slidesPerView: 1,
			
 
				+      slidesPerGroup: 1,
			
 
				+      watchSlidesProgress: true,
			
 
				+      spaceBetween: 0,
			
 
				+      virtualTranslate: !swiper.params.cssMode
			
 
				+    })
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { EffectFade as default };
			
--- a/node_modules/swiper/modules/effect-fade.scss
+++ b/node_modules/swiper/modules/effect-fade.scss
@@ -0,0 +1,20 @@
 
				+.swiper-fade {
			
 
				+  &.swiper-free-mode {
			
 
				+    .swiper-slide {
			
 
				+      transition-timing-function: ease-out;
			
 
				+    }
			
 
				+  }
			
 
				+  .swiper-slide {
			
 
				+    pointer-events: none;
			
 
				+    transition-property: opacity;
			
 
				+    .swiper-slide {
			
 
				+      pointer-events: none;
			
 
				+    }
			
 
				+  }
			
 
				+  .swiper-slide-active {
			
 
				+    &,
			
 
				+    & .swiper-slide-active {
			
 
				+      pointer-events: auto;
			
 
				+    }
			
 
				+  }
			
 
				+}
			
--- a/node_modules/swiper/modules/effect-flip-element.css
+++ b/node_modules/swiper/modules/effect-flip-element.css
@@ -0,0 +1,17 @@
 
				+.swiper.swiper-flip {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-flip ::slotted(swiper-slide) {
			
 
				+  pointer-events: none;
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+  z-index: 1;
			
 
				+}
			
 
				+.swiper-flip ::slotted(swiper-slide) ::slotted(swiper-slide) {
			
 
				+  pointer-events: none;
			
 
				+}
			
 
				+.swiper-flip ::slotted(.swiper-slide-active),
			
 
				+.swiper-flip ::slotted(.swiper-slide-active) ::slotted(.swiper-slide-active) {
			
 
				+  pointer-events: auto;
			
 
				+}
			
 
				+/* Flip slide shadows start *//* Flip slide shadows end */
			
--- a/node_modules/swiper/modules/effect-flip-element.min.css
+++ b/node_modules/swiper/modules/effect-flip-element.min.css
@@ -0,0 +1 @@
 
				+.swiper.swiper-flip{overflow:visible}.swiper-flip ::slotted(swiper-slide){pointer-events:none;-webkit-backface-visibility:hidden;backface-visibility:hidden;z-index:1}.swiper-flip ::slotted(swiper-slide) ::slotted(swiper-slide){pointer-events:none}.swiper-flip ::slotted(.swiper-slide-active),.swiper-flip ::slotted(.swiper-slide-active) ::slotted(.swiper-slide-active){pointer-events:auto}
			
--- a/node_modules/swiper/modules/effect-flip.css
+++ b/node_modules/swiper/modules/effect-flip.css
@@ -0,0 +1,26 @@
 
				+.swiper.swiper-flip {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-flip .swiper-slide {
			
 
				+  pointer-events: none;
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+  z-index: 1;
			
 
				+}
			
 
				+.swiper-flip .swiper-slide .swiper-slide {
			
 
				+  pointer-events: none;
			
 
				+}
			
 
				+.swiper-flip .swiper-slide-active,
			
 
				+.swiper-flip .swiper-slide-active .swiper-slide-active {
			
 
				+  pointer-events: auto;
			
 
				+}
			
 
				+/* Flip slide shadows start */
			
 
				+.swiper-flip .swiper-slide-shadow-flip.swiper-slide-shadow-top,
			
 
				+.swiper-flip .swiper-slide-shadow-flip.swiper-slide-shadow-bottom,
			
 
				+.swiper-flip .swiper-slide-shadow-flip.swiper-slide-shadow-left,
			
 
				+.swiper-flip .swiper-slide-shadow-flip.swiper-slide-shadow-right {
			
 
				+  z-index: 0;
			
 
				+  -webkit-backface-visibility: hidden;
			
 
				+          backface-visibility: hidden;
			
 
				+}
			
 
				+/* Flip slide shadows end */
			
--- a/node_modules/swiper/modules/effect-flip.less
+++ b/node_modules/swiper/modules/effect-flip.less
@@ -0,0 +1,30 @@
 
				+.swiper.swiper-flip {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-flip {
			
 
				+  .swiper-slide {
			
 
				+    pointer-events: none;
			
 
				+    backface-visibility: hidden;
			
 
				+    z-index: 1;
			
 
				+    .swiper-slide {
			
 
				+      pointer-events: none;
			
 
				+    }
			
 
				+  }
			
 
				+  .swiper-slide-active {
			
 
				+    &,
			
 
				+    & .swiper-slide-active {
			
 
				+      pointer-events: auto;
			
 
				+    }
			
 
				+  }
			
 
				+}
			
 
				+/* Flip slide shadows start */
			
 
				+.swiper-flip {
			
 
				+  .swiper-slide-shadow-flip.swiper-slide-shadow-top,
			
 
				+  .swiper-slide-shadow-flip.swiper-slide-shadow-bottom,
			
 
				+  .swiper-slide-shadow-flip.swiper-slide-shadow-left,
			
 
				+  .swiper-slide-shadow-flip.swiper-slide-shadow-right {
			
 
				+    z-index: 0;
			
 
				+    backface-visibility: hidden;
			
 
				+  }
			
 
				+}
			
 
				+/* Flip slide shadows end */
			
--- a/node_modules/swiper/modules/effect-flip.min.css
+++ b/node_modules/swiper/modules/effect-flip.min.css
@@ -0,0 +1 @@
 
				+.swiper.swiper-flip{overflow:visible}.swiper-flip .swiper-slide{pointer-events:none;-webkit-backface-visibility:hidden;backface-visibility:hidden;z-index:1}.swiper-flip .swiper-slide .swiper-slide{pointer-events:none}.swiper-flip .swiper-slide-active,.swiper-flip .swiper-slide-active .swiper-slide-active{pointer-events:auto}.swiper-flip .swiper-slide-shadow-flip.swiper-slide-shadow-bottom,.swiper-flip .swiper-slide-shadow-flip.swiper-slide-shadow-left,.swiper-flip .swiper-slide-shadow-flip.swiper-slide-shadow-right,.swiper-flip .swiper-slide-shadow-flip.swiper-slide-shadow-top{z-index:0;-webkit-backface-visibility:hidden;backface-visibility:hidden}
			
--- a/node_modules/swiper/modules/effect-flip.min.mjs
+++ b/node_modules/swiper/modules/effect-flip.min.mjs
--- a/node_modules/swiper/modules/effect-flip.min.mjs.map
+++ b/node_modules/swiper/modules/effect-flip.min.mjs.map
--- a/node_modules/swiper/modules/effect-flip.mjs
+++ b/node_modules/swiper/modules/effect-flip.mjs
@@ -0,0 +1,111 @@
 
				+import { c as createShadow } from '../shared/create-shadow.mjs';
			
 
				+import { e as effectInit } from '../shared/effect-init.mjs';
			
 
				+import { e as effectTarget } from '../shared/effect-target.mjs';
			
 
				+import { e as effectVirtualTransitionEnd } from '../shared/effect-virtual-transition-end.mjs';
			
 
				+import { g as getSlideTransformEl, o as getRotateFix } from '../shared/utils.mjs';
			
 
				+
			
 
				+function EffectFlip(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    on
			
 
				+  } = _ref;
			
 
				+  extendParams({
			
 
				+    flipEffect: {
			
 
				+      slideShadows: true,
			
 
				+      limitRotation: true
			
 
				+    }
			
 
				+  });
			
 
				+  const createSlideShadows = (slideEl, progress) => {
			
 
				+    let shadowBefore = swiper.isHorizontal() ? slideEl.querySelector('.swiper-slide-shadow-left') : slideEl.querySelector('.swiper-slide-shadow-top');
			
 
				+    let shadowAfter = swiper.isHorizontal() ? slideEl.querySelector('.swiper-slide-shadow-right') : slideEl.querySelector('.swiper-slide-shadow-bottom');
			
 
				+    if (!shadowBefore) {
			
 
				+      shadowBefore = createShadow('flip', slideEl, swiper.isHorizontal() ? 'left' : 'top');
			
 
				+    }
			
 
				+    if (!shadowAfter) {
			
 
				+      shadowAfter = createShadow('flip', slideEl, swiper.isHorizontal() ? 'right' : 'bottom');
			
 
				+    }
			
 
				+    if (shadowBefore) shadowBefore.style.opacity = Math.max(-progress, 0);
			
 
				+    if (shadowAfter) shadowAfter.style.opacity = Math.max(progress, 0);
			
 
				+  };
			
 
				+  const recreateShadows = () => {
			
 
				+    // Set shadows
			
 
				+    swiper.params.flipEffect;
			
 
				+    swiper.slides.forEach(slideEl => {
			
 
				+      let progress = slideEl.progress;
			
 
				+      if (swiper.params.flipEffect.limitRotation) {
			
 
				+        progress = Math.max(Math.min(slideEl.progress, 1), -1);
			
 
				+      }
			
 
				+      createSlideShadows(slideEl, progress);
			
 
				+    });
			
 
				+  };
			
 
				+  const setTranslate = () => {
			
 
				+    const {
			
 
				+      slides,
			
 
				+      rtlTranslate: rtl
			
 
				+    } = swiper;
			
 
				+    const params = swiper.params.flipEffect;
			
 
				+    const rotateFix = getRotateFix(swiper);
			
 
				+    for (let i = 0; i < slides.length; i += 1) {
			
 
				+      const slideEl = slides[i];
			
 
				+      let progress = slideEl.progress;
			
 
				+      if (swiper.params.flipEffect.limitRotation) {
			
 
				+        progress = Math.max(Math.min(slideEl.progress, 1), -1);
			
 
				+      }
			
 
				+      const offset = slideEl.swiperSlideOffset;
			
 
				+      const rotate = -180 * progress;
			
 
				+      let rotateY = rotate;
			
 
				+      let rotateX = 0;
			
 
				+      let tx = swiper.params.cssMode ? -offset - swiper.translate : -offset;
			
 
				+      let ty = 0;
			
 
				+      if (!swiper.isHorizontal()) {
			
 
				+        ty = tx;
			
 
				+        tx = 0;
			
 
				+        rotateX = -rotateY;
			
 
				+        rotateY = 0;
			
 
				+      } else if (rtl) {
			
 
				+        rotateY = -rotateY;
			
 
				+      }
			
 
				+      slideEl.style.zIndex = -Math.abs(Math.round(progress)) + slides.length;
			
 
				+      if (params.slideShadows) {
			
 
				+        createSlideShadows(slideEl, progress);
			
 
				+      }
			
 
				+      const transform = `translate3d(${tx}px, ${ty}px, 0px) rotateX(${rotateFix(rotateX)}deg) rotateY(${rotateFix(rotateY)}deg)`;
			
 
				+      const targetEl = effectTarget(params, slideEl);
			
 
				+      targetEl.style.transform = transform;
			
 
				+    }
			
 
				+  };
			
 
				+  const setTransition = duration => {
			
 
				+    const transformElements = swiper.slides.map(slideEl => getSlideTransformEl(slideEl));
			
 
				+    transformElements.forEach(el => {
			
 
				+      el.style.transitionDuration = `${duration}ms`;
			
 
				+      el.querySelectorAll('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').forEach(shadowEl => {
			
 
				+        shadowEl.style.transitionDuration = `${duration}ms`;
			
 
				+      });
			
 
				+    });
			
 
				+    effectVirtualTransitionEnd({
			
 
				+      swiper,
			
 
				+      duration,
			
 
				+      transformElements
			
 
				+    });
			
 
				+  };
			
 
				+  effectInit({
			
 
				+    effect: 'flip',
			
 
				+    swiper,
			
 
				+    on,
			
 
				+    setTranslate,
			
 
				+    setTransition,
			
 
				+    recreateShadows,
			
 
				+    getEffectParams: () => swiper.params.flipEffect,
			
 
				+    perspective: () => true,
			
 
				+    overwriteParams: () => ({
			
 
				+      slidesPerView: 1,
			
 
				+      slidesPerGroup: 1,
			
 
				+      watchSlidesProgress: true,
			
 
				+      spaceBetween: 0,
			
 
				+      virtualTranslate: !swiper.params.cssMode
			
 
				+    })
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { EffectFlip as default };
			
--- a/node_modules/swiper/modules/effect-flip.scss
+++ b/node_modules/swiper/modules/effect-flip.scss
@@ -0,0 +1,30 @@
 
				+.swiper.swiper-flip {
			
 
				+  overflow: visible;
			
 
				+}
			
 
				+.swiper-flip {
			
 
				+  .swiper-slide {
			
 
				+    pointer-events: none;
			
 
				+    backface-visibility: hidden;
			
 
				+    z-index: 1;
			
 
				+    .swiper-slide {
			
 
				+      pointer-events: none;
			
 
				+    }
			
 
				+  }
			
 
				+  .swiper-slide-active {
			
 
				+    &,
			
 
				+    & .swiper-slide-active {
			
 
				+      pointer-events: auto;
			
 
				+    }
			
 
				+  }
			
 
				+}
			
 
				+/* Flip slide shadows start */
			
 
				+.swiper-flip {
			
 
				+  .swiper-slide-shadow-flip.swiper-slide-shadow-top,
			
 
				+  .swiper-slide-shadow-flip.swiper-slide-shadow-bottom,
			
 
				+  .swiper-slide-shadow-flip.swiper-slide-shadow-left,
			
 
				+  .swiper-slide-shadow-flip.swiper-slide-shadow-right {
			
 
				+    z-index: 0;
			
 
				+    backface-visibility: hidden;
			
 
				+  }
			
 
				+}
			
 
				+/* Flip slide shadows end */
			
--- a/node_modules/swiper/modules/free-mode-element.css
+++ b/node_modules/swiper/modules/free-mode-element.css
@@ -0,0 +1,4 @@
 
				+.swiper-free-mode > .swiper-wrapper {
			
 
				+  transition-timing-function: ease-out;
			
 
				+  margin: 0 auto;
			
 
				+}
			
--- a/node_modules/swiper/modules/free-mode-element.min.css
+++ b/node_modules/swiper/modules/free-mode-element.min.css
@@ -0,0 +1 @@
 
				+.swiper-free-mode>.swiper-wrapper{transition-timing-function:ease-out;margin:0 auto}
			
--- a/node_modules/swiper/modules/free-mode.css
+++ b/node_modules/swiper/modules/free-mode.css
@@ -0,0 +1,4 @@
 
				+.swiper-free-mode > .swiper-wrapper {
			
 
				+  transition-timing-function: ease-out;
			
 
				+  margin: 0 auto;
			
 
				+}
			
--- a/node_modules/swiper/modules/free-mode.less
+++ b/node_modules/swiper/modules/free-mode.less
@@ -0,0 +1,4 @@
 
				+.swiper-free-mode > .swiper-wrapper {
			
 
				+  transition-timing-function: ease-out;
			
 
				+  margin: 0 auto;
			
 
				+}
			
--- a/node_modules/swiper/modules/free-mode.min.css
+++ b/node_modules/swiper/modules/free-mode.min.css
@@ -0,0 +1 @@
 
				+.swiper-free-mode>.swiper-wrapper{transition-timing-function:ease-out;margin:0 auto}
			
--- a/node_modules/swiper/modules/free-mode.min.mjs
+++ b/node_modules/swiper/modules/free-mode.min.mjs
--- a/node_modules/swiper/modules/free-mode.min.mjs.map
+++ b/node_modules/swiper/modules/free-mode.min.mjs.map
--- a/node_modules/swiper/modules/free-mode.mjs
+++ b/node_modules/swiper/modules/free-mode.mjs
@@ -0,0 +1,237 @@
 
				+import { d as now, k as elementTransitionEnd } from '../shared/utils.mjs';
			
 
				+
			
 
				+function freeMode(_ref) {
			
 
				+  let {
			
 
				+    swiper,
			
 
				+    extendParams,
			
 
				+    emit,
			
 
				+    once
			
 
				+  } = _ref;
			
 
				+  extendParams({
			
 
				+    freeMode: {
			
 
				+      enabled: false,
			
 
				+      momentum: true,
			
 
				+      momentumRatio: 1,
			
 
				+      momentumBounce: true,
			
 
				+      momentumBounceRatio: 1,
			
 
				+      momentumVelocityRatio: 1,
			
 
				+      sticky: false,
			
 
				+      minimumVelocity: 0.02
			
 
				+    }
			
 
				+  });
			
 
				+  function onTouchStart() {
			
 
				+    if (swiper.params.cssMode) return;
			
 
				+    const translate = swiper.getTranslate();
			
 
				+    swiper.setTranslate(translate);
			
 
				+    swiper.setTransition(0);
			
 
				+    swiper.touchEventsData.velocities.length = 0;
			
 
				+    swiper.freeMode.onTouchEnd({
			
 
				+      currentPos: swiper.rtl ? swiper.translate : -swiper.translate
			
 
				+    });
			
 
				+  }
			
 
				+  function onTouchMove() {
			
 
				+    if (swiper.params.cssMode) return;
			
 
				+    const {
			
 
				+      touchEventsData: data,
			
 
				+      touches
			
 
				+    } = swiper;
			
 
				+    // Velocity
			
 
				+    if (data.velocities.length === 0) {
			
 
				+      data.velocities.push({
			
 
				+        position: touches[swiper.isHorizontal() ? 'startX' : 'startY'],
			
 
				+        time: data.touchStartTime
			
 
				+      });
			
 
				+    }
			
 
				+    data.velocities.push({
			
 
				+      position: touches[swiper.isHorizontal() ? 'currentX' : 'currentY'],
			
 
				+      time: now()
			
 
				+    });
			
 
				+  }
			
 
				+  function onTouchEnd(_ref2) {
			
 
				+    let {
			
 
				+      currentPos
			
 
				+    } = _ref2;
			
 
				+    if (swiper.params.cssMode) return;
			
 
				+    const {
			
 
				+      params,
			
 
				+      wrapperEl,
			
 
				+      rtlTranslate: rtl,
			
 
				+      snapGrid,
			
 
				+      touchEventsData: data
			
 
				+    } = swiper;
			
 
				+    // Time diff
			
 
				+    const touchEndTime = now();
			
 
				+    const timeDiff = touchEndTime - data.touchStartTime;
			
 
				+    if (currentPos < -swiper.minTranslate()) {
			
 
				+      swiper.slideTo(swiper.activeIndex);
			
 
				+      return;
			
 
				+    }
			
 
				+    if (currentPos > -swiper.maxTranslate()) {
			
 
				+      if (swiper.slides.length < snapGrid.length) {
			
 
				+        swiper.slideTo(snapGrid.length - 1);
			
 
				+      } else {
			
 
				+        swiper.slideTo(swiper.slides.length - 1);
			
 
				+      }
			
 
				+      return;
			
 
				+    }
			
 
				+    if (params.freeMode.momentum) {
			
 
				+      if (data.velocities.length > 1) {
			
 
				+        const lastMoveEvent = data.velocities.pop();
			
 
				+        const velocityEvent = data.velocities.pop();
			
 
				+        const distance = lastMoveEvent.position - velocityEvent.position;
			
 
				+        const time = lastMoveEvent.time - velocityEvent.time;
			
 
				+        swiper.velocity = distance / time;
			
 
				+        swiper.velocity /= 2;
			
 
				+        if (Math.abs(swiper.velocity) < params.freeMode.minimumVelocity) {
			
 
				+          swiper.velocity = 0;
			
 
				+        }
			
 
				+        // this implies that the user stopped moving a finger then released.
			
 
				+        // There would be no events with distance zero, so the last event is stale.
			
 
				+        if (time > 150 || now() - lastMoveEvent.time > 300) {
			
 
				+          swiper.velocity = 0;
			
 
				+        }
			
 
				+      } else {
			
 
				+        swiper.velocity = 0;
			
 
				+      }
			
 
				+      swiper.velocity *= params.freeMode.momentumVelocityRatio;
			
 
				+      data.velocities.length = 0;
			
 
				+      let momentumDuration = 1000 * params.freeMode.momentumRatio;
			
 
				+      const momentumDistance = swiper.velocity * momentumDuration;
			
 
				+      let newPosition = swiper.translate + momentumDistance;
			
 
				+      if (rtl) newPosition = -newPosition;
			
 
				+      let doBounce = false;
			
 
				+      let afterBouncePosition;
			
 
				+      const bounceAmount = Math.abs(swiper.velocity) * 20 * params.freeMode.momentumBounceRatio;
			
 
				+      let needsLoopFix;
			
 
				+      if (newPosition < swiper.maxTranslate()) {
			
 
				+        if (params.freeMode.momentumBounce) {
			
 
				+          if (newPosition + swiper.maxTranslate() < -bounceAmount) {
			
 
				+            newPosition = swiper.maxTranslate() - bounceAmount;
			
 
				+          }
			
 
				+          afterBouncePosition = swiper.maxTranslate();
			
 
				+          doBounce = true;
			
 
				+          data.allowMomentumBounce = true;
			
 
				+        } else {
			
 
				+          newPosition = swiper.maxTranslate();
			
 
				+        }
			
 
				+        if (params.loop && params.centeredSlides) needsLoopFix = true;
			
 
				+      } else if (newPosition > swiper.minTranslate()) {
			
 
				+        if (params.freeMode.momentumBounce) {
			
 
				+          if (newPosition - swiper.minTranslate() > bounceAmount) {
			
 
				+            newPosition = swiper.minTranslate() + bounceAmount;
			
 
				+          }
			
 
				+          afterBouncePosition = swiper.minTranslate();
			
 
				+          doBounce = true;
			
 
				+          data.allowMomentumBounce = true;
			
 
				+        } else {
			
 
				+          newPosition = swiper.minTranslate();
			
 
				+        }
			
 
				+        if (params.loop && params.centeredSlides) needsLoopFix = true;
			
 
				+      } else if (params.freeMode.sticky) {
			
 
				+        let nextSlide;
			
 
				+        for (let j = 0; j < snapGrid.length; j += 1) {
			
 
				+          if (snapGrid[j] > -newPosition) {
			
 
				+            nextSlide = j;
			
 
				+            break;
			
 
				+          }
			
 
				+        }
			
 
				+        if (Math.abs(snapGrid[nextSlide] - newPosition) < Math.abs(snapGrid[nextSlide - 1] - newPosition) || swiper.swipeDirection === 'next') {
			
 
				+          newPosition = snapGrid[nextSlide];
			
 
				+        } else {
			
 
				+          newPosition = snapGrid[nextSlide - 1];
			
 
				+        }
			
 
				+        newPosition = -newPosition;
			
 
				+      }
			
 
				+      if (needsLoopFix) {
			
 
				+        once('transitionEnd', () => {
			
 
				+          swiper.loopFix();
			
 
				+        });
			
 
				+      }
			
 
				+      // Fix duration
			
 
				+      if (swiper.velocity !== 0) {
			
 
				+        if (rtl) {
			
 
				+          momentumDuration = Math.abs((-newPosition - swiper.translate) / swiper.velocity);
			
 
				+        } else {
			
 
				+          momentumDuration = Math.abs((newPosition - swiper.translate) / swiper.velocity);
			
 
				+        }
			
 
				+        if (params.freeMode.sticky) {
			
 
				+          // If freeMode.sticky is active and the user ends a swipe with a slow-velocity
			
 
				+          // event, then durations can be 20+ seconds to slide one (or zero!) slides.
			
 
				+          // It's easy to see this when simulating touch with mouse events. To fix this,
			
 
				+          // limit single-slide swipes to the default slide duration. This also has the
			
 
				+          // nice side effect of matching slide speed if the user stopped moving before
			
 
				+          // lifting finger or mouse vs. moving slowly before lifting the finger/mouse.
			
 
				+          // For faster swipes, also apply limits (albeit higher ones).
			
 
				+          const moveDistance = Math.abs((rtl ? -newPosition : newPosition) - swiper.translate);
			
 
				+          const currentSlideSize = swiper.slidesSizesGrid[swiper.activeIndex];
			
 
				+          if (moveDistance < currentSlideSize) {
			
 
				+            momentumDuration = params.speed;
			
 
				+          } else if (moveDistance < 2 * currentSlideSize) {
			
 
				+            momentumDuration = params.speed * 1.5;
			
 
				+          } else {
			
 
				+            momentumDuration = params.speed * 2.5;
			
 
				+          }
			
 
				+        }
			
 
				+      } else if (params.freeMode.sticky) {
			
 
				+        swiper.slideToClosest();
			
 
				+        return;
			
 
				+      }
			
 
				+      if (params.freeMode.momentumBounce && doBounce) {
			
 
				+        swiper.updateProgress(afterBouncePosition);
			
 
				+        swiper.setTransition(momentumDuration);
			
 
				+        swiper.setTranslate(newPosition);
			
 
				+        swiper.transitionStart(true, swiper.swipeDirection);
			
 
				+        swiper.animating = true;
			
 
				+        elementTransitionEnd(wrapperEl, () => {
			
 
				+          if (!swiper || swiper.destroyed || !data.allowMomentumBounce) return;
			
 
				+          emit('momentumBounce');
			
 
				+          swiper.setTransition(params.speed);
			
 
				+          setTimeout(() => {
			
 
				+            swiper.setTranslate(afterBouncePosition);
			
 
				+            elementTransitionEnd(wrapperEl, () => {
			
 
				+              if (!swiper || swiper.destroyed) return;
			
 
				+              swiper.transitionEnd();
			
 
				+            });
			
 
				+          }, 0);
			
 
				+        });
			
 
				+      } else if (swiper.velocity) {
			
 
				+        emit('_freeModeNoMomentumRelease');
			
 
				+        swiper.updateProgress(newPosition);
			
 
				+        swiper.setTransition(momentumDuration);
			
 
				+        swiper.setTranslate(newPosition);
			
 
				+        swiper.transitionStart(true, swiper.swipeDirection);
			
 
				+        if (!swiper.animating) {
			
 
				+          swiper.animating = true;
			
 
				+          elementTransitionEnd(wrapperEl, () => {
			
 
				+            if (!swiper || swiper.destroyed) return;
			
 
				+            swiper.transitionEnd();
			
 
				+          });
			
 
				+        }
			
 
				+      } else {
			
 
				+        swiper.updateProgress(newPosition);
			
 
				+      }
			
 
				+      swiper.updateActiveIndex();
			
 
				+      swiper.updateSlidesClasses();
			
 
				+    } else if (params.freeMode.sticky) {
			
 
				+      swiper.slideToClosest();
			
 
				+      return;
			
 
				+    } else if (params.freeMode) {
			
 
				+      emit('_freeModeNoMomentumRelease');
			
 
				+    }
			
 
				+    if (!params.freeMode.momentum || timeDiff >= params.longSwipesMs) {
			
 
				+      emit('_freeModeStaticRelease');
			
 
				+      swiper.updateProgress();
			
 
				+      swiper.updateActiveIndex();
			
 
				+      swiper.updateSlidesClasses();
			
 
				+    }
			
 
				+  }
			
 
				+  Object.assign(swiper, {
			
 
				+    freeMode: {
			
 
				+      onTouchStart,
			
 
				+      onTouchMove,
			
 
				+      onTouchEnd
			
 
				+    }
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+export { freeMode as default };
			
--- a/node_modules/swiper/modules/free-mode.scss
+++ b/node_modules/swiper/modules/free-mode.scss
@@ -0,0 +1,4 @@
 
				+.swiper-free-mode > .swiper-wrapper {
			
 
				+  transition-timing-function: ease-out;
			
 
				+  margin: 0 auto;
			
 
				+}
			
--- a/node_modules/swiper/modules/grid-element.css
+++ b/node_modules/swiper/modules/grid-element.css
@@ -0,0 +1,7 @@
 
				+.swiper-grid > .swiper-wrapper {
			
 
				+  flex-wrap: wrap;
			
 
				+}
			
 
				+.swiper-grid-column > .swiper-wrapper {
			
 
				+  flex-wrap: wrap;
			
 
				+  flex-direction: column;
			
 
				+}
			
--- a/node_modules/swiper/modules/grid-element.min.css
+++ b/node_modules/swiper/modules/grid-element.min.css
@@ -0,0 +1 @@
 
				+.swiper-grid>.swiper-wrapper{flex-wrap:wrap}.swiper-grid-column>.swiper-wrapper{flex-wrap:wrap;flex-direction:column}
			
--- a/node_modules/swiper/modules/grid.css
+++ b/node_modules/swiper/modules/grid.css
@@ -0,0 +1,7 @@
 
				+.swiper-grid > .swiper-wrapper {
			
 
				+  flex-wrap: wrap;
			
 
				+}
			
 
				+.swiper-grid-column > .swiper-wrapper {
			
 
				+  flex-wrap: wrap;
			
 
				+  flex-direction: column;
			
 
				+}
			
--- a/node_modules/swiper/modules/grid.less
+++ b/node_modules/swiper/modules/grid.less
@@ -0,0 +1,7 @@
 
				+.swiper-grid > .swiper-wrapper {
			
 
				+  flex-wrap: wrap;
			
 
				+}
			
 
				+.swiper-grid-column > .swiper-wrapper {
			
 
				+  flex-wrap: wrap;
			
 
				+  flex-direction: column;
			
 
				+}
			
--- a/node_modules/swiper/modules/grid.min.css
+++ b/node_modules/swiper/modules/grid.min.css
@@ -0,0 +1 @@
 
				+.swiper-grid>.swiper-wrapper{flex-wrap:wrap}.swiper-grid-column>.swiper-wrapper{flex-wrap:wrap;flex-direction:column}
			
--- a/node_modules/swiper/modules/grid.min.mjs
+++ b/node_modules/swiper/modules/grid.min.mjs
		`@@ -0,0 +1 @@`
		`+.swiper .swiper-notification{position:absolute;left:0;top:0;pointer-events:none;opacity:0;z-index:-1000}`
		`@@ -0,0 +1 @@`
		`+.swiper.swiper-cards{overflow:visible}.swiper-cards .swiper-slide{transform-origin:center bottom;-webkit-backface-visibility:hidden;backface-visibility:hidden;overflow:hidden}`
		`@@ -0,0 +1 @@`
		`+.swiper-creative ::slotted(swiper-slide){-webkit-backface-visibility:hidden;backface-visibility:hidden;overflow:hidden;transition-property:transform,opacity,height}`
		`@@ -0,0 +1 @@`
		`+.swiper-creative .swiper-slide{-webkit-backface-visibility:hidden;backface-visibility:hidden;overflow:hidden;transition-property:transform,opacity,height}`
		`@@ -0,0 +1 @@`
		`+.swiper-free-mode>.swiper-wrapper{transition-timing-function:ease-out;margin:0 auto}`
		`@@ -0,0 +1 @@`
		`+.swiper-grid>.swiper-wrapper{flex-wrap:wrap}.swiper-grid-column>.swiper-wrapper{flex-wrap:wrap;flex-direction:column}`