feat: Add comprehensive documentation suite and reorganize project structure

- Created complete documentation in docs/ directory
- Added PROJECT_OVERVIEW.md with feature highlights and getting started guide
- Added ARCHITECTURE.md with system design and technical details
- Added SECURITY.md with comprehensive security implementation guide
- Added DEVELOPMENT.md with development workflows and best practices
- Added DEPLOYMENT.md with production deployment instructions
- Added API.md with complete REST API documentation
- Added CONTRIBUTING.md with contribution guidelines
- Added CHANGELOG.md with version history and migration notes
- Reorganized all documentation files into docs/ directory for better organization
- Updated README.md with proper documentation links and quick navigation
- Enhanced project structure with professional documentation standards

f_scripts/shared/swiper/vue/context.js

@@ -0,0 +1,7 @@
+import { inject } from 'vue';
+export const useSwiperSlide = () => {
+  return inject('swiperSlide');
+};
+export const useSwiper = () => {
+  return inject('swiper');
+};

f_scripts/shared/swiper/vue/get-children.js

@@ -0,0 +1,40 @@
+function getChildren(originalSlots, slidesRef, oldSlidesRef) {
+  if (originalSlots === void 0) {
+    originalSlots = {};
+  }
+  const slides = [];
+  const slots = {
+    'container-start': [],
+    'container-end': [],
+    'wrapper-start': [],
+    'wrapper-end': []
+  };
+  const getSlidesFromElements = (els, slotName) => {
+    if (!Array.isArray(els)) {
+      return;
+    }
+    els.forEach(vnode => {
+      const isFragment = typeof vnode.type === 'symbol';
+      if (slotName === 'default') slotName = 'container-end';
+      if (isFragment && vnode.children) {
+        getSlidesFromElements(vnode.children, 'default');
+      } else if (vnode.type && (vnode.type.name === 'SwiperSlide' || vnode.type.name === 'AsyncComponentWrapper')) {
+        slides.push(vnode);
+      } else if (slots[slotName]) {
+        slots[slotName].push(vnode);
+      }
+    });
+  };
+  Object.keys(originalSlots).forEach(slotName => {
+    if (typeof originalSlots[slotName] !== 'function') return;
+    const els = originalSlots[slotName]();
+    getSlidesFromElements(els, slotName);
+  });
+  oldSlidesRef.value = slidesRef.value;
+  slidesRef.value = slides;
+  return {
+    slides,
+    slots
+  };
+}
+export { getChildren };

f_scripts/shared/swiper/vue/swiper-slide.js

@@ -0,0 +1,102 @@
+import { h, ref, onMounted, onUpdated, onBeforeUpdate, computed, onBeforeUnmount, provide } from 'vue';
+import { uniqueClasses } from '../components-shared/utils.js';
+const SwiperSlide = {
+  name: 'SwiperSlide',
+  props: {
+    tag: {
+      type: String,
+      default: 'div'
+    },
+    swiperRef: {
+      type: Object,
+      required: false
+    },
+    swiperSlideIndex: {
+      type: Number,
+      default: undefined,
+      required: false
+    },
+    zoom: {
+      type: Boolean,
+      default: undefined,
+      required: false
+    },
+    lazy: {
+      type: Boolean,
+      default: false,
+      required: false
+    },
+    virtualIndex: {
+      type: [String, Number],
+      default: undefined
+    }
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    let eventAttached = false;
+    const {
+      swiperRef
+    } = props;
+    const slideElRef = ref(null);
+    const slideClasses = ref('swiper-slide');
+    const lazyLoaded = ref(false);
+    function updateClasses(swiper, el, classNames) {
+      if (el === slideElRef.value) {
+        slideClasses.value = classNames;
+      }
+    }
+    onMounted(() => {
+      if (!swiperRef || !swiperRef.value) return;
+      swiperRef.value.on('_slideClass', updateClasses);
+      eventAttached = true;
+    });
+    onBeforeUpdate(() => {
+      if (eventAttached || !swiperRef || !swiperRef.value) return;
+      swiperRef.value.on('_slideClass', updateClasses);
+      eventAttached = true;
+    });
+    onUpdated(() => {
+      if (!slideElRef.value || !swiperRef || !swiperRef.value) return;
+      if (typeof props.swiperSlideIndex !== 'undefined') {
+        slideElRef.value.swiperSlideIndex = props.swiperSlideIndex;
+      }
+      if (swiperRef.value.destroyed) {
+        if (slideClasses.value !== 'swiper-slide') {
+          slideClasses.value = 'swiper-slide';
+        }
+      }
+    });
+    onBeforeUnmount(() => {
+      if (!swiperRef || !swiperRef.value) return;
+      swiperRef.value.off('_slideClass', updateClasses);
+    });
+    const slideData = computed(() => ({
+      isActive: slideClasses.value.indexOf('swiper-slide-active') >= 0,
+      isVisible: slideClasses.value.indexOf('swiper-slide-visible') >= 0,
+      isPrev: slideClasses.value.indexOf('swiper-slide-prev') >= 0,
+      isNext: slideClasses.value.indexOf('swiper-slide-next') >= 0
+    }));
+    provide('swiperSlide', slideData);
+    const onLoad = () => {
+      lazyLoaded.value = true;
+    };
+    return () => {
+      return h(props.tag, {
+        class: uniqueClasses(`${slideClasses.value}`),
+        ref: slideElRef,
+        'data-swiper-slide-index': typeof props.virtualIndex === 'undefined' && swiperRef && swiperRef.value && swiperRef.value.params.loop ? props.swiperSlideIndex : props.virtualIndex,
+        onLoadCapture: onLoad
+      }, props.zoom ? h('div', {
+        class: 'swiper-zoom-container',
+        'data-swiper-zoom': typeof props.zoom === 'number' ? props.zoom : undefined
+      }, [slots.default && slots.default(slideData.value), props.lazy && !lazyLoaded.value && h('div', {
+        class: 'swiper-lazy-preloader'
+      })]) : [slots.default && slots.default(slideData.value), props.lazy && !lazyLoaded.value && h('div', {
+        class: 'swiper-lazy-preloader'
+      })]);
+    };
+  }
+};
+export { SwiperSlide };

f_scripts/shared/swiper/vue/swiper-vue.d.ts

@@ -0,0 +1,845 @@
+import {
+  A11yOptions,
+  AutoplayOptions,
+  ControllerOptions,
+  CoverflowEffectOptions,
+  CubeEffectOptions,
+  FadeEffectOptions,
+  FlipEffectOptions,
+  CreativeEffectOptions,
+  CardsEffectOptions,
+  HashNavigationOptions,
+  HistoryOptions,
+  KeyboardOptions,
+  MousewheelOptions,
+  NavigationOptions,
+  PaginationOptions,
+  ParallaxOptions,
+  ScrollbarOptions,
+  ThumbsOptions,
+  VirtualOptions,
+  ZoomOptions,
+  FreeModeOptions,
+  GridOptions,
+} from '../types';
+import { ComponentOptionsMixin, DefineComponent, PropType, Ref } from 'vue';
+import { SwiperOptions, Swiper as SwiperClass } from '../types';
+
+declare const Swiper: DefineComponent<
+  {
+    tag: {
+      type: StringConstructor;
+      default: string;
+    };
+    wrapperTag: {
+      type: StringConstructor;
+      default: string;
+    };
+    modules: {
+      type: ArrayConstructor;
+      default: undefined;
+    };
+    init: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    direction: {
+      type: PropType<SwiperOptions['direction']>;
+      default: SwiperOptions['direction'];
+    };
+    oneWayMovement: {
+      type: PropType<SwiperOptions['oneWayMovement']>;
+      default: SwiperOptions['oneWayMovement'];
+    };
+    touchEventsTarget: {
+      type: PropType<SwiperOptions['touchEventsTarget']>;
+      default: undefined;
+    };
+    initialSlide: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    speed: { type: NumberConstructor; default: undefined };
+    cssMode: { type: BooleanConstructor; default: undefined };
+    updateOnWindowResize: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    resizeObserver: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    nested: { type: BooleanConstructor; default: undefined };
+    focusableElements: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    width: { type: NumberConstructor; default: undefined };
+    height: { type: NumberConstructor; default: undefined };
+    preventInteractionOnTransition: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    userAgent: { type: StringConstructor; default: undefined };
+    url: { type: StringConstructor; default: undefined };
+    edgeSwipeDetection: {
+      type: BooleanConstructor | StringConstructor;
+      default: undefined;
+    };
+    edgeSwipeThreshold: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    autoHeight: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    setWrapperSize: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    virtualTranslate: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    effect: {
+      type: PropType<SwiperOptions['effect']>;
+      default: undefined;
+    };
+    breakpoints: {
+      type: PropType<SwiperOptions['breakpoints']>;
+      default: undefined;
+    };
+    spaceBetween: {
+      type: PropType<SwiperOptions['spaceBetween']>;
+      default: undefined;
+    };
+    slidesPerView: {
+      type: PropType<SwiperOptions['slidesPerView']>;
+      default: undefined;
+    };
+    maxBackfaceHiddenSlides: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    slidesPerGroup: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    slidesPerGroupSkip: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    slidesPerGroupAuto: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    centeredSlides: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    centeredSlidesBounds: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    slidesOffsetBefore: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    slidesOffsetAfter: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    normalizeSlideIndex: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    centerInsufficientSlides: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    watchOverflow: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    roundLengths: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    touchRatio: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    touchAngle: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    simulateTouch: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    shortSwipes: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    longSwipes: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    longSwipesRatio: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    longSwipesMs: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    followFinger: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    allowTouchMove: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    threshold: { type: NumberConstructor; default: undefined };
+    touchMoveStopPropagation: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    touchStartPreventDefault: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    touchStartForcePreventDefault: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    touchReleaseOnEdges: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    uniqueNavElements: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    resistance: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    resistanceRatio: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    watchSlidesProgress: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    grabCursor: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    preventClicks: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    preventClicksPropagation: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    slideToClickedSlide: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    loop: { type: BooleanConstructor; default: undefined };
+    loopedSlides: {
+      type: NumberConstructor;
+      default: undefined;
+    };
+    loopPreventsSliding: { type: BooleanConstructor; default: undefined };
+    rewind: { type: BooleanConstructor; default: undefined };
+    allowSlidePrev: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    allowSlideNext: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    swipeHandler: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    noSwiping: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    noSwipingClass: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    noSwipingSelector: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    passiveListeners: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    containerModifierClass: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    slideClass: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    slideActiveClass: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    slideVisibleClass: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    slideNextClass: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    slidePrevClass: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    wrapperClass: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    lazyPreloaderClass: {
+      type: StringConstructor;
+      default: undefined;
+    };
+    runCallbacksOnInit: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    observer: { type: BooleanConstructor; default: undefined };
+    observeParents: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    observeSlideChildren: {
+      type: BooleanConstructor;
+      default: undefined;
+    };
+    a11y: {
+      type: PropType<A11yOptions | boolean>;
+      default: undefined;
+    };
+    autoplay: {
+      type: PropType<AutoplayOptions | boolean>;
+      default: undefined;
+    };
+    controller: {
+      type: PropType<ControllerOptions>;
+      default: undefined;
+    };
+    coverflowEffect: {
+      type: PropType<CoverflowEffectOptions>;
+      default: undefined;
+    };
+    cubeEffect: {
+      type: PropType<CubeEffectOptions>;
+      default: undefined;
+    };
+    fadeEffect: {
+      type: PropType<FadeEffectOptions>;
+      default: undefined;
+    };
+    flipEffect: {
+      type: PropType<FlipEffectOptions>;
+      default: undefined;
+    };
+    creativeEffect: {
+      type: PropType<CreativeEffectOptions>;
+      default: undefined;
+    };
+    cardsEffect: {
+      type: PropType<CardsEffectOptions>;
+      default: undefined;
+    };
+    hashNavigation: {
+      type: PropType<HashNavigationOptions | boolean>;
+      default: undefined;
+    };
+    history: {
+      type: PropType<HistoryOptions | boolean>;
+      default: undefined;
+    };
+    keyboard: {
+      type: PropType<KeyboardOptions | boolean>;
+      default: undefined;
+    };
+    mousewheel: {
+      type: PropType<MousewheelOptions | boolean>;
+      default: undefined;
+    };
+    navigation: {
+      type: PropType<NavigationOptions | boolean>;
+      default: undefined;
+    };
+    pagination: {
+      type: PropType<PaginationOptions | boolean>;
+      default: undefined;
+    };
+    parallax: {
+      type: PropType<ParallaxOptions | boolean>;
+      default: undefined;
+    };
+    scrollbar: {
+      type: PropType<ScrollbarOptions | boolean>;
+      default: undefined;
+    };
+    thumbs: { type: PropType<ThumbsOptions>; default: undefined };
+    virtual: {
+      type: PropType<VirtualOptions | boolean>;
+      default: undefined;
+    };
+    zoom: {
+      type: PropType<ZoomOptions | boolean>;
+      default: undefined;
+    };
+    freeMode: {
+      type: PropType<FreeModeOptions | boolean>;
+      default: undefined;
+    };
+    grid: {
+      type: PropType<GridOptions>;
+      default: undefined;
+    };
+  },
+  () => JSX.Element,
+  unknown,
+  {},
+  {},
+  ComponentOptionsMixin,
+  ComponentOptionsMixin,
+  {
+    swiper: (swiper: SwiperClass) => void;
+    /**
+   * Event will be fired in when autoplay started
+   */
+  autoplayStart: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired when autoplay stopped
+   */
+  autoplayStop: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired on autoplay pause
+   */
+  autoplayPause: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired on autoplay resume
+   */
+  autoplayResume: (swiper: SwiperClass) => void;
+  /**
+   * Event triggers continuously while autoplay is enabled. It contains time left (in ms) before transition to next slide and percentage of that time related to autoplay delay
+   */
+  autoplayTimeLeft: (swiper: SwiperClass, timeLeft: number, percentage: number) => void;
+  /**
+   * Event will be fired when slide changed with autoplay
+   */
+  autoplay: (swiper: SwiperClass) => void;/**
+   * Event will be fired on window hash change
+   */
+  hashChange: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired when swiper updates the hash
+   */
+  hashSet: (swiper: SwiperClass) => void;/**
+   * Event will be fired on mousewheel scroll
+   */
+  scroll: (swiper: SwiperClass, event: WheelEvent) => void;/**
+   * Event will be fired on key press
+   */
+  keyPress: (swiper: SwiperClass, keyCode: string) => void;/**
+   * Event will be fired on navigation hide
+   */
+  navigationHide: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired on navigation show
+   */
+  navigationShow: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired on navigation prev button click
+   */
+  navigationPrev: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired on navigation next button click
+   */
+  navigationNext: (swiper: SwiperClass) => void;/**
+   * Event will be fired after pagination rendered
+   */
+  paginationRender: (swiper: SwiperClass, paginationEl: HTMLElement) => void;
+
+  /**
+   * Event will be fired when pagination updated
+   */
+  paginationUpdate: (swiper: SwiperClass, paginationEl: HTMLElement) => void;
+
+  /**
+   * Event will be fired on pagination hide
+   */
+  paginationHide: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired on pagination show
+   */
+  paginationShow: (swiper: SwiperClass) => void;/**
+   * Event will be fired on draggable scrollbar drag start
+   */
+  scrollbarDragStart: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired on draggable scrollbar drag move
+   */
+  scrollbarDragMove: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired on draggable scrollbar drag end
+   */
+  scrollbarDragEnd: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;/**
+   * Event will be fired on zoom change
+   */
+  zoomChange: (swiper: SwiperClass, scale: number, imageEl: HTMLElement, slideEl: HTMLElement) => void;
+    
+  /**
+   * Fired right after Swiper initialization.
+   * @note Note that with `swiper.on('init')` syntax it will
+   * work only in case you set `init: false` parameter.
+   *
+   * @example
+   * ```js
+   * const swiper = new Swiper('.swiper', {
+   *   init: false,
+   *   // other parameters
+   * });
+   * swiper.on('init', function() {
+   *  // do something
+   * });
+   * // init Swiper
+   * swiper.init();
+   * ```
+   *
+   * @example
+   * ```js
+   * // Otherwise use it as the parameter:
+   * const swiper = new Swiper('.swiper', {
+   *   // other parameters
+   *   on: {
+   *     init: function () {
+   *       // do something
+   *     },
+   *   }
+   * });
+   * ```
+   */
+  init: (swiper: SwiperClass) => any;
+
+  /**
+   * Event will be fired right before Swiper destroyed
+   */
+  beforeDestroy: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired when currently active slide is changed
+   */
+  slideChange: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired in the beginning of animation to other slide (next or previous).
+   */
+  slideChangeTransitionStart: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired after animation to other slide (next or previous).
+   */
+  slideChangeTransitionEnd: (swiper: SwiperClass) => void;
+
+  /**
+   * Same as "slideChangeTransitionStart" but for "forward" direction only
+   */
+  slideNextTransitionStart: (swiper: SwiperClass) => void;
+
+  /**
+   * Same as "slideChangeTransitionEnd" but for "forward" direction only
+   */
+  slideNextTransitionEnd: (swiper: SwiperClass) => void;
+
+  /**
+   * Same as "slideChangeTransitionStart" but for "backward" direction only
+   */
+  slidePrevTransitionStart: (swiper: SwiperClass) => void;
+
+  /**
+   * Same as "slideChangeTransitionEnd" but for "backward" direction only
+   */
+  slidePrevTransitionEnd: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired in the beginning of transition.
+   */
+  transitionStart: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired after transition.
+   */
+  transitionEnd: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired when user touch Swiper. Receives `touchstart` event as an arguments.
+   */
+  touchStart: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired when user touch and move finger over Swiper. Receives `touchmove` event as an arguments.
+   */
+  touchMove: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired when user touch and move finger over Swiper in direction opposite to direction parameter. Receives `touchmove` event as an arguments.
+   */
+  touchMoveOpposite: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired when user touch and move finger over Swiper and move it. Receives `touchmove` event as an arguments.
+   */
+  sliderMove: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired when user release Swiper. Receives `touchend` event as an arguments.
+   */
+  touchEnd: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired when user click/tap on Swiper. Receives `touchend` event as an arguments.
+   */
+  click: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired when user click/tap on Swiper. Receives `touchend` event as an arguments.
+   */
+  tap: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired when user double tap on Swiper's container. Receives `touchend` event as an arguments
+   */
+  doubleTap: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+
+  /**
+   * Event will be fired when Swiper progress is changed, as an arguments it receives progress that is always from 0 to 1
+   */
+  progress: (swiper: SwiperClass, progress: number) => void;
+
+  /**
+   * Event will be fired when Swiper reach its beginning (initial position)
+   */
+  reachBeginning: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired when Swiper reach last slide
+   */
+  reachEnd: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired when Swiper goes to beginning or end position
+   */
+  toEdge: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired when Swiper goes from beginning or end position
+   */
+  fromEdge: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired when swiper's wrapper change its position. Receives current translate value as an arguments
+   */
+  setTranslate: (swiper: SwiperClass, translate: number) => void;
+
+  /**
+   * Event will be fired everytime when swiper starts animation. Receives current transition duration (in ms) as an arguments
+   */
+  setTransition: (swiper: SwiperClass, transition: number) => void;
+
+  /**
+   * Event will be fired on window resize right before swiper's onresize manipulation
+   */
+  resize: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired if observer is enabled and it detects DOM mutations
+   */
+  observerUpdate: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired right before "loop fix"
+   */
+  beforeLoopFix: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired after "loop fix"
+   */
+  loopFix: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will be fired on breakpoint change
+   */
+  breakpoint: (swiper: SwiperClass, breakpointParams: SwiperOptions) => void;
+
+  /**
+   * !INTERNAL: Event will fired right before breakpoint change
+   */
+  _beforeBreakpoint: (swiper: SwiperClass, breakpointParams: SwiperOptions) => void;
+
+  /**
+   * !INTERNAL: Event will fired after setting CSS classes on swiper container element
+   */
+  _containerClasses: (swiper: SwiperClass, classNames: string) => void;
+
+  /**
+   * !INTERNAL: Event will fired after setting CSS classes on swiper slide element
+   */
+  _slideClass: (swiper: SwiperClass, slideEl: HTMLElement, classNames: string) => void;
+
+  /**
+   * !INTERNAL: Event will fired after setting CSS classes on all swiper slides
+   */
+  _slideClasses: (
+    swiper: SwiperClass,
+    slides: { slideEl: HTMLElement; classNames: string; index: number }[],
+  ) => void;
+
+  /**
+   * !INTERNAL: Event will fired as soon as swiper instance available (before init)
+   */
+  _swiper: (swiper: SwiperClass) => void;
+
+  /**
+   * !INTERNAL: Event will be fired on free mode touch end (release) and there will no be momentum
+   */
+  _freeModeNoMomentumRelease: (swiper: SwiperClass) => void;
+
+  /**
+   * Event will fired on active index change
+   */
+  activeIndexChange: (swiper: SwiperClass) => void;
+  /**
+   * Event will fired on snap index change
+   */
+  snapIndexChange: (swiper: SwiperClass) => void;
+  /**
+   * Event will fired on real index change
+   */
+  realIndexChange: (swiper: SwiperClass) => void;
+  /**
+   * Event will fired right after initialization
+   */
+  afterInit: (swiper: SwiperClass) => void;
+  /**
+   * Event will fired right before initialization
+   */
+  beforeInit: (swiper: SwiperClass) => void;
+  /**
+   * Event will fired before resize handler
+   */
+  beforeResize: (swiper: SwiperClass) => void;
+  /**
+   * Event will fired before slide change transition start
+   */
+  beforeSlideChangeStart: (swiper: SwiperClass) => void;
+  /**
+   * Event will fired before transition start
+   */
+  beforeTransitionStart: (swiper: SwiperClass, speed: number, internal: any) => void; // what is internal?
+  /**
+   * Event will fired on direction change
+   */
+  changeDirection: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired when user double click/tap on Swiper
+   */
+  doubleClick: (swiper: SwiperClass, event: MouseEvent | TouchEvent | PointerEvent) => void;
+  /**
+   * Event will be fired on swiper destroy
+   */
+  destroy: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired on momentum bounce
+   */
+  momentumBounce: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired on orientation change (e.g. landscape -> portrait)
+   */
+  orientationchange: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired in the beginning of animation of resetting slide to current one
+   */
+  slideResetTransitionStart: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired in the end of animation of resetting slide to current one
+   */
+  slideResetTransitionEnd: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired with first touch/drag move
+   */
+  sliderFirstMove: (swiper: SwiperClass, event: TouchEvent) => void;
+  /**
+   * Event will be fired when number of slides has changed
+   */
+  slidesLengthChange: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired when slides grid has changed
+   */
+  slidesGridLengthChange: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired when snap grid has changed
+   */
+  snapGridLengthChange: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired after swiper.update() call
+   */
+  update: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired when swiper is locked (when `watchOverflow` enabled)
+   */
+  lock: (swiper: SwiperClass) => void;
+  /**
+   * Event will be fired when swiper is unlocked (when `watchOverflow` enabled)
+   */
+  unlock: (swiper: SwiperClass) => void;
+  
+  }
+>;
+
+declare const SwiperSlide: DefineComponent<{
+  tag: {
+    type: StringConstructor;
+    default: string;
+  };
+  swiperRef: { type: PropType<SwiperClass>; required: false };
+  lazy: { type: BooleanConstructor; default: false };
+  zoom: { type: BooleanConstructor; default: undefined };
+  virtualIndex: {
+    type: StringConstructor | NumberConstructor;
+    default: undefined;
+  };
+}>;
+
+declare const useSwiper: () => Ref<SwiperClass>;
+declare const useSwiperSlide: () => Ref<{
+  isActive: boolean;
+  isVisible: boolean;
+  isPrev: boolean;
+  isNext: boolean;
+}>;
+
+export { Swiper, SwiperSlide, useSwiper, useSwiperSlide };

f_scripts/shared/swiper/vue/swiper-vue.js

@@ -0,0 +1,16 @@
+/**
+ * Swiper Vue 9.1.0
+ * Most modern mobile touch slider and framework with hardware accelerated transitions
+ * https://swiperjs.com
+ *
+ * Copyright 2014-2023 Vladimir Kharlampidi
+ *
+ * Released under the MIT License
+ *
+ * Released on: February 28, 2023
+ */
+
+import { Swiper } from './swiper.js';
+import { SwiperSlide } from './swiper-slide.js';
+export { useSwiperSlide, useSwiper } from './context.js';
+export { Swiper, SwiperSlide };

f_scripts/shared/swiper/vue/swiper.js

@@ -0,0 +1,609 @@
+import { h, ref, onMounted, onUpdated, onBeforeUnmount, watch, nextTick, provide } from 'vue';
+import SwiperCore from 'swiper';
+import { getParams } from '../components-shared/get-params.js';
+import { mountSwiper } from '../components-shared/mount-swiper.js';
+import { needsScrollbar, needsNavigation, needsPagination, uniqueClasses, extend, wrapperClass } from '../components-shared/utils.js';
+import { getChangedParams } from '../components-shared/get-changed-params.js';
+import { getChildren } from './get-children.js';
+import { updateSwiper } from '../components-shared/update-swiper.js';
+import { renderVirtual } from './virtual.js';
+import { updateOnVirtualData } from '../components-shared/update-on-virtual-data.js';
+const Swiper = {
+  name: 'Swiper',
+  props: {
+    tag: {
+      type: String,
+      default: 'div'
+    },
+    wrapperTag: {
+      type: String,
+      default: 'div'
+    },
+    modules: {
+      type: Array,
+      default: undefined
+    },
+    init: {
+      type: Boolean,
+      default: undefined
+    },
+    direction: {
+      type: String,
+      default: undefined
+    },
+    oneWayMovement: {
+      type: Boolean,
+      default: undefined
+    },
+    touchEventsTarget: {
+      type: String,
+      default: undefined
+    },
+    initialSlide: {
+      type: Number,
+      default: undefined
+    },
+    speed: {
+      type: Number,
+      default: undefined
+    },
+    cssMode: {
+      type: Boolean,
+      default: undefined
+    },
+    updateOnWindowResize: {
+      type: Boolean,
+      default: undefined
+    },
+    resizeObserver: {
+      type: Boolean,
+      default: undefined
+    },
+    nested: {
+      type: Boolean,
+      default: undefined
+    },
+    focusableElements: {
+      type: String,
+      default: undefined
+    },
+    width: {
+      type: Number,
+      default: undefined
+    },
+    height: {
+      type: Number,
+      default: undefined
+    },
+    preventInteractionOnTransition: {
+      type: Boolean,
+      default: undefined
+    },
+    userAgent: {
+      type: String,
+      default: undefined
+    },
+    url: {
+      type: String,
+      default: undefined
+    },
+    edgeSwipeDetection: {
+      type: [Boolean, String],
+      default: undefined
+    },
+    edgeSwipeThreshold: {
+      type: Number,
+      default: undefined
+    },
+    autoHeight: {
+      type: Boolean,
+      default: undefined
+    },
+    setWrapperSize: {
+      type: Boolean,
+      default: undefined
+    },
+    virtualTranslate: {
+      type: Boolean,
+      default: undefined
+    },
+    effect: {
+      type: String,
+      default: undefined
+    },
+    breakpoints: {
+      type: Object,
+      default: undefined
+    },
+    spaceBetween: {
+      type: [Number, String],
+      default: undefined
+    },
+    slidesPerView: {
+      type: [Number, String],
+      default: undefined
+    },
+    maxBackfaceHiddenSlides: {
+      type: Number,
+      default: undefined
+    },
+    slidesPerGroup: {
+      type: Number,
+      default: undefined
+    },
+    slidesPerGroupSkip: {
+      type: Number,
+      default: undefined
+    },
+    slidesPerGroupAuto: {
+      type: Boolean,
+      default: undefined
+    },
+    centeredSlides: {
+      type: Boolean,
+      default: undefined
+    },
+    centeredSlidesBounds: {
+      type: Boolean,
+      default: undefined
+    },
+    slidesOffsetBefore: {
+      type: Number,
+      default: undefined
+    },
+    slidesOffsetAfter: {
+      type: Number,
+      default: undefined
+    },
+    normalizeSlideIndex: {
+      type: Boolean,
+      default: undefined
+    },
+    centerInsufficientSlides: {
+      type: Boolean,
+      default: undefined
+    },
+    watchOverflow: {
+      type: Boolean,
+      default: undefined
+    },
+    roundLengths: {
+      type: Boolean,
+      default: undefined
+    },
+    touchRatio: {
+      type: Number,
+      default: undefined
+    },
+    touchAngle: {
+      type: Number,
+      default: undefined
+    },
+    simulateTouch: {
+      type: Boolean,
+      default: undefined
+    },
+    shortSwipes: {
+      type: Boolean,
+      default: undefined
+    },
+    longSwipes: {
+      type: Boolean,
+      default: undefined
+    },
+    longSwipesRatio: {
+      type: Number,
+      default: undefined
+    },
+    longSwipesMs: {
+      type: Number,
+      default: undefined
+    },
+    followFinger: {
+      type: Boolean,
+      default: undefined
+    },
+    allowTouchMove: {
+      type: Boolean,
+      default: undefined
+    },
+    threshold: {
+      type: Number,
+      default: undefined
+    },
+    touchMoveStopPropagation: {
+      type: Boolean,
+      default: undefined
+    },
+    touchStartPreventDefault: {
+      type: Boolean,
+      default: undefined
+    },
+    touchStartForcePreventDefault: {
+      type: Boolean,
+      default: undefined
+    },
+    touchReleaseOnEdges: {
+      type: Boolean,
+      default: undefined
+    },
+    uniqueNavElements: {
+      type: Boolean,
+      default: undefined
+    },
+    resistance: {
+      type: Boolean,
+      default: undefined
+    },
+    resistanceRatio: {
+      type: Number,
+      default: undefined
+    },
+    watchSlidesProgress: {
+      type: Boolean,
+      default: undefined
+    },
+    grabCursor: {
+      type: Boolean,
+      default: undefined
+    },
+    preventClicks: {
+      type: Boolean,
+      default: undefined
+    },
+    preventClicksPropagation: {
+      type: Boolean,
+      default: undefined
+    },
+    slideToClickedSlide: {
+      type: Boolean,
+      default: undefined
+    },
+    loop: {
+      type: Boolean,
+      default: undefined
+    },
+    loopedSlides: {
+      type: Number,
+      default: undefined
+    },
+    loopPreventsSliding: {
+      type: Boolean,
+      default: undefined
+    },
+    rewind: {
+      type: Boolean,
+      default: undefined
+    },
+    allowSlidePrev: {
+      type: Boolean,
+      default: undefined
+    },
+    allowSlideNext: {
+      type: Boolean,
+      default: undefined
+    },
+    swipeHandler: {
+      type: Boolean,
+      default: undefined
+    },
+    noSwiping: {
+      type: Boolean,
+      default: undefined
+    },
+    noSwipingClass: {
+      type: String,
+      default: undefined
+    },
+    noSwipingSelector: {
+      type: String,
+      default: undefined
+    },
+    passiveListeners: {
+      type: Boolean,
+      default: undefined
+    },
+    containerModifierClass: {
+      type: String,
+      default: undefined
+    },
+    slideClass: {
+      type: String,
+      default: undefined
+    },
+    slideActiveClass: {
+      type: String,
+      default: undefined
+    },
+    slideVisibleClass: {
+      type: String,
+      default: undefined
+    },
+    slideNextClass: {
+      type: String,
+      default: undefined
+    },
+    slidePrevClass: {
+      type: String,
+      default: undefined
+    },
+    wrapperClass: {
+      type: String,
+      default: undefined
+    },
+    lazyPreloaderClass: {
+      type: String,
+      default: undefined
+    },
+    runCallbacksOnInit: {
+      type: Boolean,
+      default: undefined
+    },
+    observer: {
+      type: Boolean,
+      default: undefined
+    },
+    observeParents: {
+      type: Boolean,
+      default: undefined
+    },
+    observeSlideChildren: {
+      type: Boolean,
+      default: undefined
+    },
+    a11y: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    autoplay: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    controller: {
+      type: Object,
+      default: undefined
+    },
+    coverflowEffect: {
+      type: Object,
+      default: undefined
+    },
+    cubeEffect: {
+      type: Object,
+      default: undefined
+    },
+    fadeEffect: {
+      type: Object,
+      default: undefined
+    },
+    flipEffect: {
+      type: Object,
+      default: undefined
+    },
+    creativeEffect: {
+      type: Object,
+      default: undefined
+    },
+    cardsEffect: {
+      type: Object,
+      default: undefined
+    },
+    hashNavigation: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    history: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    keyboard: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    mousewheel: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    navigation: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    pagination: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    parallax: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    scrollbar: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    thumbs: {
+      type: Object,
+      default: undefined
+    },
+    virtual: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    zoom: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    grid: {
+      type: [Object],
+      default: undefined
+    },
+    freeMode: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    enabled: {
+      type: Boolean,
+      default: undefined
+    }
+  },
+  emits: ['_beforeBreakpoint', '_containerClasses', '_slideClass', '_slideClasses', '_swiper', '_freeModeNoMomentumRelease', 'activeIndexChange', 'afterInit', 'autoplay', 'autoplayStart', 'autoplayStop', 'autoplayPause', 'autoplayResume', 'autoplayTimeLeft', 'beforeDestroy', 'beforeInit', 'beforeLoopFix', 'beforeResize', 'beforeSlideChangeStart', 'beforeTransitionStart', 'breakpoint', 'changeDirection', 'click', 'disable', 'doubleTap', 'doubleClick', 'destroy', 'enable', 'fromEdge', 'hashChange', 'hashSet', 'init', 'keyPress', 'lock', 'loopFix', 'momentumBounce', 'navigationHide', 'navigationShow', 'navigationPrev', 'navigationNext', 'observerUpdate', 'orientationchange', 'paginationHide', 'paginationRender', 'paginationShow', 'paginationUpdate', 'progress', 'reachBeginning', 'reachEnd', 'realIndexChange', 'resize', 'scroll', 'scrollbarDragEnd', 'scrollbarDragMove', 'scrollbarDragStart', 'setTransition', 'setTranslate', 'slideChange', 'slideChangeTransitionEnd', 'slideChangeTransitionStart', 'slideNextTransitionEnd', 'slideNextTransitionStart', 'slidePrevTransitionEnd', 'slidePrevTransitionStart', 'slideResetTransitionStart', 'slideResetTransitionEnd', 'sliderMove', 'sliderFirstMove', 'slidesLengthChange', 'slidesGridLengthChange', 'snapGridLengthChange', 'snapIndexChange', 'swiper', 'tap', 'toEdge', 'touchEnd', 'touchMove', 'touchMoveOpposite', 'touchStart', 'transitionEnd', 'transitionStart', 'unlock', 'update', 'virtualUpdate', 'zoomChange'],
+  setup(props, _ref) {
+    let {
+      slots: originalSlots,
+      emit
+    } = _ref;
+    const {
+      tag: Tag,
+      wrapperTag: WrapperTag
+    } = props;
+    const containerClasses = ref('swiper');
+    const virtualData = ref(null);
+    const breakpointChanged = ref(false);
+    const initializedRef = ref(false);
+    const swiperElRef = ref(null);
+    const swiperRef = ref(null);
+    const oldPassedParamsRef = ref(null);
+    const slidesRef = {
+      value: []
+    };
+    const oldSlidesRef = {
+      value: []
+    };
+    const nextElRef = ref(null);
+    const prevElRef = ref(null);
+    const paginationElRef = ref(null);
+    const scrollbarElRef = ref(null);
+    const {
+      params: swiperParams,
+      passedParams
+    } = getParams(props, false);
+    getChildren(originalSlots, slidesRef, oldSlidesRef);
+    oldPassedParamsRef.value = passedParams;
+    oldSlidesRef.value = slidesRef.value;
+    const onBeforeBreakpoint = () => {
+      getChildren(originalSlots, slidesRef, oldSlidesRef);
+      breakpointChanged.value = true;
+    };
+    swiperParams.onAny = function (event) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      emit(event, ...args);
+    };
+    Object.assign(swiperParams.on, {
+      _beforeBreakpoint: onBeforeBreakpoint,
+      _containerClasses(swiper, classes) {
+        containerClasses.value = classes;
+      }
+    });
+
+    // init Swiper
+    const passParams = {
+      ...swiperParams
+    };
+    delete passParams.wrapperClass;
+    swiperRef.value = new SwiperCore(passParams);
+    if (swiperRef.value.virtual && swiperRef.value.params.virtual.enabled) {
+      swiperRef.value.virtual.slides = slidesRef.value;
+      const extendWith = {
+        cache: false,
+        slides: slidesRef.value,
+        renderExternal: data => {
+          virtualData.value = data;
+        },
+        renderExternalUpdate: false
+      };
+      extend(swiperRef.value.params.virtual, extendWith);
+      extend(swiperRef.value.originalParams.virtual, extendWith);
+    }
+    onUpdated(() => {
+      // set initialized flag
+      if (!initializedRef.value && swiperRef.value) {
+        swiperRef.value.emitSlidesClasses();
+        initializedRef.value = true;
+      }
+      // watch for params change
+      const {
+        passedParams: newPassedParams
+      } = getParams(props, false);
+      const changedParams = getChangedParams(newPassedParams, oldPassedParamsRef.value, slidesRef.value, oldSlidesRef.value, c => c.props && c.props.key);
+      oldPassedParamsRef.value = newPassedParams;
+      if ((changedParams.length || breakpointChanged.value) && swiperRef.value && !swiperRef.value.destroyed) {
+        updateSwiper({
+          swiper: swiperRef.value,
+          slides: slidesRef.value,
+          passedParams: newPassedParams,
+          changedParams,
+          nextEl: nextElRef.value,
+          prevEl: prevElRef.value,
+          scrollbarEl: scrollbarElRef.value,
+          paginationEl: paginationElRef.value
+        });
+      }
+      breakpointChanged.value = false;
+    });
+    provide('swiper', swiperRef);
+
+    // update on virtual update
+    watch(virtualData, () => {
+      nextTick(() => {
+        updateOnVirtualData(swiperRef.value);
+      });
+    });
+
+    // mount swiper
+    onMounted(() => {
+      if (!swiperElRef.value) return;
+      mountSwiper({
+        el: swiperElRef.value,
+        nextEl: nextElRef.value,
+        prevEl: prevElRef.value,
+        paginationEl: paginationElRef.value,
+        scrollbarEl: scrollbarElRef.value,
+        swiper: swiperRef.value
+      }, swiperParams);
+      emit('swiper', swiperRef.value);
+    });
+    onBeforeUnmount(() => {
+      if (swiperRef.value && !swiperRef.value.destroyed) {
+        swiperRef.value.destroy(true, false);
+      }
+    });
+
+    // bypass swiper instance to slides
+    function renderSlides(slides) {
+      if (swiperParams.virtual) {
+        return renderVirtual(swiperRef, slides, virtualData.value);
+      }
+      slides.forEach((slide, index) => {
+        if (!slide.props) slide.props = {};
+        slide.props.swiperRef = swiperRef;
+        slide.props.swiperSlideIndex = index;
+      });
+      return slides;
+    }
+    return () => {
+      const {
+        slides,
+        slots
+      } = getChildren(originalSlots, slidesRef, oldSlidesRef);
+      return h(Tag, {
+        ref: swiperElRef,
+        class: uniqueClasses(containerClasses.value)
+      }, [slots['container-start'], h(WrapperTag, {
+        class: wrapperClass(swiperParams.wrapperClass)
+      }, [slots['wrapper-start'], renderSlides(slides), slots['wrapper-end']]), needsNavigation(props) && [h('div', {
+        ref: prevElRef,
+        class: 'swiper-button-prev'
+      }), h('div', {
+        ref: nextElRef,
+        class: 'swiper-button-next'
+      })], needsScrollbar(props) && h('div', {
+        ref: scrollbarElRef,
+        class: 'swiper-scrollbar'
+      }), needsPagination(props) && h('div', {
+        ref: paginationElRef,
+        class: 'swiper-pagination'
+      }), slots['container-end']]);
+    };
+  }
+};
+export { Swiper };

f_scripts/shared/swiper/vue/virtual.js

@@ -0,0 +1,41 @@
+import { h } from 'vue';
+function renderVirtual(swiperRef, slides, virtualData) {
+  if (!virtualData) return null;
+  const getSlideIndex = index => {
+    let slideIndex = index;
+    if (index < 0) {
+      slideIndex = slides.length + index;
+    } else if (slideIndex >= slides.length) {
+      // eslint-disable-next-line
+      slideIndex = slideIndex - slides.length;
+    }
+    return slideIndex;
+  };
+  const style = swiperRef.value.isHorizontal() ? {
+    [swiperRef.value.rtlTranslate ? 'right' : 'left']: `${virtualData.offset}px`
+  } : {
+    top: `${virtualData.offset}px`
+  };
+  const {
+    from,
+    to
+  } = virtualData;
+  const loopFrom = swiperRef.value.params.loop ? -slides.length : 0;
+  const loopTo = swiperRef.value.params.loop ? slides.length * 2 : slides.length;
+  const slidesToRender = [];
+  for (let i = loopFrom; i < loopTo; i += 1) {
+    if (i >= from && i <= to) {
+      slidesToRender.push(slides[getSlideIndex(i)]);
+    }
+  }
+  return slidesToRender.map(slide => {
+    if (!slide.props) slide.props = {};
+    if (!slide.props.style) slide.props.style = {};
+    slide.props.swiperRef = swiperRef;
+    slide.props.style = style;
+    return h(slide.type, {
+      ...slide.props
+    }, slide.children);
+  });
+}
+export { renderVirtual };