First upload

public/copiaintegra/dist/assets/libs/swiper/esm/vue/get-changed-params.js

@@ -0,0 +1,51 @@
+import { paramsList } from './params-list';
+import { isObject } from './utils';
+
+function getChangedParams(swiperParams, oldParams, children, oldChildren) {
+  var keys = [];
+  if (!oldParams) return keys;
+
+  var addKey = function addKey(key) {
+    if (keys.indexOf(key) < 0) keys.push(key);
+  };
+
+  var oldChildrenKeys = oldChildren.map(function (child) {
+    return child.props && child.props.key;
+  });
+  var childrenKeys = children.map(function (child) {
+    return child.props && child.props.key;
+  });
+  if (oldChildrenKeys.join('') !== childrenKeys.join('')) keys.push('children');
+  if (oldChildren.length !== children.length) keys.push('children');
+  var watchParams = paramsList.filter(function (key) {
+    return key[0] === '_';
+  }).map(function (key) {
+    return key.replace(/_/, '');
+  });
+  watchParams.forEach(function (key) {
+    if (key in swiperParams && key in oldParams) {
+      if (isObject(swiperParams[key]) && isObject(oldParams[key])) {
+        var newKeys = Object.keys(swiperParams[key]);
+        var oldKeys = Object.keys(oldParams[key]);
+
+        if (newKeys.length !== oldKeys.length) {
+          addKey(key);
+        } else {
+          newKeys.forEach(function (newKey) {
+            if (swiperParams[key][newKey] !== oldParams[key][newKey]) {
+              addKey(key);
+            }
+          });
+          oldKeys.forEach(function (oldKey) {
+            if (swiperParams[key][oldKey] !== oldParams[key][oldKey]) addKey(key);
+          });
+        }
+      } else if (swiperParams[key] !== oldParams[key]) {
+        addKey(key);
+      }
+    }
+  });
+  return keys;
+}
+
+export { getChangedParams };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/get-children.js

@@ -0,0 +1,45 @@
+function getChildren(originalSlots, slidesRef, oldSlidesRef) {
+  if (originalSlots === void 0) {
+    originalSlots = {};
+  }
+
+  var slides = [];
+  var slots = {
+    'container-start': [],
+    'container-end': [],
+    'wrapper-start': [],
+    'wrapper-end': []
+  };
+
+  var getSlidesFromElements = function getSlidesFromElements(els, slotName) {
+    if (!Array.isArray(els)) {
+      return;
+    }
+
+    els.forEach(function (vnode) {
+      var 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(function (slotName) {
+    var els = originalSlots[slotName]();
+    getSlidesFromElements(els, slotName);
+  });
+  oldSlidesRef.value = slidesRef.value;
+  slidesRef.value = slides;
+  return {
+    slides: slides,
+    slots: slots
+  };
+}
+
+export { getChildren };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/get-params.js

@@ -0,0 +1,55 @@
+// eslint-disable-next-line
+import Swiper from '../../core';
+import { isObject, extend } from './utils';
+import { paramsList } from './params-list';
+
+function getParams(obj) {
+  if (obj === void 0) {
+    obj = {};
+  }
+
+  var params = {
+    on: {}
+  };
+  var passedParams = {};
+  extend(params, Swiper.defaults);
+  extend(params, Swiper.extendedDefaults);
+  params._emitClasses = true;
+  params.init = false;
+  var rest = {};
+  var allowedParams = paramsList.map(function (key) {
+    return key.replace(/_/, '');
+  }); // Prevent empty Object.keys(obj) array on ios.
+
+  var plainObj = Object.assign({}, obj);
+  Object.keys(plainObj).forEach(function (key) {
+    if (typeof obj[key] === 'undefined') return;
+
+    if (allowedParams.indexOf(key) >= 0) {
+      if (isObject(obj[key])) {
+        params[key] = {};
+        passedParams[key] = {};
+        extend(params[key], obj[key]);
+        extend(passedParams[key], obj[key]);
+      } else {
+        params[key] = obj[key];
+        passedParams[key] = obj[key];
+      }
+    } else if (key.search(/on[A-Z]/) === 0 && typeof obj[key] === 'function') {
+      params.on["" + key[2].toLowerCase() + key.substr(3)] = obj[key];
+    } else {
+      rest[key] = obj[key];
+    }
+  });
+  ['navigation', 'pagination', 'scrollbar'].forEach(function (key) {
+    if (params[key] === true) params[key] = {};
+    if (params[key] === false) delete params[key];
+  });
+  return {
+    params: params,
+    passedParams: passedParams,
+    rest: rest
+  };
+}
+
+export { getParams };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/init-swiper.js

@@ -0,0 +1,37 @@
+// eslint-disable-next-line
+import Swiper from '../../core';
+import { needsNavigation, needsPagination, needsScrollbar } from './utils';
+
+function initSwiper(swiperParams) {
+  return new Swiper(swiperParams);
+}
+
+function mountSwiper(_ref, swiperParams) {
+  var el = _ref.el,
+      nextEl = _ref.nextEl,
+      prevEl = _ref.prevEl,
+      paginationEl = _ref.paginationEl,
+      scrollbarEl = _ref.scrollbarEl,
+      swiper = _ref.swiper;
+
+  if (needsNavigation(swiperParams) && nextEl && prevEl) {
+    swiper.params.navigation.nextEl = nextEl;
+    swiper.originalParams.navigation.nextEl = nextEl;
+    swiper.params.navigation.prevEl = prevEl;
+    swiper.originalParams.navigation.prevEl = prevEl;
+  }
+
+  if (needsPagination(swiperParams) && paginationEl) {
+    swiper.params.pagination.el = paginationEl;
+    swiper.originalParams.pagination.el = paginationEl;
+  }
+
+  if (needsScrollbar(swiperParams) && scrollbarEl) {
+    swiper.params.scrollbar.el = scrollbarEl;
+    swiper.originalParams.scrollbar.el = scrollbarEl;
+  }
+
+  swiper.init(el);
+}
+
+export { initSwiper, mountSwiper };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/loop.js

@@ -0,0 +1,82 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import { h } from 'vue'; // eslint-disable-next-line
+
+import Swiper from '../../core';
+
+function calcLoopedSlides(slides, swiperParams) {
+  var slidesPerViewParams = swiperParams.slidesPerView;
+
+  if (swiperParams.breakpoints) {
+    var breakpoint = Swiper.prototype.getBreakpoint(swiperParams.breakpoints);
+    var breakpointOnlyParams = breakpoint in swiperParams.breakpoints ? swiperParams.breakpoints[breakpoint] : undefined;
+
+    if (breakpointOnlyParams && breakpointOnlyParams.slidesPerView) {
+      slidesPerViewParams = breakpointOnlyParams.slidesPerView;
+    }
+  }
+
+  var loopedSlides = Math.ceil(parseFloat(swiperParams.loopedSlides || slidesPerViewParams, 10));
+  loopedSlides += swiperParams.loopAdditionalSlides;
+
+  if (loopedSlides > slides.length) {
+    loopedSlides = slides.length;
+  }
+
+  return loopedSlides;
+}
+
+function renderLoop(swiperRef, slides, swiperParams) {
+  var modifiedSlides = slides.map(function (child, index) {
+    if (!child.props) child.props = {};
+    child.props.swiperRef = swiperRef;
+    child.props['data-swiper-slide-index'] = index;
+    return child;
+  });
+
+  function duplicateSlide(child, index, position) {
+    if (!child.props) child.props = {};
+    return h(child.type, _extends({}, child.props, {
+      key: child.key + "-duplicate-" + index + "-" + position,
+      class: (child.props.className || '') + " " + swiperParams.slideDuplicateClass + " " + (child.props.class || '')
+    }), child.children);
+  }
+
+  if (swiperParams.loopFillGroupWithBlank) {
+    var blankSlidesNum = swiperParams.slidesPerGroup - modifiedSlides.length % swiperParams.slidesPerGroup;
+
+    if (blankSlidesNum !== swiperParams.slidesPerGroup) {
+      for (var i = 0; i < blankSlidesNum; i += 1) {
+        var blankSlide = h('div', {
+          class: swiperParams.slideClass + " " + swiperParams.slideBlankClass
+        });
+        modifiedSlides.push(blankSlide);
+      }
+    }
+  }
+
+  if (swiperParams.slidesPerView === 'auto' && !swiperParams.loopedSlides) {
+    swiperParams.loopedSlides = modifiedSlides.length;
+  }
+
+  var loopedSlides = calcLoopedSlides(modifiedSlides, swiperParams);
+  var prependSlides = [];
+  var appendSlides = [];
+  modifiedSlides.forEach(function (child, index) {
+    if (index < loopedSlides) {
+      appendSlides.push(duplicateSlide(child, index, 'prepend'));
+    }
+
+    if (index < modifiedSlides.length && index >= modifiedSlides.length - loopedSlides) {
+      prependSlides.push(duplicateSlide(child, index, 'append'));
+    }
+  });
+
+  if (swiperRef.value) {
+    swiperRef.value.loopedSlides = loopedSlides;
+  }
+
+  return [].concat(prependSlides, modifiedSlides, appendSlides);
+}
+
+export { calcLoopedSlides, renderLoop };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/params-list.js

@@ -0,0 +1,4 @@
+/* underscore in name -> watch for changes */
+var paramsList = ['init', '_direction', 'touchEventsTarget', 'initialSlide', '_speed', 'cssMode', 'updateOnWindowResize', 'resizeObserver', 'nested', 'focusableElements', '_enabled', '_width', '_height', 'preventInteractionOnTransition', 'userAgent', 'url', '_edgeSwipeDetection', '_edgeSwipeThreshold', '_freeMode', '_freeModeMomentum', '_freeModeMomentumRatio', '_freeModeMomentumBounce', '_freeModeMomentumBounceRatio', '_freeModeMomentumVelocityRatio', '_freeModeSticky', '_freeModeMinimumVelocity', '_autoHeight', 'setWrapperSize', 'virtualTranslate', '_effect', 'breakpoints', '_spaceBetween', '_slidesPerView', '_slidesPerColumn', '_slidesPerColumnFill', '_slidesPerGroup', '_slidesPerGroupSkip', '_centeredSlides', '_centeredSlidesBounds', '_slidesOffsetBefore', '_slidesOffsetAfter', 'normalizeSlideIndex', '_centerInsufficientSlides', '_watchOverflow', 'roundLengths', 'touchRatio', 'touchAngle', 'simulateTouch', '_shortSwipes', '_longSwipes', 'longSwipesRatio', 'longSwipesMs', '_followFinger', 'allowTouchMove', '_threshold', 'touchMoveStopPropagation', 'touchStartPreventDefault', 'touchStartForcePreventDefault', 'touchReleaseOnEdges', 'uniqueNavElements', '_resistance', '_resistanceRatio', '_watchSlidesProgress', '_watchSlidesVisibility', '_grabCursor', 'preventClicks', 'preventClicksPropagation', '_slideToClickedSlide', '_preloadImages', 'updateOnImagesReady', '_loop', '_loopAdditionalSlides', '_loopedSlides', '_loopFillGroupWithBlank', 'loopPreventsSlide', '_allowSlidePrev', '_allowSlideNext', '_swipeHandler', '_noSwiping', 'noSwipingClass', 'noSwipingSelector', 'passiveListeners', 'containerModifierClass', 'slideClass', 'slideBlankClass', 'slideActiveClass', 'slideDuplicateActiveClass', 'slideVisibleClass', 'slideDuplicateClass', 'slideNextClass', 'slideDuplicateNextClass', 'slidePrevClass', 'slideDuplicatePrevClass', 'wrapperClass', 'runCallbacksOnInit', 'observer', 'observeParents', 'observeSlideChildren', // modules
+'a11y', 'autoplay', '_controller', 'coverflowEffect', 'cubeEffect', 'fadeEffect', 'flipEffect', 'hashNavigation', 'history', 'keyboard', 'lazy', 'mousewheel', '_navigation', '_pagination', 'parallax', '_scrollbar', '_thumbs', 'virtual', 'zoom'];
+export { paramsList };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/swiper-slide.js

@@ -0,0 +1,77 @@
+import { h, ref, onMounted, onUpdated, onBeforeUpdate, computed, onBeforeUnmount } from 'vue';
+import { uniqueClasses } from './utils';
+var SwiperSlide = {
+  name: 'SwiperSlide',
+  props: {
+    tag: {
+      type: String,
+      default: 'div'
+    },
+    swiperRef: Object,
+    zoom: {
+      type: Boolean,
+      default: undefined
+    },
+    virtualIndex: {
+      type: [String, Number],
+      default: undefined
+    }
+  },
+  setup: function setup(props, _ref) {
+    var slots = _ref.slots;
+    var eventAttached = false;
+    var swiperRef = props.swiperRef;
+    var slideElRef = ref(null);
+    var slideClasses = ref('swiper-slide');
+
+    function updateClasses(swiper, el, classNames) {
+      if (el === slideElRef.value) {
+        slideClasses.value = classNames;
+      }
+    }
+
+    onMounted(function () {
+      if (!swiperRef.value) return;
+      swiperRef.value.on('_slideClass', updateClasses);
+      eventAttached = true;
+    });
+    onBeforeUpdate(function () {
+      if (eventAttached || !swiperRef || !swiperRef.value) return;
+      swiperRef.value.on('_slideClass', updateClasses);
+      eventAttached = true;
+    });
+    onUpdated(function () {
+      if (!slideElRef.value || !swiperRef || !swiperRef.value) return;
+
+      if (swiperRef.value.destroyed) {
+        if (slideClasses.value !== 'swiper-slide') {
+          slideClasses.value = 'swiper-slide';
+        }
+      }
+    });
+    onBeforeUnmount(function () {
+      if (!swiperRef || !swiperRef.value) return;
+      swiperRef.value.off('_slideClass', updateClasses);
+    });
+    var slideData = computed(function () {
+      return {
+        isActive: slideClasses.value.indexOf('swiper-slide-active') >= 0 || slideClasses.value.indexOf('swiper-slide-duplicate-active') >= 0,
+        isVisible: slideClasses.value.indexOf('swiper-slide-visible') >= 0,
+        isDuplicate: slideClasses.value.indexOf('swiper-slide-duplicate') >= 0,
+        isPrev: slideClasses.value.indexOf('swiper-slide-prev') >= 0 || slideClasses.value.indexOf('swiper-slide-duplicate-prev') >= 0,
+        isNext: slideClasses.value.indexOf('swiper-slide-next') >= 0 || slideClasses.value.indexOf('swiper-slide-duplicate-next') >= 0
+      };
+    });
+    return function () {
+      return h(props.tag, {
+        class: uniqueClasses("" + slideClasses.value),
+        ref: slideElRef,
+        'data-swiper-slide-index': props.virtualIndex
+      }, props.zoom ? h('div', {
+        class: 'swiper-zoom-container',
+        'data-swiper-zoom': typeof props.zoom === 'number' ? props.zoom : undefined
+      }, slots.default && slots.default(slideData.value)) : slots.default && slots.default(slideData.value));
+    };
+  }
+};
+export { SwiperSlide };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/swiper.js

@@ -0,0 +1,657 @@
+import { h, ref, onMounted, onUpdated, onBeforeUnmount, watch, nextTick } from 'vue';
+import { getParams } from './get-params';
+import { initSwiper, mountSwiper } from './init-swiper';
+import { needsScrollbar, needsNavigation, needsPagination, uniqueClasses, extend } from './utils';
+import { renderLoop, calcLoopedSlides } from './loop';
+import { getChangedParams } from './get-changed-params';
+import { getChildren } from './get-children';
+import { updateSwiper } from './update-swiper';
+import { renderVirtual, updateOnVirtualData } from './virtual';
+var Swiper = {
+  name: 'Swiper',
+  props: {
+    tag: {
+      type: String,
+      default: 'div'
+    },
+    wrapperTag: {
+      type: String,
+      default: 'div'
+    },
+    init: {
+      type: Boolean,
+      default: undefined
+    },
+    direction: {
+      type: String,
+      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
+    },
+    freeMode: {
+      type: Boolean,
+      default: undefined
+    },
+    freeModeMomentum: {
+      type: Boolean,
+      default: undefined
+    },
+    freeModeMomentumRatio: {
+      type: Number,
+      default: undefined
+    },
+    freeModeMomentumBounce: {
+      type: Boolean,
+      default: undefined
+    },
+    freeModeMomentumBounceRatio: {
+      type: Number,
+      default: undefined
+    },
+    freeModeMomentumVelocityRatio: {
+      type: Number,
+      default: undefined
+    },
+    freeModeSticky: {
+      type: Boolean,
+      default: undefined
+    },
+    freeModeMinimumVelocity: {
+      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,
+      default: undefined
+    },
+    slidesPerView: {
+      type: [Number, String],
+      default: undefined
+    },
+    slidesPerColumn: {
+      type: Number,
+      default: undefined
+    },
+    slidesPerColumnFill: {
+      type: String,
+      default: undefined
+    },
+    slidesPerGroup: {
+      type: Number,
+      default: undefined
+    },
+    slidesPerGroupSkip: {
+      type: Number,
+      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
+    },
+    watchSlidesVisibility: {
+      type: Boolean,
+      default: undefined
+    },
+    grabCursor: {
+      type: Boolean,
+      default: undefined
+    },
+    preventClicks: {
+      type: Boolean,
+      default: undefined
+    },
+    preventClicksPropagation: {
+      type: Boolean,
+      default: undefined
+    },
+    slideToClickedSlide: {
+      type: Boolean,
+      default: undefined
+    },
+    preloadImages: {
+      type: Boolean,
+      default: undefined
+    },
+    updateOnImagesReady: {
+      type: Boolean,
+      default: undefined
+    },
+    loop: {
+      type: Boolean,
+      default: undefined
+    },
+    loopAdditionalSlides: {
+      type: Number,
+      default: undefined
+    },
+    loopedSlides: {
+      type: Number,
+      default: undefined
+    },
+    loopFillGroupWithBlank: {
+      type: Boolean,
+      default: undefined
+    },
+    loopPreventsSlide: {
+      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
+    },
+    slideBlankClass: {
+      type: String,
+      default: undefined
+    },
+    slideActiveClass: {
+      type: String,
+      default: undefined
+    },
+    slideDuplicateActiveClass: {
+      type: String,
+      default: undefined
+    },
+    slideVisibleClass: {
+      type: String,
+      default: undefined
+    },
+    slideDuplicateClass: {
+      type: String,
+      default: undefined
+    },
+    slideNextClass: {
+      type: String,
+      default: undefined
+    },
+    slideDuplicateNextClass: {
+      type: String,
+      default: undefined
+    },
+    slidePrevClass: {
+      type: String,
+      default: undefined
+    },
+    slideDuplicatePrevClass: {
+      type: String,
+      default: undefined
+    },
+    wrapperClass: {
+      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
+    },
+    hashNavigation: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    history: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    keyboard: {
+      type: [Boolean, Object],
+      default: undefined
+    },
+    lazy: {
+      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
+    }
+  },
+  emits: ['_beforeBreakpoint', '_containerClasses', '_slideClass', '_slideClasses', '_swiper', 'activeIndexChange', 'afterInit', 'autoplay', 'autoplayStart', 'autoplayStop', 'beforeDestroy', 'beforeInit', 'beforeLoopFix', 'beforeResize', 'beforeSlideChangeStart', 'beforeTransitionStart', 'breakpoint', 'changeDirection', 'click', 'disable', 'doubleTap', 'doubleClick', 'destroy', 'enable', 'fromEdge', 'hashChange', 'hashSet', 'imagesReady', 'init', 'keyPress', 'lazyImageLoad', 'lazyImageReady', 'lock', 'loopFix', 'momentumBounce', 'navigationHide', 'navigationShow', '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', 'zoomChange'],
+  setup: function setup(props, _ref) {
+    var originalSlots = _ref.slots,
+        emit = _ref.emit;
+    var Tag = props.tag,
+        WrapperTag = props.wrapperTag;
+    var containerClasses = ref('swiper-container');
+    var virtualData = ref(null);
+    var breakpointChanged = ref(false);
+    var initializedRef = ref(false);
+    var swiperElRef = ref(null);
+    var swiperRef = ref(null);
+    var oldPassedParamsRef = ref(null);
+    var slidesRef = {
+      value: []
+    };
+    var oldSlidesRef = {
+      value: []
+    };
+    var nextElRef = ref(null);
+    var prevElRef = ref(null);
+    var paginationElRef = ref(null);
+    var scrollbarElRef = ref(null);
+
+    var _getParams = getParams(props),
+        swiperParams = _getParams.params,
+        passedParams = _getParams.passedParams;
+
+    getChildren(originalSlots, slidesRef, oldSlidesRef);
+    oldPassedParamsRef.value = passedParams;
+    oldSlidesRef.value = slidesRef.value;
+
+    var onBeforeBreakpoint = function 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.apply(void 0, [event].concat(args));
+    };
+
+    Object.assign(swiperParams.on, {
+      _beforeBreakpoint: onBeforeBreakpoint,
+      _containerClasses: function _containerClasses(swiper, classes) {
+        containerClasses.value = classes;
+      }
+    }); // init Swiper
+
+    swiperRef.value = initSwiper(swiperParams);
+
+    swiperRef.value.loopCreate = function () {};
+
+    swiperRef.value.loopDestroy = function () {};
+
+    if (swiperParams.loop) {
+      swiperRef.value.loopedSlides = calcLoopedSlides(slidesRef.value, swiperParams);
+    }
+
+    if (swiperRef.value.virtual && swiperRef.value.params.virtual.enabled) {
+      swiperRef.value.virtual.slides = slidesRef.value;
+      var extendWith = {
+        cache: false,
+        renderExternal: function renderExternal(data) {
+          virtualData.value = data;
+        },
+        renderExternalUpdate: false
+      };
+      extend(swiperRef.value.params.virtual, extendWith);
+      extend(swiperRef.value.originalParams.virtual, extendWith);
+    }
+
+    onUpdated(function () {
+      // set initialized flag
+      if (!initializedRef.value && swiperRef.value) {
+        swiperRef.value.emitSlidesClasses();
+        initializedRef.value = true;
+      } // watch for params change
+
+
+      var _getParams2 = getParams(props),
+          newPassedParams = _getParams2.passedParams;
+
+      var changedParams = getChangedParams(newPassedParams, oldPassedParamsRef.value, slidesRef.value, oldSlidesRef.value);
+      oldPassedParamsRef.value = newPassedParams;
+
+      if ((changedParams.length || breakpointChanged.value) && swiperRef.value && !swiperRef.value.destroyed) {
+        updateSwiper({
+          swiper: swiperRef.value,
+          slides: slidesRef.value,
+          passedParams: newPassedParams,
+          changedParams: changedParams,
+          nextEl: nextElRef.value,
+          prevEl: prevElRef.value,
+          scrollbarEl: scrollbarElRef.value,
+          paginationEl: paginationElRef.value
+        });
+      }
+
+      breakpointChanged.value = false;
+    }); // update on virtual update
+
+    watch(virtualData, function () {
+      nextTick(function () {
+        updateOnVirtualData(swiperRef.value);
+      });
+    }); // mount swiper
+
+    onMounted(function () {
+      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(function () {
+      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);
+      }
+
+      if (!swiperParams.loop || swiperRef.value && swiperRef.value.destroyed) {
+        slides.forEach(function (slide) {
+          if (!slide.props) slide.props = {};
+          slide.props.swiperRef = swiperRef;
+        });
+        return slides;
+      }
+
+      return renderLoop(swiperRef, slides, swiperParams);
+    }
+
+    return function () {
+      var _getChildren = getChildren(originalSlots, slidesRef, oldSlidesRef),
+          slides = _getChildren.slides,
+          slots = _getChildren.slots;
+
+      return h(Tag, {
+        ref: swiperElRef,
+        class: uniqueClasses(containerClasses.value)
+      }, [slots['container-start'], 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'
+      }), h(WrapperTag, {
+        class: 'swiper-wrapper'
+      }, [slots['wrapper-start'], renderSlides(slides), slots['wrapper-end']]), slots['container-end']]);
+    };
+  }
+};
+export { Swiper };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/update-swiper.js

@@ -0,0 +1,130 @@
+import { isObject, extend } from './utils';
+
+function updateSwiper(_ref) {
+  var swiper = _ref.swiper,
+      slides = _ref.slides,
+      passedParams = _ref.passedParams,
+      changedParams = _ref.changedParams,
+      nextEl = _ref.nextEl,
+      prevEl = _ref.prevEl,
+      paginationEl = _ref.paginationEl,
+      scrollbarEl = _ref.scrollbarEl;
+  var updateParams = changedParams.filter(function (key) {
+    return key !== 'children' && key !== 'direction';
+  });
+  var currentParams = swiper.params,
+      pagination = swiper.pagination,
+      navigation = swiper.navigation,
+      scrollbar = swiper.scrollbar,
+      virtual = swiper.virtual,
+      thumbs = swiper.thumbs;
+  var needThumbsInit;
+  var needControllerInit;
+  var needPaginationInit;
+  var needScrollbarInit;
+  var needNavigationInit;
+
+  if (changedParams.includes('thumbs') && passedParams.thumbs && passedParams.thumbs.swiper && currentParams.thumbs && !currentParams.thumbs.swiper) {
+    needThumbsInit = true;
+  }
+
+  if (changedParams.includes('controller') && passedParams.controller && passedParams.controller.control && currentParams.controller && !currentParams.controller.control) {
+    needControllerInit = true;
+  }
+
+  if (changedParams.includes('pagination') && passedParams.pagination && (passedParams.pagination.el || paginationEl) && (currentParams.pagination || currentParams.pagination === false) && pagination && !pagination.el) {
+    needPaginationInit = true;
+  }
+
+  if (changedParams.includes('scrollbar') && passedParams.scrollbar && (passedParams.scrollbar.el || scrollbarEl) && (currentParams.scrollbar || currentParams.scrollbar === false) && scrollbar && !scrollbar.el) {
+    needScrollbarInit = true;
+  }
+
+  if (changedParams.includes('navigation') && passedParams.navigation && (passedParams.navigation.prevEl || prevEl) && (passedParams.navigation.nextEl || nextEl) && (currentParams.navigation || currentParams.navigation === false) && navigation && !navigation.prevEl && !navigation.nextEl) {
+    needNavigationInit = true;
+  }
+
+  var destroyModule = function destroyModule(mod) {
+    if (!swiper[mod]) return;
+    swiper[mod].destroy();
+
+    if (mod === 'navigation') {
+      currentParams[mod].prevEl = undefined;
+      currentParams[mod].nextEl = undefined;
+      swiper[mod].prevEl = undefined;
+      swiper[mod].nextEl = undefined;
+    } else {
+      currentParams[mod].el = undefined;
+      swiper[mod].el = undefined;
+    }
+  };
+
+  updateParams.forEach(function (key) {
+    if (isObject(currentParams[key]) && isObject(passedParams[key])) {
+      extend(currentParams[key], passedParams[key]);
+    } else {
+      var newValue = passedParams[key];
+
+      if ((newValue === true || newValue === false) && (key === 'navigation' || key === 'pagination' || key === 'scrollbar')) {
+        if (newValue === false) {
+          destroyModule(key);
+        }
+      } else {
+        currentParams[key] = passedParams[key];
+      }
+    }
+  });
+
+  if (changedParams.includes('children') && virtual && currentParams.virtual.enabled) {
+    virtual.slides = slides;
+    virtual.update(true);
+  } else if (changedParams.includes('children') && swiper.lazy && swiper.params.lazy.enabled) {
+    swiper.lazy.load();
+  }
+
+  if (needThumbsInit) {
+    var initialized = thumbs.init();
+    if (initialized) thumbs.update(true);
+  }
+
+  if (needControllerInit) {
+    swiper.controller.control = currentParams.controller.control;
+  }
+
+  if (needPaginationInit) {
+    if (paginationEl) currentParams.pagination.el = paginationEl;
+    pagination.init();
+    pagination.render();
+    pagination.update();
+  }
+
+  if (needScrollbarInit) {
+    if (scrollbarEl) currentParams.scrollbar.el = scrollbarEl;
+    scrollbar.init();
+    scrollbar.updateSize();
+    scrollbar.setTranslate();
+  }
+
+  if (needNavigationInit) {
+    if (nextEl) currentParams.navigation.nextEl = nextEl;
+    if (prevEl) currentParams.navigation.prevEl = prevEl;
+    navigation.init();
+    navigation.update();
+  }
+
+  if (changedParams.includes('allowSlideNext')) {
+    swiper.allowSlideNext = passedParams.allowSlideNext;
+  }
+
+  if (changedParams.includes('allowSlidePrev')) {
+    swiper.allowSlidePrev = passedParams.allowSlidePrev;
+  }
+
+  if (changedParams.includes('direction')) {
+    swiper.changeDirection(passedParams.direction, false);
+  }
+
+  swiper.update();
+}
+
+export { updateSwiper };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/utils.js

@@ -0,0 +1,59 @@
+function isObject(o) {
+  return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';
+}
+
+function extend(target, src) {
+  var noExtend = ['__proto__', 'constructor', 'prototype'];
+  Object.keys(src).filter(function (key) {
+    return noExtend.indexOf(key) < 0;
+  }).forEach(function (key) {
+    if (typeof target[key] === 'undefined') target[key] = src[key];else if (isObject(src[key]) && isObject(target[key]) && Object.keys(src[key]).length > 0) {
+      if (src[key].__swiper__) target[key] = src[key];else extend(target[key], src[key]);
+    } else {
+      target[key] = src[key];
+    }
+  });
+}
+
+function needsNavigation(props) {
+  if (props === void 0) {
+    props = {};
+  }
+
+  return props.navigation && typeof props.navigation.nextEl === 'undefined' && typeof props.navigation.prevEl === 'undefined';
+}
+
+function needsPagination(props) {
+  if (props === void 0) {
+    props = {};
+  }
+
+  return props.pagination && typeof props.pagination.el === 'undefined';
+}
+
+function needsScrollbar(props) {
+  if (props === void 0) {
+    props = {};
+  }
+
+  return props.scrollbar && typeof props.scrollbar.el === 'undefined';
+}
+
+function uniqueClasses(classNames) {
+  if (classNames === void 0) {
+    classNames = '';
+  }
+
+  var classes = classNames.split(' ').map(function (c) {
+    return c.trim();
+  }).filter(function (c) {
+    return !!c;
+  });
+  var unique = [];
+  classes.forEach(function (c) {
+    if (unique.indexOf(c) < 0) unique.push(c);
+  });
+  return unique.join(' ');
+}
+
+export { isObject, extend, needsNavigation, needsPagination, needsScrollbar, uniqueClasses };

public/copiaintegra/dist/assets/libs/swiper/esm/vue/virtual.js

@@ -0,0 +1,38 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import { h } from 'vue';
+
+function updateOnVirtualData(swiper) {
+  if (!swiper || swiper.destroyed || !swiper.params.virtual || swiper.params.virtual && !swiper.params.virtual.enabled) return;
+  swiper.updateSlides();
+  swiper.updateProgress();
+  swiper.updateSlidesClasses();
+
+  if (swiper.lazy && swiper.params.lazy.enabled) {
+    swiper.lazy.load();
+  }
+
+  if (swiper.parallax && swiper.params.parallax && swiper.params.parallax.enabled) {
+    swiper.parallax.setTranslate();
+  }
+}
+
+function renderVirtual(swiperRef, slides, virtualData) {
+  var _ref;
+
+  if (!virtualData) return null;
+  var style = swiperRef.value.isHorizontal() ? (_ref = {}, _ref[swiperRef.value.rtlTranslate ? 'right' : 'left'] = virtualData.offset + "px", _ref) : {
+    top: virtualData.offset + "px"
+  };
+  return slides.filter(function (slide, index) {
+    return index >= virtualData.from && index <= virtualData.to;
+  }).map(function (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, _extends({}, slide.props), slide.children);
+  });
+}
+
+export { renderVirtual, updateOnVirtualData };