feat: enhance My Space page with dynamic content and improved UI

- Redesigned My Space page with sidebar navigation and content area layout
- Implemented dynamic content switching between sections without routing
- Added active state highlighting for menu items
- Improved visual design with better spacing, shadows and transitions
- Added welcome message and placeholder content for sub-sections
- Updated SCSS for responsive layout and better visual hierarchy

Added Swiper dependency for future carousel/scroll features

cloth-dit-web/src/modules/cloth/color/page/pages-my-space/pages-my-space/pages-my-space.html

@@ -1,4 +1,3 @@
-<p>pages-my-space works!</p>
 <div class="profile-page">
   <div class="profile-header">
     <div class="avatar">👤</div>
@@ -7,47 +6,69 @@
   </div>
 
   <div class="profile-menu">
-    <div class="menu-item" (click)="showMyDesigns()">
+    <!-- 我的设计稿 -->
+    <div class="menu-item" (click)="showMyDesigns()" [class.active]="activeMenu === 'my-designs'">
       <div class="menu-left">
         <span class="menu-icon">🎨</span>
         <span>我的设计稿</span>
       </div>
-      <span>></span>
+      <span *ngIf="!isLoading || activeMenu !== 'my-designs'">></span>
+      <span *ngIf="isLoading && activeMenu === 'my-designs'" class="loading">...</span>
     </div>
-    <div class="menu-item" (click)="showTryOnHistory()">
+    
+    <!-- 试穿历史 -->
+    <div class="menu-item" (click)="showTryOnHistory()" [class.active]="activeMenu === 'fitting-history'">
       <div class="menu-left">
         <span class="menu-icon">👕</span>
         <span>试穿历史</span>
       </div>
-      <span>></span>
+      <span *ngIf="!isLoading || activeMenu !== 'fitting-history'">></span>
+      <span *ngIf="isLoading && activeMenu === 'fitting-history'" class="loading">...</span>
     </div>
-    <div class="menu-item" (click)="showOrders()">
+    
+    <!-- 订单管理 -->
+    <div class="menu-item" (click)="showOrders()" [class.active]="activeMenu === 'order-management'">
       <div class="menu-left">
         <span class="menu-icon">📦</span>
         <span>订单管理</span>
       </div>
-      <span>></span>
+      <span *ngIf="!isLoading || activeMenu !== 'order-management'">></span>
+      <span *ngIf="isLoading && activeMenu === 'order-management'" class="loading">...</span>
     </div>
-    <div class="menu-item" (click)="showCollections()">
+    
+    <!-- 收藏夹 -->
+    <div class="menu-item" (click)="showCollections()" [class.active]="activeMenu === 'collections'">
       <div class="menu-left">
         <span class="menu-icon">❤️</span>
         <span>收藏夹</span>
       </div>
-      <span>></span>
+      <span *ngIf="!isLoading || activeMenu !== 'collections'">></span>
+      <span *ngIf="isLoading && activeMenu === 'collections'" class="loading">...</span>
     </div>
-    <div class="menu-item" (click)="showFollowers()">
+    
+    <!-- 粉丝管理 -->
+    <div class="menu-item" (click)="showFollowers()" [class.active]="activeMenu === 'followers'">
       <div class="menu-left">
         <span class="menu-icon">👥</span>
         <span>粉丝管理</span>
       </div>
-      <span>></span>
+      <span *ngIf="!isLoading || activeMenu !== 'followers'">></span>
+      <span *ngIf="isLoading && activeMenu === 'followers'" class="loading">...</span>
     </div>
-    <div class="menu-item" (click)="showSettings()">
+    
+    <!-- 设置 -->
+    <div class="menu-item" (click)="showSettings()" [class.active]="activeMenu === 'settings'">
       <div class="menu-left">
         <span class="menu-icon">⚙️</span>
         <span>设置</span>
       </div>
-      <span>></span>
+      <span *ngIf="!isLoading || activeMenu !== 'settings'">></span>
+      <span *ngIf="isLoading && activeMenu === 'settings'" class="loading">...</span>
     </div>
   </div>
+  
+  <!-- 全局加载指示器 -->
+  <div *ngIf="isLoading" class="global-loading">
+    <div class="loading-spinner"></div>
+  </div>
 </div>

cloth-dit-web/src/modules/cloth/color/page/pages-my-space/pages-my-space/pages-my-space.scss

@@ -53,4 +53,44 @@
 .menu-icon {
   font-size: 18px;
   color: #667eea;
+}
+
+// pages-my-space.scss
+/* 原有样式保持不变，添加以下新样式 */
+
+.menu-item.active {
+  background-color: #f0f4ff;
+  border-left: 4px solid #667eea;
+}
+
+.loading {
+  color: #667eea;
+  font-weight: bold;
+}
+
+.global-loading {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(255, 255, 255, 0.7);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+}
+
+.loading-spinner {
+  width: 40px;
+  height: 40px;
+  border: 4px solid #f3f3f3;
+  border-top: 4px solid #667eea;
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
 }

cloth-dit-web/src/modules/cloth/color/page/pages-my-space/pages-my-space/pages-my-space.ts

@@ -1,4 +1,6 @@
+// pages-my-space.ts
 import { Component } from '@angular/core';
+import { Router } from '@angular/router';
 
 @Component({
   selector: 'app-pages-my-space',
@@ -7,33 +9,49 @@ import { Component } from '@angular/core';
   styleUrl: './pages-my-space.scss'
 })
 export class PagesMySpace {
+  isLoading = false;
+  activeMenu: string | null = null;
+
+  constructor(private router: Router) {}
+
+  async navigateTo(route: string) {
+    this.isLoading = true;
+    this.activeMenu = route;
+    
+    try {
+      // 模拟网络延迟
+      await new Promise(resolve => setTimeout(resolve, 300));
+      
+      // 在实际应用中，你可以使用:
+      // this.router.navigate([route]);
+      
+      console.log(`Navigate to ${route}`);
+    } finally {
+      this.isLoading = false;
+    }
+  }
+
   showMyDesigns() {
-    console.log('Navigate to My Designs');
-    // In a real app, you would navigate to the my-designs component
+    this.navigateTo('my-designs');
   }
 
   showTryOnHistory() {
-    console.log('Navigate to Fitting History');
-    // In a real app, you would navigate to the fitting-history component
+    this.navigateTo('fitting-history');
   }
 
   showOrders() {
-    console.log('Navigate to Order Management');
-    // In a real app, you would navigate to the order-management component
+    this.navigateTo('order-management');
   }
 
   showCollections() {
-    console.log('Navigate to Collections');
-    // In a real app, you would navigate to the collections component
+    this.navigateTo('collections');
   }
 
   showFollowers() {
-    console.log('Navigate to Followers');
-    // In a real app, you would navigate to the followers component
+    this.navigateTo('followers');
   }
 
   showSettings() {
-    console.log('Navigate to Settings');
-    // In a real app, you would navigate to the settings component
+    this.navigateTo('settings');
   }
 }

node_modules/.package-lock.json

@@ -0,0 +1,32 @@
+{
+  "name": "cloth-color11",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@types/swiper": {
+      "version": "5.4.3",
+      "resolved": "https://registry.npmjs.org/@types/swiper/-/swiper-5.4.3.tgz",
+      "integrity": "sha512-hJXpVeANf+XQXgbvmuFZdsnaSOKqOEZcaLDnHhZOJDRow+lfboatwubW+Ay9XiHobMGyEomkgpXSYRlDVn4gMQ==",
+      "license": "MIT"
+    },
+    "node_modules/swiper": {
+      "version": "11.2.10",
+      "resolved": "https://registry.npmjs.org/swiper/-/swiper-11.2.10.tgz",
+      "integrity": "sha512-RMeVUUjTQH+6N3ckimK93oxz6Sn5la4aDlgPzB+rBrG/smPdCTicXyhxa+woIpopz+jewEloiEE3lKo1h9w2YQ==",
+      "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/@types/swiper/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

node_modules/@types/swiper/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/swiper`
+
+# Summary
+This package contains type definitions for Swiper (https://github.com/nolimits4web/Swiper).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/swiper.
+
+### Additional Details
+ * Last updated: Fri, 02 Jul 2021 22:33:19 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Sebastián Galiano](https://github.com/sgaliano), [Luca Trazzi](https://github.com/lucax88x), [Eugene Matseruk](https://github.com/ematseruk), [Luiz M.](https://github.com/odahcam), [Justin Abene](https://github.com/jmca), [Asif Rahman](https://github.com/daem0ndev), [Liad Idan](https://github.com/LiadIdan), and [Sangwon Lee](https://github.com/john015).

node_modules/@types/swiper/index.d.ts

@@ -0,0 +1,1684 @@
+// Type definitions for Swiper 5.4
+// Project: https://github.com/nolimits4web/Swiper, http://www.idangero.us/swiper
+// Definitions by: Sebastián Galiano <https://github.com/sgaliano>
+//                 Luca Trazzi <https://github.com/lucax88x>
+//                 Eugene Matseruk <https://github.com/ematseruk>
+//                 Luiz M. <https://github.com/odahcam>
+//                 Justin Abene <https://github.com/jmca>
+//                 Asif Rahman <https://github.com/daem0ndev>
+//                 Liad Idan <https://github.com/LiadIdan>
+//                 Sangwon Lee <https://github.com/john015>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.9
+
+/**
+ * Common Swiper events.
+ */
+export type CommonEvent =
+    | 'init'
+    | 'beforeDestroy'
+    | 'slideChange'
+    | 'slideChangeTransitionStart'
+    | 'slideChangeTransitionEnd'
+    | 'slideNextTransitionStart'
+    | 'slideNextTransitionEnd'
+    | 'slidePrevTransitionStart'
+    | 'slidePrevTransitionEnd'
+    | 'transitionStart'
+    | 'transitionEnd'
+    | 'touchStart'
+    | 'touchMove'
+    | 'touchMoveOpposite'
+    | 'sliderMove'
+    | 'touchEnd'
+    | 'click'
+    | 'tap'
+    | 'doubleTap'
+    | 'imagesReady'
+    | 'progress'
+    | 'reachBeginning'
+    | 'reachEnd'
+    | 'fromEdge'
+    | 'setTranslate'
+    | 'setTransition'
+    | 'resize'
+    | 'observerUpdate'
+    | 'beforeLoopFix'
+    | 'loopFix';
+
+/**
+ * Swiper pagination event names.
+ */
+export type PaginationEvent = 'paginationRender' | 'paginationUpdate';
+
+/**
+ * Swiper autoplay event names.
+ */
+export type AutoplayEvent = 'autoplayStart' | 'autoplayStop' | 'autoplay';
+
+/**
+ * Swiper lazy-loading event names.
+ */
+export type LazyLoadingEvent = 'lazyImageLoad' | 'lazyImageReady';
+
+/**
+ * Swiper hash-navigation event names.
+ */
+export type HashNavigationEvent = 'hashChange' | 'hashSet';
+
+/**
+ * Swiper event names.
+ */
+export type SwiperEvent = CommonEvent | PaginationEvent | AutoplayEvent | LazyLoadingEvent | HashNavigationEvent;
+
+/**
+ * Swiper module types.
+ */
+export type SwiperModule =
+    | Navigation
+    | Pagination
+    | Scrollbar
+    | Autoplay
+    | Parallax
+    | Lazy
+    | EffectFade
+    | EffectCoverflow
+    | EffectFlip
+    | EffectCube
+    | Zoom
+    | Keyboard
+    | Mousewheel
+    | Virtual
+    | HashNavigation
+    | History
+    | Controller
+    | A11y;
+
+export type DOM7Element = any;
+export type SelectableElement = string | HTMLElement;
+
+/*
+ * Swiper options and events.
+ */
+
+/**
+ * Main constructor options.
+ */
+export interface SwiperOptions {
+    /**
+     * Whether Swiper should be initialised automatically when you create an instance.
+     * If disabled, then you need to init it manually by calling mySwiper.init()
+     *
+     * @default true
+     */
+    init?: boolean | undefined;
+
+    /**
+     * Swiper will recalculate slides position on window resize (orientationchange)
+     *
+     * @default true
+     */
+    updateOnWindowResize?: boolean | undefined;
+
+    /**
+     * Index number of initial slide.
+     *
+     * @default 0
+     */
+    initialSlide?: number | undefined;
+
+    /**
+     * Could be 'horizontal' or 'vertical' (for vertical slider).
+     *
+     * @default 'horizontal'
+     */
+    direction?: 'horizontal' | 'vertical' | undefined;
+
+    /**
+     * Duration of transition between slides (in ms)
+     *
+     * @default 300
+     */
+    speed?: number | undefined;
+
+    /**
+     * Enabled this option and plugin will set width/height on swiper wrapper equal to total size of all slides.
+     * Mostly should be used as compatibility fallback option for browser that don't support flexbox layout well
+     */
+    setWrapperSize?: boolean | undefined;
+
+    /**
+     * Enabled this option and swiper will be operated as usual except it will not move, real translate values on wrapper will not be set.
+     * Useful when you may need to create custom slide transition
+     */
+    virtualTranslate?: boolean | undefined;
+
+    /**
+     * Swiper width (in px). Parameter allows to force Swiper width.
+     * Useful only if you initialize Swiper when it is hidden.
+     *
+     * @note Setting this parameter will make Swiper not responsive
+     */
+    width?: number | undefined;
+
+    /**
+     * Swiper height (in px). Parameter allows to force Swiper height.
+     * Useful only if you initialize Swiper when it is hidden.
+     *
+     * @note Setting this parameter will make Swiper not responsive
+     */
+    height?: number | undefined;
+
+    /**
+     * Set to true and slider wrapper will adopt its height to the height of the currently active slide
+     *
+     * @default false
+     */
+    autoHeight?: boolean | undefined;
+
+    /**
+     * Set to true to round values of slides width and height to prevent blurry texts on usual
+     * resolution screens (if you have such)
+     *
+     * @default false
+     */
+    roundLengths?: boolean | undefined;
+
+    /**
+     * Set to true on  Swiper for correct touch events interception. Use only on
+     * swipers that use same direction as the parent one
+     *
+     * @default false
+     */
+    nested?: boolean | undefined;
+
+    /**
+     * If enabled (by default) and navigation elements' parameters passed as a string (like ".pagination")
+     * then Swiper will look for such elements through child elements first.
+     * Applies for pagination, prev/next buttons and scrollbar elements
+     *
+     * @default true
+     */
+    uniqueNavElements?: boolean | undefined;
+
+    /**
+     * Tranisition effect. Could be "slide", "fade", "cube", "coverflow" or "flip"
+     *
+     * @default 'slide'
+     */
+    effect?: 'slide' | 'fade' | 'cube' | 'coverflow' | 'flip' | undefined;
+
+    /**
+     * Fire [Transition/SlideChange][Start/End] events on swiper initialization.
+     * Such events will be fired on initialization in case of your initialSlide is not 0, or you use loop mode
+     *
+     * @default true
+     */
+    runCallbacksOnInit?: boolean | undefined;
+
+    /**
+     * When enabled Swiper will be disabled and hide navigation buttons on
+     * case there are not enough slides for sliding.
+     *
+     * @default false
+     */
+    watchOverflow?: boolean | undefined;
+
+    /**
+     * Register event handlers.
+     */
+    on?: {
+        [key in Exclude<SwiperEvent, LazyLoadingEvent>]?: (this: Swiper, swiper: Swiper) => void;
+    } & {
+        [key in LazyLoadingEvent]?: (this: Swiper, slideEl: HTMLElement, imageEl: HTMLImageElement) => void;
+    } | undefined;
+
+    // CSS Scroll Snap
+
+    /**
+     * When enabled it will use modern CSS Scroll Snap API.
+     * It doesn't support all of Swiper's features, but potentially should bring a much better performance in simple configurations.
+     *
+     * @default false
+     */
+    cssMode?: boolean | undefined;
+
+    // Slides grid
+
+    /**
+     * Distance between slides in px.
+     */
+    spaceBetween?: number | undefined;
+
+    /**
+     * Number of slides per view (slides visible at the same time on slider's container).
+     * If you use it with "auto" value and along with loop: true then you need to specify loopedSlides parameter with amount of slides to loop (duplicate)
+     * slidesPerView: 'auto' is currently not compatible with multirow mode, when slidesPerColumn > 1
+     */
+    slidesPerView?: number | 'auto' | undefined;
+
+    /**
+     * Number of slides per column, for multirow layout
+     * slidesPerColumn > 1 is currently not compatible with loop mode (loop: true)
+     */
+    slidesPerColumn?: number | undefined;
+
+    /**
+     * Could be 'column' or 'row'. Defines how slides should fill rows, by column or by row
+     */
+    slidesPerColumnFill?: 'row' | 'column' | undefined;
+
+    /**
+     * Set numbers of slides to define and enable group sliding. Useful to use with slidesPerView > 1
+     */
+    slidesPerGroup?: number | undefined;
+
+    /**
+     * The parameter works in the following way: If slidesPerGroupSkip equals 0 (default), no slides are excluded from grouping, and the resulting behaviour is the same as without this change.
+     * If slidesPerGroupSkip is equal or greater than 1 the first X slides are treated as single groups, whereas all following slides are grouped by the slidesPerGroup value.
+     *
+     * @default 0
+     */
+    slidesPerGroupSkip?: number | undefined;
+
+    /**
+     * If true, then active slide will be centered, not always on the left side.
+     */
+    centeredSlides?: boolean | undefined;
+
+    /**
+     * If true, then active slide will be centered without adding gaps at the beginning and end of slider.
+     * Required centeredSlides: true. Not intended to be used with loop or pagination
+     *
+     * @default false
+     */
+    centeredSlidesBounds?: boolean | undefined;
+
+    /**
+     * Add (in px) additional slide offset in the beginning of the container (before all slides)
+     */
+    slidesOffsetBefore?: number | undefined;
+
+    /**
+     * Add (in px) additional slide offset in the end of the container (after all slides)
+     */
+    slidesOffsetAfter?: number | undefined;
+
+    /**
+     * Normalize slide index.
+     */
+    normalizeSlideIndex?: boolean | undefined;
+
+    /**
+     * When enabled it center slides if the amount of slides less than `slidesPerView`. Not intended to be used loop mode and slidesPerColumn
+     */
+    centerInsufficientSlides?: boolean | undefined;
+
+    // Grab Cursor
+    grabCursor?: boolean | undefined;
+
+    // Touches
+
+    /**
+     * Target element to listen touch events on. Can be 'container' (to listen for touch events on swiper-container) or 'wrapper'
+     * (to listen for touch events on swiper-wrapper)
+     */
+    touchEventsTarget?: 'container' | 'wrapper' | undefined;
+
+    /**
+     * Touch ratio
+     */
+    touchRatio?: number | undefined;
+
+    /**
+     * Allowable angle (in degrees) to trigger touch move
+     */
+    touchAngle?: number | undefined;
+
+    /**
+     * If true, Swiper will accept mouse events like touch events (click and drag to change slides)
+     */
+    simulateTouch?: boolean | undefined;
+
+    /**
+     * Set to false if you want to disable short swipes
+     */
+    shortSwipes?: boolean | undefined;
+
+    /**
+     * Set to false if you want to disable long swipes
+     */
+    longSwipes?: boolean | undefined;
+
+    /**
+     * Ratio to trigger swipe to next/previous slide during long swipes
+     */
+    longSwipesRatio?: number | undefined;
+
+    /**
+     * Minimal duration (in ms) to trigger swipe to next/previous slide during long swipes
+     */
+    longSwipesMs?: number | undefined;
+
+    /**
+     * If disabled, then slider will be animated only when you release it, it will not move while you hold your finger on it
+     */
+    followFinger?: boolean | undefined;
+
+    /**
+     * If false, then the only way to switch the slide is use of external API functions like slidePrev or slideNext
+     */
+    allowTouchMove?: boolean | undefined;
+
+    /**
+     * Threshold value in px. If "touch distance" will be lower than this value then swiper will not move
+     */
+    threshold?: number | undefined;
+
+    /**
+     * If disabled, `touchstart` (`mousedown`) event won't be prevented
+     */
+    touchStartPreventDefault?: boolean | undefined;
+
+    /**
+     * Force to always prevent default for `touchstart` (`mousedown`) event
+     */
+    touchStartForcePreventDefault?: boolean | undefined;
+
+    /**
+     * If enabled, then propagation of "touchmove" will be stopped
+     */
+    touchMoveStopPropagation?: boolean | undefined;
+
+    /**
+     * Enable to release Swiper events for swipe-to-go-back work in iOS UIWebView
+     */
+    iOSEdgeSwipeDetection?: boolean | undefined;
+
+    /**
+     * Area (in px) from left edge of the screen to release touch events for swipe-to-go-back in iOS UIWebView
+     */
+    iOSEdgeSwipeThreshold?: number | undefined;
+
+    /**
+     * Enable to release touch events on slider edge position (beginning, end) to allow for further page scrolling
+     */
+    touchReleaseOnEdges?: boolean | undefined;
+
+    /**
+     * Passive event listeners will be used by default where possible to improve scrolling performance on mobile devices.
+     * But if you need to use `e.preventDefault` and you have conflict with it, then you should disable this parameter
+     */
+    passiveListeners?: boolean | undefined;
+
+    // Touch Resistance
+
+    /**
+     * Set to false if you want to disable resistant bounds
+     */
+    resistance?: boolean | undefined;
+
+    /**
+     * This option allows you to control resistance ratio
+     */
+    resistanceRatio?: number | undefined;
+
+    // Swiping / No swiping
+    preventInteractionOnTransition?: boolean | undefined;
+    allowSlidePrev?: boolean | undefined;
+    allowSlideNext?: boolean | undefined;
+    noSwiping?: boolean | undefined;
+    noSwipingClass?: string | undefined;
+    noSwipingSelector?: string | undefined;
+    swipeHandler?: SelectableElement | undefined;
+
+    // Clicks
+    preventClicks?: boolean | undefined;
+    preventClicksPropagation?: boolean | undefined;
+    slideToClickedSlide?: boolean | undefined;
+
+    // Freemode
+    freeMode?: boolean | undefined;
+    freeModeMomentum?: boolean | undefined;
+    freeModeMomentumRatio?: number | undefined;
+    freeModeMomentumVelocityRatio?: number | undefined;
+    freeModeMomentumBounce?: boolean | undefined;
+    freeModeMomentumBounceRatio?: number | undefined;
+    freeModeMinimumVelocity?: number | undefined;
+    freeModeSticky?: boolean | undefined;
+
+    // Progress
+    watchSlidesProgress?: boolean | undefined;
+    watchSlidesVisibility?: boolean | undefined;
+
+    // Images
+    preloadImages?: boolean | undefined;
+    updateOnImagesReady?: boolean | undefined;
+
+    // Loop
+    loop?: boolean | undefined;
+    loopAdditionalSlides?: number | undefined;
+    loopedSlides?: number | undefined;
+    loopFillGroupWithBlank?: boolean | undefined;
+
+    // Breakpoints
+    breakpoints?: {
+        [index: number]: SwiperOptions;
+    } | undefined;
+    breakpointsInverse?: boolean | undefined;
+
+    // Observer
+
+    /**
+     * Set to true if you also need to watch Mutations for Swiper slide children elements
+     *
+     * @default false
+     */
+    observeSlideChildren?: boolean | undefined;
+
+    observer?: boolean | undefined;
+    observeParents?: boolean | undefined;
+
+    // Namespace
+    containerModifierClass?: string | undefined;
+    slideClass?: string | undefined;
+    slideActiveClass?: string | undefined;
+    slideDuplicateActiveClass?: string | undefined;
+    slideVisibleClass?: string | undefined;
+    slideDuplicateClass?: string | undefined;
+    slideNextClass?: string | undefined;
+    slideDuplicateNextClass?: string | undefined;
+    slidePrevClass?: string | undefined;
+    slideDuplicatePrevClass?: string | undefined;
+    wrapperClass?: string | undefined;
+
+    // Components
+    controller?: ControllerOptions | boolean | undefined;
+    navigation?: NavigationOptions | undefined;
+    pagination?: PaginationOptions | undefined;
+    scrollbar?: ScrollbarOptions | undefined;
+    autoplay?: AutoplayOptions | boolean | undefined;
+    parallax?: boolean | undefined;
+    lazy?: LazyOptions | boolean | undefined;
+    fadeEffect?: FadeEffectOptions | undefined;
+    coverflowEffect?: CoverflowEffectOptions | undefined;
+    flipEffect?: FlipEffectOptions | undefined;
+    cubeEffect?: CubeEffectOptions | undefined;
+    thumbs?: ThumbsOptions | undefined;
+    zoom?: ZoomOptions | boolean | undefined;
+    keyboard?: KeyboardOptions | boolean | undefined;
+    mousewheel?: MousewheelOptions | boolean | undefined;
+    virtual?: VirtualOptions | boolean | undefined;
+    hashNavigation?: HashNavigationOptions | boolean | undefined;
+    history?: HistoryNavigationOptions | boolean | undefined;
+    a11y?: A11yOptions | boolean | undefined;
+}
+
+export interface EventsOptions {
+    /**
+     * Fired right after Swiper initialization.
+     * Note that with swiper.on('init') syntax it will
+     * work only in case you set init: false parameter.
+     *
+     * @example
+     * var swiper = new Swiper('.swiper-container', {
+     *   init: false,
+     *   // other parameters
+     * });
+     *
+     * @example
+     * swiper.on('init', function() {
+     *  // do something
+     * });
+     *
+     * @example
+     * // init Swiper
+     * swiper.init();
+     *
+     * @example
+     * // Otherwise use it as the parameter:
+     * var swiper = new Swiper('.swiper-container', {
+     *   // other parameters
+     *   on: {
+     *     init: function () {
+     *       // do something
+     *     },
+     *   }
+     * });
+     */
+    init?: (() => any) | undefined;
+
+    /**
+     * Triggered right beforey Swiper destoryed
+     */
+    beforeDestroy?: (() => any) | undefined;
+
+    /**
+     * Triggered when currently active slide is changed
+     */
+    slideChange?: (() => any) | undefined;
+
+    /**
+     * Triggered in the beginning of animation to other slide (next or previous).
+     */
+    slideChangeTransitionStart?: (() => any) | undefined;
+
+    /**
+     * Triggered after animation to other slide (next or previous).
+     */
+    slideChangeTransitionEnd?: (() => any) | undefined;
+
+    /**
+     * Same as "slideChangeTransitionStart" but for "forward" direction only
+     */
+    slideNextTransitionStart?: (() => any) | undefined;
+
+    /**
+     * Same as "slideChangeTransitionEnd" but for "forward" direction only
+     */
+    slideNextTransitionEnd?: (() => any) | undefined;
+
+    /**
+     * Same as "slideChangeTransitionStart" but for "backward" direction only
+     */
+    slidePrevTransitionStart?: (() => any) | undefined;
+
+    /**
+     * Same as "slideChangeTransitionEnd" but for "backward" direction only
+     */
+    slidePrevTransitionEnd?: (() => any) | undefined;
+
+    /**
+     * Triggered in the beginning of transition.
+     */
+    transitionStart?: (() => any) | undefined;
+
+    /**
+     * Triggered after transition.
+     */
+    transitionEnd?: (() => any) | undefined;
+
+    /**
+     * Triggered when user touch Swiper. Receives 'touchstart' event as an arguments.
+     */
+    touchStart?: ((event: any) => any) | undefined;
+
+    /**
+     * Triggered when user touch and move finger over Swiper. Receives 'touchmove' event as an arguments.
+     */
+    touchMove?: ((event: any) => any) | undefined;
+
+    /**
+     * Fired when user touch and move finger over
+     * Swiper in direction opposite to direction parameter.
+     * Receives 'touchmove' event as an arguments.
+     */
+    touchMoveOpposite?: ((event: any) => any) | undefined;
+
+    /**
+     * Triggered when user touch and move finger over Swiper and move it.
+     * Receives 'touchmove' event as an arguments.
+     */
+    sliderMove?: ((event: any) => any) | undefined;
+
+    /**
+     * Triggered when user release Swiper. Receives 'touchend' event as an arguments.
+     */
+    touchEnd?: ((event: any) => any) | undefined;
+
+    /**
+     * Triggered when user click/tap on Swiper after 300ms delay. Receives 'touchend' event as an arguments.
+     */
+    click?: ((event: any) => any) | undefined;
+
+    /**
+     * Triggered when user click/tap on Swiper. Receives 'touchend' event as an arguments.
+     */
+    tap?: ((event: any) => any) | undefined;
+
+    /**
+     * Triggered when user double tap on Swiper's container. Receives 'touchend' event as an arguments
+     */
+    doubleTap?: ((event: any) => any) | undefined;
+
+    /**
+     * Triggered right after all inner images are loaded. updateOnImagesReady should be also enabled
+     */
+    imagesReady?: (() => any) | undefined;
+
+    /**
+     * Triggered when Swiper progress is changed, as an arguments it receives
+     * progress that is always from 0 to 1
+     */
+    progress?: ((progress: any) => any) | undefined;
+
+    /**
+     * Triggered when Swiper reach its beginning (initial position)
+     */
+    reachBeginning?: (() => any) | undefined;
+
+    /**
+     * Triggered when Swiper reach last slide
+     */
+    reachEnd?: (() => any) | undefined;
+
+    /**
+     * Triggered when Swiper goes from beginning or end position
+     */
+    fromEdge?: (() => any) | undefined;
+
+    /**
+     * Triggered when swiper's wrapper change its position. Receives current translate value as an arguments
+     */
+    setTranslate?: ((translate: any) => any) | undefined;
+
+    /**
+     * Triggered everytime when swiper starts animation.
+     * Receives current transition duration (in ms) as an arguments,
+     */
+    setTransition?: ((transition: any) => any) | undefined;
+
+    /**
+     * Triggered on window resize right before swiper's onresize manipulation
+     */
+    resize?: (() => any) | undefined;
+
+    /**
+     * Event will be fired if observer is enabled and it detects DOM mutations
+     */
+    observerUpdate?: (() => any) | undefined;
+
+    /**
+     * Event will be fired right before "loop fix"
+     */
+    beforeLoopFix?: (() => any) | undefined;
+
+    /**
+     * Event will be fired after "loop fix"
+     */
+    loopFix?: (() => any) | undefined;
+}
+
+export interface NavigationOptions {
+    /**
+     * String with CSS selector or HTML element of the element that will work
+     * like "next" button after click on it
+     *
+     * @default null
+     */
+    nextEl?: SelectableElement | undefined;
+
+    /**
+     * String with CSS selector or HTML element of the element that will work
+     * like "prev" button after click on it
+     *
+     * @default null
+     */
+    prevEl?: SelectableElement | undefined;
+
+    /**
+     * buttons visibility after click on Slider's container
+     *
+     * @default false Toggle navigation
+     */
+    hideOnClick?: boolean | undefined;
+
+    /**
+     * CSS class name added to navigation button when it becomes disabled
+     *
+     * @default 'swiper-button-disabled'
+     */
+    disabledClass?: string | undefined;
+
+    /**
+     * CSS class name added to navigation button when it becomes hidden
+     *
+     * @default 'swiper-button-hidden'
+     */
+    hiddenClass?: string | undefined;
+}
+
+export interface PaginationOptions {
+    /**
+     * String with CSS selector or HTML element of the container with pagination
+     */
+    el: SelectableElement;
+
+    /**
+     * String with type of pagination. Can be "bullets", "fraction", "progressbar" or "custom"
+     */
+    type?: 'bullets' | 'fraction' | 'progressbar' | 'custom' | undefined;
+
+    /**
+     * Defines which HTML tag will be use to represent single pagination bullet. Only for bullets pagination type.
+     */
+    bulletElement?: string | undefined;
+
+    /**
+     * Good to enable if you use bullets pagination with a lot of slides. So it will keep only few bullets visible at the same time.
+     */
+    dynamicBullets?: boolean | undefined;
+
+    /**
+     * The number of main bullets visible when dynamicBullets enabled.
+     */
+    dynamicMainBullets?: number | undefined;
+
+    /**
+     * Toggle (hide/true) pagination container visibility after click on Slider's container
+     */
+    hideOnClick?: boolean | undefined;
+
+    /**
+     * If true then clicking on pagination button will cause transition to appropriate slide. Only for bullets pagination type
+     */
+    clickable?: boolean | undefined;
+
+    /**
+     * Makes pagination progressbar opposite to Swiper's `direction` parameter, means vertical progressbar for horizontal swiper
+     * direction and horizontal progressbar for vertical swiper direction
+     */
+    progressbarOpposite?: boolean | undefined;
+
+    /**
+     * format fraction pagination current number. Function receives current number,
+     * and you need to return formatted value
+     */
+    formatFractionCurrent?: ((number: number) => number) | undefined;
+
+    /**
+     * format fraction pagination total number. Function receives total number, and you
+     * need to return formatted value
+     */
+    formatFractionTotal?: ((number: number) => number) | undefined;
+
+    /**
+     * This parameter allows totally customize pagination bullets, you need to pass here a function that accepts index number of
+     * pagination bullet and required element class name (className). Only for bullets pagination type
+     */
+    renderBullet?: ((index: number, className: string) => void) | undefined;
+
+    /**
+     * This parameter allows to customize "fraction" pagination html. Only for fraction pagination type
+     */
+    renderFraction?: ((currentClass: string, totalClass: string) => void) | undefined;
+
+    /**
+     * This parameter allows to customize "progress" pagination. Only for progress pagination type
+     */
+    renderProgressbar?: ((progressbarFillClass: string) => void) | undefined;
+
+    /**
+     * This parameter is required for custom pagination type where you have to specify
+     * how it should be rendered.
+     *
+     * @example
+     * var swiper = new Swiper('.swiper-container', {
+     *   //...
+     *   renderCustom: function (swiper, current, total) {
+     *     return current + ' of ' + total;
+     *   }
+     * });
+     */
+    renderCustom?: ((swiper: Swiper, current: number, total: number) => void) | undefined;
+
+    /**
+     * CSS class name of single pagination bullet
+     */
+    bulletClass?: string | undefined;
+
+    /**
+     * CSS class name of currently active pagination bullet
+     */
+    bulletActiveClass?: string | undefined;
+
+    /**
+     * The beginning of the modifier CSS class name that will be added to pagination depending on parameters
+     */
+    modifierClass?: string | undefined;
+
+    /**
+     * CSS class name of the element with currently active index in "fraction" pagination
+     */
+    currentClass?: string | undefined;
+
+    /**
+     * CSS class name of the element with total number of "snaps" in "fraction" pagination
+     */
+    totalClass?: string | undefined;
+
+    /**
+     * CSS class name of pagination when it becomes inactive
+     */
+    hiddenClass?: string | undefined;
+
+    /**
+     * CSS class name of pagination progressbar fill element
+     */
+    progressbarFillClass?: string | undefined;
+
+    /**
+     * CSS class name set to pagination when it is clickable
+     */
+    clickableClass?: string | undefined;
+}
+
+/**
+ * Object with scrollbar parameters.
+ *
+ * @example
+ * var mySwiper = new Swiper('.swiper-container', {
+ *   scrollbar: {
+ *     el: '.swiper-scrollbar',
+ *     draggable: true,
+ *   },
+ * });
+ */
+export interface ScrollbarOptions {
+    /**
+     * String with CSS selector or HTML element of the container with scrollbar.
+     */
+    el: SelectableElement;
+
+    /**
+     * Hide scrollbar automatically after user interaction
+     *
+     * @default true
+     */
+    hide?: boolean | undefined;
+
+    /**
+     * Set to true to enable make scrollbar draggable that allows you to control slider position
+     *
+     * @default true
+     */
+    draggable?: boolean | undefined;
+
+    /**
+     * Set to true to snap slider position to slides when you release scrollbar
+     *
+     * @default false
+     */
+    snapOnRelease?: boolean | undefined;
+
+    /**
+     * Size of scrollbar draggable element in px
+     *
+     * @default 'auto'
+     */
+    dragSize?: 'auto' | number | undefined;
+
+    /**
+     * Scrollbar element additional CSS class when it is disabled
+     *
+     * @default 'swiper-scrollbar-lock'
+     */
+    lockClass?: string | undefined;
+
+    /**
+     *     Scrollbar draggable element CSS class
+     *
+     * @default 'swiper-scrollbar-drag'
+     */
+    dragClass?: string | undefined;
+}
+
+/**
+ * Object with autoplay parameters or boolean true to enable with default settings.
+ *
+ * @example
+ * var mySwiper = new Swiper('.swiper-container', {
+ *   autoplay: {
+ *     delay: 5000,
+ *   },
+ * });
+ */
+export interface AutoplayOptions {
+    /**
+     * Delay between transitions (in ms). If this parameter is not specified, auto play will be disabled
+     *
+     * If you need to specify different delay for specifi slides you can do it by using
+     * data-swiper-autoplay (in ms) attribute on slide.
+     *
+     * @example
+     * <!-- hold this slide for 2 seconds -->
+     * <div class="swiper-slide" data-swiper-autoplay="2000">
+     *
+     * @default 3000
+     */
+    delay?: number | undefined;
+
+    /**
+     * Enable this parameter and autoplay will be stopped when it reaches last slide (has no effect in loop mode)
+     *
+     * @default false
+     */
+    stopOnLastSlide?: boolean | undefined;
+
+    /**
+     * Set to false and autoplay will not be disabled after
+     * user interactions (swipes), it will be restarted
+     * every time after interaction
+     *
+     * @default true
+     */
+    disableOnInteraction?: boolean | undefined;
+
+    /**
+     * Enables autoplay in reverse direction
+     *
+     * @default false
+     */
+    reverseDirection?: boolean | undefined;
+
+    /**
+     * When enabled autoplay will wait for wrapper transition to continue.
+     * Can be disabled in case of using Virtual Translate when your
+     * slider may not have transition
+     *
+     * @default true
+     */
+    waitForTransition?: boolean | undefined;
+}
+
+export interface LazyOptions {
+    loadPrevNext?: boolean | undefined;
+    loadPrevNextAmount?: number | undefined;
+    loadOnTransitionStart?: boolean | undefined;
+    elementClass?: string | undefined;
+    loadingClass?: string | undefined;
+    loadedClass?: string | undefined;
+    preloaderClass?: string | undefined;
+}
+
+/*
+ * Options - Effect
+ */
+
+export interface FadeEffectOptions {
+    crossFade?: boolean | undefined;
+}
+
+export interface CoverflowEffectOptions {
+    slideShadows?: boolean | undefined;
+    rotate?: number | undefined;
+    stretch?: number | undefined;
+    depth?: number | undefined;
+    modifier?: number | undefined;
+}
+
+export interface FlipEffectOptions {
+    slideShadows?: boolean | undefined;
+    limitRotation?: boolean | undefined;
+}
+
+export interface CubeEffectOptions {
+    slideShadows?: boolean | undefined;
+    shadow?: boolean | undefined;
+    shadowOffset?: number | undefined;
+    shadowScale?: number | undefined;
+}
+
+export interface ThumbsOptions {
+    swiper?: Swiper | undefined;
+    slideThumbActiveClass?: string | undefined;
+    thumbsContainerClass?: string | undefined;
+    multipleActiveThumbs?: boolean | undefined;
+    autoScrollOffset?: number | undefined;
+}
+
+export interface ZoomOptions {
+    maxRatio?: number | undefined;
+    minRatio?: number | undefined;
+    toggle?: boolean | undefined;
+    containerClass?: string | undefined;
+    zoomedSlideClass?: string | undefined;
+}
+
+export interface KeyboardOptions {
+    enabled?: boolean | undefined;
+    onlyInViewport?: boolean | undefined;
+}
+
+export interface MousewheelOptions {
+    forceToAxis?: boolean | undefined;
+    releaseOnEdges?: boolean | undefined;
+    invert?: boolean | undefined;
+    sensitivity?: number | undefined;
+    eventsTarged?: SelectableElement | undefined;
+}
+
+export interface VirtualOptions {
+    slides?: any[] | undefined;
+    cache?: boolean | undefined;
+    addSlidesBefore?: number | undefined;
+    addSlidesAfter?: number | undefined;
+    renderSlide?: ((slide: any, index: any) => any) | undefined;
+    renderExternal?: ((data: any) => any) | undefined;
+}
+
+export interface HashNavigationOptions {
+    /**
+     * Set to true to enable also navigation through slides (when hashnav
+     * is enabled) by browser history or by setting directly hash on document location
+     *
+     * @default false
+     */
+    watchState?: boolean | undefined;
+
+    /**
+     * Works in addition to hashnav to replace current url state with the
+     * new one instead of adding it to history
+     *
+     * @default     false
+     */
+    replaceState?: boolean | undefined;
+}
+
+export interface HistoryNavigationOptions {
+    /**
+     * Works in addition to hashnav or history to replace current url state with the
+     * new one instead of adding it to history
+     *
+     * @default false
+     */
+    replaceState?: boolean | undefined;
+
+    /**
+     * Url key for slides
+     *
+     * @default 'slides'
+     */
+    key?: string | undefined;
+}
+
+/**
+ * Object with controller parameters or boolean true to enable with default settings. For example:
+ *
+ * @example
+ * var mySwiper = new Swiper('.swiper-container', {
+ *   controller: {
+ *     inverse: true,
+ *   },
+ * });
+ */
+export interface ControllerOptions {
+    /**
+     * Pass here another Swiper instance or array with Swiper instances that should be controlled
+     * by this Swiper
+     */
+    control?: Swiper | undefined;
+
+    /**
+     * Set to true and controlling will be in inverse direction
+     *
+     * @default false
+     */
+    inverse?: boolean | undefined;
+
+    /**
+     * Can be 'slide' or 'container'. Defines a way how to control another slider: slide by slide
+     * (with respect to other slider's grid) or depending on all slides/container
+     * (depending on total slider percentage).
+     *
+     * @default 'slide'
+     */
+    by?: 'slide' | 'container' | undefined;
+}
+
+export interface A11yOptions {
+    /**
+     * Enables A11y
+     *
+     * @default true
+     */
+    enabled?: boolean | undefined;
+
+    /**
+     * Message for screen readers for previous button
+     *
+     * @default 'Previous slide'
+     */
+    prevSlideMessage?: string | undefined;
+
+    /**
+     * Message for screen readers for next button
+     *
+     * @default 'Next slide'
+     */
+    nextSlideMessage?: string | undefined;
+
+    /**
+     * Message for screen readers for previous button when swiper is on first slide
+     *
+     * @default 'This is the first slide'
+     */
+    firstSlideMessage?: string | undefined;
+
+    /**
+     * Message for screen readers for previous button when swiper is on last slide
+     *
+     * @default 'This is the last slide'
+     */
+    lastSlideMessage?: string | undefined;
+
+    /**
+     * Message for screen readers for single pagination bullet
+     *
+     * @default 'Go to slide {{index}}'
+     */
+    paginationBulletMessage?: string | undefined;
+
+    /**
+     * CSS class name of a11 notification
+     *
+     * @default 'swiper-notification'
+     */
+    notificationClass?: string | undefined;
+}
+
+import {
+    Virtual,
+    Keyboard,
+    Mousewheel,
+    Navigation,
+    Pagination,
+    Scrollbar,
+    Parallax,
+    Zoom,
+    Lazy,
+    Controller,
+    A11y,
+    History,
+    HashNavigation,
+    Autoplay,
+    EffectFade,
+    EffectCube,
+    EffectFlip,
+    EffectCoverflow
+} from './js/swiper.esm';
+
+/**
+ * Core module
+ */
+// XXX: This is an export assignment in `dist/js/swiper.js` (referenced by
+// the "main" field of package.json) but a default export in
+// `dist/js/swiper.esm.bundle.js` (referenced by the "module" field).  Short
+// of trying to convince upstream to change their packaging, the best we can
+// do is choose one or the other and hope that users use `esModuleInterop`.
+export default class Swiper {
+    /**
+     * Constructs a new Swiper instance.
+     *
+     * @param container Where Swiper applies to.
+     * @param options   Instance options.
+     */
+    constructor(container: SelectableElement, options?: SwiperOptions);
+
+    /**
+     * Object with passed initialization parameters
+     */
+    params: SwiperOptions;
+
+    /**
+     * Element with slider container.
+     */
+    el: HTMLElement;
+
+    /**
+     * Dom7 element with slider container HTML element. To get vanilla HTMLElement use el
+     */
+    $el: DOM7Element;
+
+    /**
+     * Slider wrapper HTML element.
+     */
+    wrapperEl: HTMLElement;
+
+    /**
+     * Dom7 element with slider wrapper HTML element. To get vanilla HTMLElement use wrapperEl
+     */
+    $wrapperEl: DOM7Element;
+
+    /**
+     * Dom7 array-like collection of slides HTML elements. To get specific slide HTMLElement use slides[1]
+     */
+    slides: DOM7Element[];
+
+    /**
+     * Width of container
+     */
+    width: number;
+
+    /**
+     * Height of container
+     */
+    height: number;
+
+    /**
+     * Current value of wrapper translate
+     */
+    translate: number;
+
+    /**
+     * Current progress of wrapper translate (from 0 to 1)
+     */
+    progress: number;
+
+    /**
+     * Index number of currently active slide.
+     *
+     * @note Note, that in loop mode active index value will be always shifted
+     * on a number of looped/duplicated slides.
+     */
+    activeIndex: number;
+
+    /**
+     * Index number of currently active slide considering duplicated slides in loop mode
+     */
+    realIndex: number;
+
+    /**
+     * Index number of previously active slide
+     */
+    previousIndex: number;
+
+    /**
+     * true if slider on most "left"/"top" position
+     */
+    isBeginning: true;
+
+    /**
+     * true if slider on most "right"/"bottom" position
+     */
+    isEnd: boolean;
+
+    /**
+     * true if swiper is in transition
+     */
+    animating: boolean;
+
+    /**
+     * Object with the following touch event properties:
+     */
+    touches: {
+        startX: number;
+        startY: number;
+        currentX: number;
+        currentY: number;
+        diff: number;
+    };
+
+    /**
+     * Index number of last clicked slide
+     */
+    clickedIndex: number;
+
+    /**
+     * Link to last clicked slide (HTMLElement)
+     */
+    clickedSlide: HTMLElement;
+
+    /**
+     * Disable/enable ability to slide to the next slides by assigning false/true to this property
+     *
+     * @default true
+     */
+    allowSlideNext: boolean;
+
+    /**
+     * Disable/enable ability to slide to the previous slides by assigning false/true to this property
+     *
+     * @default true
+     */
+    allowSlidePrev: boolean;
+
+    /**
+     * Disable/enable ability move slider by grabbing it with
+     * mouse or by touching it with finger (on touch screens)
+     * by assigning false/true to this property
+     *
+     * @default true
+     */
+    allowTouchMove: boolean;
+
+    // Methods
+    /**
+     * Run transition to next slide.
+     *
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideNext(speed?: number, runCallbacks?: boolean): void;
+
+    /**
+     * Run transition to previous slide.
+     *
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slidePrev(speed?: number, runCallbacks?: boolean): void;
+
+    /**
+     * Run transition to the slide with index number equal to 'index' parameter for the
+     *  duration equal to 'speed' parameter.
+     *
+     * @param index Index number of slide.
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideTo(index: number, speed?: number, runCallbacks?: boolean): void;
+
+    /**
+     * Does the same as .slideTo but for the case when used with enabled loop. So this
+     * method will slide to slides with realIndex matching to passed index
+     *
+     * @param index Index number of slide.
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideToLoop(index: number, speed?: number, runCallbacks?: boolean): void;
+
+    /**
+     * Reset swiper position to currently active slide for the duration equal to 'speed'
+     * parameter.
+     *
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideReset(speed?: number, runCallbacks?: boolean): void;
+
+    /**
+     * Reset swiper position to closest slide/snap point for the duration equal to 'speed' parameter.
+     *
+     * @param speed Transition duration (in ms).
+     * @param runCallbacks Set it to false (by default it is true) and transition will
+     *  not produce transition events.
+     */
+    slideToClosest(speed?: number, runCallbacks?: boolean): void;
+
+    /**
+     * Force swiper to update its height (when autoHeight enabled) for the duration equal to
+     * 'speed' parameter
+     *
+     * @param speed Transition duration (in ms).
+     */
+    updateAutoHeight(speed?: number): void;
+
+    /**
+     * You should call it after you add/remove slides
+     * manually, or after you hide/show it, or do any
+     * custom DOM modifications with Swiper
+     * This method also includes subcall of the following
+     * methods which you can use separately:
+     */
+    update(): void;
+
+    /**
+     * recalculate size of swiper container
+     */
+    updateSize(): void;
+
+    /**
+     * recalculate number of slides and their offsets. Useful after you add/remove slides with JavaScript
+     */
+    updateSlides(): void;
+
+    /**
+     * recalculate swiper progress
+     */
+    updateProgress(): void;
+
+    /**
+     * update active/prev/next classes on slides and bullets
+     */
+    updateSlidesClasses(): void;
+
+    /**
+     * tach all events listeners
+     */
+    detachEvents(): void;
+
+    /**
+     * Atach all events listeners again
+     */
+    attachEvents(): void;
+
+    /**
+     * Destroy slider instance and detach all events listeners, where
+     */
+    destroy(deleteInstance: boolean, cleanupStyles: boolean): void;
+
+    /**
+     * Set it to false (by default it is true) to not to delete Swiper instance
+     */
+    deleteInstance: boolean;
+
+    /**
+     * Set it to true (by default it is true) and all
+     * custom styles will be removed from slides,
+     * wrapper and container. Useful if you need to
+     * destroy Swiper and to init again with new
+     * options or in different direction
+     */
+    cleanStyles: boolean;
+
+    /**
+     * Installs modules on Swiper in runtime.
+     */
+    static use(modules: SwiperModule[]): void;
+
+    /**
+     * Add new slides to the end. slides could be
+     * HTMLElement or HTML string with new slide or
+     * array with such slides, for example:
+     *
+     * @example appendSlide('<div class="swiper-slide">Slide 10"</div>')
+     * @example
+     * appendSlide([
+     *  '<div class="swiper-slide">Slide 10"</div>',
+     *  '<div class="swiper-slide">Slide 11"</div>'
+     * ]);
+     */
+    appendSlide(slides: HTMLElement | string | string[]): void;
+
+    /**
+     * Add new slides to the beginning. slides could be
+     * HTMLElement or HTML string with new slide or array with such slides, for example:
+     *
+     * @example prependSlide('<div class="swiper-slide">Slide 0"</div>')
+     * @example prependSlide([
+     *  '<div class="swiper-slide">Slide 1"</div>',
+     *  '<div class="swiper-slide">Slide 2"</div>'
+     * ]);
+     */
+    prependSlide(slides: HTMLElement | string | string[]): void;
+
+    /**
+     * Add new slides to the required index. slides could be HTMLElement or HTML string with new slide or array with such slides, for example:
+     *
+     * @example addSlide(1, '<div class="swiper-slide">Slide 10"</div>')
+     * @example addSlide(1, [
+     *  '<div class="swiper-slide">Slide 10"</div>',
+     *  '<div class="swiper-slide">Slide 11"</div>'
+     * ]);
+     */
+    addSlide(index: number, slides: HTMLElement | string | string[]): void;
+
+    /**
+     * Remove selected slides. slideIndex could be a number with slide index to remove or array with indexes.
+     *
+     * @example removeSlide(0); // remove first slide
+     * @example removeSlide([0, 1]); // remove first and second slides
+     * @example removeAllSlides();    // Remove all slides
+     */
+    removeSlide(slideIndex: number | number[]): void;
+
+    /**
+     * Remove all slides
+     */
+    removeAllSlides(): void;
+
+    /**
+     * Set custom css3 transform's translate value for swiper wrapper
+     */
+    setTranslate(translate: any): void;
+
+    /**
+     * Get current value of swiper wrapper css3 transform translate
+     */
+    getTranslate(): any;
+
+    /**
+     * Animate custom css3 transform's translate value for swiper wrapper
+     */
+    translateTo(translate: number, speed: number, runCallbacks?: boolean, translateBounds?: boolean): any;
+
+    /**
+     * Add event listener
+     */
+    on(event: SwiperEvent, handler: () => void): void;
+
+    /**
+     * Add event listener that will be executed only once
+     */
+    once(event: SwiperEvent, handler: () => void): void;
+
+    /**
+     * Remove event listener for specified event
+     * If no handler specified, removes all listeners for specified event
+     */
+    off(event: SwiperEvent, handler?: () => void): void;
+
+    /**
+     * Disable mousewheel control
+     */
+    disableMousewheelControl(): void;
+
+    /**
+     * Enable mousewheel control
+     */
+    enableMousewheelControl(): void;
+
+    /**
+     * Disable keyboard control
+     */
+    disableKeyboardControl(): void;
+
+    /**
+     * Enable keyboard control
+     */
+    enableKeyboardControl(): void;
+
+    /**
+     * Unset grab cursor
+     */
+    unsetGrabCursor(): void;
+
+    /**
+     * Set grab cursor
+     */
+    setGrabCursor(): void;
+
+    // Components
+
+    /**
+     * Swiper Navigation module.
+     */
+    navigation?: Navigation | undefined;
+
+    /**
+     * Swiper Pagination module.
+     */
+    pagination?: Pagination | undefined;
+
+    /**
+     * Swiper Scrollbar module.
+     */
+    scrollbar?: Scrollbar | undefined;
+
+    /**
+     * Swiper Autoplay module.
+     */
+    autoplay?: Autoplay | undefined;
+
+    /**
+     * Swiper Parallax module.
+     */
+    parallax?: Parallax | undefined;
+
+    /**
+     * Swiper Lazy module.
+     */
+    lazy?: Lazy | undefined;
+
+    /**
+     * Swiper FadeEffect module.
+     */
+    fadeEffect?: EffectFade | undefined;
+
+    /**
+     * Swiper CoverflowEffect module.
+     */
+    coverflowEffect?: EffectCoverflow | undefined;
+
+    /**
+     * Swiper FlipEffect module.
+     */
+    flipEffect?: EffectFlip | undefined;
+
+    /**
+     * Swiper CubeEffect module.
+     */
+    cubeEffect?: EffectCube | undefined;
+
+    /**
+     * Swiper Thumbs module.
+     */
+    thumbs?: object | undefined;
+
+    /**
+     * Swiper Zoom module.
+     */
+    zoom?: Zoom | undefined;
+
+    /**
+     * Swiper Keyboard module.
+     */
+    keyboard?: Keyboard | undefined;
+
+    /**
+     * Swiper Mousewheel module.
+     */
+    mousewheel?: Mousewheel | undefined;
+
+    /**
+     * Swiper Virtual module.
+     */
+    virtual?: Virtual | undefined;
+
+    /**
+     * Swiper HashNavigation module.
+     */
+    hashNavigation?: HashNavigation | undefined;
+
+    /**
+     * Swiper History module.
+     */
+    history?: History | undefined;
+
+    /**
+     * Swiper Controller module.
+     */
+    controller?: Controller | undefined;
+
+    /**
+     * Swiper A11y module.
+     */
+    a11y?: A11y | undefined;
+}

node_modules/@types/swiper/js/swiper.esm.d.ts

@@ -0,0 +1,312 @@
+import Swiper, { DOM7Element } from '../index';
+
+// Reexport everything from `swiper` except the default export of the
+// `Swiper` class, which is instead provided as a named export by
+// `swiper.esm`.
+export * from '../index';
+export { Swiper };
+
+/*
+ * Swiper exports the following as ES5 module (in swiper.esm.js).
+ */
+
+/**
+ * Virtual Slides module.
+ */
+export class Virtual {
+    /**
+     * Object with cached slides HTML elements
+     */
+    cache: object;
+
+    /**
+     * Index of first rendered slide
+     */
+    from: number;
+
+    /**
+     * Index of last rendered slide
+     */
+    to: number;
+
+    /**
+     * Array with slide items passed by virtual.slides parameter
+     */
+    slides: any[];
+
+    /*
+     * Methods
+     */
+
+    /**
+     * Add new slides to the end. slides could be HTMLElement or HTML string with new slide or array
+     * with such slides, for example:
+     *
+     * @example
+     * mySwiper.appendSlide('<div class="swiper-slide">Slide 10"</div>')
+     * mySwiper.appendSlide([
+     *   '<div class="swiper-slide">Slide 10"</div>',
+     *   '<div class="swiper-slide">Slide 11"</div>'
+     * ]);
+     */
+    appendSlide(slide: HTMLElement | string): void;
+
+    /**
+     * Add new slides to the beginning. slides could be HTMLElement or HTML string with new slide or
+     * array with such slides, for example:
+     *
+     * @example
+     * mySwiper.prependSlide('<div class="swiper-slide">Slide 0"</div>')
+     * mySwiper.prependSlide([
+     * '<div class="swiper-slide">Slide 1"</div>',
+     * '<div class="swiper-slide">Slide 2"</div>'
+     * ]);
+     */
+    prependSlide(slide: HTMLElement | string): void;
+
+    /**
+     * Update virutal slides state
+     */
+    update(): void;
+}
+
+/**
+ * Keyboard Control module.
+ */
+export class Keyboard {
+    /**
+     * Whether the keyboard control is enabled
+     */
+    enabled: boolean;
+
+    // Methods
+    /**
+     * Enable keyboard control
+     */
+    enable(): void;
+
+    /**
+     * Disable keyboard control
+     */
+    disable(): void;
+}
+
+/**
+ * Mousewheel Control module.
+ */
+export class Mousewheel {
+    /**
+     * Whether the mousewheel control is enabled
+     */
+    enabled: boolean;
+
+    // Methods
+    /**
+     * Enable mousewheel control
+     */
+    enable(): void;
+
+    /**
+     * Disable mousewheel control
+     */
+    disable(): void;
+}
+
+/**
+ * Navigation module.
+ */
+export class Navigation {
+    /**
+     * HTMLElement of "next" navigation button
+     */
+    nextEl: HTMLElement;
+
+    /**
+     * HTMLElement of "previous" navigation button
+     */
+    prevEl: HTMLElement;
+
+    /**
+     * Update navigation buttons state (enabled/disabled)
+     */
+    update(): void;
+}
+
+/**
+ * Pagination module.
+ */
+export class Pagination {
+    /**
+     * HTMLElement of pagination container element
+     */
+    el: HTMLElement;
+
+    /**
+     * Dom7 array-like collection of pagination bullets
+     * HTML elements. To get specific slide HTMLElement
+     * use `mySwiper.pagination.bullets[1]`.
+     */
+    bullets: DOM7Element[];
+
+    /**
+     * Render pagination layout
+     */
+    render(): void;
+
+    /**
+     * Update pagination state (enabled/disabled/active)
+     */
+    update(): void;
+}
+
+/**
+ * Scrollbar module.
+ */
+export class Scrollbar {
+    // Properties
+    /**
+     * HTMLElement of Scrollbar container element
+     */
+    el: HTMLElement;
+
+    /**
+     * HTMLElement of Scrollbar draggable handler element
+     */
+    dragEl: HTMLElement;
+
+    // Methods
+    /**
+     * Updates scrollbar track and handler sizes
+     */
+    updateSize(): void;
+}
+
+/**
+ * Parallax module.
+ */
+export class Parallax { }
+
+/**
+ * Zoom module.
+ */
+export class Zoom {
+    /**
+     * Whether the zoom module is enabled
+     */
+    enabled: boolean;
+
+    /**
+     * Current image scale ratio
+     */
+    scale: number;
+
+    /**
+     * Enable zoom module
+     */
+    enable(): void;
+
+    /**
+     * Disable zoom module
+     */
+    disable(): void;
+
+    /**
+     * Zoom in image of the currently active slide
+     */
+    in(): void;
+
+    /**
+     * Zoom out image of the currently active slide
+     */
+    out(): void;
+
+    /**
+     * Toggle image zoom of the currently active slide
+     */
+    toggle(): void;
+}
+
+/**
+ * Lazy module.
+ */
+export class Lazy {
+    /**
+     * Load/update lazy images based on current slider state (position)
+     */
+    load(): void;
+
+    /**
+     * Force to load lazy images in slide by specified index
+     * @param number index number of slide to load lazy images in
+     */
+    loadInSlide(index: number): void;
+}
+
+/**
+ * Controller module.
+ */
+export class Controller {
+    /**
+     * Pass here another Swiper instance or array with Swiper instances that should be controlled
+     * by this Swiper
+     */
+    control?: Swiper | Swiper[] | undefined;
+}
+
+/**
+ * Accessibility module (a11y$)
+ */
+export class A11y { }
+
+/**
+ * History Navigation module.
+ */
+export class History { }
+
+/**
+ * Hash Navigation module.
+ */
+export class HashNavigation {
+}
+
+/**
+ * Autoplay module.
+ */
+export class Autoplay {
+    // Properties
+    /**
+     * Whether autoplay enabled and running
+     */
+    running: boolean;
+
+    // Methods
+    /**
+     * Start autoplay
+     */
+    start(): boolean;
+
+    /**
+     * Stop autoplay
+     */
+    stop(): boolean;
+}
+
+/**
+ * Fade Effect module.
+ */
+export class EffectFade { }
+
+/**
+ * Cube Effect module.
+ */
+export class EffectCube { }
+
+/**
+ * Flip Effect module.
+ */
+export class EffectFlip { }
+
+/**
+ * Coverflow Effect module.
+ */
+export class EffectCoverflow { }

node_modules/@types/swiper/package.json

@@ -0,0 +1,60 @@
+{
+    "name": "@types/swiper",
+    "version": "5.4.3",
+    "description": "TypeScript definitions for Swiper",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/swiper",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Sebastián Galiano",
+            "url": "https://github.com/sgaliano",
+            "githubUsername": "sgaliano"
+        },
+        {
+            "name": "Luca Trazzi",
+            "url": "https://github.com/lucax88x",
+            "githubUsername": "lucax88x"
+        },
+        {
+            "name": "Eugene Matseruk",
+            "url": "https://github.com/ematseruk",
+            "githubUsername": "ematseruk"
+        },
+        {
+            "name": "Luiz M.",
+            "url": "https://github.com/odahcam",
+            "githubUsername": "odahcam"
+        },
+        {
+            "name": "Justin Abene",
+            "url": "https://github.com/jmca",
+            "githubUsername": "jmca"
+        },
+        {
+            "name": "Asif Rahman",
+            "url": "https://github.com/daem0ndev",
+            "githubUsername": "daem0ndev"
+        },
+        {
+            "name": "Liad Idan",
+            "url": "https://github.com/LiadIdan",
+            "githubUsername": "LiadIdan"
+        },
+        {
+            "name": "Sangwon Lee",
+            "url": "https://github.com/john015",
+            "githubUsername": "john015"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/swiper"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "d45848bad7490dc6713c80e383953000999cf2bb73b18280b9f95371c6388741",
+    "typeScriptVersion": "3.6"
+}

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.

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/)

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;
+}

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}

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;
+}

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;
+}

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}

node_modules/swiper/modules/a11y.mjs

@@ -0,0 +1,377 @@
+import { g as getDocument } from '../shared/ssr-window.esm.mjs';
+import { c as classesToSelector } from '../shared/classes-to-selector.mjs';
+import { c as createElement, i as elementIndex, m as makeElementsArray, s as setInnerHTML } 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;
+    setInnerHTML(notification, 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(swiper.getSlideIndexWhenGrid(parseInt(slideEl.getAttribute('data-swiper-slide-index'))), 0);
+      } else {
+        swiper.slideTo(swiper.getSlideIndexWhenGrid(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 };

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;
+}

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.find(slideEl => slideEl.classList.contains('swiper-slide-active'));
+    } 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 };

node_modules/swiper/modules/controller.mjs

@@ -0,0 +1,191 @@
+import { n as nextTick, l 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 };

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;
+}

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}

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;
+}

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;
+  }
+}

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}

node_modules/swiper/modules/effect-cards.mjs

@@ -0,0 +1,128 @@
+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: () => ({
+      _loopSwapReset: false,
+      watchSlidesProgress: true,
+      loopAdditionalSlides: swiper.params.cardsEffect.rotate ? 3 : 2,
+      centeredSlides: true,
+      virtualTranslate: !swiper.params.cssMode
+    })
+  });
+}
+
+export { EffectCards as default };

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;
+  }
+}

node_modules/swiper/modules/effect-coverflow.less

@@ -0,0 +1,2 @@
+.swiper-coverflow {
+}

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, p 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 };

node_modules/swiper/modules/effect-coverflow.scss

@@ -0,0 +1,2 @@
+.swiper-coverflow {
+}

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;
+}

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}

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;
+}

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;
+  }
+}

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}

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, p 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 };

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;
+  }
+}

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 */

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}

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 */

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 */

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}

node_modules/swiper/modules/effect-cube.mjs

@@ -0,0 +1,174 @@
+import { e as effectInit } from '../shared/effect-init.mjs';
+import { c as createElement, p 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 };

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 */

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;
+}

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}

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;
+}

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;
+    }
+  }
+}

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}

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

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"}

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 };

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;
+    }
+  }
+}

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 */

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}

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 */

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 */

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}

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, p 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 };

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 */

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;
+}

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}

node_modules/swiper/modules/free-mode.css

@@ -0,0 +1,4 @@
+.swiper-free-mode > .swiper-wrapper {
+  transition-timing-function: ease-out;
+  margin: 0 auto;
+}

node_modules/swiper/modules/free-mode.less

@@ -0,0 +1,4 @@
+.swiper-free-mode > .swiper-wrapper {
+  transition-timing-function: ease-out;
+  margin: 0 auto;
+}

node_modules/swiper/modules/free-mode.min.css

@@ -0,0 +1 @@
+.swiper-free-mode>.swiper-wrapper{transition-timing-function:ease-out;margin:0 auto}

node_modules/swiper/modules/free-mode.mjs

@@ -0,0 +1,237 @@
+import { f as now, l 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 };