5249 lines
174 KiB
JavaScript
5249 lines
174 KiB
JavaScript
import {
|
|
classesToTokens,
|
|
createElement,
|
|
elementChildren,
|
|
elementIndex,
|
|
elementOffset,
|
|
elementOuterSize,
|
|
elementParents,
|
|
elementTransitionEnd,
|
|
getDocument,
|
|
getRotateFix,
|
|
getSlideTransformEl,
|
|
getTranslate,
|
|
getWindow,
|
|
isObject,
|
|
makeElementsArray,
|
|
nextTick,
|
|
now,
|
|
setCSSProperty
|
|
} from "./chunk-XLOWEJT4.js";
|
|
import "./chunk-5WRI5ZAA.js";
|
|
|
|
// node_modules/swiper/modules/virtual.mjs
|
|
function Virtual(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on,
|
|
emit
|
|
} = _ref;
|
|
extendParams({
|
|
virtual: {
|
|
enabled: false,
|
|
slides: [],
|
|
cache: true,
|
|
renderSlide: null,
|
|
renderExternal: null,
|
|
renderExternalUpdate: true,
|
|
addSlidesBefore: 0,
|
|
addSlidesAfter: 0
|
|
}
|
|
});
|
|
let cssModeTimeout;
|
|
const document2 = getDocument();
|
|
swiper.virtual = {
|
|
cache: {},
|
|
from: void 0,
|
|
to: void 0,
|
|
slides: [],
|
|
offset: 0,
|
|
slidesGrid: []
|
|
};
|
|
const tempDOM = document2.createElement("div");
|
|
function renderSlide(slide, index) {
|
|
const params = swiper.params.virtual;
|
|
if (params.cache && swiper.virtual.cache[index]) {
|
|
return swiper.virtual.cache[index];
|
|
}
|
|
let slideEl;
|
|
if (params.renderSlide) {
|
|
slideEl = params.renderSlide.call(swiper, slide, index);
|
|
if (typeof slideEl === "string") {
|
|
tempDOM.innerHTML = slideEl;
|
|
slideEl = tempDOM.children[0];
|
|
}
|
|
} else if (swiper.isElement) {
|
|
slideEl = createElement("swiper-slide");
|
|
} else {
|
|
slideEl = createElement("div", swiper.params.slideClass);
|
|
}
|
|
slideEl.setAttribute("data-swiper-slide-index", index);
|
|
if (!params.renderSlide) {
|
|
slideEl.innerHTML = slide;
|
|
}
|
|
if (params.cache) {
|
|
swiper.virtual.cache[index] = slideEl;
|
|
}
|
|
return slideEl;
|
|
}
|
|
function update(force, beforeInit, forceActiveIndex) {
|
|
const {
|
|
slidesPerView,
|
|
slidesPerGroup,
|
|
centeredSlides,
|
|
loop: isLoop,
|
|
initialSlide
|
|
} = swiper.params;
|
|
if (beforeInit && !isLoop && initialSlide > 0) {
|
|
return;
|
|
}
|
|
const {
|
|
addSlidesBefore,
|
|
addSlidesAfter
|
|
} = swiper.params.virtual;
|
|
const {
|
|
from: previousFrom,
|
|
to: previousTo,
|
|
slides,
|
|
slidesGrid: previousSlidesGrid,
|
|
offset: previousOffset
|
|
} = swiper.virtual;
|
|
if (!swiper.params.cssMode) {
|
|
swiper.updateActiveIndex();
|
|
}
|
|
const activeIndex = typeof forceActiveIndex === "undefined" ? swiper.activeIndex || 0 : forceActiveIndex;
|
|
let offsetProp;
|
|
if (swiper.rtlTranslate) offsetProp = "right";
|
|
else offsetProp = swiper.isHorizontal() ? "left" : "top";
|
|
let slidesAfter;
|
|
let slidesBefore;
|
|
if (centeredSlides) {
|
|
slidesAfter = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesAfter;
|
|
slidesBefore = Math.floor(slidesPerView / 2) + slidesPerGroup + addSlidesBefore;
|
|
} else {
|
|
slidesAfter = slidesPerView + (slidesPerGroup - 1) + addSlidesAfter;
|
|
slidesBefore = (isLoop ? slidesPerView : slidesPerGroup) + addSlidesBefore;
|
|
}
|
|
let from = activeIndex - slidesBefore;
|
|
let to = activeIndex + slidesAfter;
|
|
if (!isLoop) {
|
|
from = Math.max(from, 0);
|
|
to = Math.min(to, slides.length - 1);
|
|
}
|
|
let offset = (swiper.slidesGrid[from] || 0) - (swiper.slidesGrid[0] || 0);
|
|
if (isLoop && activeIndex >= slidesBefore) {
|
|
from -= slidesBefore;
|
|
if (!centeredSlides) offset += swiper.slidesGrid[0];
|
|
} else if (isLoop && activeIndex < slidesBefore) {
|
|
from = -slidesBefore;
|
|
if (centeredSlides) offset += swiper.slidesGrid[0];
|
|
}
|
|
Object.assign(swiper.virtual, {
|
|
from,
|
|
to,
|
|
offset,
|
|
slidesGrid: swiper.slidesGrid,
|
|
slidesBefore,
|
|
slidesAfter
|
|
});
|
|
function onRendered() {
|
|
swiper.updateSlides();
|
|
swiper.updateProgress();
|
|
swiper.updateSlidesClasses();
|
|
emit("virtualUpdate");
|
|
}
|
|
if (previousFrom === from && previousTo === to && !force) {
|
|
if (swiper.slidesGrid !== previousSlidesGrid && offset !== previousOffset) {
|
|
swiper.slides.forEach((slideEl) => {
|
|
slideEl.style[offsetProp] = `${offset - Math.abs(swiper.cssOverflowAdjustment())}px`;
|
|
});
|
|
}
|
|
swiper.updateProgress();
|
|
emit("virtualUpdate");
|
|
return;
|
|
}
|
|
if (swiper.params.virtual.renderExternal) {
|
|
swiper.params.virtual.renderExternal.call(swiper, {
|
|
offset,
|
|
from,
|
|
to,
|
|
slides: function getSlides() {
|
|
const slidesToRender = [];
|
|
for (let i = from; i <= to; i += 1) {
|
|
slidesToRender.push(slides[i]);
|
|
}
|
|
return slidesToRender;
|
|
}()
|
|
});
|
|
if (swiper.params.virtual.renderExternalUpdate) {
|
|
onRendered();
|
|
} else {
|
|
emit("virtualUpdate");
|
|
}
|
|
return;
|
|
}
|
|
const prependIndexes = [];
|
|
const appendIndexes = [];
|
|
const getSlideIndex = (index) => {
|
|
let slideIndex = index;
|
|
if (index < 0) {
|
|
slideIndex = slides.length + index;
|
|
} else if (slideIndex >= slides.length) {
|
|
slideIndex = slideIndex - slides.length;
|
|
}
|
|
return slideIndex;
|
|
};
|
|
if (force) {
|
|
swiper.slides.filter((el) => el.matches(`.${swiper.params.slideClass}, swiper-slide`)).forEach((slideEl) => {
|
|
slideEl.remove();
|
|
});
|
|
} else {
|
|
for (let i = previousFrom; i <= previousTo; i += 1) {
|
|
if (i < from || i > to) {
|
|
const slideIndex = getSlideIndex(i);
|
|
swiper.slides.filter((el) => el.matches(`.${swiper.params.slideClass}[data-swiper-slide-index="${slideIndex}"], swiper-slide[data-swiper-slide-index="${slideIndex}"]`)).forEach((slideEl) => {
|
|
slideEl.remove();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
const loopFrom = isLoop ? -slides.length : 0;
|
|
const loopTo = isLoop ? slides.length * 2 : slides.length;
|
|
for (let i = loopFrom; i < loopTo; i += 1) {
|
|
if (i >= from && i <= to) {
|
|
const slideIndex = getSlideIndex(i);
|
|
if (typeof previousTo === "undefined" || force) {
|
|
appendIndexes.push(slideIndex);
|
|
} else {
|
|
if (i > previousTo) appendIndexes.push(slideIndex);
|
|
if (i < previousFrom) prependIndexes.push(slideIndex);
|
|
}
|
|
}
|
|
}
|
|
appendIndexes.forEach((index) => {
|
|
swiper.slidesEl.append(renderSlide(slides[index], index));
|
|
});
|
|
if (isLoop) {
|
|
for (let i = prependIndexes.length - 1; i >= 0; i -= 1) {
|
|
const index = prependIndexes[i];
|
|
swiper.slidesEl.prepend(renderSlide(slides[index], index));
|
|
}
|
|
} else {
|
|
prependIndexes.sort((a, b) => b - a);
|
|
prependIndexes.forEach((index) => {
|
|
swiper.slidesEl.prepend(renderSlide(slides[index], index));
|
|
});
|
|
}
|
|
elementChildren(swiper.slidesEl, ".swiper-slide, swiper-slide").forEach((slideEl) => {
|
|
slideEl.style[offsetProp] = `${offset - Math.abs(swiper.cssOverflowAdjustment())}px`;
|
|
});
|
|
onRendered();
|
|
}
|
|
function appendSlide2(slides) {
|
|
if (typeof slides === "object" && "length" in slides) {
|
|
for (let i = 0; i < slides.length; i += 1) {
|
|
if (slides[i]) swiper.virtual.slides.push(slides[i]);
|
|
}
|
|
} else {
|
|
swiper.virtual.slides.push(slides);
|
|
}
|
|
update(true);
|
|
}
|
|
function prependSlide2(slides) {
|
|
const activeIndex = swiper.activeIndex;
|
|
let newActiveIndex = activeIndex + 1;
|
|
let numberOfNewSlides = 1;
|
|
if (Array.isArray(slides)) {
|
|
for (let i = 0; i < slides.length; i += 1) {
|
|
if (slides[i]) swiper.virtual.slides.unshift(slides[i]);
|
|
}
|
|
newActiveIndex = activeIndex + slides.length;
|
|
numberOfNewSlides = slides.length;
|
|
} else {
|
|
swiper.virtual.slides.unshift(slides);
|
|
}
|
|
if (swiper.params.virtual.cache) {
|
|
const cache = swiper.virtual.cache;
|
|
const newCache = {};
|
|
Object.keys(cache).forEach((cachedIndex) => {
|
|
const cachedEl = cache[cachedIndex];
|
|
const cachedElIndex = cachedEl.getAttribute("data-swiper-slide-index");
|
|
if (cachedElIndex) {
|
|
cachedEl.setAttribute("data-swiper-slide-index", parseInt(cachedElIndex, 10) + numberOfNewSlides);
|
|
}
|
|
newCache[parseInt(cachedIndex, 10) + numberOfNewSlides] = cachedEl;
|
|
});
|
|
swiper.virtual.cache = newCache;
|
|
}
|
|
update(true);
|
|
swiper.slideTo(newActiveIndex, 0);
|
|
}
|
|
function removeSlide2(slidesIndexes) {
|
|
if (typeof slidesIndexes === "undefined" || slidesIndexes === null) return;
|
|
let activeIndex = swiper.activeIndex;
|
|
if (Array.isArray(slidesIndexes)) {
|
|
for (let i = slidesIndexes.length - 1; i >= 0; i -= 1) {
|
|
if (swiper.params.virtual.cache) {
|
|
delete swiper.virtual.cache[slidesIndexes[i]];
|
|
Object.keys(swiper.virtual.cache).forEach((key) => {
|
|
if (key > slidesIndexes) {
|
|
swiper.virtual.cache[key - 1] = swiper.virtual.cache[key];
|
|
swiper.virtual.cache[key - 1].setAttribute("data-swiper-slide-index", key - 1);
|
|
delete swiper.virtual.cache[key];
|
|
}
|
|
});
|
|
}
|
|
swiper.virtual.slides.splice(slidesIndexes[i], 1);
|
|
if (slidesIndexes[i] < activeIndex) activeIndex -= 1;
|
|
activeIndex = Math.max(activeIndex, 0);
|
|
}
|
|
} else {
|
|
if (swiper.params.virtual.cache) {
|
|
delete swiper.virtual.cache[slidesIndexes];
|
|
Object.keys(swiper.virtual.cache).forEach((key) => {
|
|
if (key > slidesIndexes) {
|
|
swiper.virtual.cache[key - 1] = swiper.virtual.cache[key];
|
|
swiper.virtual.cache[key - 1].setAttribute("data-swiper-slide-index", key - 1);
|
|
delete swiper.virtual.cache[key];
|
|
}
|
|
});
|
|
}
|
|
swiper.virtual.slides.splice(slidesIndexes, 1);
|
|
if (slidesIndexes < activeIndex) activeIndex -= 1;
|
|
activeIndex = Math.max(activeIndex, 0);
|
|
}
|
|
update(true);
|
|
swiper.slideTo(activeIndex, 0);
|
|
}
|
|
function removeAllSlides2() {
|
|
swiper.virtual.slides = [];
|
|
if (swiper.params.virtual.cache) {
|
|
swiper.virtual.cache = {};
|
|
}
|
|
update(true);
|
|
swiper.slideTo(0, 0);
|
|
}
|
|
on("beforeInit", () => {
|
|
if (!swiper.params.virtual.enabled) return;
|
|
let domSlidesAssigned;
|
|
if (typeof swiper.passedParams.virtual.slides === "undefined") {
|
|
const slides = [...swiper.slidesEl.children].filter((el) => el.matches(`.${swiper.params.slideClass}, swiper-slide`));
|
|
if (slides && slides.length) {
|
|
swiper.virtual.slides = [...slides];
|
|
domSlidesAssigned = true;
|
|
slides.forEach((slideEl, slideIndex) => {
|
|
slideEl.setAttribute("data-swiper-slide-index", slideIndex);
|
|
swiper.virtual.cache[slideIndex] = slideEl;
|
|
slideEl.remove();
|
|
});
|
|
}
|
|
}
|
|
if (!domSlidesAssigned) {
|
|
swiper.virtual.slides = swiper.params.virtual.slides;
|
|
}
|
|
swiper.classNames.push(`${swiper.params.containerModifierClass}virtual`);
|
|
swiper.params.watchSlidesProgress = true;
|
|
swiper.originalParams.watchSlidesProgress = true;
|
|
update(false, true);
|
|
});
|
|
on("setTranslate", () => {
|
|
if (!swiper.params.virtual.enabled) return;
|
|
if (swiper.params.cssMode && !swiper._immediateVirtual) {
|
|
clearTimeout(cssModeTimeout);
|
|
cssModeTimeout = setTimeout(() => {
|
|
update();
|
|
}, 100);
|
|
} else {
|
|
update();
|
|
}
|
|
});
|
|
on("init update resize", () => {
|
|
if (!swiper.params.virtual.enabled) return;
|
|
if (swiper.params.cssMode) {
|
|
setCSSProperty(swiper.wrapperEl, "--swiper-virtual-size", `${swiper.virtualSize}px`);
|
|
}
|
|
});
|
|
Object.assign(swiper.virtual, {
|
|
appendSlide: appendSlide2,
|
|
prependSlide: prependSlide2,
|
|
removeSlide: removeSlide2,
|
|
removeAllSlides: removeAllSlides2,
|
|
update
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/keyboard.mjs
|
|
function Keyboard(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on,
|
|
emit
|
|
} = _ref;
|
|
const document2 = getDocument();
|
|
const window2 = getWindow();
|
|
swiper.keyboard = {
|
|
enabled: false
|
|
};
|
|
extendParams({
|
|
keyboard: {
|
|
enabled: false,
|
|
onlyInViewport: true,
|
|
pageUpDown: true
|
|
}
|
|
});
|
|
function handle(event2) {
|
|
if (!swiper.enabled) return;
|
|
const {
|
|
rtlTranslate: rtl
|
|
} = swiper;
|
|
let e = event2;
|
|
if (e.originalEvent) e = e.originalEvent;
|
|
const kc = e.keyCode || e.charCode;
|
|
const pageUpDown = swiper.params.keyboard.pageUpDown;
|
|
const isPageUp = pageUpDown && kc === 33;
|
|
const isPageDown = pageUpDown && kc === 34;
|
|
const isArrowLeft = kc === 37;
|
|
const isArrowRight = kc === 39;
|
|
const isArrowUp = kc === 38;
|
|
const isArrowDown = kc === 40;
|
|
if (!swiper.allowSlideNext && (swiper.isHorizontal() && isArrowRight || swiper.isVertical() && isArrowDown || isPageDown)) {
|
|
return false;
|
|
}
|
|
if (!swiper.allowSlidePrev && (swiper.isHorizontal() && isArrowLeft || swiper.isVertical() && isArrowUp || isPageUp)) {
|
|
return false;
|
|
}
|
|
if (e.shiftKey || e.altKey || e.ctrlKey || e.metaKey) {
|
|
return void 0;
|
|
}
|
|
if (document2.activeElement && document2.activeElement.nodeName && (document2.activeElement.nodeName.toLowerCase() === "input" || document2.activeElement.nodeName.toLowerCase() === "textarea")) {
|
|
return void 0;
|
|
}
|
|
if (swiper.params.keyboard.onlyInViewport && (isPageUp || isPageDown || isArrowLeft || isArrowRight || isArrowUp || isArrowDown)) {
|
|
let inView = false;
|
|
if (elementParents(swiper.el, `.${swiper.params.slideClass}, swiper-slide`).length > 0 && elementParents(swiper.el, `.${swiper.params.slideActiveClass}`).length === 0) {
|
|
return void 0;
|
|
}
|
|
const el = swiper.el;
|
|
const swiperWidth = el.clientWidth;
|
|
const swiperHeight = el.clientHeight;
|
|
const windowWidth = window2.innerWidth;
|
|
const windowHeight = window2.innerHeight;
|
|
const swiperOffset = elementOffset(el);
|
|
if (rtl) swiperOffset.left -= el.scrollLeft;
|
|
const swiperCoord = [[swiperOffset.left, swiperOffset.top], [swiperOffset.left + swiperWidth, swiperOffset.top], [swiperOffset.left, swiperOffset.top + swiperHeight], [swiperOffset.left + swiperWidth, swiperOffset.top + swiperHeight]];
|
|
for (let i = 0; i < swiperCoord.length; i += 1) {
|
|
const point = swiperCoord[i];
|
|
if (point[0] >= 0 && point[0] <= windowWidth && point[1] >= 0 && point[1] <= windowHeight) {
|
|
if (point[0] === 0 && point[1] === 0) continue;
|
|
inView = true;
|
|
}
|
|
}
|
|
if (!inView) return void 0;
|
|
}
|
|
if (swiper.isHorizontal()) {
|
|
if (isPageUp || isPageDown || isArrowLeft || isArrowRight) {
|
|
if (e.preventDefault) e.preventDefault();
|
|
else e.returnValue = false;
|
|
}
|
|
if ((isPageDown || isArrowRight) && !rtl || (isPageUp || isArrowLeft) && rtl) swiper.slideNext();
|
|
if ((isPageUp || isArrowLeft) && !rtl || (isPageDown || isArrowRight) && rtl) swiper.slidePrev();
|
|
} else {
|
|
if (isPageUp || isPageDown || isArrowUp || isArrowDown) {
|
|
if (e.preventDefault) e.preventDefault();
|
|
else e.returnValue = false;
|
|
}
|
|
if (isPageDown || isArrowDown) swiper.slideNext();
|
|
if (isPageUp || isArrowUp) swiper.slidePrev();
|
|
}
|
|
emit("keyPress", kc);
|
|
return void 0;
|
|
}
|
|
function enable() {
|
|
if (swiper.keyboard.enabled) return;
|
|
document2.addEventListener("keydown", handle);
|
|
swiper.keyboard.enabled = true;
|
|
}
|
|
function disable() {
|
|
if (!swiper.keyboard.enabled) return;
|
|
document2.removeEventListener("keydown", handle);
|
|
swiper.keyboard.enabled = false;
|
|
}
|
|
on("init", () => {
|
|
if (swiper.params.keyboard.enabled) {
|
|
enable();
|
|
}
|
|
});
|
|
on("destroy", () => {
|
|
if (swiper.keyboard.enabled) {
|
|
disable();
|
|
}
|
|
});
|
|
Object.assign(swiper.keyboard, {
|
|
enable,
|
|
disable
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/mousewheel.mjs
|
|
function Mousewheel(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on,
|
|
emit
|
|
} = _ref;
|
|
const window2 = getWindow();
|
|
extendParams({
|
|
mousewheel: {
|
|
enabled: false,
|
|
releaseOnEdges: false,
|
|
invert: false,
|
|
forceToAxis: false,
|
|
sensitivity: 1,
|
|
eventsTarget: "container",
|
|
thresholdDelta: null,
|
|
thresholdTime: null,
|
|
noMousewheelClass: "swiper-no-mousewheel"
|
|
}
|
|
});
|
|
swiper.mousewheel = {
|
|
enabled: false
|
|
};
|
|
let timeout;
|
|
let lastScrollTime = now();
|
|
let lastEventBeforeSnap;
|
|
const recentWheelEvents = [];
|
|
function normalize(e) {
|
|
const PIXEL_STEP = 10;
|
|
const LINE_HEIGHT = 40;
|
|
const PAGE_HEIGHT = 800;
|
|
let sX = 0;
|
|
let sY = 0;
|
|
let pX = 0;
|
|
let pY = 0;
|
|
if ("detail" in e) {
|
|
sY = e.detail;
|
|
}
|
|
if ("wheelDelta" in e) {
|
|
sY = -e.wheelDelta / 120;
|
|
}
|
|
if ("wheelDeltaY" in e) {
|
|
sY = -e.wheelDeltaY / 120;
|
|
}
|
|
if ("wheelDeltaX" in e) {
|
|
sX = -e.wheelDeltaX / 120;
|
|
}
|
|
if ("axis" in e && e.axis === e.HORIZONTAL_AXIS) {
|
|
sX = sY;
|
|
sY = 0;
|
|
}
|
|
pX = sX * PIXEL_STEP;
|
|
pY = sY * PIXEL_STEP;
|
|
if ("deltaY" in e) {
|
|
pY = e.deltaY;
|
|
}
|
|
if ("deltaX" in e) {
|
|
pX = e.deltaX;
|
|
}
|
|
if (e.shiftKey && !pX) {
|
|
pX = pY;
|
|
pY = 0;
|
|
}
|
|
if ((pX || pY) && e.deltaMode) {
|
|
if (e.deltaMode === 1) {
|
|
pX *= LINE_HEIGHT;
|
|
pY *= LINE_HEIGHT;
|
|
} else {
|
|
pX *= PAGE_HEIGHT;
|
|
pY *= PAGE_HEIGHT;
|
|
}
|
|
}
|
|
if (pX && !sX) {
|
|
sX = pX < 1 ? -1 : 1;
|
|
}
|
|
if (pY && !sY) {
|
|
sY = pY < 1 ? -1 : 1;
|
|
}
|
|
return {
|
|
spinX: sX,
|
|
spinY: sY,
|
|
pixelX: pX,
|
|
pixelY: pY
|
|
};
|
|
}
|
|
function handleMouseEnter() {
|
|
if (!swiper.enabled) return;
|
|
swiper.mouseEntered = true;
|
|
}
|
|
function handleMouseLeave() {
|
|
if (!swiper.enabled) return;
|
|
swiper.mouseEntered = false;
|
|
}
|
|
function animateSlider(newEvent) {
|
|
if (swiper.params.mousewheel.thresholdDelta && newEvent.delta < swiper.params.mousewheel.thresholdDelta) {
|
|
return false;
|
|
}
|
|
if (swiper.params.mousewheel.thresholdTime && now() - lastScrollTime < swiper.params.mousewheel.thresholdTime) {
|
|
return false;
|
|
}
|
|
if (newEvent.delta >= 6 && now() - lastScrollTime < 60) {
|
|
return true;
|
|
}
|
|
if (newEvent.direction < 0) {
|
|
if ((!swiper.isEnd || swiper.params.loop) && !swiper.animating) {
|
|
swiper.slideNext();
|
|
emit("scroll", newEvent.raw);
|
|
}
|
|
} else if ((!swiper.isBeginning || swiper.params.loop) && !swiper.animating) {
|
|
swiper.slidePrev();
|
|
emit("scroll", newEvent.raw);
|
|
}
|
|
lastScrollTime = new window2.Date().getTime();
|
|
return false;
|
|
}
|
|
function releaseScroll(newEvent) {
|
|
const params = swiper.params.mousewheel;
|
|
if (newEvent.direction < 0) {
|
|
if (swiper.isEnd && !swiper.params.loop && params.releaseOnEdges) {
|
|
return true;
|
|
}
|
|
} else if (swiper.isBeginning && !swiper.params.loop && params.releaseOnEdges) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function handle(event2) {
|
|
let e = event2;
|
|
let disableParentSwiper = true;
|
|
if (!swiper.enabled) return;
|
|
if (event2.target.closest(`.${swiper.params.mousewheel.noMousewheelClass}`)) return;
|
|
const params = swiper.params.mousewheel;
|
|
if (swiper.params.cssMode) {
|
|
e.preventDefault();
|
|
}
|
|
let targetEl = swiper.el;
|
|
if (swiper.params.mousewheel.eventsTarget !== "container") {
|
|
targetEl = document.querySelector(swiper.params.mousewheel.eventsTarget);
|
|
}
|
|
const targetElContainsTarget = targetEl && targetEl.contains(e.target);
|
|
if (!swiper.mouseEntered && !targetElContainsTarget && !params.releaseOnEdges) return true;
|
|
if (e.originalEvent) e = e.originalEvent;
|
|
let delta = 0;
|
|
const rtlFactor = swiper.rtlTranslate ? -1 : 1;
|
|
const data = normalize(e);
|
|
if (params.forceToAxis) {
|
|
if (swiper.isHorizontal()) {
|
|
if (Math.abs(data.pixelX) > Math.abs(data.pixelY)) delta = -data.pixelX * rtlFactor;
|
|
else return true;
|
|
} else if (Math.abs(data.pixelY) > Math.abs(data.pixelX)) delta = -data.pixelY;
|
|
else return true;
|
|
} else {
|
|
delta = Math.abs(data.pixelX) > Math.abs(data.pixelY) ? -data.pixelX * rtlFactor : -data.pixelY;
|
|
}
|
|
if (delta === 0) return true;
|
|
if (params.invert) delta = -delta;
|
|
let positions = swiper.getTranslate() + delta * params.sensitivity;
|
|
if (positions >= swiper.minTranslate()) positions = swiper.minTranslate();
|
|
if (positions <= swiper.maxTranslate()) positions = swiper.maxTranslate();
|
|
disableParentSwiper = swiper.params.loop ? true : !(positions === swiper.minTranslate() || positions === swiper.maxTranslate());
|
|
if (disableParentSwiper && swiper.params.nested) e.stopPropagation();
|
|
if (!swiper.params.freeMode || !swiper.params.freeMode.enabled) {
|
|
const newEvent = {
|
|
time: now(),
|
|
delta: Math.abs(delta),
|
|
direction: Math.sign(delta),
|
|
raw: event2
|
|
};
|
|
if (recentWheelEvents.length >= 2) {
|
|
recentWheelEvents.shift();
|
|
}
|
|
const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : void 0;
|
|
recentWheelEvents.push(newEvent);
|
|
if (prevEvent) {
|
|
if (newEvent.direction !== prevEvent.direction || newEvent.delta > prevEvent.delta || newEvent.time > prevEvent.time + 150) {
|
|
animateSlider(newEvent);
|
|
}
|
|
} else {
|
|
animateSlider(newEvent);
|
|
}
|
|
if (releaseScroll(newEvent)) {
|
|
return true;
|
|
}
|
|
} else {
|
|
const newEvent = {
|
|
time: now(),
|
|
delta: Math.abs(delta),
|
|
direction: Math.sign(delta)
|
|
};
|
|
const ignoreWheelEvents = lastEventBeforeSnap && newEvent.time < lastEventBeforeSnap.time + 500 && newEvent.delta <= lastEventBeforeSnap.delta && newEvent.direction === lastEventBeforeSnap.direction;
|
|
if (!ignoreWheelEvents) {
|
|
lastEventBeforeSnap = void 0;
|
|
let position = swiper.getTranslate() + delta * params.sensitivity;
|
|
const wasBeginning = swiper.isBeginning;
|
|
const wasEnd = swiper.isEnd;
|
|
if (position >= swiper.minTranslate()) position = swiper.minTranslate();
|
|
if (position <= swiper.maxTranslate()) position = swiper.maxTranslate();
|
|
swiper.setTransition(0);
|
|
swiper.setTranslate(position);
|
|
swiper.updateProgress();
|
|
swiper.updateActiveIndex();
|
|
swiper.updateSlidesClasses();
|
|
if (!wasBeginning && swiper.isBeginning || !wasEnd && swiper.isEnd) {
|
|
swiper.updateSlidesClasses();
|
|
}
|
|
if (swiper.params.loop) {
|
|
swiper.loopFix({
|
|
direction: newEvent.direction < 0 ? "next" : "prev",
|
|
byMousewheel: true
|
|
});
|
|
}
|
|
if (swiper.params.freeMode.sticky) {
|
|
clearTimeout(timeout);
|
|
timeout = void 0;
|
|
if (recentWheelEvents.length >= 15) {
|
|
recentWheelEvents.shift();
|
|
}
|
|
const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : void 0;
|
|
const firstEvent = recentWheelEvents[0];
|
|
recentWheelEvents.push(newEvent);
|
|
if (prevEvent && (newEvent.delta > prevEvent.delta || newEvent.direction !== prevEvent.direction)) {
|
|
recentWheelEvents.splice(0);
|
|
} else if (recentWheelEvents.length >= 15 && newEvent.time - firstEvent.time < 500 && firstEvent.delta - newEvent.delta >= 1 && newEvent.delta <= 6) {
|
|
const snapToThreshold = delta > 0 ? 0.8 : 0.2;
|
|
lastEventBeforeSnap = newEvent;
|
|
recentWheelEvents.splice(0);
|
|
timeout = nextTick(() => {
|
|
if (swiper.destroyed || !swiper.params) return;
|
|
swiper.slideToClosest(swiper.params.speed, true, void 0, snapToThreshold);
|
|
}, 0);
|
|
}
|
|
if (!timeout) {
|
|
timeout = nextTick(() => {
|
|
if (swiper.destroyed || !swiper.params) return;
|
|
const snapToThreshold = 0.5;
|
|
lastEventBeforeSnap = newEvent;
|
|
recentWheelEvents.splice(0);
|
|
swiper.slideToClosest(swiper.params.speed, true, void 0, snapToThreshold);
|
|
}, 500);
|
|
}
|
|
}
|
|
if (!ignoreWheelEvents) emit("scroll", e);
|
|
if (swiper.params.autoplay && swiper.params.autoplay.disableOnInteraction) swiper.autoplay.stop();
|
|
if (params.releaseOnEdges && (position === swiper.minTranslate() || position === swiper.maxTranslate())) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (e.preventDefault) e.preventDefault();
|
|
else e.returnValue = false;
|
|
return false;
|
|
}
|
|
function events(method) {
|
|
let targetEl = swiper.el;
|
|
if (swiper.params.mousewheel.eventsTarget !== "container") {
|
|
targetEl = document.querySelector(swiper.params.mousewheel.eventsTarget);
|
|
}
|
|
targetEl[method]("mouseenter", handleMouseEnter);
|
|
targetEl[method]("mouseleave", handleMouseLeave);
|
|
targetEl[method]("wheel", handle);
|
|
}
|
|
function enable() {
|
|
if (swiper.params.cssMode) {
|
|
swiper.wrapperEl.removeEventListener("wheel", handle);
|
|
return true;
|
|
}
|
|
if (swiper.mousewheel.enabled) return false;
|
|
events("addEventListener");
|
|
swiper.mousewheel.enabled = true;
|
|
return true;
|
|
}
|
|
function disable() {
|
|
if (swiper.params.cssMode) {
|
|
swiper.wrapperEl.addEventListener(event, handle);
|
|
return true;
|
|
}
|
|
if (!swiper.mousewheel.enabled) return false;
|
|
events("removeEventListener");
|
|
swiper.mousewheel.enabled = false;
|
|
return true;
|
|
}
|
|
on("init", () => {
|
|
if (!swiper.params.mousewheel.enabled && swiper.params.cssMode) {
|
|
disable();
|
|
}
|
|
if (swiper.params.mousewheel.enabled) enable();
|
|
});
|
|
on("destroy", () => {
|
|
if (swiper.params.cssMode) {
|
|
enable();
|
|
}
|
|
if (swiper.mousewheel.enabled) disable();
|
|
});
|
|
Object.assign(swiper.mousewheel, {
|
|
enable,
|
|
disable
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/shared/create-element-if-not-defined.mjs
|
|
function createElementIfNotDefined(swiper, originalParams, params, checkProps) {
|
|
if (swiper.params.createElements) {
|
|
Object.keys(checkProps).forEach((key) => {
|
|
if (!params[key] && params.auto === true) {
|
|
let element = elementChildren(swiper.el, `.${checkProps[key]}`)[0];
|
|
if (!element) {
|
|
element = createElement("div", checkProps[key]);
|
|
element.className = checkProps[key];
|
|
swiper.el.append(element);
|
|
}
|
|
params[key] = element;
|
|
originalParams[key] = element;
|
|
}
|
|
});
|
|
}
|
|
return params;
|
|
}
|
|
|
|
// node_modules/swiper/modules/navigation.mjs
|
|
function Navigation(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on,
|
|
emit
|
|
} = _ref;
|
|
extendParams({
|
|
navigation: {
|
|
nextEl: null,
|
|
prevEl: null,
|
|
hideOnClick: false,
|
|
disabledClass: "swiper-button-disabled",
|
|
hiddenClass: "swiper-button-hidden",
|
|
lockClass: "swiper-button-lock",
|
|
navigationDisabledClass: "swiper-navigation-disabled"
|
|
}
|
|
});
|
|
swiper.navigation = {
|
|
nextEl: null,
|
|
prevEl: null
|
|
};
|
|
function getEl(el) {
|
|
let res;
|
|
if (el && typeof el === "string" && swiper.isElement) {
|
|
res = swiper.el.querySelector(el) || swiper.hostEl.querySelector(el);
|
|
if (res) return res;
|
|
}
|
|
if (el) {
|
|
if (typeof el === "string") res = [...document.querySelectorAll(el)];
|
|
if (swiper.params.uniqueNavElements && typeof el === "string" && res && res.length > 1 && swiper.el.querySelectorAll(el).length === 1) {
|
|
res = swiper.el.querySelector(el);
|
|
} else if (res && res.length === 1) {
|
|
res = res[0];
|
|
}
|
|
}
|
|
if (el && !res) return el;
|
|
return res;
|
|
}
|
|
function toggleEl(el, disabled) {
|
|
const params = swiper.params.navigation;
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
if (subEl) {
|
|
subEl.classList[disabled ? "add" : "remove"](...params.disabledClass.split(" "));
|
|
if (subEl.tagName === "BUTTON") subEl.disabled = disabled;
|
|
if (swiper.params.watchOverflow && swiper.enabled) {
|
|
subEl.classList[swiper.isLocked ? "add" : "remove"](params.lockClass);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function update() {
|
|
const {
|
|
nextEl,
|
|
prevEl
|
|
} = swiper.navigation;
|
|
if (swiper.params.loop) {
|
|
toggleEl(prevEl, false);
|
|
toggleEl(nextEl, false);
|
|
return;
|
|
}
|
|
toggleEl(prevEl, swiper.isBeginning && !swiper.params.rewind);
|
|
toggleEl(nextEl, swiper.isEnd && !swiper.params.rewind);
|
|
}
|
|
function onPrevClick(e) {
|
|
e.preventDefault();
|
|
if (swiper.isBeginning && !swiper.params.loop && !swiper.params.rewind) return;
|
|
swiper.slidePrev();
|
|
emit("navigationPrev");
|
|
}
|
|
function onNextClick(e) {
|
|
e.preventDefault();
|
|
if (swiper.isEnd && !swiper.params.loop && !swiper.params.rewind) return;
|
|
swiper.slideNext();
|
|
emit("navigationNext");
|
|
}
|
|
function init() {
|
|
const params = swiper.params.navigation;
|
|
swiper.params.navigation = createElementIfNotDefined(swiper, swiper.originalParams.navigation, swiper.params.navigation, {
|
|
nextEl: "swiper-button-next",
|
|
prevEl: "swiper-button-prev"
|
|
});
|
|
if (!(params.nextEl || params.prevEl)) return;
|
|
let nextEl = getEl(params.nextEl);
|
|
let prevEl = getEl(params.prevEl);
|
|
Object.assign(swiper.navigation, {
|
|
nextEl,
|
|
prevEl
|
|
});
|
|
nextEl = makeElementsArray(nextEl);
|
|
prevEl = makeElementsArray(prevEl);
|
|
const initButton = (el, dir) => {
|
|
if (el) {
|
|
el.addEventListener("click", dir === "next" ? onNextClick : onPrevClick);
|
|
}
|
|
if (!swiper.enabled && el) {
|
|
el.classList.add(...params.lockClass.split(" "));
|
|
}
|
|
};
|
|
nextEl.forEach((el) => initButton(el, "next"));
|
|
prevEl.forEach((el) => initButton(el, "prev"));
|
|
}
|
|
function destroy() {
|
|
let {
|
|
nextEl,
|
|
prevEl
|
|
} = swiper.navigation;
|
|
nextEl = makeElementsArray(nextEl);
|
|
prevEl = makeElementsArray(prevEl);
|
|
const destroyButton = (el, dir) => {
|
|
el.removeEventListener("click", dir === "next" ? onNextClick : onPrevClick);
|
|
el.classList.remove(...swiper.params.navigation.disabledClass.split(" "));
|
|
};
|
|
nextEl.forEach((el) => destroyButton(el, "next"));
|
|
prevEl.forEach((el) => destroyButton(el, "prev"));
|
|
}
|
|
on("init", () => {
|
|
if (swiper.params.navigation.enabled === false) {
|
|
disable();
|
|
} else {
|
|
init();
|
|
update();
|
|
}
|
|
});
|
|
on("toEdge fromEdge lock unlock", () => {
|
|
update();
|
|
});
|
|
on("destroy", () => {
|
|
destroy();
|
|
});
|
|
on("enable disable", () => {
|
|
let {
|
|
nextEl,
|
|
prevEl
|
|
} = swiper.navigation;
|
|
nextEl = makeElementsArray(nextEl);
|
|
prevEl = makeElementsArray(prevEl);
|
|
if (swiper.enabled) {
|
|
update();
|
|
return;
|
|
}
|
|
[...nextEl, ...prevEl].filter((el) => !!el).forEach((el) => el.classList.add(swiper.params.navigation.lockClass));
|
|
});
|
|
on("click", (_s, e) => {
|
|
let {
|
|
nextEl,
|
|
prevEl
|
|
} = swiper.navigation;
|
|
nextEl = makeElementsArray(nextEl);
|
|
prevEl = makeElementsArray(prevEl);
|
|
const targetEl = e.target;
|
|
let targetIsButton = prevEl.includes(targetEl) || nextEl.includes(targetEl);
|
|
if (swiper.isElement && !targetIsButton) {
|
|
const path = e.path || e.composedPath && e.composedPath();
|
|
if (path) {
|
|
targetIsButton = path.find((pathEl) => nextEl.includes(pathEl) || prevEl.includes(pathEl));
|
|
}
|
|
}
|
|
if (swiper.params.navigation.hideOnClick && !targetIsButton) {
|
|
if (swiper.pagination && swiper.params.pagination && swiper.params.pagination.clickable && (swiper.pagination.el === targetEl || swiper.pagination.el.contains(targetEl))) return;
|
|
let isHidden;
|
|
if (nextEl.length) {
|
|
isHidden = nextEl[0].classList.contains(swiper.params.navigation.hiddenClass);
|
|
} else if (prevEl.length) {
|
|
isHidden = prevEl[0].classList.contains(swiper.params.navigation.hiddenClass);
|
|
}
|
|
if (isHidden === true) {
|
|
emit("navigationShow");
|
|
} else {
|
|
emit("navigationHide");
|
|
}
|
|
[...nextEl, ...prevEl].filter((el) => !!el).forEach((el) => el.classList.toggle(swiper.params.navigation.hiddenClass));
|
|
}
|
|
});
|
|
const enable = () => {
|
|
swiper.el.classList.remove(...swiper.params.navigation.navigationDisabledClass.split(" "));
|
|
init();
|
|
update();
|
|
};
|
|
const disable = () => {
|
|
swiper.el.classList.add(...swiper.params.navigation.navigationDisabledClass.split(" "));
|
|
destroy();
|
|
};
|
|
Object.assign(swiper.navigation, {
|
|
enable,
|
|
disable,
|
|
update,
|
|
init,
|
|
destroy
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/shared/classes-to-selector.mjs
|
|
function classesToSelector(classes) {
|
|
if (classes === void 0) {
|
|
classes = "";
|
|
}
|
|
return `.${classes.trim().replace(/([\.:!+\/])/g, "\\$1").replace(/ /g, ".")}`;
|
|
}
|
|
|
|
// node_modules/swiper/modules/pagination.mjs
|
|
function Pagination(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on,
|
|
emit
|
|
} = _ref;
|
|
const pfx = "swiper-pagination";
|
|
extendParams({
|
|
pagination: {
|
|
el: null,
|
|
bulletElement: "span",
|
|
clickable: false,
|
|
hideOnClick: false,
|
|
renderBullet: null,
|
|
renderProgressbar: null,
|
|
renderFraction: null,
|
|
renderCustom: null,
|
|
progressbarOpposite: false,
|
|
type: "bullets",
|
|
// 'bullets' or 'progressbar' or 'fraction' or 'custom'
|
|
dynamicBullets: false,
|
|
dynamicMainBullets: 1,
|
|
formatFractionCurrent: (number) => number,
|
|
formatFractionTotal: (number) => number,
|
|
bulletClass: `${pfx}-bullet`,
|
|
bulletActiveClass: `${pfx}-bullet-active`,
|
|
modifierClass: `${pfx}-`,
|
|
currentClass: `${pfx}-current`,
|
|
totalClass: `${pfx}-total`,
|
|
hiddenClass: `${pfx}-hidden`,
|
|
progressbarFillClass: `${pfx}-progressbar-fill`,
|
|
progressbarOppositeClass: `${pfx}-progressbar-opposite`,
|
|
clickableClass: `${pfx}-clickable`,
|
|
lockClass: `${pfx}-lock`,
|
|
horizontalClass: `${pfx}-horizontal`,
|
|
verticalClass: `${pfx}-vertical`,
|
|
paginationDisabledClass: `${pfx}-disabled`
|
|
}
|
|
});
|
|
swiper.pagination = {
|
|
el: null,
|
|
bullets: []
|
|
};
|
|
let bulletSize;
|
|
let dynamicBulletIndex = 0;
|
|
function isPaginationDisabled() {
|
|
return !swiper.params.pagination.el || !swiper.pagination.el || Array.isArray(swiper.pagination.el) && swiper.pagination.el.length === 0;
|
|
}
|
|
function setSideBullets(bulletEl, position) {
|
|
const {
|
|
bulletActiveClass
|
|
} = swiper.params.pagination;
|
|
if (!bulletEl) return;
|
|
bulletEl = bulletEl[`${position === "prev" ? "previous" : "next"}ElementSibling`];
|
|
if (bulletEl) {
|
|
bulletEl.classList.add(`${bulletActiveClass}-${position}`);
|
|
bulletEl = bulletEl[`${position === "prev" ? "previous" : "next"}ElementSibling`];
|
|
if (bulletEl) {
|
|
bulletEl.classList.add(`${bulletActiveClass}-${position}-${position}`);
|
|
}
|
|
}
|
|
}
|
|
function getMoveDirection(prevIndex, nextIndex, length) {
|
|
prevIndex = prevIndex % length;
|
|
nextIndex = nextIndex % length;
|
|
if (nextIndex === prevIndex + 1) {
|
|
return "next";
|
|
} else if (nextIndex === prevIndex - 1) {
|
|
return "previous";
|
|
}
|
|
return;
|
|
}
|
|
function onBulletClick(e) {
|
|
const bulletEl = e.target.closest(classesToSelector(swiper.params.pagination.bulletClass));
|
|
if (!bulletEl) {
|
|
return;
|
|
}
|
|
e.preventDefault();
|
|
const index = elementIndex(bulletEl) * swiper.params.slidesPerGroup;
|
|
if (swiper.params.loop) {
|
|
if (swiper.realIndex === index) return;
|
|
const moveDirection = getMoveDirection(swiper.realIndex, index, swiper.slides.length);
|
|
if (moveDirection === "next") {
|
|
swiper.slideNext();
|
|
} else if (moveDirection === "previous") {
|
|
swiper.slidePrev();
|
|
} else {
|
|
swiper.slideToLoop(index);
|
|
}
|
|
} else {
|
|
swiper.slideTo(index);
|
|
}
|
|
}
|
|
function update() {
|
|
const rtl = swiper.rtl;
|
|
const params = swiper.params.pagination;
|
|
if (isPaginationDisabled()) return;
|
|
let el = swiper.pagination.el;
|
|
el = makeElementsArray(el);
|
|
let current;
|
|
let previousIndex;
|
|
const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;
|
|
const total = swiper.params.loop ? Math.ceil(slidesLength / swiper.params.slidesPerGroup) : swiper.snapGrid.length;
|
|
if (swiper.params.loop) {
|
|
previousIndex = swiper.previousRealIndex || 0;
|
|
current = swiper.params.slidesPerGroup > 1 ? Math.floor(swiper.realIndex / swiper.params.slidesPerGroup) : swiper.realIndex;
|
|
} else if (typeof swiper.snapIndex !== "undefined") {
|
|
current = swiper.snapIndex;
|
|
previousIndex = swiper.previousSnapIndex;
|
|
} else {
|
|
previousIndex = swiper.previousIndex || 0;
|
|
current = swiper.activeIndex || 0;
|
|
}
|
|
if (params.type === "bullets" && swiper.pagination.bullets && swiper.pagination.bullets.length > 0) {
|
|
const bullets = swiper.pagination.bullets;
|
|
let firstIndex;
|
|
let lastIndex;
|
|
let midIndex;
|
|
if (params.dynamicBullets) {
|
|
bulletSize = elementOuterSize(bullets[0], swiper.isHorizontal() ? "width" : "height", true);
|
|
el.forEach((subEl) => {
|
|
subEl.style[swiper.isHorizontal() ? "width" : "height"] = `${bulletSize * (params.dynamicMainBullets + 4)}px`;
|
|
});
|
|
if (params.dynamicMainBullets > 1 && previousIndex !== void 0) {
|
|
dynamicBulletIndex += current - (previousIndex || 0);
|
|
if (dynamicBulletIndex > params.dynamicMainBullets - 1) {
|
|
dynamicBulletIndex = params.dynamicMainBullets - 1;
|
|
} else if (dynamicBulletIndex < 0) {
|
|
dynamicBulletIndex = 0;
|
|
}
|
|
}
|
|
firstIndex = Math.max(current - dynamicBulletIndex, 0);
|
|
lastIndex = firstIndex + (Math.min(bullets.length, params.dynamicMainBullets) - 1);
|
|
midIndex = (lastIndex + firstIndex) / 2;
|
|
}
|
|
bullets.forEach((bulletEl) => {
|
|
const classesToRemove = [...["", "-next", "-next-next", "-prev", "-prev-prev", "-main"].map((suffix) => `${params.bulletActiveClass}${suffix}`)].map((s) => typeof s === "string" && s.includes(" ") ? s.split(" ") : s).flat();
|
|
bulletEl.classList.remove(...classesToRemove);
|
|
});
|
|
if (el.length > 1) {
|
|
bullets.forEach((bullet) => {
|
|
const bulletIndex = elementIndex(bullet);
|
|
if (bulletIndex === current) {
|
|
bullet.classList.add(...params.bulletActiveClass.split(" "));
|
|
} else if (swiper.isElement) {
|
|
bullet.setAttribute("part", "bullet");
|
|
}
|
|
if (params.dynamicBullets) {
|
|
if (bulletIndex >= firstIndex && bulletIndex <= lastIndex) {
|
|
bullet.classList.add(...`${params.bulletActiveClass}-main`.split(" "));
|
|
}
|
|
if (bulletIndex === firstIndex) {
|
|
setSideBullets(bullet, "prev");
|
|
}
|
|
if (bulletIndex === lastIndex) {
|
|
setSideBullets(bullet, "next");
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
const bullet = bullets[current];
|
|
if (bullet) {
|
|
bullet.classList.add(...params.bulletActiveClass.split(" "));
|
|
}
|
|
if (swiper.isElement) {
|
|
bullets.forEach((bulletEl, bulletIndex) => {
|
|
bulletEl.setAttribute("part", bulletIndex === current ? "bullet-active" : "bullet");
|
|
});
|
|
}
|
|
if (params.dynamicBullets) {
|
|
const firstDisplayedBullet = bullets[firstIndex];
|
|
const lastDisplayedBullet = bullets[lastIndex];
|
|
for (let i = firstIndex; i <= lastIndex; i += 1) {
|
|
if (bullets[i]) {
|
|
bullets[i].classList.add(...`${params.bulletActiveClass}-main`.split(" "));
|
|
}
|
|
}
|
|
setSideBullets(firstDisplayedBullet, "prev");
|
|
setSideBullets(lastDisplayedBullet, "next");
|
|
}
|
|
}
|
|
if (params.dynamicBullets) {
|
|
const dynamicBulletsLength = Math.min(bullets.length, params.dynamicMainBullets + 4);
|
|
const bulletsOffset = (bulletSize * dynamicBulletsLength - bulletSize) / 2 - midIndex * bulletSize;
|
|
const offsetProp = rtl ? "right" : "left";
|
|
bullets.forEach((bullet) => {
|
|
bullet.style[swiper.isHorizontal() ? offsetProp : "top"] = `${bulletsOffset}px`;
|
|
});
|
|
}
|
|
}
|
|
el.forEach((subEl, subElIndex) => {
|
|
if (params.type === "fraction") {
|
|
subEl.querySelectorAll(classesToSelector(params.currentClass)).forEach((fractionEl) => {
|
|
fractionEl.textContent = params.formatFractionCurrent(current + 1);
|
|
});
|
|
subEl.querySelectorAll(classesToSelector(params.totalClass)).forEach((totalEl) => {
|
|
totalEl.textContent = params.formatFractionTotal(total);
|
|
});
|
|
}
|
|
if (params.type === "progressbar") {
|
|
let progressbarDirection;
|
|
if (params.progressbarOpposite) {
|
|
progressbarDirection = swiper.isHorizontal() ? "vertical" : "horizontal";
|
|
} else {
|
|
progressbarDirection = swiper.isHorizontal() ? "horizontal" : "vertical";
|
|
}
|
|
const scale = (current + 1) / total;
|
|
let scaleX = 1;
|
|
let scaleY = 1;
|
|
if (progressbarDirection === "horizontal") {
|
|
scaleX = scale;
|
|
} else {
|
|
scaleY = scale;
|
|
}
|
|
subEl.querySelectorAll(classesToSelector(params.progressbarFillClass)).forEach((progressEl) => {
|
|
progressEl.style.transform = `translate3d(0,0,0) scaleX(${scaleX}) scaleY(${scaleY})`;
|
|
progressEl.style.transitionDuration = `${swiper.params.speed}ms`;
|
|
});
|
|
}
|
|
if (params.type === "custom" && params.renderCustom) {
|
|
subEl.innerHTML = params.renderCustom(swiper, current + 1, total);
|
|
if (subElIndex === 0) emit("paginationRender", subEl);
|
|
} else {
|
|
if (subElIndex === 0) emit("paginationRender", subEl);
|
|
emit("paginationUpdate", subEl);
|
|
}
|
|
if (swiper.params.watchOverflow && swiper.enabled) {
|
|
subEl.classList[swiper.isLocked ? "add" : "remove"](params.lockClass);
|
|
}
|
|
});
|
|
}
|
|
function render() {
|
|
const params = swiper.params.pagination;
|
|
if (isPaginationDisabled()) return;
|
|
const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.grid && swiper.params.grid.rows > 1 ? swiper.slides.length / Math.ceil(swiper.params.grid.rows) : swiper.slides.length;
|
|
let el = swiper.pagination.el;
|
|
el = makeElementsArray(el);
|
|
let paginationHTML = "";
|
|
if (params.type === "bullets") {
|
|
let numberOfBullets = swiper.params.loop ? Math.ceil(slidesLength / swiper.params.slidesPerGroup) : swiper.snapGrid.length;
|
|
if (swiper.params.freeMode && swiper.params.freeMode.enabled && numberOfBullets > slidesLength) {
|
|
numberOfBullets = slidesLength;
|
|
}
|
|
for (let i = 0; i < numberOfBullets; i += 1) {
|
|
if (params.renderBullet) {
|
|
paginationHTML += params.renderBullet.call(swiper, i, params.bulletClass);
|
|
} else {
|
|
paginationHTML += `<${params.bulletElement} ${swiper.isElement ? 'part="bullet"' : ""} class="${params.bulletClass}"></${params.bulletElement}>`;
|
|
}
|
|
}
|
|
}
|
|
if (params.type === "fraction") {
|
|
if (params.renderFraction) {
|
|
paginationHTML = params.renderFraction.call(swiper, params.currentClass, params.totalClass);
|
|
} else {
|
|
paginationHTML = `<span class="${params.currentClass}"></span> / <span class="${params.totalClass}"></span>`;
|
|
}
|
|
}
|
|
if (params.type === "progressbar") {
|
|
if (params.renderProgressbar) {
|
|
paginationHTML = params.renderProgressbar.call(swiper, params.progressbarFillClass);
|
|
} else {
|
|
paginationHTML = `<span class="${params.progressbarFillClass}"></span>`;
|
|
}
|
|
}
|
|
swiper.pagination.bullets = [];
|
|
el.forEach((subEl) => {
|
|
if (params.type !== "custom") {
|
|
subEl.innerHTML = paginationHTML || "";
|
|
}
|
|
if (params.type === "bullets") {
|
|
swiper.pagination.bullets.push(...subEl.querySelectorAll(classesToSelector(params.bulletClass)));
|
|
}
|
|
});
|
|
if (params.type !== "custom") {
|
|
emit("paginationRender", el[0]);
|
|
}
|
|
}
|
|
function init() {
|
|
swiper.params.pagination = createElementIfNotDefined(swiper, swiper.originalParams.pagination, swiper.params.pagination, {
|
|
el: "swiper-pagination"
|
|
});
|
|
const params = swiper.params.pagination;
|
|
if (!params.el) return;
|
|
let el;
|
|
if (typeof params.el === "string" && swiper.isElement) {
|
|
el = swiper.el.querySelector(params.el);
|
|
}
|
|
if (!el && typeof params.el === "string") {
|
|
el = [...document.querySelectorAll(params.el)];
|
|
}
|
|
if (!el) {
|
|
el = params.el;
|
|
}
|
|
if (!el || el.length === 0) return;
|
|
if (swiper.params.uniqueNavElements && typeof params.el === "string" && Array.isArray(el) && el.length > 1) {
|
|
el = [...swiper.el.querySelectorAll(params.el)];
|
|
if (el.length > 1) {
|
|
el = el.find((subEl) => {
|
|
if (elementParents(subEl, ".swiper")[0] !== swiper.el) return false;
|
|
return true;
|
|
});
|
|
}
|
|
}
|
|
if (Array.isArray(el) && el.length === 1) el = el[0];
|
|
Object.assign(swiper.pagination, {
|
|
el
|
|
});
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
if (params.type === "bullets" && params.clickable) {
|
|
subEl.classList.add(...(params.clickableClass || "").split(" "));
|
|
}
|
|
subEl.classList.add(params.modifierClass + params.type);
|
|
subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
|
|
if (params.type === "bullets" && params.dynamicBullets) {
|
|
subEl.classList.add(`${params.modifierClass}${params.type}-dynamic`);
|
|
dynamicBulletIndex = 0;
|
|
if (params.dynamicMainBullets < 1) {
|
|
params.dynamicMainBullets = 1;
|
|
}
|
|
}
|
|
if (params.type === "progressbar" && params.progressbarOpposite) {
|
|
subEl.classList.add(params.progressbarOppositeClass);
|
|
}
|
|
if (params.clickable) {
|
|
subEl.addEventListener("click", onBulletClick);
|
|
}
|
|
if (!swiper.enabled) {
|
|
subEl.classList.add(params.lockClass);
|
|
}
|
|
});
|
|
}
|
|
function destroy() {
|
|
const params = swiper.params.pagination;
|
|
if (isPaginationDisabled()) return;
|
|
let el = swiper.pagination.el;
|
|
if (el) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.classList.remove(params.hiddenClass);
|
|
subEl.classList.remove(params.modifierClass + params.type);
|
|
subEl.classList.remove(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
|
|
if (params.clickable) {
|
|
subEl.classList.remove(...(params.clickableClass || "").split(" "));
|
|
subEl.removeEventListener("click", onBulletClick);
|
|
}
|
|
});
|
|
}
|
|
if (swiper.pagination.bullets) swiper.pagination.bullets.forEach((subEl) => subEl.classList.remove(...params.bulletActiveClass.split(" ")));
|
|
}
|
|
on("changeDirection", () => {
|
|
if (!swiper.pagination || !swiper.pagination.el) return;
|
|
const params = swiper.params.pagination;
|
|
let {
|
|
el
|
|
} = swiper.pagination;
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.classList.remove(params.horizontalClass, params.verticalClass);
|
|
subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
|
|
});
|
|
});
|
|
on("init", () => {
|
|
if (swiper.params.pagination.enabled === false) {
|
|
disable();
|
|
} else {
|
|
init();
|
|
render();
|
|
update();
|
|
}
|
|
});
|
|
on("activeIndexChange", () => {
|
|
if (typeof swiper.snapIndex === "undefined") {
|
|
update();
|
|
}
|
|
});
|
|
on("snapIndexChange", () => {
|
|
update();
|
|
});
|
|
on("snapGridLengthChange", () => {
|
|
render();
|
|
update();
|
|
});
|
|
on("destroy", () => {
|
|
destroy();
|
|
});
|
|
on("enable disable", () => {
|
|
let {
|
|
el
|
|
} = swiper.pagination;
|
|
if (el) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => subEl.classList[swiper.enabled ? "remove" : "add"](swiper.params.pagination.lockClass));
|
|
}
|
|
});
|
|
on("lock unlock", () => {
|
|
update();
|
|
});
|
|
on("click", (_s, e) => {
|
|
const targetEl = e.target;
|
|
const el = makeElementsArray(swiper.pagination.el);
|
|
if (swiper.params.pagination.el && swiper.params.pagination.hideOnClick && el && el.length > 0 && !targetEl.classList.contains(swiper.params.pagination.bulletClass)) {
|
|
if (swiper.navigation && (swiper.navigation.nextEl && targetEl === swiper.navigation.nextEl || swiper.navigation.prevEl && targetEl === swiper.navigation.prevEl)) return;
|
|
const isHidden = el[0].classList.contains(swiper.params.pagination.hiddenClass);
|
|
if (isHidden === true) {
|
|
emit("paginationShow");
|
|
} else {
|
|
emit("paginationHide");
|
|
}
|
|
el.forEach((subEl) => subEl.classList.toggle(swiper.params.pagination.hiddenClass));
|
|
}
|
|
});
|
|
const enable = () => {
|
|
swiper.el.classList.remove(swiper.params.pagination.paginationDisabledClass);
|
|
let {
|
|
el
|
|
} = swiper.pagination;
|
|
if (el) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => subEl.classList.remove(swiper.params.pagination.paginationDisabledClass));
|
|
}
|
|
init();
|
|
render();
|
|
update();
|
|
};
|
|
const disable = () => {
|
|
swiper.el.classList.add(swiper.params.pagination.paginationDisabledClass);
|
|
let {
|
|
el
|
|
} = swiper.pagination;
|
|
if (el) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => subEl.classList.add(swiper.params.pagination.paginationDisabledClass));
|
|
}
|
|
destroy();
|
|
};
|
|
Object.assign(swiper.pagination, {
|
|
enable,
|
|
disable,
|
|
render,
|
|
update,
|
|
init,
|
|
destroy
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/scrollbar.mjs
|
|
function Scrollbar(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on,
|
|
emit
|
|
} = _ref;
|
|
const document2 = getDocument();
|
|
let isTouched = false;
|
|
let timeout = null;
|
|
let dragTimeout = null;
|
|
let dragStartPos;
|
|
let dragSize;
|
|
let trackSize;
|
|
let divider;
|
|
extendParams({
|
|
scrollbar: {
|
|
el: null,
|
|
dragSize: "auto",
|
|
hide: false,
|
|
draggable: false,
|
|
snapOnRelease: true,
|
|
lockClass: "swiper-scrollbar-lock",
|
|
dragClass: "swiper-scrollbar-drag",
|
|
scrollbarDisabledClass: "swiper-scrollbar-disabled",
|
|
horizontalClass: `swiper-scrollbar-horizontal`,
|
|
verticalClass: `swiper-scrollbar-vertical`
|
|
}
|
|
});
|
|
swiper.scrollbar = {
|
|
el: null,
|
|
dragEl: null
|
|
};
|
|
function setTranslate() {
|
|
if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
|
|
const {
|
|
scrollbar,
|
|
rtlTranslate: rtl
|
|
} = swiper;
|
|
const {
|
|
dragEl,
|
|
el
|
|
} = scrollbar;
|
|
const params = swiper.params.scrollbar;
|
|
const progress = swiper.params.loop ? swiper.progressLoop : swiper.progress;
|
|
let newSize = dragSize;
|
|
let newPos = (trackSize - dragSize) * progress;
|
|
if (rtl) {
|
|
newPos = -newPos;
|
|
if (newPos > 0) {
|
|
newSize = dragSize - newPos;
|
|
newPos = 0;
|
|
} else if (-newPos + dragSize > trackSize) {
|
|
newSize = trackSize + newPos;
|
|
}
|
|
} else if (newPos < 0) {
|
|
newSize = dragSize + newPos;
|
|
newPos = 0;
|
|
} else if (newPos + dragSize > trackSize) {
|
|
newSize = trackSize - newPos;
|
|
}
|
|
if (swiper.isHorizontal()) {
|
|
dragEl.style.transform = `translate3d(${newPos}px, 0, 0)`;
|
|
dragEl.style.width = `${newSize}px`;
|
|
} else {
|
|
dragEl.style.transform = `translate3d(0px, ${newPos}px, 0)`;
|
|
dragEl.style.height = `${newSize}px`;
|
|
}
|
|
if (params.hide) {
|
|
clearTimeout(timeout);
|
|
el.style.opacity = 1;
|
|
timeout = setTimeout(() => {
|
|
el.style.opacity = 0;
|
|
el.style.transitionDuration = "400ms";
|
|
}, 1e3);
|
|
}
|
|
}
|
|
function setTransition(duration) {
|
|
if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
|
|
swiper.scrollbar.dragEl.style.transitionDuration = `${duration}ms`;
|
|
}
|
|
function updateSize() {
|
|
if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
|
|
const {
|
|
scrollbar
|
|
} = swiper;
|
|
const {
|
|
dragEl,
|
|
el
|
|
} = scrollbar;
|
|
dragEl.style.width = "";
|
|
dragEl.style.height = "";
|
|
trackSize = swiper.isHorizontal() ? el.offsetWidth : el.offsetHeight;
|
|
divider = swiper.size / (swiper.virtualSize + swiper.params.slidesOffsetBefore - (swiper.params.centeredSlides ? swiper.snapGrid[0] : 0));
|
|
if (swiper.params.scrollbar.dragSize === "auto") {
|
|
dragSize = trackSize * divider;
|
|
} else {
|
|
dragSize = parseInt(swiper.params.scrollbar.dragSize, 10);
|
|
}
|
|
if (swiper.isHorizontal()) {
|
|
dragEl.style.width = `${dragSize}px`;
|
|
} else {
|
|
dragEl.style.height = `${dragSize}px`;
|
|
}
|
|
if (divider >= 1) {
|
|
el.style.display = "none";
|
|
} else {
|
|
el.style.display = "";
|
|
}
|
|
if (swiper.params.scrollbar.hide) {
|
|
el.style.opacity = 0;
|
|
}
|
|
if (swiper.params.watchOverflow && swiper.enabled) {
|
|
scrollbar.el.classList[swiper.isLocked ? "add" : "remove"](swiper.params.scrollbar.lockClass);
|
|
}
|
|
}
|
|
function getPointerPosition(e) {
|
|
return swiper.isHorizontal() ? e.clientX : e.clientY;
|
|
}
|
|
function setDragPosition(e) {
|
|
const {
|
|
scrollbar,
|
|
rtlTranslate: rtl
|
|
} = swiper;
|
|
const {
|
|
el
|
|
} = scrollbar;
|
|
let positionRatio;
|
|
positionRatio = (getPointerPosition(e) - elementOffset(el)[swiper.isHorizontal() ? "left" : "top"] - (dragStartPos !== null ? dragStartPos : dragSize / 2)) / (trackSize - dragSize);
|
|
positionRatio = Math.max(Math.min(positionRatio, 1), 0);
|
|
if (rtl) {
|
|
positionRatio = 1 - positionRatio;
|
|
}
|
|
const position = swiper.minTranslate() + (swiper.maxTranslate() - swiper.minTranslate()) * positionRatio;
|
|
swiper.updateProgress(position);
|
|
swiper.setTranslate(position);
|
|
swiper.updateActiveIndex();
|
|
swiper.updateSlidesClasses();
|
|
}
|
|
function onDragStart(e) {
|
|
const params = swiper.params.scrollbar;
|
|
const {
|
|
scrollbar,
|
|
wrapperEl
|
|
} = swiper;
|
|
const {
|
|
el,
|
|
dragEl
|
|
} = scrollbar;
|
|
isTouched = true;
|
|
dragStartPos = e.target === dragEl ? getPointerPosition(e) - e.target.getBoundingClientRect()[swiper.isHorizontal() ? "left" : "top"] : null;
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
wrapperEl.style.transitionDuration = "100ms";
|
|
dragEl.style.transitionDuration = "100ms";
|
|
setDragPosition(e);
|
|
clearTimeout(dragTimeout);
|
|
el.style.transitionDuration = "0ms";
|
|
if (params.hide) {
|
|
el.style.opacity = 1;
|
|
}
|
|
if (swiper.params.cssMode) {
|
|
swiper.wrapperEl.style["scroll-snap-type"] = "none";
|
|
}
|
|
emit("scrollbarDragStart", e);
|
|
}
|
|
function onDragMove(e) {
|
|
const {
|
|
scrollbar,
|
|
wrapperEl
|
|
} = swiper;
|
|
const {
|
|
el,
|
|
dragEl
|
|
} = scrollbar;
|
|
if (!isTouched) return;
|
|
if (e.preventDefault && e.cancelable) e.preventDefault();
|
|
else e.returnValue = false;
|
|
setDragPosition(e);
|
|
wrapperEl.style.transitionDuration = "0ms";
|
|
el.style.transitionDuration = "0ms";
|
|
dragEl.style.transitionDuration = "0ms";
|
|
emit("scrollbarDragMove", e);
|
|
}
|
|
function onDragEnd(e) {
|
|
const params = swiper.params.scrollbar;
|
|
const {
|
|
scrollbar,
|
|
wrapperEl
|
|
} = swiper;
|
|
const {
|
|
el
|
|
} = scrollbar;
|
|
if (!isTouched) return;
|
|
isTouched = false;
|
|
if (swiper.params.cssMode) {
|
|
swiper.wrapperEl.style["scroll-snap-type"] = "";
|
|
wrapperEl.style.transitionDuration = "";
|
|
}
|
|
if (params.hide) {
|
|
clearTimeout(dragTimeout);
|
|
dragTimeout = nextTick(() => {
|
|
el.style.opacity = 0;
|
|
el.style.transitionDuration = "400ms";
|
|
}, 1e3);
|
|
}
|
|
emit("scrollbarDragEnd", e);
|
|
if (params.snapOnRelease) {
|
|
swiper.slideToClosest();
|
|
}
|
|
}
|
|
function events(method) {
|
|
const {
|
|
scrollbar,
|
|
params
|
|
} = swiper;
|
|
const el = scrollbar.el;
|
|
if (!el) return;
|
|
const target = el;
|
|
const activeListener = params.passiveListeners ? {
|
|
passive: false,
|
|
capture: false
|
|
} : false;
|
|
const passiveListener = params.passiveListeners ? {
|
|
passive: true,
|
|
capture: false
|
|
} : false;
|
|
if (!target) return;
|
|
const eventMethod = method === "on" ? "addEventListener" : "removeEventListener";
|
|
target[eventMethod]("pointerdown", onDragStart, activeListener);
|
|
document2[eventMethod]("pointermove", onDragMove, activeListener);
|
|
document2[eventMethod]("pointerup", onDragEnd, passiveListener);
|
|
}
|
|
function enableDraggable() {
|
|
if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
|
|
events("on");
|
|
}
|
|
function disableDraggable() {
|
|
if (!swiper.params.scrollbar.el || !swiper.scrollbar.el) return;
|
|
events("off");
|
|
}
|
|
function init() {
|
|
const {
|
|
scrollbar,
|
|
el: swiperEl
|
|
} = swiper;
|
|
swiper.params.scrollbar = createElementIfNotDefined(swiper, swiper.originalParams.scrollbar, swiper.params.scrollbar, {
|
|
el: "swiper-scrollbar"
|
|
});
|
|
const params = swiper.params.scrollbar;
|
|
if (!params.el) return;
|
|
let el;
|
|
if (typeof params.el === "string" && swiper.isElement) {
|
|
el = swiper.el.querySelector(params.el);
|
|
}
|
|
if (!el && typeof params.el === "string") {
|
|
el = document2.querySelectorAll(params.el);
|
|
if (!el.length) return;
|
|
} else if (!el) {
|
|
el = params.el;
|
|
}
|
|
if (swiper.params.uniqueNavElements && typeof params.el === "string" && el.length > 1 && swiperEl.querySelectorAll(params.el).length === 1) {
|
|
el = swiperEl.querySelector(params.el);
|
|
}
|
|
if (el.length > 0) el = el[0];
|
|
el.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
|
|
let dragEl;
|
|
if (el) {
|
|
dragEl = el.querySelector(classesToSelector(swiper.params.scrollbar.dragClass));
|
|
if (!dragEl) {
|
|
dragEl = createElement("div", swiper.params.scrollbar.dragClass);
|
|
el.append(dragEl);
|
|
}
|
|
}
|
|
Object.assign(scrollbar, {
|
|
el,
|
|
dragEl
|
|
});
|
|
if (params.draggable) {
|
|
enableDraggable();
|
|
}
|
|
if (el) {
|
|
el.classList[swiper.enabled ? "remove" : "add"](...classesToTokens(swiper.params.scrollbar.lockClass));
|
|
}
|
|
}
|
|
function destroy() {
|
|
const params = swiper.params.scrollbar;
|
|
const el = swiper.scrollbar.el;
|
|
if (el) {
|
|
el.classList.remove(...classesToTokens(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass));
|
|
}
|
|
disableDraggable();
|
|
}
|
|
on("changeDirection", () => {
|
|
if (!swiper.scrollbar || !swiper.scrollbar.el) return;
|
|
const params = swiper.params.scrollbar;
|
|
let {
|
|
el
|
|
} = swiper.scrollbar;
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.classList.remove(params.horizontalClass, params.verticalClass);
|
|
subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
|
|
});
|
|
});
|
|
on("init", () => {
|
|
if (swiper.params.scrollbar.enabled === false) {
|
|
disable();
|
|
} else {
|
|
init();
|
|
updateSize();
|
|
setTranslate();
|
|
}
|
|
});
|
|
on("update resize observerUpdate lock unlock changeDirection", () => {
|
|
updateSize();
|
|
});
|
|
on("setTranslate", () => {
|
|
setTranslate();
|
|
});
|
|
on("setTransition", (_s, duration) => {
|
|
setTransition(duration);
|
|
});
|
|
on("enable disable", () => {
|
|
const {
|
|
el
|
|
} = swiper.scrollbar;
|
|
if (el) {
|
|
el.classList[swiper.enabled ? "remove" : "add"](...classesToTokens(swiper.params.scrollbar.lockClass));
|
|
}
|
|
});
|
|
on("destroy", () => {
|
|
destroy();
|
|
});
|
|
const enable = () => {
|
|
swiper.el.classList.remove(...classesToTokens(swiper.params.scrollbar.scrollbarDisabledClass));
|
|
if (swiper.scrollbar.el) {
|
|
swiper.scrollbar.el.classList.remove(...classesToTokens(swiper.params.scrollbar.scrollbarDisabledClass));
|
|
}
|
|
init();
|
|
updateSize();
|
|
setTranslate();
|
|
};
|
|
const disable = () => {
|
|
swiper.el.classList.add(...classesToTokens(swiper.params.scrollbar.scrollbarDisabledClass));
|
|
if (swiper.scrollbar.el) {
|
|
swiper.scrollbar.el.classList.add(...classesToTokens(swiper.params.scrollbar.scrollbarDisabledClass));
|
|
}
|
|
destroy();
|
|
};
|
|
Object.assign(swiper.scrollbar, {
|
|
enable,
|
|
disable,
|
|
updateSize,
|
|
setTranslate,
|
|
init,
|
|
destroy
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/parallax.mjs
|
|
function Parallax(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on
|
|
} = _ref;
|
|
extendParams({
|
|
parallax: {
|
|
enabled: false
|
|
}
|
|
});
|
|
const elementsSelector = "[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]";
|
|
const setTransform = (el, progress) => {
|
|
const {
|
|
rtl
|
|
} = swiper;
|
|
const rtlFactor = rtl ? -1 : 1;
|
|
const p = el.getAttribute("data-swiper-parallax") || "0";
|
|
let x = el.getAttribute("data-swiper-parallax-x");
|
|
let y = el.getAttribute("data-swiper-parallax-y");
|
|
const scale = el.getAttribute("data-swiper-parallax-scale");
|
|
const opacity = el.getAttribute("data-swiper-parallax-opacity");
|
|
const rotate = el.getAttribute("data-swiper-parallax-rotate");
|
|
if (x || y) {
|
|
x = x || "0";
|
|
y = y || "0";
|
|
} else if (swiper.isHorizontal()) {
|
|
x = p;
|
|
y = "0";
|
|
} else {
|
|
y = p;
|
|
x = "0";
|
|
}
|
|
if (x.indexOf("%") >= 0) {
|
|
x = `${parseInt(x, 10) * progress * rtlFactor}%`;
|
|
} else {
|
|
x = `${x * progress * rtlFactor}px`;
|
|
}
|
|
if (y.indexOf("%") >= 0) {
|
|
y = `${parseInt(y, 10) * progress}%`;
|
|
} else {
|
|
y = `${y * progress}px`;
|
|
}
|
|
if (typeof opacity !== "undefined" && opacity !== null) {
|
|
const currentOpacity = opacity - (opacity - 1) * (1 - Math.abs(progress));
|
|
el.style.opacity = currentOpacity;
|
|
}
|
|
let transform = `translate3d(${x}, ${y}, 0px)`;
|
|
if (typeof scale !== "undefined" && scale !== null) {
|
|
const currentScale = scale - (scale - 1) * (1 - Math.abs(progress));
|
|
transform += ` scale(${currentScale})`;
|
|
}
|
|
if (rotate && typeof rotate !== "undefined" && rotate !== null) {
|
|
const currentRotate = rotate * progress * -1;
|
|
transform += ` rotate(${currentRotate}deg)`;
|
|
}
|
|
el.style.transform = transform;
|
|
};
|
|
const setTranslate = () => {
|
|
const {
|
|
el,
|
|
slides,
|
|
progress,
|
|
snapGrid,
|
|
isElement
|
|
} = swiper;
|
|
const elements = elementChildren(el, elementsSelector);
|
|
if (swiper.isElement) {
|
|
elements.push(...elementChildren(swiper.hostEl, elementsSelector));
|
|
}
|
|
elements.forEach((subEl) => {
|
|
setTransform(subEl, progress);
|
|
});
|
|
slides.forEach((slideEl, slideIndex) => {
|
|
let slideProgress = slideEl.progress;
|
|
if (swiper.params.slidesPerGroup > 1 && swiper.params.slidesPerView !== "auto") {
|
|
slideProgress += Math.ceil(slideIndex / 2) - progress * (snapGrid.length - 1);
|
|
}
|
|
slideProgress = Math.min(Math.max(slideProgress, -1), 1);
|
|
slideEl.querySelectorAll(`${elementsSelector}, [data-swiper-parallax-rotate]`).forEach((subEl) => {
|
|
setTransform(subEl, slideProgress);
|
|
});
|
|
});
|
|
};
|
|
const setTransition = function(duration) {
|
|
if (duration === void 0) {
|
|
duration = swiper.params.speed;
|
|
}
|
|
const {
|
|
el,
|
|
hostEl
|
|
} = swiper;
|
|
const elements = [...el.querySelectorAll(elementsSelector)];
|
|
if (swiper.isElement) {
|
|
elements.push(...hostEl.querySelectorAll(elementsSelector));
|
|
}
|
|
elements.forEach((parallaxEl) => {
|
|
let parallaxDuration = parseInt(parallaxEl.getAttribute("data-swiper-parallax-duration"), 10) || duration;
|
|
if (duration === 0) parallaxDuration = 0;
|
|
parallaxEl.style.transitionDuration = `${parallaxDuration}ms`;
|
|
});
|
|
};
|
|
on("beforeInit", () => {
|
|
if (!swiper.params.parallax.enabled) return;
|
|
swiper.params.watchSlidesProgress = true;
|
|
swiper.originalParams.watchSlidesProgress = true;
|
|
});
|
|
on("init", () => {
|
|
if (!swiper.params.parallax.enabled) return;
|
|
setTranslate();
|
|
});
|
|
on("setTranslate", () => {
|
|
if (!swiper.params.parallax.enabled) return;
|
|
setTranslate();
|
|
});
|
|
on("setTransition", (_swiper, duration) => {
|
|
if (!swiper.params.parallax.enabled) return;
|
|
setTransition(duration);
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/zoom.mjs
|
|
function Zoom(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on,
|
|
emit
|
|
} = _ref;
|
|
const window2 = getWindow();
|
|
extendParams({
|
|
zoom: {
|
|
enabled: false,
|
|
limitToOriginalSize: false,
|
|
maxRatio: 3,
|
|
minRatio: 1,
|
|
panOnMouseMove: false,
|
|
toggle: true,
|
|
containerClass: "swiper-zoom-container",
|
|
zoomedSlideClass: "swiper-slide-zoomed"
|
|
}
|
|
});
|
|
swiper.zoom = {
|
|
enabled: false
|
|
};
|
|
let currentScale = 1;
|
|
let isScaling = false;
|
|
let isPanningWithMouse = false;
|
|
let mousePanStart = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
const mousePanSensitivity = -3;
|
|
let fakeGestureTouched;
|
|
let fakeGestureMoved;
|
|
const evCache = [];
|
|
const gesture = {
|
|
originX: 0,
|
|
originY: 0,
|
|
slideEl: void 0,
|
|
slideWidth: void 0,
|
|
slideHeight: void 0,
|
|
imageEl: void 0,
|
|
imageWrapEl: void 0,
|
|
maxRatio: 3
|
|
};
|
|
const image = {
|
|
isTouched: void 0,
|
|
isMoved: void 0,
|
|
currentX: void 0,
|
|
currentY: void 0,
|
|
minX: void 0,
|
|
minY: void 0,
|
|
maxX: void 0,
|
|
maxY: void 0,
|
|
width: void 0,
|
|
height: void 0,
|
|
startX: void 0,
|
|
startY: void 0,
|
|
touchesStart: {},
|
|
touchesCurrent: {}
|
|
};
|
|
const velocity = {
|
|
x: void 0,
|
|
y: void 0,
|
|
prevPositionX: void 0,
|
|
prevPositionY: void 0,
|
|
prevTime: void 0
|
|
};
|
|
let scale = 1;
|
|
Object.defineProperty(swiper.zoom, "scale", {
|
|
get() {
|
|
return scale;
|
|
},
|
|
set(value) {
|
|
if (scale !== value) {
|
|
const imageEl = gesture.imageEl;
|
|
const slideEl = gesture.slideEl;
|
|
emit("zoomChange", value, imageEl, slideEl);
|
|
}
|
|
scale = value;
|
|
}
|
|
});
|
|
function getDistanceBetweenTouches() {
|
|
if (evCache.length < 2) return 1;
|
|
const x1 = evCache[0].pageX;
|
|
const y1 = evCache[0].pageY;
|
|
const x2 = evCache[1].pageX;
|
|
const y2 = evCache[1].pageY;
|
|
const distance = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
|
|
return distance;
|
|
}
|
|
function getMaxRatio() {
|
|
const params = swiper.params.zoom;
|
|
const maxRatio = gesture.imageWrapEl.getAttribute("data-swiper-zoom") || params.maxRatio;
|
|
if (params.limitToOriginalSize && gesture.imageEl && gesture.imageEl.naturalWidth) {
|
|
const imageMaxRatio = gesture.imageEl.naturalWidth / gesture.imageEl.offsetWidth;
|
|
return Math.min(imageMaxRatio, maxRatio);
|
|
}
|
|
return maxRatio;
|
|
}
|
|
function getScaleOrigin() {
|
|
if (evCache.length < 2) return {
|
|
x: null,
|
|
y: null
|
|
};
|
|
const box = gesture.imageEl.getBoundingClientRect();
|
|
return [(evCache[0].pageX + (evCache[1].pageX - evCache[0].pageX) / 2 - box.x - window2.scrollX) / currentScale, (evCache[0].pageY + (evCache[1].pageY - evCache[0].pageY) / 2 - box.y - window2.scrollY) / currentScale];
|
|
}
|
|
function getSlideSelector() {
|
|
return swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
|
|
}
|
|
function eventWithinSlide(e) {
|
|
const slideSelector = getSlideSelector();
|
|
if (e.target.matches(slideSelector)) return true;
|
|
if (swiper.slides.filter((slideEl) => slideEl.contains(e.target)).length > 0) return true;
|
|
return false;
|
|
}
|
|
function eventWithinZoomContainer(e) {
|
|
const selector = `.${swiper.params.zoom.containerClass}`;
|
|
if (e.target.matches(selector)) return true;
|
|
if ([...swiper.hostEl.querySelectorAll(selector)].filter((containerEl) => containerEl.contains(e.target)).length > 0) return true;
|
|
return false;
|
|
}
|
|
function onGestureStart(e) {
|
|
if (e.pointerType === "mouse") {
|
|
evCache.splice(0, evCache.length);
|
|
}
|
|
if (!eventWithinSlide(e)) return;
|
|
const params = swiper.params.zoom;
|
|
fakeGestureTouched = false;
|
|
fakeGestureMoved = false;
|
|
evCache.push(e);
|
|
if (evCache.length < 2) {
|
|
return;
|
|
}
|
|
fakeGestureTouched = true;
|
|
gesture.scaleStart = getDistanceBetweenTouches();
|
|
if (!gesture.slideEl) {
|
|
gesture.slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);
|
|
if (!gesture.slideEl) gesture.slideEl = swiper.slides[swiper.activeIndex];
|
|
let imageEl = gesture.slideEl.querySelector(`.${params.containerClass}`);
|
|
if (imageEl) {
|
|
imageEl = imageEl.querySelectorAll("picture, img, svg, canvas, .swiper-zoom-target")[0];
|
|
}
|
|
gesture.imageEl = imageEl;
|
|
if (imageEl) {
|
|
gesture.imageWrapEl = elementParents(gesture.imageEl, `.${params.containerClass}`)[0];
|
|
} else {
|
|
gesture.imageWrapEl = void 0;
|
|
}
|
|
if (!gesture.imageWrapEl) {
|
|
gesture.imageEl = void 0;
|
|
return;
|
|
}
|
|
gesture.maxRatio = getMaxRatio();
|
|
}
|
|
if (gesture.imageEl) {
|
|
const [originX, originY] = getScaleOrigin();
|
|
gesture.originX = originX;
|
|
gesture.originY = originY;
|
|
gesture.imageEl.style.transitionDuration = "0ms";
|
|
}
|
|
isScaling = true;
|
|
}
|
|
function onGestureChange(e) {
|
|
if (!eventWithinSlide(e)) return;
|
|
const params = swiper.params.zoom;
|
|
const zoom = swiper.zoom;
|
|
const pointerIndex = evCache.findIndex((cachedEv) => cachedEv.pointerId === e.pointerId);
|
|
if (pointerIndex >= 0) evCache[pointerIndex] = e;
|
|
if (evCache.length < 2) {
|
|
return;
|
|
}
|
|
fakeGestureMoved = true;
|
|
gesture.scaleMove = getDistanceBetweenTouches();
|
|
if (!gesture.imageEl) {
|
|
return;
|
|
}
|
|
zoom.scale = gesture.scaleMove / gesture.scaleStart * currentScale;
|
|
if (zoom.scale > gesture.maxRatio) {
|
|
zoom.scale = gesture.maxRatio - 1 + (zoom.scale - gesture.maxRatio + 1) ** 0.5;
|
|
}
|
|
if (zoom.scale < params.minRatio) {
|
|
zoom.scale = params.minRatio + 1 - (params.minRatio - zoom.scale + 1) ** 0.5;
|
|
}
|
|
gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;
|
|
}
|
|
function onGestureEnd(e) {
|
|
if (!eventWithinSlide(e)) return;
|
|
if (e.pointerType === "mouse" && e.type === "pointerout") return;
|
|
const params = swiper.params.zoom;
|
|
const zoom = swiper.zoom;
|
|
const pointerIndex = evCache.findIndex((cachedEv) => cachedEv.pointerId === e.pointerId);
|
|
if (pointerIndex >= 0) evCache.splice(pointerIndex, 1);
|
|
if (!fakeGestureTouched || !fakeGestureMoved) {
|
|
return;
|
|
}
|
|
fakeGestureTouched = false;
|
|
fakeGestureMoved = false;
|
|
if (!gesture.imageEl) return;
|
|
zoom.scale = Math.max(Math.min(zoom.scale, gesture.maxRatio), params.minRatio);
|
|
gesture.imageEl.style.transitionDuration = `${swiper.params.speed}ms`;
|
|
gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;
|
|
currentScale = zoom.scale;
|
|
isScaling = false;
|
|
if (zoom.scale > 1 && gesture.slideEl) {
|
|
gesture.slideEl.classList.add(`${params.zoomedSlideClass}`);
|
|
} else if (zoom.scale <= 1 && gesture.slideEl) {
|
|
gesture.slideEl.classList.remove(`${params.zoomedSlideClass}`);
|
|
}
|
|
if (zoom.scale === 1) {
|
|
gesture.originX = 0;
|
|
gesture.originY = 0;
|
|
gesture.slideEl = void 0;
|
|
}
|
|
}
|
|
let allowTouchMoveTimeout;
|
|
function allowTouchMove() {
|
|
swiper.touchEventsData.preventTouchMoveFromPointerMove = false;
|
|
}
|
|
function preventTouchMove() {
|
|
clearTimeout(allowTouchMoveTimeout);
|
|
swiper.touchEventsData.preventTouchMoveFromPointerMove = true;
|
|
allowTouchMoveTimeout = setTimeout(() => {
|
|
if (swiper.destroyed) return;
|
|
allowTouchMove();
|
|
});
|
|
}
|
|
function onTouchStart(e) {
|
|
const device = swiper.device;
|
|
if (!gesture.imageEl) return;
|
|
if (image.isTouched) return;
|
|
if (device.android && e.cancelable) e.preventDefault();
|
|
image.isTouched = true;
|
|
const event2 = evCache.length > 0 ? evCache[0] : e;
|
|
image.touchesStart.x = event2.pageX;
|
|
image.touchesStart.y = event2.pageY;
|
|
}
|
|
function onTouchMove(e) {
|
|
const isMouseEvent = e.pointerType === "mouse";
|
|
const isMousePan = isMouseEvent && swiper.params.zoom.panOnMouseMove;
|
|
if (!eventWithinSlide(e) || !eventWithinZoomContainer(e)) {
|
|
return;
|
|
}
|
|
const zoom = swiper.zoom;
|
|
if (!gesture.imageEl) {
|
|
return;
|
|
}
|
|
if (!image.isTouched || !gesture.slideEl) {
|
|
if (isMousePan) onMouseMove(e);
|
|
return;
|
|
}
|
|
if (isMousePan) {
|
|
onMouseMove(e);
|
|
return;
|
|
}
|
|
if (!image.isMoved) {
|
|
image.width = gesture.imageEl.offsetWidth || gesture.imageEl.clientWidth;
|
|
image.height = gesture.imageEl.offsetHeight || gesture.imageEl.clientHeight;
|
|
image.startX = getTranslate(gesture.imageWrapEl, "x") || 0;
|
|
image.startY = getTranslate(gesture.imageWrapEl, "y") || 0;
|
|
gesture.slideWidth = gesture.slideEl.offsetWidth;
|
|
gesture.slideHeight = gesture.slideEl.offsetHeight;
|
|
gesture.imageWrapEl.style.transitionDuration = "0ms";
|
|
}
|
|
const scaledWidth = image.width * zoom.scale;
|
|
const scaledHeight = image.height * zoom.scale;
|
|
image.minX = Math.min(gesture.slideWidth / 2 - scaledWidth / 2, 0);
|
|
image.maxX = -image.minX;
|
|
image.minY = Math.min(gesture.slideHeight / 2 - scaledHeight / 2, 0);
|
|
image.maxY = -image.minY;
|
|
image.touchesCurrent.x = evCache.length > 0 ? evCache[0].pageX : e.pageX;
|
|
image.touchesCurrent.y = evCache.length > 0 ? evCache[0].pageY : e.pageY;
|
|
const touchesDiff = Math.max(Math.abs(image.touchesCurrent.x - image.touchesStart.x), Math.abs(image.touchesCurrent.y - image.touchesStart.y));
|
|
if (touchesDiff > 5) {
|
|
swiper.allowClick = false;
|
|
}
|
|
if (!image.isMoved && !isScaling) {
|
|
if (swiper.isHorizontal() && (Math.floor(image.minX) === Math.floor(image.startX) && image.touchesCurrent.x < image.touchesStart.x || Math.floor(image.maxX) === Math.floor(image.startX) && image.touchesCurrent.x > image.touchesStart.x)) {
|
|
image.isTouched = false;
|
|
allowTouchMove();
|
|
return;
|
|
}
|
|
if (!swiper.isHorizontal() && (Math.floor(image.minY) === Math.floor(image.startY) && image.touchesCurrent.y < image.touchesStart.y || Math.floor(image.maxY) === Math.floor(image.startY) && image.touchesCurrent.y > image.touchesStart.y)) {
|
|
image.isTouched = false;
|
|
allowTouchMove();
|
|
return;
|
|
}
|
|
}
|
|
if (e.cancelable) {
|
|
e.preventDefault();
|
|
}
|
|
e.stopPropagation();
|
|
preventTouchMove();
|
|
image.isMoved = true;
|
|
const scaleRatio = (zoom.scale - currentScale) / (gesture.maxRatio - swiper.params.zoom.minRatio);
|
|
const {
|
|
originX,
|
|
originY
|
|
} = gesture;
|
|
image.currentX = image.touchesCurrent.x - image.touchesStart.x + image.startX + scaleRatio * (image.width - originX * 2);
|
|
image.currentY = image.touchesCurrent.y - image.touchesStart.y + image.startY + scaleRatio * (image.height - originY * 2);
|
|
if (image.currentX < image.minX) {
|
|
image.currentX = image.minX + 1 - (image.minX - image.currentX + 1) ** 0.8;
|
|
}
|
|
if (image.currentX > image.maxX) {
|
|
image.currentX = image.maxX - 1 + (image.currentX - image.maxX + 1) ** 0.8;
|
|
}
|
|
if (image.currentY < image.minY) {
|
|
image.currentY = image.minY + 1 - (image.minY - image.currentY + 1) ** 0.8;
|
|
}
|
|
if (image.currentY > image.maxY) {
|
|
image.currentY = image.maxY - 1 + (image.currentY - image.maxY + 1) ** 0.8;
|
|
}
|
|
if (!velocity.prevPositionX) velocity.prevPositionX = image.touchesCurrent.x;
|
|
if (!velocity.prevPositionY) velocity.prevPositionY = image.touchesCurrent.y;
|
|
if (!velocity.prevTime) velocity.prevTime = Date.now();
|
|
velocity.x = (image.touchesCurrent.x - velocity.prevPositionX) / (Date.now() - velocity.prevTime) / 2;
|
|
velocity.y = (image.touchesCurrent.y - velocity.prevPositionY) / (Date.now() - velocity.prevTime) / 2;
|
|
if (Math.abs(image.touchesCurrent.x - velocity.prevPositionX) < 2) velocity.x = 0;
|
|
if (Math.abs(image.touchesCurrent.y - velocity.prevPositionY) < 2) velocity.y = 0;
|
|
velocity.prevPositionX = image.touchesCurrent.x;
|
|
velocity.prevPositionY = image.touchesCurrent.y;
|
|
velocity.prevTime = Date.now();
|
|
gesture.imageWrapEl.style.transform = `translate3d(${image.currentX}px, ${image.currentY}px,0)`;
|
|
}
|
|
function onTouchEnd() {
|
|
const zoom = swiper.zoom;
|
|
evCache.length = 0;
|
|
if (!gesture.imageEl) return;
|
|
if (!image.isTouched || !image.isMoved) {
|
|
image.isTouched = false;
|
|
image.isMoved = false;
|
|
return;
|
|
}
|
|
image.isTouched = false;
|
|
image.isMoved = false;
|
|
let momentumDurationX = 300;
|
|
let momentumDurationY = 300;
|
|
const momentumDistanceX = velocity.x * momentumDurationX;
|
|
const newPositionX = image.currentX + momentumDistanceX;
|
|
const momentumDistanceY = velocity.y * momentumDurationY;
|
|
const newPositionY = image.currentY + momentumDistanceY;
|
|
if (velocity.x !== 0) momentumDurationX = Math.abs((newPositionX - image.currentX) / velocity.x);
|
|
if (velocity.y !== 0) momentumDurationY = Math.abs((newPositionY - image.currentY) / velocity.y);
|
|
const momentumDuration = Math.max(momentumDurationX, momentumDurationY);
|
|
image.currentX = newPositionX;
|
|
image.currentY = newPositionY;
|
|
const scaledWidth = image.width * zoom.scale;
|
|
const scaledHeight = image.height * zoom.scale;
|
|
image.minX = Math.min(gesture.slideWidth / 2 - scaledWidth / 2, 0);
|
|
image.maxX = -image.minX;
|
|
image.minY = Math.min(gesture.slideHeight / 2 - scaledHeight / 2, 0);
|
|
image.maxY = -image.minY;
|
|
image.currentX = Math.max(Math.min(image.currentX, image.maxX), image.minX);
|
|
image.currentY = Math.max(Math.min(image.currentY, image.maxY), image.minY);
|
|
gesture.imageWrapEl.style.transitionDuration = `${momentumDuration}ms`;
|
|
gesture.imageWrapEl.style.transform = `translate3d(${image.currentX}px, ${image.currentY}px,0)`;
|
|
}
|
|
function onTransitionEnd() {
|
|
const zoom = swiper.zoom;
|
|
if (gesture.slideEl && swiper.activeIndex !== swiper.slides.indexOf(gesture.slideEl)) {
|
|
if (gesture.imageEl) {
|
|
gesture.imageEl.style.transform = "translate3d(0,0,0) scale(1)";
|
|
}
|
|
if (gesture.imageWrapEl) {
|
|
gesture.imageWrapEl.style.transform = "translate3d(0,0,0)";
|
|
}
|
|
gesture.slideEl.classList.remove(`${swiper.params.zoom.zoomedSlideClass}`);
|
|
zoom.scale = 1;
|
|
currentScale = 1;
|
|
gesture.slideEl = void 0;
|
|
gesture.imageEl = void 0;
|
|
gesture.imageWrapEl = void 0;
|
|
gesture.originX = 0;
|
|
gesture.originY = 0;
|
|
}
|
|
}
|
|
function onMouseMove(e) {
|
|
if (currentScale <= 1 || !gesture.imageWrapEl) return;
|
|
if (!eventWithinSlide(e) || !eventWithinZoomContainer(e)) return;
|
|
const currentTransform = window2.getComputedStyle(gesture.imageWrapEl).transform;
|
|
const matrix = new window2.DOMMatrix(currentTransform);
|
|
if (!isPanningWithMouse) {
|
|
isPanningWithMouse = true;
|
|
mousePanStart.x = e.clientX;
|
|
mousePanStart.y = e.clientY;
|
|
image.startX = matrix.e;
|
|
image.startY = matrix.f;
|
|
image.width = gesture.imageEl.offsetWidth || gesture.imageEl.clientWidth;
|
|
image.height = gesture.imageEl.offsetHeight || gesture.imageEl.clientHeight;
|
|
gesture.slideWidth = gesture.slideEl.offsetWidth;
|
|
gesture.slideHeight = gesture.slideEl.offsetHeight;
|
|
return;
|
|
}
|
|
const deltaX = (e.clientX - mousePanStart.x) * mousePanSensitivity;
|
|
const deltaY = (e.clientY - mousePanStart.y) * mousePanSensitivity;
|
|
const scaledWidth = image.width * currentScale;
|
|
const scaledHeight = image.height * currentScale;
|
|
const slideWidth = gesture.slideWidth;
|
|
const slideHeight = gesture.slideHeight;
|
|
const minX = Math.min(slideWidth / 2 - scaledWidth / 2, 0);
|
|
const maxX = -minX;
|
|
const minY = Math.min(slideHeight / 2 - scaledHeight / 2, 0);
|
|
const maxY = -minY;
|
|
const newX = Math.max(Math.min(image.startX + deltaX, maxX), minX);
|
|
const newY = Math.max(Math.min(image.startY + deltaY, maxY), minY);
|
|
gesture.imageWrapEl.style.transitionDuration = "0ms";
|
|
gesture.imageWrapEl.style.transform = `translate3d(${newX}px, ${newY}px, 0)`;
|
|
mousePanStart.x = e.clientX;
|
|
mousePanStart.y = e.clientY;
|
|
image.startX = newX;
|
|
image.startY = newY;
|
|
image.currentX = newX;
|
|
image.currentY = newY;
|
|
}
|
|
function zoomIn(e) {
|
|
const zoom = swiper.zoom;
|
|
const params = swiper.params.zoom;
|
|
if (!gesture.slideEl) {
|
|
if (e && e.target) {
|
|
gesture.slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);
|
|
}
|
|
if (!gesture.slideEl) {
|
|
if (swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual) {
|
|
gesture.slideEl = elementChildren(swiper.slidesEl, `.${swiper.params.slideActiveClass}`)[0];
|
|
} else {
|
|
gesture.slideEl = swiper.slides[swiper.activeIndex];
|
|
}
|
|
}
|
|
let imageEl = gesture.slideEl.querySelector(`.${params.containerClass}`);
|
|
if (imageEl) {
|
|
imageEl = imageEl.querySelectorAll("picture, img, svg, canvas, .swiper-zoom-target")[0];
|
|
}
|
|
gesture.imageEl = imageEl;
|
|
if (imageEl) {
|
|
gesture.imageWrapEl = elementParents(gesture.imageEl, `.${params.containerClass}`)[0];
|
|
} else {
|
|
gesture.imageWrapEl = void 0;
|
|
}
|
|
}
|
|
if (!gesture.imageEl || !gesture.imageWrapEl) return;
|
|
if (swiper.params.cssMode) {
|
|
swiper.wrapperEl.style.overflow = "hidden";
|
|
swiper.wrapperEl.style.touchAction = "none";
|
|
}
|
|
gesture.slideEl.classList.add(`${params.zoomedSlideClass}`);
|
|
let touchX;
|
|
let touchY;
|
|
let offsetX;
|
|
let offsetY;
|
|
let diffX;
|
|
let diffY;
|
|
let translateX;
|
|
let translateY;
|
|
let imageWidth;
|
|
let imageHeight;
|
|
let scaledWidth;
|
|
let scaledHeight;
|
|
let translateMinX;
|
|
let translateMinY;
|
|
let translateMaxX;
|
|
let translateMaxY;
|
|
let slideWidth;
|
|
let slideHeight;
|
|
if (typeof image.touchesStart.x === "undefined" && e) {
|
|
touchX = e.pageX;
|
|
touchY = e.pageY;
|
|
} else {
|
|
touchX = image.touchesStart.x;
|
|
touchY = image.touchesStart.y;
|
|
}
|
|
const prevScale = currentScale;
|
|
const forceZoomRatio = typeof e === "number" ? e : null;
|
|
if (currentScale === 1 && forceZoomRatio) {
|
|
touchX = void 0;
|
|
touchY = void 0;
|
|
image.touchesStart.x = void 0;
|
|
image.touchesStart.y = void 0;
|
|
}
|
|
const maxRatio = getMaxRatio();
|
|
zoom.scale = forceZoomRatio || maxRatio;
|
|
currentScale = forceZoomRatio || maxRatio;
|
|
if (e && !(currentScale === 1 && forceZoomRatio)) {
|
|
slideWidth = gesture.slideEl.offsetWidth;
|
|
slideHeight = gesture.slideEl.offsetHeight;
|
|
offsetX = elementOffset(gesture.slideEl).left + window2.scrollX;
|
|
offsetY = elementOffset(gesture.slideEl).top + window2.scrollY;
|
|
diffX = offsetX + slideWidth / 2 - touchX;
|
|
diffY = offsetY + slideHeight / 2 - touchY;
|
|
imageWidth = gesture.imageEl.offsetWidth || gesture.imageEl.clientWidth;
|
|
imageHeight = gesture.imageEl.offsetHeight || gesture.imageEl.clientHeight;
|
|
scaledWidth = imageWidth * zoom.scale;
|
|
scaledHeight = imageHeight * zoom.scale;
|
|
translateMinX = Math.min(slideWidth / 2 - scaledWidth / 2, 0);
|
|
translateMinY = Math.min(slideHeight / 2 - scaledHeight / 2, 0);
|
|
translateMaxX = -translateMinX;
|
|
translateMaxY = -translateMinY;
|
|
if (prevScale > 0 && forceZoomRatio && typeof image.currentX === "number" && typeof image.currentY === "number") {
|
|
translateX = image.currentX * zoom.scale / prevScale;
|
|
translateY = image.currentY * zoom.scale / prevScale;
|
|
} else {
|
|
translateX = diffX * zoom.scale;
|
|
translateY = diffY * zoom.scale;
|
|
}
|
|
if (translateX < translateMinX) {
|
|
translateX = translateMinX;
|
|
}
|
|
if (translateX > translateMaxX) {
|
|
translateX = translateMaxX;
|
|
}
|
|
if (translateY < translateMinY) {
|
|
translateY = translateMinY;
|
|
}
|
|
if (translateY > translateMaxY) {
|
|
translateY = translateMaxY;
|
|
}
|
|
} else {
|
|
translateX = 0;
|
|
translateY = 0;
|
|
}
|
|
if (forceZoomRatio && zoom.scale === 1) {
|
|
gesture.originX = 0;
|
|
gesture.originY = 0;
|
|
}
|
|
image.currentX = translateX;
|
|
image.currentY = translateY;
|
|
gesture.imageWrapEl.style.transitionDuration = "300ms";
|
|
gesture.imageWrapEl.style.transform = `translate3d(${translateX}px, ${translateY}px,0)`;
|
|
gesture.imageEl.style.transitionDuration = "300ms";
|
|
gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;
|
|
}
|
|
function zoomOut() {
|
|
const zoom = swiper.zoom;
|
|
const params = swiper.params.zoom;
|
|
if (!gesture.slideEl) {
|
|
if (swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual) {
|
|
gesture.slideEl = elementChildren(swiper.slidesEl, `.${swiper.params.slideActiveClass}`)[0];
|
|
} else {
|
|
gesture.slideEl = swiper.slides[swiper.activeIndex];
|
|
}
|
|
let imageEl = gesture.slideEl.querySelector(`.${params.containerClass}`);
|
|
if (imageEl) {
|
|
imageEl = imageEl.querySelectorAll("picture, img, svg, canvas, .swiper-zoom-target")[0];
|
|
}
|
|
gesture.imageEl = imageEl;
|
|
if (imageEl) {
|
|
gesture.imageWrapEl = elementParents(gesture.imageEl, `.${params.containerClass}`)[0];
|
|
} else {
|
|
gesture.imageWrapEl = void 0;
|
|
}
|
|
}
|
|
if (!gesture.imageEl || !gesture.imageWrapEl) return;
|
|
if (swiper.params.cssMode) {
|
|
swiper.wrapperEl.style.overflow = "";
|
|
swiper.wrapperEl.style.touchAction = "";
|
|
}
|
|
zoom.scale = 1;
|
|
currentScale = 1;
|
|
image.currentX = void 0;
|
|
image.currentY = void 0;
|
|
image.touchesStart.x = void 0;
|
|
image.touchesStart.y = void 0;
|
|
gesture.imageWrapEl.style.transitionDuration = "300ms";
|
|
gesture.imageWrapEl.style.transform = "translate3d(0,0,0)";
|
|
gesture.imageEl.style.transitionDuration = "300ms";
|
|
gesture.imageEl.style.transform = "translate3d(0,0,0) scale(1)";
|
|
gesture.slideEl.classList.remove(`${params.zoomedSlideClass}`);
|
|
gesture.slideEl = void 0;
|
|
gesture.originX = 0;
|
|
gesture.originY = 0;
|
|
if (swiper.params.zoom.panOnMouseMove) {
|
|
mousePanStart = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
if (isPanningWithMouse) {
|
|
isPanningWithMouse = false;
|
|
image.startX = 0;
|
|
image.startY = 0;
|
|
}
|
|
}
|
|
}
|
|
function zoomToggle(e) {
|
|
const zoom = swiper.zoom;
|
|
if (zoom.scale && zoom.scale !== 1) {
|
|
zoomOut();
|
|
} else {
|
|
zoomIn(e);
|
|
}
|
|
}
|
|
function getListeners() {
|
|
const passiveListener = swiper.params.passiveListeners ? {
|
|
passive: true,
|
|
capture: false
|
|
} : false;
|
|
const activeListenerWithCapture = swiper.params.passiveListeners ? {
|
|
passive: false,
|
|
capture: true
|
|
} : true;
|
|
return {
|
|
passiveListener,
|
|
activeListenerWithCapture
|
|
};
|
|
}
|
|
function enable() {
|
|
const zoom = swiper.zoom;
|
|
if (zoom.enabled) return;
|
|
zoom.enabled = true;
|
|
const {
|
|
passiveListener,
|
|
activeListenerWithCapture
|
|
} = getListeners();
|
|
swiper.wrapperEl.addEventListener("pointerdown", onGestureStart, passiveListener);
|
|
swiper.wrapperEl.addEventListener("pointermove", onGestureChange, activeListenerWithCapture);
|
|
["pointerup", "pointercancel", "pointerout"].forEach((eventName) => {
|
|
swiper.wrapperEl.addEventListener(eventName, onGestureEnd, passiveListener);
|
|
});
|
|
swiper.wrapperEl.addEventListener("pointermove", onTouchMove, activeListenerWithCapture);
|
|
}
|
|
function disable() {
|
|
const zoom = swiper.zoom;
|
|
if (!zoom.enabled) return;
|
|
zoom.enabled = false;
|
|
const {
|
|
passiveListener,
|
|
activeListenerWithCapture
|
|
} = getListeners();
|
|
swiper.wrapperEl.removeEventListener("pointerdown", onGestureStart, passiveListener);
|
|
swiper.wrapperEl.removeEventListener("pointermove", onGestureChange, activeListenerWithCapture);
|
|
["pointerup", "pointercancel", "pointerout"].forEach((eventName) => {
|
|
swiper.wrapperEl.removeEventListener(eventName, onGestureEnd, passiveListener);
|
|
});
|
|
swiper.wrapperEl.removeEventListener("pointermove", onTouchMove, activeListenerWithCapture);
|
|
}
|
|
on("init", () => {
|
|
if (swiper.params.zoom.enabled) {
|
|
enable();
|
|
}
|
|
});
|
|
on("destroy", () => {
|
|
disable();
|
|
});
|
|
on("touchStart", (_s, e) => {
|
|
if (!swiper.zoom.enabled) return;
|
|
onTouchStart(e);
|
|
});
|
|
on("touchEnd", (_s, e) => {
|
|
if (!swiper.zoom.enabled) return;
|
|
onTouchEnd();
|
|
});
|
|
on("doubleTap", (_s, e) => {
|
|
if (!swiper.animating && swiper.params.zoom.enabled && swiper.zoom.enabled && swiper.params.zoom.toggle) {
|
|
zoomToggle(e);
|
|
}
|
|
});
|
|
on("transitionEnd", () => {
|
|
if (swiper.zoom.enabled && swiper.params.zoom.enabled) {
|
|
onTransitionEnd();
|
|
}
|
|
});
|
|
on("slideChange", () => {
|
|
if (swiper.zoom.enabled && swiper.params.zoom.enabled && swiper.params.cssMode) {
|
|
onTransitionEnd();
|
|
}
|
|
});
|
|
Object.assign(swiper.zoom, {
|
|
enable,
|
|
disable,
|
|
in: zoomIn,
|
|
out: zoomOut,
|
|
toggle: zoomToggle
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/controller.mjs
|
|
function Controller(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on
|
|
} = _ref;
|
|
extendParams({
|
|
controller: {
|
|
control: void 0,
|
|
inverse: false,
|
|
by: "slide"
|
|
// or 'container'
|
|
}
|
|
});
|
|
swiper.controller = {
|
|
control: void 0
|
|
};
|
|
function LinearSpline(x, y) {
|
|
const binarySearch = /* @__PURE__ */ 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;
|
|
let i1;
|
|
let i3;
|
|
this.interpolate = function interpolate(x2) {
|
|
if (!x2) return 0;
|
|
i3 = binarySearch(this.x, x2);
|
|
i1 = i3 - 1;
|
|
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;
|
|
const translate = swiper.rtlTranslate ? -swiper.translate : swiper.translate;
|
|
if (swiper.params.controller.by === "slide") {
|
|
getInterpolateFunction(c);
|
|
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 = void 0;
|
|
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
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/a11y.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 = (/* @__PURE__ */ new Date()).getTime();
|
|
function notify(message) {
|
|
const notification = liveRegion;
|
|
if (notification.length === 0) return;
|
|
notification.innerHTML = "";
|
|
notification.innerHTML = message;
|
|
}
|
|
function getRandomNumber(size) {
|
|
if (size === void 0) {
|
|
size = 16;
|
|
}
|
|
const randomChar = () => Math.round(16 * Math.random()).toString(16);
|
|
return "x".repeat(size).replace(/x/g, randomChar);
|
|
}
|
|
function makeElFocusable(el) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("tabIndex", "0");
|
|
});
|
|
}
|
|
function makeElNotFocusable(el) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("tabIndex", "-1");
|
|
});
|
|
}
|
|
function addElRole(el, role) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("role", role);
|
|
});
|
|
}
|
|
function addElRoleDescription(el, description) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("aria-roledescription", description);
|
|
});
|
|
}
|
|
function addElControls(el, controls) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("aria-controls", controls);
|
|
});
|
|
}
|
|
function addElLabel(el, label) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("aria-label", label);
|
|
});
|
|
}
|
|
function addElId(el, id) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("id", id);
|
|
});
|
|
}
|
|
function addElLive(el, live) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("aria-live", live);
|
|
});
|
|
}
|
|
function disableEl(el) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("aria-disabled", true);
|
|
});
|
|
}
|
|
function enableEl(el) {
|
|
el = makeElementsArray(el);
|
|
el.forEach((subEl) => {
|
|
subEl.setAttribute("aria-disabled", false);
|
|
});
|
|
}
|
|
function onEnterOrSpaceKey(e) {
|
|
if (e.keyCode !== 13 && e.keyCode !== 32) return;
|
|
const params = swiper.params.a11y;
|
|
const targetEl = e.target;
|
|
if (swiper.pagination && swiper.pagination.el && (targetEl === swiper.pagination.el || swiper.pagination.el.contains(e.target))) {
|
|
if (!e.target.matches(classesToSelector(swiper.params.pagination.bulletClass))) return;
|
|
}
|
|
if (swiper.navigation && swiper.navigation.prevEl && swiper.navigation.nextEl) {
|
|
const prevEls = makeElementsArray(swiper.navigation.prevEl);
|
|
const nextEls = makeElementsArray(swiper.navigation.nextEl);
|
|
if (nextEls.includes(targetEl)) {
|
|
if (!(swiper.isEnd && !swiper.params.loop)) {
|
|
swiper.slideNext();
|
|
}
|
|
if (swiper.isEnd) {
|
|
notify(params.lastSlideMessage);
|
|
} else {
|
|
notify(params.nextSlideMessage);
|
|
}
|
|
}
|
|
if (prevEls.includes(targetEl)) {
|
|
if (!(swiper.isBeginning && !swiper.params.loop)) {
|
|
swiper.slidePrev();
|
|
}
|
|
if (swiper.isBeginning) {
|
|
notify(params.firstSlideMessage);
|
|
} else {
|
|
notify(params.prevSlideMessage);
|
|
}
|
|
}
|
|
}
|
|
if (swiper.pagination && targetEl.matches(classesToSelector(swiper.params.pagination.bulletClass))) {
|
|
targetEl.click();
|
|
}
|
|
}
|
|
function updateNavigation() {
|
|
if (swiper.params.loop || swiper.params.rewind || !swiper.navigation) return;
|
|
const {
|
|
nextEl,
|
|
prevEl
|
|
} = swiper.navigation;
|
|
if (prevEl) {
|
|
if (swiper.isBeginning) {
|
|
disableEl(prevEl);
|
|
makeElNotFocusable(prevEl);
|
|
} else {
|
|
enableEl(prevEl);
|
|
makeElFocusable(prevEl);
|
|
}
|
|
}
|
|
if (nextEl) {
|
|
if (swiper.isEnd) {
|
|
disableEl(nextEl);
|
|
makeElNotFocusable(nextEl);
|
|
} else {
|
|
enableEl(nextEl);
|
|
makeElFocusable(nextEl);
|
|
}
|
|
}
|
|
}
|
|
function hasPagination() {
|
|
return swiper.pagination && swiper.pagination.bullets && swiper.pagination.bullets.length;
|
|
}
|
|
function hasClickablePagination() {
|
|
return hasPagination() && swiper.params.pagination.clickable;
|
|
}
|
|
function updatePagination() {
|
|
const params = swiper.params.a11y;
|
|
if (!hasPagination()) return;
|
|
swiper.pagination.bullets.forEach((bulletEl) => {
|
|
if (swiper.params.pagination.clickable) {
|
|
makeElFocusable(bulletEl);
|
|
if (!swiper.params.pagination.renderBullet) {
|
|
addElRole(bulletEl, "button");
|
|
addElLabel(bulletEl, params.paginationBulletMessage.replace(/\{\{index\}\}/, elementIndex(bulletEl) + 1));
|
|
}
|
|
}
|
|
if (bulletEl.matches(classesToSelector(swiper.params.pagination.bulletActiveClass))) {
|
|
bulletEl.setAttribute("aria-current", "true");
|
|
} else {
|
|
bulletEl.removeAttribute("aria-current");
|
|
}
|
|
});
|
|
}
|
|
const initNavEl = (el, wrapperId, message) => {
|
|
makeElFocusable(el);
|
|
if (el.tagName !== "BUTTON") {
|
|
addElRole(el, "button");
|
|
el.addEventListener("keydown", onEnterOrSpaceKey);
|
|
}
|
|
addElLabel(el, message);
|
|
addElControls(el, wrapperId);
|
|
};
|
|
const handlePointerDown = (e) => {
|
|
if (focusTargetSlideEl && focusTargetSlideEl !== e.target && !focusTargetSlideEl.contains(e.target)) {
|
|
preventFocusHandler = true;
|
|
}
|
|
swiper.a11y.clicked = true;
|
|
};
|
|
const handlePointerUp = () => {
|
|
preventFocusHandler = false;
|
|
requestAnimationFrame(() => {
|
|
requestAnimationFrame(() => {
|
|
if (!swiper.destroyed) {
|
|
swiper.a11y.clicked = false;
|
|
}
|
|
});
|
|
});
|
|
};
|
|
const onVisibilityChange = (e) => {
|
|
visibilityChangedTimestamp = (/* @__PURE__ */ new Date()).getTime();
|
|
};
|
|
const handleFocus = (e) => {
|
|
if (swiper.a11y.clicked || !swiper.params.a11y.scrollOnFocus) return;
|
|
if ((/* @__PURE__ */ new Date()).getTime() - visibilityChangedTimestamp < 100) return;
|
|
const slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);
|
|
if (!slideEl || !swiper.slides.includes(slideEl)) return;
|
|
focusTargetSlideEl = slideEl;
|
|
const isActive = swiper.slides.indexOf(slideEl) === swiper.activeIndex;
|
|
const isVisible = swiper.params.watchSlidesProgress && swiper.visibleSlides && swiper.visibleSlides.includes(slideEl);
|
|
if (isActive || isVisible) return;
|
|
if (e.sourceCapabilities && e.sourceCapabilities.firesTouchEvents) return;
|
|
if (swiper.isHorizontal()) {
|
|
swiper.el.scrollLeft = 0;
|
|
} else {
|
|
swiper.el.scrollTop = 0;
|
|
}
|
|
requestAnimationFrame(() => {
|
|
if (preventFocusHandler) return;
|
|
if (swiper.params.loop) {
|
|
swiper.slideToLoop(parseInt(slideEl.getAttribute("data-swiper-slide-index")), 0);
|
|
} else {
|
|
swiper.slideTo(swiper.slides.indexOf(slideEl), 0);
|
|
}
|
|
preventFocusHandler = false;
|
|
});
|
|
};
|
|
const initSlides = () => {
|
|
const params = swiper.params.a11y;
|
|
if (params.itemRoleDescriptionMessage) {
|
|
addElRoleDescription(swiper.slides, params.itemRoleDescriptionMessage);
|
|
}
|
|
if (params.slideRole) {
|
|
addElRole(swiper.slides, params.slideRole);
|
|
}
|
|
const slidesLength = swiper.slides.length;
|
|
if (params.slideLabelMessage) {
|
|
swiper.slides.forEach((slideEl, index) => {
|
|
const slideIndex = swiper.params.loop ? parseInt(slideEl.getAttribute("data-swiper-slide-index"), 10) : index;
|
|
const ariaLabelMessage = params.slideLabelMessage.replace(/\{\{index\}\}/, slideIndex + 1).replace(/\{\{slidesLength\}\}/, slidesLength);
|
|
addElLabel(slideEl, ariaLabelMessage);
|
|
});
|
|
}
|
|
};
|
|
const init = () => {
|
|
const params = swiper.params.a11y;
|
|
swiper.el.append(liveRegion);
|
|
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);
|
|
}
|
|
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);
|
|
initSlides();
|
|
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));
|
|
}
|
|
if (hasClickablePagination()) {
|
|
const paginationEl = makeElementsArray(swiper.pagination.el);
|
|
paginationEl.forEach((el) => {
|
|
el.addEventListener("keydown", onEnterOrSpaceKey);
|
|
});
|
|
}
|
|
const document2 = getDocument();
|
|
document2.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));
|
|
}
|
|
if (hasClickablePagination()) {
|
|
const paginationEl = makeElementsArray(swiper.pagination.el);
|
|
paginationEl.forEach((el) => {
|
|
el.removeEventListener("keydown", onEnterOrSpaceKey);
|
|
});
|
|
}
|
|
const document2 = getDocument();
|
|
document2.removeEventListener("visibilitychange", onVisibilityChange);
|
|
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();
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/history.mjs
|
|
function History(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on
|
|
} = _ref;
|
|
extendParams({
|
|
history: {
|
|
enabled: false,
|
|
root: "",
|
|
replaceState: false,
|
|
key: "slides",
|
|
keepQuery: false
|
|
}
|
|
});
|
|
let initialized = false;
|
|
let paths = {};
|
|
const slugify = (text) => {
|
|
return text.toString().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
|
|
};
|
|
const getPathValues = (urlOverride) => {
|
|
const window2 = getWindow();
|
|
let location;
|
|
if (urlOverride) {
|
|
location = new URL(urlOverride);
|
|
} else {
|
|
location = window2.location;
|
|
}
|
|
const pathArray = location.pathname.slice(1).split("/").filter((part) => part !== "");
|
|
const total = pathArray.length;
|
|
const key = pathArray[total - 2];
|
|
const value = pathArray[total - 1];
|
|
return {
|
|
key,
|
|
value
|
|
};
|
|
};
|
|
const setHistory = (key, index) => {
|
|
const window2 = getWindow();
|
|
if (!initialized || !swiper.params.history.enabled) return;
|
|
let location;
|
|
if (swiper.params.url) {
|
|
location = new URL(swiper.params.url);
|
|
} else {
|
|
location = window2.location;
|
|
}
|
|
const slide = swiper.virtual && swiper.params.virtual.enabled ? swiper.slidesEl.querySelector(`[data-swiper-slide-index="${index}"]`) : swiper.slides[index];
|
|
let value = slugify(slide.getAttribute("data-history"));
|
|
if (swiper.params.history.root.length > 0) {
|
|
let root = swiper.params.history.root;
|
|
if (root[root.length - 1] === "/") root = root.slice(0, root.length - 1);
|
|
value = `${root}/${key ? `${key}/` : ""}${value}`;
|
|
} else if (!location.pathname.includes(key)) {
|
|
value = `${key ? `${key}/` : ""}${value}`;
|
|
}
|
|
if (swiper.params.history.keepQuery) {
|
|
value += location.search;
|
|
}
|
|
const currentState = window2.history.state;
|
|
if (currentState && currentState.value === value) {
|
|
return;
|
|
}
|
|
if (swiper.params.history.replaceState) {
|
|
window2.history.replaceState({
|
|
value
|
|
}, null, value);
|
|
} else {
|
|
window2.history.pushState({
|
|
value
|
|
}, null, value);
|
|
}
|
|
};
|
|
const scrollToSlide = (speed, value, runCallbacks) => {
|
|
if (value) {
|
|
for (let i = 0, length = swiper.slides.length; i < length; i += 1) {
|
|
const slide = swiper.slides[i];
|
|
const slideHistory = slugify(slide.getAttribute("data-history"));
|
|
if (slideHistory === value) {
|
|
const index = swiper.getSlideIndex(slide);
|
|
swiper.slideTo(index, speed, runCallbacks);
|
|
}
|
|
}
|
|
} else {
|
|
swiper.slideTo(0, speed, runCallbacks);
|
|
}
|
|
};
|
|
const setHistoryPopState = () => {
|
|
paths = getPathValues(swiper.params.url);
|
|
scrollToSlide(swiper.params.speed, paths.value, false);
|
|
};
|
|
const init = () => {
|
|
const window2 = getWindow();
|
|
if (!swiper.params.history) return;
|
|
if (!window2.history || !window2.history.pushState) {
|
|
swiper.params.history.enabled = false;
|
|
swiper.params.hashNavigation.enabled = true;
|
|
return;
|
|
}
|
|
initialized = true;
|
|
paths = getPathValues(swiper.params.url);
|
|
if (!paths.key && !paths.value) {
|
|
if (!swiper.params.history.replaceState) {
|
|
window2.addEventListener("popstate", setHistoryPopState);
|
|
}
|
|
return;
|
|
}
|
|
scrollToSlide(0, paths.value, swiper.params.runCallbacksOnInit);
|
|
if (!swiper.params.history.replaceState) {
|
|
window2.addEventListener("popstate", setHistoryPopState);
|
|
}
|
|
};
|
|
const destroy = () => {
|
|
const window2 = getWindow();
|
|
if (!swiper.params.history.replaceState) {
|
|
window2.removeEventListener("popstate", setHistoryPopState);
|
|
}
|
|
};
|
|
on("init", () => {
|
|
if (swiper.params.history.enabled) {
|
|
init();
|
|
}
|
|
});
|
|
on("destroy", () => {
|
|
if (swiper.params.history.enabled) {
|
|
destroy();
|
|
}
|
|
});
|
|
on("transitionEnd _freeModeNoMomentumRelease", () => {
|
|
if (initialized) {
|
|
setHistory(swiper.params.history.key, swiper.activeIndex);
|
|
}
|
|
});
|
|
on("slideChange", () => {
|
|
if (initialized && swiper.params.cssMode) {
|
|
setHistory(swiper.params.history.key, swiper.activeIndex);
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/hash-navigation.mjs
|
|
function HashNavigation(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
emit,
|
|
on
|
|
} = _ref;
|
|
let initialized = false;
|
|
const document2 = getDocument();
|
|
const window2 = getWindow();
|
|
extendParams({
|
|
hashNavigation: {
|
|
enabled: false,
|
|
replaceState: false,
|
|
watchState: false,
|
|
getSlideIndex(_s, hash) {
|
|
if (swiper.virtual && swiper.params.virtual.enabled) {
|
|
const slideWithHash = swiper.slides.find((slideEl) => slideEl.getAttribute("data-hash") === hash);
|
|
if (!slideWithHash) return 0;
|
|
const index = parseInt(slideWithHash.getAttribute("data-swiper-slide-index"), 10);
|
|
return index;
|
|
}
|
|
return swiper.getSlideIndex(elementChildren(swiper.slidesEl, `.${swiper.params.slideClass}[data-hash="${hash}"], swiper-slide[data-hash="${hash}"]`)[0]);
|
|
}
|
|
}
|
|
});
|
|
const onHashChange = () => {
|
|
emit("hashChange");
|
|
const newHash = document2.location.hash.replace("#", "");
|
|
const activeSlideEl = swiper.virtual && swiper.params.virtual.enabled ? swiper.slidesEl.querySelector(`[data-swiper-slide-index="${swiper.activeIndex}"]`) : swiper.slides[swiper.activeIndex];
|
|
const activeSlideHash = activeSlideEl ? activeSlideEl.getAttribute("data-hash") : "";
|
|
if (newHash !== activeSlideHash) {
|
|
const newIndex = swiper.params.hashNavigation.getSlideIndex(swiper, newHash);
|
|
if (typeof newIndex === "undefined" || Number.isNaN(newIndex)) return;
|
|
swiper.slideTo(newIndex);
|
|
}
|
|
};
|
|
const setHash = () => {
|
|
if (!initialized || !swiper.params.hashNavigation.enabled) return;
|
|
const activeSlideEl = swiper.virtual && swiper.params.virtual.enabled ? swiper.slidesEl.querySelector(`[data-swiper-slide-index="${swiper.activeIndex}"]`) : swiper.slides[swiper.activeIndex];
|
|
const activeSlideHash = activeSlideEl ? activeSlideEl.getAttribute("data-hash") || activeSlideEl.getAttribute("data-history") : "";
|
|
if (swiper.params.hashNavigation.replaceState && window2.history && window2.history.replaceState) {
|
|
window2.history.replaceState(null, null, `#${activeSlideHash}` || "");
|
|
emit("hashSet");
|
|
} else {
|
|
document2.location.hash = activeSlideHash || "";
|
|
emit("hashSet");
|
|
}
|
|
};
|
|
const init = () => {
|
|
if (!swiper.params.hashNavigation.enabled || swiper.params.history && swiper.params.history.enabled) return;
|
|
initialized = true;
|
|
const hash = document2.location.hash.replace("#", "");
|
|
if (hash) {
|
|
const speed = 0;
|
|
const index = swiper.params.hashNavigation.getSlideIndex(swiper, hash);
|
|
swiper.slideTo(index || 0, speed, swiper.params.runCallbacksOnInit, true);
|
|
}
|
|
if (swiper.params.hashNavigation.watchState) {
|
|
window2.addEventListener("hashchange", onHashChange);
|
|
}
|
|
};
|
|
const destroy = () => {
|
|
if (swiper.params.hashNavigation.watchState) {
|
|
window2.removeEventListener("hashchange", onHashChange);
|
|
}
|
|
};
|
|
on("init", () => {
|
|
if (swiper.params.hashNavigation.enabled) {
|
|
init();
|
|
}
|
|
});
|
|
on("destroy", () => {
|
|
if (swiper.params.hashNavigation.enabled) {
|
|
destroy();
|
|
}
|
|
});
|
|
on("transitionEnd _freeModeNoMomentumRelease", () => {
|
|
if (initialized) {
|
|
setHash();
|
|
}
|
|
});
|
|
on("slideChange", () => {
|
|
if (initialized && swiper.params.cssMode) {
|
|
setHash();
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/autoplay.mjs
|
|
function Autoplay(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on,
|
|
emit,
|
|
params
|
|
} = _ref;
|
|
swiper.autoplay = {
|
|
running: false,
|
|
paused: false,
|
|
timeLeft: 0
|
|
};
|
|
extendParams({
|
|
autoplay: {
|
|
enabled: false,
|
|
delay: 3e3,
|
|
waitForTransition: true,
|
|
disableOnInteraction: false,
|
|
stopOnLastSlide: false,
|
|
reverseDirection: false,
|
|
pauseOnMouseEnter: false
|
|
}
|
|
});
|
|
let timeout;
|
|
let raf;
|
|
let autoplayDelayTotal = params && params.autoplay ? params.autoplay.delay : 3e3;
|
|
let autoplayDelayCurrent = params && params.autoplay ? params.autoplay.delay : 3e3;
|
|
let autoplayTimeLeft;
|
|
let autoplayStartTime = (/* @__PURE__ */ 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 - (/* @__PURE__ */ 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 void 0;
|
|
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 = (/* @__PURE__ */ new Date()).getTime();
|
|
requestAnimationFrame(() => {
|
|
run();
|
|
});
|
|
}
|
|
};
|
|
if (delay > 0) {
|
|
clearTimeout(timeout);
|
|
timeout = setTimeout(() => {
|
|
proceed();
|
|
}, delay);
|
|
} else {
|
|
requestAnimationFrame(() => {
|
|
proceed();
|
|
});
|
|
}
|
|
return delay;
|
|
};
|
|
const start = () => {
|
|
autoplayStartTime = (/* @__PURE__ */ 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 - ((/* @__PURE__ */ 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 = (/* @__PURE__ */ 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 document2 = getDocument();
|
|
if (document2.visibilityState === "hidden") {
|
|
pausedByInteraction = true;
|
|
pause(true);
|
|
}
|
|
if (document2.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 document2 = getDocument();
|
|
document2.addEventListener("visibilitychange", onVisibilityChange);
|
|
};
|
|
const detachDocumentEvents = () => {
|
|
const document2 = getDocument();
|
|
document2.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
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/thumbs.mjs
|
|
function Thumb(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on
|
|
} = _ref;
|
|
extendParams({
|
|
thumbs: {
|
|
swiper: null,
|
|
multipleActiveThumbs: true,
|
|
autoScrollOffset: 0,
|
|
slideThumbActiveClass: "swiper-slide-thumb-active",
|
|
thumbsContainerClass: "swiper-thumbs"
|
|
}
|
|
});
|
|
let initialized = false;
|
|
let swiperCreated = false;
|
|
swiper.thumbs = {
|
|
swiper: null
|
|
};
|
|
function onThumbClick() {
|
|
const thumbsSwiper = swiper.thumbs.swiper;
|
|
if (!thumbsSwiper || thumbsSwiper.destroyed) return;
|
|
const clickedIndex = thumbsSwiper.clickedIndex;
|
|
const clickedSlide = thumbsSwiper.clickedSlide;
|
|
if (clickedSlide && clickedSlide.classList.contains(swiper.params.thumbs.slideThumbActiveClass)) return;
|
|
if (typeof clickedIndex === "undefined" || clickedIndex === null) return;
|
|
let slideToIndex;
|
|
if (thumbsSwiper.params.loop) {
|
|
slideToIndex = parseInt(thumbsSwiper.clickedSlide.getAttribute("data-swiper-slide-index"), 10);
|
|
} else {
|
|
slideToIndex = clickedIndex;
|
|
}
|
|
if (swiper.params.loop) {
|
|
swiper.slideToLoop(slideToIndex);
|
|
} else {
|
|
swiper.slideTo(slideToIndex);
|
|
}
|
|
}
|
|
function init() {
|
|
const {
|
|
thumbs: thumbsParams
|
|
} = swiper.params;
|
|
if (initialized) return false;
|
|
initialized = true;
|
|
const SwiperClass = swiper.constructor;
|
|
if (thumbsParams.swiper instanceof SwiperClass) {
|
|
if (thumbsParams.swiper.destroyed) {
|
|
initialized = false;
|
|
return false;
|
|
}
|
|
swiper.thumbs.swiper = thumbsParams.swiper;
|
|
Object.assign(swiper.thumbs.swiper.originalParams, {
|
|
watchSlidesProgress: true,
|
|
slideToClickedSlide: false
|
|
});
|
|
Object.assign(swiper.thumbs.swiper.params, {
|
|
watchSlidesProgress: true,
|
|
slideToClickedSlide: false
|
|
});
|
|
swiper.thumbs.swiper.update();
|
|
} else if (isObject(thumbsParams.swiper)) {
|
|
const thumbsSwiperParams = Object.assign({}, thumbsParams.swiper);
|
|
Object.assign(thumbsSwiperParams, {
|
|
watchSlidesProgress: true,
|
|
slideToClickedSlide: false
|
|
});
|
|
swiper.thumbs.swiper = new SwiperClass(thumbsSwiperParams);
|
|
swiperCreated = true;
|
|
}
|
|
swiper.thumbs.swiper.el.classList.add(swiper.params.thumbs.thumbsContainerClass);
|
|
swiper.thumbs.swiper.on("tap", onThumbClick);
|
|
return true;
|
|
}
|
|
function update(initial) {
|
|
const thumbsSwiper = swiper.thumbs.swiper;
|
|
if (!thumbsSwiper || thumbsSwiper.destroyed) return;
|
|
const slidesPerView = thumbsSwiper.params.slidesPerView === "auto" ? thumbsSwiper.slidesPerViewDynamic() : thumbsSwiper.params.slidesPerView;
|
|
let thumbsToActivate = 1;
|
|
const thumbActiveClass = swiper.params.thumbs.slideThumbActiveClass;
|
|
if (swiper.params.slidesPerView > 1 && !swiper.params.centeredSlides) {
|
|
thumbsToActivate = swiper.params.slidesPerView;
|
|
}
|
|
if (!swiper.params.thumbs.multipleActiveThumbs) {
|
|
thumbsToActivate = 1;
|
|
}
|
|
thumbsToActivate = Math.floor(thumbsToActivate);
|
|
thumbsSwiper.slides.forEach((slideEl) => slideEl.classList.remove(thumbActiveClass));
|
|
if (thumbsSwiper.params.loop || thumbsSwiper.params.virtual && thumbsSwiper.params.virtual.enabled) {
|
|
for (let i = 0; i < thumbsToActivate; i += 1) {
|
|
elementChildren(thumbsSwiper.slidesEl, `[data-swiper-slide-index="${swiper.realIndex + i}"]`).forEach((slideEl) => {
|
|
slideEl.classList.add(thumbActiveClass);
|
|
});
|
|
}
|
|
} else {
|
|
for (let i = 0; i < thumbsToActivate; i += 1) {
|
|
if (thumbsSwiper.slides[swiper.realIndex + i]) {
|
|
thumbsSwiper.slides[swiper.realIndex + i].classList.add(thumbActiveClass);
|
|
}
|
|
}
|
|
}
|
|
const autoScrollOffset = swiper.params.thumbs.autoScrollOffset;
|
|
const useOffset = autoScrollOffset && !thumbsSwiper.params.loop;
|
|
if (swiper.realIndex !== thumbsSwiper.realIndex || useOffset) {
|
|
const currentThumbsIndex = thumbsSwiper.activeIndex;
|
|
let newThumbsIndex;
|
|
let direction;
|
|
if (thumbsSwiper.params.loop) {
|
|
const newThumbsSlide = thumbsSwiper.slides.find((slideEl) => slideEl.getAttribute("data-swiper-slide-index") === `${swiper.realIndex}`);
|
|
newThumbsIndex = thumbsSwiper.slides.indexOf(newThumbsSlide);
|
|
direction = swiper.activeIndex > swiper.previousIndex ? "next" : "prev";
|
|
} else {
|
|
newThumbsIndex = swiper.realIndex;
|
|
direction = newThumbsIndex > swiper.previousIndex ? "next" : "prev";
|
|
}
|
|
if (useOffset) {
|
|
newThumbsIndex += direction === "next" ? autoScrollOffset : -1 * autoScrollOffset;
|
|
}
|
|
if (thumbsSwiper.visibleSlidesIndexes && thumbsSwiper.visibleSlidesIndexes.indexOf(newThumbsIndex) < 0) {
|
|
if (thumbsSwiper.params.centeredSlides) {
|
|
if (newThumbsIndex > currentThumbsIndex) {
|
|
newThumbsIndex = newThumbsIndex - Math.floor(slidesPerView / 2) + 1;
|
|
} else {
|
|
newThumbsIndex = newThumbsIndex + Math.floor(slidesPerView / 2) - 1;
|
|
}
|
|
} else if (newThumbsIndex > currentThumbsIndex && thumbsSwiper.params.slidesPerGroup === 1) ;
|
|
thumbsSwiper.slideTo(newThumbsIndex, initial ? 0 : void 0);
|
|
}
|
|
}
|
|
}
|
|
on("beforeInit", () => {
|
|
const {
|
|
thumbs
|
|
} = swiper.params;
|
|
if (!thumbs || !thumbs.swiper) return;
|
|
if (typeof thumbs.swiper === "string" || thumbs.swiper instanceof HTMLElement) {
|
|
const document2 = getDocument();
|
|
const getThumbsElementAndInit = () => {
|
|
const thumbsElement = typeof thumbs.swiper === "string" ? document2.querySelector(thumbs.swiper) : thumbs.swiper;
|
|
if (thumbsElement && thumbsElement.swiper) {
|
|
thumbs.swiper = thumbsElement.swiper;
|
|
init();
|
|
update(true);
|
|
} else if (thumbsElement) {
|
|
const eventName = `${swiper.params.eventsPrefix}init`;
|
|
const onThumbsSwiper = (e) => {
|
|
thumbs.swiper = e.detail[0];
|
|
thumbsElement.removeEventListener(eventName, onThumbsSwiper);
|
|
init();
|
|
update(true);
|
|
thumbs.swiper.update();
|
|
swiper.update();
|
|
};
|
|
thumbsElement.addEventListener(eventName, onThumbsSwiper);
|
|
}
|
|
return thumbsElement;
|
|
};
|
|
const watchForThumbsToAppear = () => {
|
|
if (swiper.destroyed) return;
|
|
const thumbsElement = getThumbsElementAndInit();
|
|
if (!thumbsElement) {
|
|
requestAnimationFrame(watchForThumbsToAppear);
|
|
}
|
|
};
|
|
requestAnimationFrame(watchForThumbsToAppear);
|
|
} else {
|
|
init();
|
|
update(true);
|
|
}
|
|
});
|
|
on("slideChange update resize observerUpdate", () => {
|
|
update();
|
|
});
|
|
on("setTransition", (_s, duration) => {
|
|
const thumbsSwiper = swiper.thumbs.swiper;
|
|
if (!thumbsSwiper || thumbsSwiper.destroyed) return;
|
|
thumbsSwiper.setTransition(duration);
|
|
});
|
|
on("beforeDestroy", () => {
|
|
const thumbsSwiper = swiper.thumbs.swiper;
|
|
if (!thumbsSwiper || thumbsSwiper.destroyed) return;
|
|
if (swiperCreated) {
|
|
thumbsSwiper.destroy();
|
|
}
|
|
});
|
|
Object.assign(swiper.thumbs, {
|
|
init,
|
|
update
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/free-mode.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;
|
|
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;
|
|
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;
|
|
}
|
|
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 = 1e3 * 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();
|
|
});
|
|
}
|
|
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) {
|
|
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
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/grid.mjs
|
|
function Grid(_ref) {
|
|
let {
|
|
swiper,
|
|
extendParams,
|
|
on
|
|
} = _ref;
|
|
extendParams({
|
|
grid: {
|
|
rows: 1,
|
|
fill: "column"
|
|
}
|
|
});
|
|
let slidesNumberEvenToRows;
|
|
let slidesPerRow;
|
|
let numFullColumns;
|
|
let wasMultiRow;
|
|
const getSpaceBetween = () => {
|
|
let spaceBetween = swiper.params.spaceBetween;
|
|
if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) {
|
|
spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiper.size;
|
|
} else if (typeof spaceBetween === "string") {
|
|
spaceBetween = parseFloat(spaceBetween);
|
|
}
|
|
return spaceBetween;
|
|
};
|
|
const initSlides = (slides) => {
|
|
const {
|
|
slidesPerView
|
|
} = swiper.params;
|
|
const {
|
|
rows,
|
|
fill
|
|
} = swiper.params.grid;
|
|
const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : slides.length;
|
|
numFullColumns = Math.floor(slidesLength / rows);
|
|
if (Math.floor(slidesLength / rows) === slidesLength / rows) {
|
|
slidesNumberEvenToRows = slidesLength;
|
|
} else {
|
|
slidesNumberEvenToRows = Math.ceil(slidesLength / rows) * rows;
|
|
}
|
|
if (slidesPerView !== "auto" && fill === "row") {
|
|
slidesNumberEvenToRows = Math.max(slidesNumberEvenToRows, slidesPerView * rows);
|
|
}
|
|
slidesPerRow = slidesNumberEvenToRows / rows;
|
|
};
|
|
const unsetSlides = () => {
|
|
if (swiper.slides) {
|
|
swiper.slides.forEach((slide) => {
|
|
if (slide.swiperSlideGridSet) {
|
|
slide.style.height = "";
|
|
slide.style[swiper.getDirectionLabel("margin-top")] = "";
|
|
}
|
|
});
|
|
}
|
|
};
|
|
const updateSlide = (i, slide, slides) => {
|
|
const {
|
|
slidesPerGroup
|
|
} = swiper.params;
|
|
const spaceBetween = getSpaceBetween();
|
|
const {
|
|
rows,
|
|
fill
|
|
} = swiper.params.grid;
|
|
const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : slides.length;
|
|
let newSlideOrderIndex;
|
|
let column;
|
|
let row;
|
|
if (fill === "row" && slidesPerGroup > 1) {
|
|
const groupIndex = Math.floor(i / (slidesPerGroup * rows));
|
|
const slideIndexInGroup = i - rows * slidesPerGroup * groupIndex;
|
|
const columnsInGroup = groupIndex === 0 ? slidesPerGroup : Math.min(Math.ceil((slidesLength - groupIndex * rows * slidesPerGroup) / rows), slidesPerGroup);
|
|
row = Math.floor(slideIndexInGroup / columnsInGroup);
|
|
column = slideIndexInGroup - row * columnsInGroup + groupIndex * slidesPerGroup;
|
|
newSlideOrderIndex = column + row * slidesNumberEvenToRows / rows;
|
|
slide.style.order = newSlideOrderIndex;
|
|
} else if (fill === "column") {
|
|
column = Math.floor(i / rows);
|
|
row = i - column * rows;
|
|
if (column > numFullColumns || column === numFullColumns && row === rows - 1) {
|
|
row += 1;
|
|
if (row >= rows) {
|
|
row = 0;
|
|
column += 1;
|
|
}
|
|
}
|
|
} else {
|
|
row = Math.floor(i / slidesPerRow);
|
|
column = i - row * slidesPerRow;
|
|
}
|
|
slide.row = row;
|
|
slide.column = column;
|
|
slide.style.height = `calc((100% - ${(rows - 1) * spaceBetween}px) / ${rows})`;
|
|
slide.style[swiper.getDirectionLabel("margin-top")] = row !== 0 ? spaceBetween && `${spaceBetween}px` : "";
|
|
slide.swiperSlideGridSet = true;
|
|
};
|
|
const updateWrapperSize = (slideSize, snapGrid) => {
|
|
const {
|
|
centeredSlides,
|
|
roundLengths
|
|
} = swiper.params;
|
|
const spaceBetween = getSpaceBetween();
|
|
const {
|
|
rows
|
|
} = swiper.params.grid;
|
|
swiper.virtualSize = (slideSize + spaceBetween) * slidesNumberEvenToRows;
|
|
swiper.virtualSize = Math.ceil(swiper.virtualSize / rows) - spaceBetween;
|
|
if (!swiper.params.cssMode) {
|
|
swiper.wrapperEl.style[swiper.getDirectionLabel("width")] = `${swiper.virtualSize + spaceBetween}px`;
|
|
}
|
|
if (centeredSlides) {
|
|
const newSlidesGrid = [];
|
|
for (let i = 0; i < snapGrid.length; i += 1) {
|
|
let slidesGridItem = snapGrid[i];
|
|
if (roundLengths) slidesGridItem = Math.floor(slidesGridItem);
|
|
if (snapGrid[i] < swiper.virtualSize + snapGrid[0]) newSlidesGrid.push(slidesGridItem);
|
|
}
|
|
snapGrid.splice(0, snapGrid.length);
|
|
snapGrid.push(...newSlidesGrid);
|
|
}
|
|
};
|
|
const onInit = () => {
|
|
wasMultiRow = swiper.params.grid && swiper.params.grid.rows > 1;
|
|
};
|
|
const onUpdate = () => {
|
|
const {
|
|
params,
|
|
el
|
|
} = swiper;
|
|
const isMultiRow = params.grid && params.grid.rows > 1;
|
|
if (wasMultiRow && !isMultiRow) {
|
|
el.classList.remove(`${params.containerModifierClass}grid`, `${params.containerModifierClass}grid-column`);
|
|
numFullColumns = 1;
|
|
swiper.emitContainerClasses();
|
|
} else if (!wasMultiRow && isMultiRow) {
|
|
el.classList.add(`${params.containerModifierClass}grid`);
|
|
if (params.grid.fill === "column") {
|
|
el.classList.add(`${params.containerModifierClass}grid-column`);
|
|
}
|
|
swiper.emitContainerClasses();
|
|
}
|
|
wasMultiRow = isMultiRow;
|
|
};
|
|
on("init", onInit);
|
|
on("update", onUpdate);
|
|
swiper.grid = {
|
|
initSlides,
|
|
unsetSlides,
|
|
updateSlide,
|
|
updateWrapperSize
|
|
};
|
|
}
|
|
|
|
// node_modules/swiper/modules/manipulation.mjs
|
|
function appendSlide(slides) {
|
|
const swiper = this;
|
|
const {
|
|
params,
|
|
slidesEl
|
|
} = swiper;
|
|
if (params.loop) {
|
|
swiper.loopDestroy();
|
|
}
|
|
const appendElement = (slideEl) => {
|
|
if (typeof slideEl === "string") {
|
|
const tempDOM = document.createElement("div");
|
|
tempDOM.innerHTML = slideEl;
|
|
slidesEl.append(tempDOM.children[0]);
|
|
tempDOM.innerHTML = "";
|
|
} else {
|
|
slidesEl.append(slideEl);
|
|
}
|
|
};
|
|
if (typeof slides === "object" && "length" in slides) {
|
|
for (let i = 0; i < slides.length; i += 1) {
|
|
if (slides[i]) appendElement(slides[i]);
|
|
}
|
|
} else {
|
|
appendElement(slides);
|
|
}
|
|
swiper.recalcSlides();
|
|
if (params.loop) {
|
|
swiper.loopCreate();
|
|
}
|
|
if (!params.observer || swiper.isElement) {
|
|
swiper.update();
|
|
}
|
|
}
|
|
function prependSlide(slides) {
|
|
const swiper = this;
|
|
const {
|
|
params,
|
|
activeIndex,
|
|
slidesEl
|
|
} = swiper;
|
|
if (params.loop) {
|
|
swiper.loopDestroy();
|
|
}
|
|
let newActiveIndex = activeIndex + 1;
|
|
const prependElement = (slideEl) => {
|
|
if (typeof slideEl === "string") {
|
|
const tempDOM = document.createElement("div");
|
|
tempDOM.innerHTML = slideEl;
|
|
slidesEl.prepend(tempDOM.children[0]);
|
|
tempDOM.innerHTML = "";
|
|
} else {
|
|
slidesEl.prepend(slideEl);
|
|
}
|
|
};
|
|
if (typeof slides === "object" && "length" in slides) {
|
|
for (let i = 0; i < slides.length; i += 1) {
|
|
if (slides[i]) prependElement(slides[i]);
|
|
}
|
|
newActiveIndex = activeIndex + slides.length;
|
|
} else {
|
|
prependElement(slides);
|
|
}
|
|
swiper.recalcSlides();
|
|
if (params.loop) {
|
|
swiper.loopCreate();
|
|
}
|
|
if (!params.observer || swiper.isElement) {
|
|
swiper.update();
|
|
}
|
|
swiper.slideTo(newActiveIndex, 0, false);
|
|
}
|
|
function addSlide(index, slides) {
|
|
const swiper = this;
|
|
const {
|
|
params,
|
|
activeIndex,
|
|
slidesEl
|
|
} = swiper;
|
|
let activeIndexBuffer = activeIndex;
|
|
if (params.loop) {
|
|
activeIndexBuffer -= swiper.loopedSlides;
|
|
swiper.loopDestroy();
|
|
swiper.recalcSlides();
|
|
}
|
|
const baseLength = swiper.slides.length;
|
|
if (index <= 0) {
|
|
swiper.prependSlide(slides);
|
|
return;
|
|
}
|
|
if (index >= baseLength) {
|
|
swiper.appendSlide(slides);
|
|
return;
|
|
}
|
|
let newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + 1 : activeIndexBuffer;
|
|
const slidesBuffer = [];
|
|
for (let i = baseLength - 1; i >= index; i -= 1) {
|
|
const currentSlide = swiper.slides[i];
|
|
currentSlide.remove();
|
|
slidesBuffer.unshift(currentSlide);
|
|
}
|
|
if (typeof slides === "object" && "length" in slides) {
|
|
for (let i = 0; i < slides.length; i += 1) {
|
|
if (slides[i]) slidesEl.append(slides[i]);
|
|
}
|
|
newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + slides.length : activeIndexBuffer;
|
|
} else {
|
|
slidesEl.append(slides);
|
|
}
|
|
for (let i = 0; i < slidesBuffer.length; i += 1) {
|
|
slidesEl.append(slidesBuffer[i]);
|
|
}
|
|
swiper.recalcSlides();
|
|
if (params.loop) {
|
|
swiper.loopCreate();
|
|
}
|
|
if (!params.observer || swiper.isElement) {
|
|
swiper.update();
|
|
}
|
|
if (params.loop) {
|
|
swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
|
|
} else {
|
|
swiper.slideTo(newActiveIndex, 0, false);
|
|
}
|
|
}
|
|
function removeSlide(slidesIndexes) {
|
|
const swiper = this;
|
|
const {
|
|
params,
|
|
activeIndex
|
|
} = swiper;
|
|
let activeIndexBuffer = activeIndex;
|
|
if (params.loop) {
|
|
activeIndexBuffer -= swiper.loopedSlides;
|
|
swiper.loopDestroy();
|
|
}
|
|
let newActiveIndex = activeIndexBuffer;
|
|
let indexToRemove;
|
|
if (typeof slidesIndexes === "object" && "length" in slidesIndexes) {
|
|
for (let i = 0; i < slidesIndexes.length; i += 1) {
|
|
indexToRemove = slidesIndexes[i];
|
|
if (swiper.slides[indexToRemove]) swiper.slides[indexToRemove].remove();
|
|
if (indexToRemove < newActiveIndex) newActiveIndex -= 1;
|
|
}
|
|
newActiveIndex = Math.max(newActiveIndex, 0);
|
|
} else {
|
|
indexToRemove = slidesIndexes;
|
|
if (swiper.slides[indexToRemove]) swiper.slides[indexToRemove].remove();
|
|
if (indexToRemove < newActiveIndex) newActiveIndex -= 1;
|
|
newActiveIndex = Math.max(newActiveIndex, 0);
|
|
}
|
|
swiper.recalcSlides();
|
|
if (params.loop) {
|
|
swiper.loopCreate();
|
|
}
|
|
if (!params.observer || swiper.isElement) {
|
|
swiper.update();
|
|
}
|
|
if (params.loop) {
|
|
swiper.slideTo(newActiveIndex + swiper.loopedSlides, 0, false);
|
|
} else {
|
|
swiper.slideTo(newActiveIndex, 0, false);
|
|
}
|
|
}
|
|
function removeAllSlides() {
|
|
const swiper = this;
|
|
const slidesIndexes = [];
|
|
for (let i = 0; i < swiper.slides.length; i += 1) {
|
|
slidesIndexes.push(i);
|
|
}
|
|
swiper.removeSlide(slidesIndexes);
|
|
}
|
|
function Manipulation(_ref) {
|
|
let {
|
|
swiper
|
|
} = _ref;
|
|
Object.assign(swiper, {
|
|
appendSlide: appendSlide.bind(swiper),
|
|
prependSlide: prependSlide.bind(swiper),
|
|
addSlide: addSlide.bind(swiper),
|
|
removeSlide: removeSlide.bind(swiper),
|
|
removeAllSlides: removeAllSlides.bind(swiper)
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/shared/effect-init.mjs
|
|
function effectInit(params) {
|
|
const {
|
|
effect,
|
|
swiper,
|
|
on,
|
|
setTranslate,
|
|
setTransition,
|
|
overwriteParams,
|
|
perspective,
|
|
recreateShadows,
|
|
getEffectParams
|
|
} = params;
|
|
on("beforeInit", () => {
|
|
if (swiper.params.effect !== effect) return;
|
|
swiper.classNames.push(`${swiper.params.containerModifierClass}${effect}`);
|
|
if (perspective && perspective()) {
|
|
swiper.classNames.push(`${swiper.params.containerModifierClass}3d`);
|
|
}
|
|
const overwriteParamsResult = overwriteParams ? overwriteParams() : {};
|
|
Object.assign(swiper.params, overwriteParamsResult);
|
|
Object.assign(swiper.originalParams, overwriteParamsResult);
|
|
});
|
|
on("setTranslate", () => {
|
|
if (swiper.params.effect !== effect) return;
|
|
setTranslate();
|
|
});
|
|
on("setTransition", (_s, duration) => {
|
|
if (swiper.params.effect !== effect) return;
|
|
setTransition(duration);
|
|
});
|
|
on("transitionEnd", () => {
|
|
if (swiper.params.effect !== effect) return;
|
|
if (recreateShadows) {
|
|
if (!getEffectParams || !getEffectParams().slideShadows) return;
|
|
swiper.slides.forEach((slideEl) => {
|
|
slideEl.querySelectorAll(".swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left").forEach((shadowEl) => shadowEl.remove());
|
|
});
|
|
recreateShadows();
|
|
}
|
|
});
|
|
let requireUpdateOnVirtual;
|
|
on("virtualUpdate", () => {
|
|
if (swiper.params.effect !== effect) return;
|
|
if (!swiper.slides.length) {
|
|
requireUpdateOnVirtual = true;
|
|
}
|
|
requestAnimationFrame(() => {
|
|
if (requireUpdateOnVirtual && swiper.slides && swiper.slides.length) {
|
|
setTranslate();
|
|
requireUpdateOnVirtual = false;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/shared/effect-target.mjs
|
|
function effectTarget(effectParams, slideEl) {
|
|
const transformEl = getSlideTransformEl(slideEl);
|
|
if (transformEl !== slideEl) {
|
|
transformEl.style.backfaceVisibility = "hidden";
|
|
transformEl.style["-webkit-backface-visibility"] = "hidden";
|
|
}
|
|
return transformEl;
|
|
}
|
|
|
|
// node_modules/swiper/shared/effect-virtual-transition-end.mjs
|
|
function effectVirtualTransitionEnd(_ref) {
|
|
let {
|
|
swiper,
|
|
duration,
|
|
transformElements,
|
|
allSlides
|
|
} = _ref;
|
|
const {
|
|
activeIndex
|
|
} = swiper;
|
|
const getSlide = (el) => {
|
|
if (!el.parentElement) {
|
|
const slide = swiper.slides.find((slideEl) => slideEl.shadowRoot && slideEl.shadowRoot === el.parentNode);
|
|
return slide;
|
|
}
|
|
return el.parentElement;
|
|
};
|
|
if (swiper.params.virtualTranslate && duration !== 0) {
|
|
let eventTriggered = false;
|
|
let transitionEndTarget;
|
|
if (allSlides) {
|
|
transitionEndTarget = transformElements;
|
|
} else {
|
|
transitionEndTarget = transformElements.filter((transformEl) => {
|
|
const el = transformEl.classList.contains("swiper-slide-transform") ? getSlide(transformEl) : transformEl;
|
|
return swiper.getSlideIndex(el) === activeIndex;
|
|
});
|
|
}
|
|
transitionEndTarget.forEach((el) => {
|
|
elementTransitionEnd(el, () => {
|
|
if (eventTriggered) return;
|
|
if (!swiper || swiper.destroyed) return;
|
|
eventTriggered = true;
|
|
swiper.animating = false;
|
|
const evt = new window.CustomEvent("transitionend", {
|
|
bubbles: true,
|
|
cancelable: true
|
|
});
|
|
swiper.wrapperEl.dispatchEvent(evt);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
// node_modules/swiper/modules/effect-fade.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
|
|
})
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/effect-cube.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 = () => {
|
|
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
|
|
})
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/shared/create-shadow.mjs
|
|
function createShadow(suffix, slideEl, side) {
|
|
const shadowClass = `swiper-slide-shadow${side ? `-${side}` : ""}${suffix ? ` swiper-slide-shadow-${suffix}` : ""}`;
|
|
const shadowContainer = getSlideTransformEl(slideEl);
|
|
let shadowEl = shadowContainer.querySelector(`.${shadowClass.split(" ").join(".")}`);
|
|
if (!shadowEl) {
|
|
shadowEl = createElement("div", shadowClass.split(" "));
|
|
shadowContainer.append(shadowEl);
|
|
}
|
|
return shadowEl;
|
|
}
|
|
|
|
// node_modules/swiper/modules/effect-flip.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 = () => {
|
|
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
|
|
})
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/effect-coverflow.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);
|
|
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;
|
|
let translateZ = -translate * Math.abs(offsetMultiplier);
|
|
let stretch = params.stretch;
|
|
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);
|
|
if (Math.abs(translateX) < 1e-3) translateX = 0;
|
|
if (Math.abs(translateY) < 1e-3) translateY = 0;
|
|
if (Math.abs(translateZ) < 1e-3) translateZ = 0;
|
|
if (Math.abs(rotateY) < 1e-3) rotateY = 0;
|
|
if (Math.abs(rotateX) < 1e-3) rotateX = 0;
|
|
if (Math.abs(scale) < 1e-3) 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) {
|
|
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
|
|
})
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/effect-creative.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;
|
|
}
|
|
t.forEach((value, index) => {
|
|
t[index] = `calc(${value}px + (${getTranslateValue(data.translate[index])} * ${Math.abs(progress * multiplier)}))`;
|
|
});
|
|
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}`;
|
|
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
|
|
})
|
|
});
|
|
}
|
|
|
|
// node_modules/swiper/modules/effect-cards.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) {
|
|
tX = `calc(${tX}px ${rtl ? "-" : "+"} (${tXAdd * Math.abs(progress)}%))`;
|
|
} else if (progress > 0) {
|
|
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}`;
|
|
const transform = `
|
|
translate3d(${tX}, ${tY}, ${tZ}px)
|
|
rotateZ(${params.rotate ? rtl ? -rotate : rotate : 0}deg)
|
|
scale(${scaleString})
|
|
`;
|
|
if (params.slideShadows) {
|
|
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 {
|
|
A11y,
|
|
Autoplay,
|
|
Controller,
|
|
EffectCards,
|
|
EffectCoverflow,
|
|
EffectCreative,
|
|
EffectCube,
|
|
EffectFade,
|
|
EffectFlip,
|
|
freeMode as FreeMode,
|
|
Grid,
|
|
HashNavigation,
|
|
History,
|
|
Keyboard,
|
|
Manipulation,
|
|
Mousewheel,
|
|
Navigation,
|
|
Pagination,
|
|
Parallax,
|
|
Scrollbar,
|
|
Thumb as Thumbs,
|
|
Virtual,
|
|
Zoom
|
|
};
|
|
//# sourceMappingURL=swiper_modules.js.map
|