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}">`;
}
}
}
if (params.type === "fraction") {
if (params.renderFraction) {
paginationHTML = params.renderFraction.call(swiper, params.currentClass, params.totalClass);
} else {
paginationHTML = ` / `;
}
}
if (params.type === "progressbar") {
if (params.renderProgressbar) {
paginationHTML = params.renderProgressbar.call(swiper, params.progressbarFillClass);
} else {
paginationHTML = ``;
}
}
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