Python-разработчик
ООО АФЛТ-СистемсМоскваудалённая работаHH.ru
Описание вакансии
О компании:
ООО «АФЛТ-Системс»– официально аккредитованная в Минцифры ИТ-компания, основанная в сентябре 2022 года. Входит в состав Группы компаний «Аэрофлот». Основное направление деятельности– внедрение, проектирование и реализация ключевых инициатив и проектов Группы компаний «Аэрофлот» в области информационных технологий.
Чем предстоит заниматься:
- Доработка существующего функционала микросервисов и монолитиных сервисов сайта ПА «Аэрофлот».
- Разработка нового функционала сервисов сайта ПАО «Аэрофлот» на основе микросервисной архитектуры.
- Разработка и проектирование API.
- Проектирование архитектурных решений для интеграции с внешними сервисами.
- Работа в Agile процессе (стримы и команды) с соблюдением релизного цикла.
- Проведение code review, написание тестов.
Чего мы ожидаем:
- Глубокое знание Python 3.8 - Python 3.12
- Опыт работы с асинхронным web-фреймворком FastAPI.
- Опыт работы с синхронными web-фреймворками.
- Понимание принципов работы асинхронности, asyncio и многопоточности в Python.
- Опыт работы с WSGI и ASGI (Uvicorn и Gunicorn).
- Знания алгоритмов, типов и структур данных, принципов ООП, паттернов проектирования и программирования.
- Знание и опыт использования следующих технологий: ORM, Celery, Kafka, RabbitMQ.
- Опыт работы с реляционными БД (PostgreSQL), нереалиционными БД (MongoDB, InfluxDB, Prometheus), кешевые хранилища (Redis, Memcache).
- Опыт работы с REST API, SOAP API, XML API, WebSockets.
- Умение работать с Legacy-кодом.
- Понимание микросервисной архитектуры.
- Навыки написания тестов.
Будет плюсом:
- Опыт работы с Docker, k8s.
- Опыт работы с DjangoCMS.
- Опыт работы с Go.
Условия:
- Гибридный или полностью удалённый формат работы. Для тех, кто предпочитает офис — в Москве: современное пространство в 5 минутах от м. Новокузнецкая (фитнес-зал, настольный теннис, комната PS 5, регулярные активности для резидентов), в Санкт-Петербурге: коворкинг в 10 минутах от м. Маяковская (PS 5, еженедельные вечеринки).
- Работа в аккредитованной ИТ-компании со всеми предусмотренными государственными льготами, включая ИТ-ипотеку.
- Полностью «белая» заработная плата. Уровень дохода обсуждается индивидуально и зависит от опыта и экспертизы.
- ИТ-отсрочка и бронь от мобилизации как для сотрудников компании с критически важной инфраструктурой.
- Корпоративные льготы на авиабилеты авиакомпаний «Аэрофлот», «Россия» и «Победа» для сотрудника и членов семьи (родители, супруг(а), дети).
- ДМС с первого рабочего дня: стоматология, помощь на дому, плановый и экстренный стационар; возможность подключения семьи на льготных условиях.
- Компенсация питания при работе из офиса.
- Курсы, сертификации, профессиональные конференции.
- Корпоративный сервис благополучия: безлимитные консультации с экспертами по юридическим, психологическим, финансовым вопросам и вопросам здорового образа жизни.
- Корпоративные мероприятия и активности: спорт, киберспорт, мотопробеги и другие форматы внерабочего общения.
- Дополнительно: кафетерий скидок, доступ к корпоративной библиотеке Alpina Digital, билеты на футбольные и баскетбольные матчи.
Работай с комфортом,
как в бизнес-классе
ИТ-аккредитация
Все бенефиты аккредитованной
ИТ-компании
Забота о здоровье
ДМС с первого дня
со стоматологией
и госпитализацией, льготные условия страхования для родственников
Развитие
Оплата обучения
и посещения конференций
Авиапривилегии
Скидки до 90% на покупку
авиабилетов на рейсы «Аэрофлота»,
«России» и «Победы»
Удаленка
и гибрид
Работа из дома
или в комфортных офисах
в Москве и Санкт-Петербурге
Кафетерий льгот
Компенсация питания, библиотека Alpina
Digital, корпоративные спортивные
мероприятия, бесплатные
билеты на футбол и баскетбол
Сервис благополучия
Онлайн-сессии с психологами,
диетологами, фитнес-тренерами,
финансовое консультирование
и юридическая поддержка
window.jqueryMigrateLTROnLoad = function() {try {
jQuery.UNSAFE_restoreLegacyHtmlPrefilter();
;
//
const main = "";
const customTitle = () => {
const allUl = document.querySelectorAll(".tmpl_hh_content ul");
allUl.forEach((ul, i) => {
const ulTitle = ul.previousElementSibling;
if (ulTitle) {
ulTitle.classList.add("tmpl_hh_content_title");
if (i === 0) {
ul.previousElementSibling.classList.add("tmpl_hh_content_title--first");
}
}
});
};
const swiper_min = "";
const effectFade_min = "";
function isObject$1(obj) {
return obj !== null && typeof obj === "object" && "constructor" in obj && obj.constructor === Object;
}
function extend$1(target = {}, src = {}) {
Object.keys(src).forEach((key) => {
if (typeof target[key] === "undefined")
target[key] = src[key];
else if (isObject$1(src[key]) && isObject$1(target[key]) && Object.keys(src[key]).length > 0) {
extend$1(target[key], src[key]);
}
});
}
const ssrDocument = {
body: {},
addEventListener() {
},
removeEventListener() {
},
activeElement: {
blur() {
},
nodeName: ""
},
querySelector() {
return null;
},
querySelectorAll() {
return [];
},
getElementById() {
return null;
},
createEvent() {
return {
initEvent() {
}
};
},
createElement() {
return {
children: [],
childNodes: [],
style: {},
setAttribute() {
},
getElementsByTagName() {
return [];
}
};
},
createElementNS() {
return {};
},
importNode() {
return null;
},
location: {
hash: "",
host: "",
hostname: "",
href: "",
origin: "",
pathname: "",
protocol: "",
search: ""
}
};
function getDocument() {
const doc = typeof document !== "undefined" ? document : {};
extend$1(doc, ssrDocument);
return doc;
}
const ssrWindow = {
document: ssrDocument,
navigator: {
userAgent: ""
},
location: {
hash: "",
host: "",
hostname: "",
href: "",
origin: "",
pathname: "",
protocol: "",
search: ""
},
history: {
replaceState() {
},
pushState() {
},
go() {
},
back() {
}
},
CustomEvent: function CustomEvent() {
return this;
},
addEventListener() {
},
removeEventListener() {
},
getComputedStyle() {
return {
getPropertyValue() {
return "";
}
};
},
Image() {
},
Date() {
},
screen: {},
setTimeout() {
},
clearTimeout() {
},
matchMedia() {
return {};
},
requestAnimationFrame(callback) {
if (typeof setTimeout === "undefined") {
callback();
return null;
}
return setTimeout(callback, 0);
},
cancelAnimationFrame(id) {
if (typeof setTimeout === "undefined") {
return;
}
clearTimeout(id);
}
};
function getWindow() {
const win = typeof window !== "undefined" ? window : {};
extend$1(win, ssrWindow);
return win;
}
function deleteProps(obj) {
const object = obj;
Object.keys(object).forEach((key) => {
try {
object[key] = null;
} catch (e) {
}
try {
delete object[key];
} catch (e) {
}
});
}
function nextTick(callback, delay = 0) {
return setTimeout(callback, delay);
}
function now() {
return Date.now();
}
function getComputedStyle$1(el) {
const window2 = getWindow();
let style;
if (window2.getComputedStyle) {
style = window2.getComputedStyle(el, null);
}
if (!style && el.currentStyle) {
style = el.currentStyle;
}
if (!style) {
style = el.style;
}
return style;
}
function getTranslate(el, axis = "x") {
const window2 = getWindow();
let matrix;
let curTransform;
let transformMatrix;
const curStyle = getComputedStyle$1(el, null);
if (window2.WebKitCSSMatrix) {
curTransform = curStyle.transform || curStyle.webkitTransform;
if (curTransform.split(",").length > 6) {
curTransform = curTransform.split(", ").map((a) => a.replace(",", ".")).join(", ");
}
transformMatrix = new window2.WebKitCSSMatrix(curTransform === "none" ? "" : curTransform);
} else {
transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue("transform").replace("translate(", "matrix(1, 0, 0, 1,");
matrix = transformMatrix.toString().split(",");
}
if (axis === "x") {
if (window2.WebKitCSSMatrix)
curTransform = transformMatrix.m41;
else if (matrix.length === 16)
curTransform = parseFloat(matrix[12]);
else
curTransform = parseFloat(matrix[4]);
}
if (axis === "y") {
if (window2.WebKitCSSMatrix)
curTransform = transformMatrix.m42;
else if (matrix.length === 16)
curTransform = parseFloat(matrix[13]);
else
curTransform = parseFloat(matrix[5]);
}
return curTransform || 0;
}
function isObject(o) {
return typeof o === "object" && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === "Object";
}
function isNode(node) {
if (typeof window !== "undefined" && typeof window.HTMLElement !== "undefined") {
return node instanceof HTMLElement;
}
return node && (node.nodeType === 1 || node.nodeType === 11);
}
function extend(...args) {
const to = Object(args[0]);
const noExtend = ["__proto__", "constructor", "prototype"];
for (let i = 1; i noExtend.indexOf(key) startPosition ? "next" : "prev";
const isOutOfBound = (current, target) => {
return dir === "next" && current >= target || dir === "prev" && current {
time = (/* @__PURE__ */ new Date()).getTime();
if (startTime === null) {
startTime = time;
}
const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;
let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
if (isOutOfBound(currentPosition, targetPosition)) {
currentPosition = targetPosition;
}
swiper.wrapperEl.scrollTo({
[side]: currentPosition
});
if (isOutOfBound(currentPosition, targetPosition)) {
swiper.wrapperEl.style.overflow = "hidden";
swiper.wrapperEl.style.scrollSnapType = "";
setTimeout(() => {
swiper.wrapperEl.style.overflow = "";
swiper.wrapperEl.scrollTo({
[side]: currentPosition
});
});
window2.cancelAnimationFrame(swiper.cssModeFrameID);
return;
}
swiper.cssModeFrameID = window2.requestAnimationFrame(animate);
};
animate();
}
function getSlideTransformEl(slideEl) {
return slideEl.querySelector(".swiper-slide-transform") || slideEl.shadowEl && slideEl.shadowEl.querySelector(".swiper-slide-transform") || slideEl;
}
function findElementsInElements(elements = [], selector = "") {
const found = [];
elements.forEach((el) => {
found.push(...el.querySelectorAll(selector));
});
return found;
}
function elementChildren(element, selector = "") {
return [...element.children].filter((el) => el.matches(selector));
}
function createElement(tag, classes2 = []) {
const el = document.createElement(tag);
el.classList.add(...Array.isArray(classes2) ? classes2 : [classes2]);
return el;
}
function elementOffset(el) {
const window2 = getWindow();
const document2 = getDocument();
const box = el.getBoundingClientRect();
const body = document2.body;
const clientTop = el.clientTop || body.clientTop || 0;
const clientLeft = el.clientLeft || body.clientLeft || 0;
const scrollTop = el === window2 ? window2.scrollY : el.scrollTop;
const scrollLeft = el === window2 ? window2.scrollX : el.scrollLeft;
return {
top: box.top + scrollTop - clientTop,
left: box.left + scrollLeft - clientLeft
};
}
function elementPrevAll(el, selector) {
const prevEls = [];
while (el.previousElementSibling) {
const prev = el.previousElementSibling;
if (selector) {
if (prev.matches(selector))
prevEls.push(prev);
} else
prevEls.push(prev);
el = prev;
}
return prevEls;
}
function elementNextAll(el, selector) {
const nextEls = [];
while (el.nextElementSibling) {
const next = el.nextElementSibling;
if (selector) {
if (next.matches(selector))
nextEls.push(next);
} else
nextEls.push(next);
el = next;
}
return nextEls;
}
function elementStyle(el, prop) {
const window2 = getWindow();
return window2.getComputedStyle(el, null).getPropertyValue(prop);
}
function elementIndex(el) {
let child = el;
let i;
if (child) {
i = 0;
while ((child = child.previousSibling) !== null) {
if (child.nodeType === 1)
i += 1;
}
return i;
}
return void 0;
}
function elementParents(el, selector) {
const parents = [];
let parent = el.parentElement;
while (parent) {
if (selector) {
if (parent.matches(selector))
parents.push(parent);
} else {
parents.push(parent);
}
parent = parent.parentElement;
}
return parents;
}
function elementTransitionEnd(el, callback) {
function fireCallBack(e) {
if (e.target !== el)
return;
callback.call(el, e);
el.removeEventListener("transitionend", fireCallBack);
}
if (callback) {
el.addEventListener("transitionend", fireCallBack);
}
}
function elementOuterSize(el, size, includeMargins) {
const window2 = getWindow();
if (includeMargins) {
return el[size === "width" ? "offsetWidth" : "offsetHeight"] + parseFloat(window2.getComputedStyle(el, null).getPropertyValue(size === "width" ? "margin-right" : "margin-top")) + parseFloat(window2.getComputedStyle(el, null).getPropertyValue(size === "width" ? "margin-left" : "margin-bottom"));
}
return el.offsetWidth;
}
let support;
function calcSupport() {
const window2 = getWindow();
const document2 = getDocument();
return {
smoothScroll: document2.documentElement && document2.documentElement.style && "scrollBehavior" in document2.documentElement.style,
touch: !!("ontouchstart" in window2 || window2.DocumentTouch && document2 instanceof window2.DocumentTouch)
};
}
function getSupport() {
if (!support) {
support = calcSupport();
}
return support;
}
let deviceCached;
function calcDevice({
userAgent
} = {}) {
const support2 = getSupport();
const window2 = getWindow();
const platform = window2.navigator.platform;
const ua = userAgent || window2.navigator.userAgent;
const device = {
ios: false,
android: false
};
const screenWidth = window2.screen.width;
const screenHeight = window2.screen.height;
const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/);
let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
const windows = platform === "Win32";
let macos = platform === "MacIntel";
const iPadScreens = ["1024x1366", "1366x1024", "834x1194", "1194x834", "834x1112", "1112x834", "768x1024", "1024x768", "820x1180", "1180x820", "810x1080", "1080x810"];
if (!ipad && macos && support2.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
ipad = ua.match(/(Version)\/([\d.]+)/);
if (!ipad)
ipad = [0, 1, "13_0_0"];
macos = false;
}
if (android && !windows) {
device.os = "android";
device.android = true;
}
if (ipad || iphone || ipod) {
device.os = "ios";
device.ios = true;
}
return device;
}
function getDevice(overrides = {}) {
if (!deviceCached) {
deviceCached = calcDevice(overrides);
}
return deviceCached;
}
let browser;
function calcBrowser() {
const window2 = getWindow();
let needPerspectiveFix = false;
function isSafari() {
const ua = window2.navigator.userAgent.toLowerCase();
return ua.indexOf("safari") >= 0 && ua.indexOf("chrome") Number(num));
needPerspectiveFix = major {
if (!swiper || swiper.destroyed || !swiper.initialized)
return;
emit("beforeResize");
emit("resize");
};
const createObserver = () => {
if (!swiper || swiper.destroyed || !swiper.initialized)
return;
observer = new ResizeObserver((entries) => {
animationFrame = window2.requestAnimationFrame(() => {
const {
width,
height
} = swiper;
let newWidth = width;
let newHeight = height;
entries.forEach(({
contentBoxSize,
contentRect,
target
}) => {
if (target && target !== swiper.el)
return;
newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
});
if (newWidth !== width || newHeight !== height) {
resizeHandler();
}
});
});
observer.observe(swiper.el);
};
const removeObserver = () => {
if (animationFrame) {
window2.cancelAnimationFrame(animationFrame);
}
if (observer && observer.unobserve && swiper.el) {
observer.unobserve(swiper.el);
observer = null;
}
};
const orientationChangeHandler = () => {
if (!swiper || swiper.destroyed || !swiper.initialized)
return;
emit("orientationchange");
};
on("init", () => {
if (swiper.params.resizeObserver && typeof window2.ResizeObserver !== "undefined") {
createObserver();
return;
}
window2.addEventListener("resize", resizeHandler);
window2.addEventListener("orientationchange", orientationChangeHandler);
});
on("destroy", () => {
removeObserver();
window2.removeEventListener("resize", resizeHandler);
window2.removeEventListener("orientationchange", orientationChangeHandler);
});
}
function Observer({
swiper,
extendParams,
on,
emit
}) {
const observers = [];
const window2 = getWindow();
const attach = (target, options = {}) => {
const ObserverFunc = window2.MutationObserver || window2.WebkitMutationObserver;
const observer = new ObserverFunc((mutations) => {
if (swiper.__preventObserver__)
return;
if (mutations.length === 1) {
emit("observerUpdate", mutations[0]);
return;
}
const observerUpdate = function observerUpdate2() {
emit("observerUpdate", mutations[0]);
};
if (window2.requestAnimationFrame) {
window2.requestAnimationFrame(observerUpdate);
} else {
window2.setTimeout(observerUpdate, 0);
}
});
observer.observe(target, {
attributes: typeof options.attributes === "undefined" ? true : options.attributes,
childList: typeof options.childList === "undefined" ? true : options.childList,
characterData: typeof options.characterData === "undefined" ? true : options.characterData
});
observers.push(observer);
};
const init = () => {
if (!swiper.params.observer)
return;
if (swiper.params.observeParents) {
const containerParents = elementParents(swiper.el);
for (let i = 0; i {
observers.forEach((observer) => {
observer.disconnect();
});
observers.splice(0, observers.length);
};
extendParams({
observer: false,
observeParents: false,
observeSlideChildren: false
});
on("init", init);
on("destroy", destroy);
}
const eventsEmitter = {
on(events2, handler, priority) {
const self = this;
if (!self.eventsListeners || self.destroyed)
return self;
if (typeof handler !== "function")
return self;
const method = priority ? "unshift" : "push";
events2.split(" ").forEach((event2) => {
if (!self.eventsListeners[event2])
self.eventsListeners[event2] = [];
self.eventsListeners[event2][method](handler);
});
return self;
},
once(events2, handler, priority) {
const self = this;
if (!self.eventsListeners || self.destroyed)
return self;
if (typeof handler !== "function")
return self;
function onceHandler(...args) {
self.off(events2, onceHandler);
if (onceHandler.__emitterProxy) {
delete onceHandler.__emitterProxy;
}
handler.apply(self, args);
}
onceHandler.__emitterProxy = handler;
return self.on(events2, onceHandler, priority);
},
onAny(handler, priority) {
const self = this;
if (!self.eventsListeners || self.destroyed)
return self;
if (typeof handler !== "function")
return self;
const method = priority ? "unshift" : "push";
if (self.eventsAnyListeners.indexOf(handler) = 0) {
self.eventsAnyListeners.splice(index, 1);
}
return self;
},
off(events2, handler) {
const self = this;
if (!self.eventsListeners || self.destroyed)
return self;
if (!self.eventsListeners)
return self;
events2.split(" ").forEach((event2) => {
if (typeof handler === "undefined") {
self.eventsListeners[event2] = [];
} else if (self.eventsListeners[event2]) {
self.eventsListeners[event2].forEach((eventHandler, index) => {
if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
self.eventsListeners[event2].splice(index, 1);
}
});
}
});
return self;
},
emit(...args) {
const self = this;
if (!self.eventsListeners || self.destroyed)
return self;
if (!self.eventsListeners)
return self;
let events2;
let data;
let context;
if (typeof args[0] === "string" || Array.isArray(args[0])) {
events2 = args[0];
data = args.slice(1, args.length);
context = self;
} else {
events2 = args[0].events;
data = args[0].data;
context = args[0].context || self;
}
data.unshift(context);
const eventsArray = Array.isArray(events2) ? events2 : events2.split(" ");
eventsArray.forEach((event2) => {
if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
self.eventsAnyListeners.forEach((eventHandler) => {
eventHandler.apply(context, [event2, ...data]);
});
}
if (self.eventsListeners && self.eventsListeners[event2]) {
self.eventsListeners[event2].forEach((eventHandler) => {
eventHandler.apply(context, data);
});
}
});
return self;
}
};
function updateSize() {
const swiper = this;
let width;
let height;
const el = swiper.el;
if (typeof swiper.params.width !== "undefined" && swiper.params.width !== null) {
width = swiper.params.width;
} else {
width = el.clientWidth;
}
if (typeof swiper.params.height !== "undefined" && swiper.params.height !== null) {
height = swiper.params.height;
} else {
height = el.clientHeight;
}
if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
return;
}
width = width - parseInt(elementStyle(el, "padding-left") || 0, 10) - parseInt(elementStyle(el, "padding-right") || 0, 10);
height = height - parseInt(elementStyle(el, "padding-top") || 0, 10) - parseInt(elementStyle(el, "padding-bottom") || 0, 10);
if (Number.isNaN(width))
width = 0;
if (Number.isNaN(height))
height = 0;
Object.assign(swiper, {
width,
height,
size: swiper.isHorizontal() ? width : height
});
}
function updateSlides() {
const swiper = this;
function getDirectionLabel(property) {
if (swiper.isHorizontal()) {
return property;
}
return {
"width": "height",
"margin-top": "margin-left",
"margin-bottom ": "margin-right",
"margin-left": "margin-top",
"margin-right": "margin-bottom",
"padding-left": "padding-top",
"padding-right": "padding-bottom",
"marginRight": "marginBottom"
}[property];
}
function getDirectionPropertyValue(node, label) {
return parseFloat(node.getPropertyValue(getDirectionLabel(label)) || 0);
}
const params = swiper.params;
const {
wrapperEl,
slidesEl,
size: swiperSize,
rtlTranslate: rtl,
wrongRTL
} = swiper;
const isVirtual = swiper.virtual && params.virtual.enabled;
const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
const slides = elementChildren(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);
const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
let snapGrid = [];
const slidesGrid = [];
const slidesSizesGrid = [];
let offsetBefore = params.slidesOffsetBefore;
if (typeof offsetBefore === "function") {
offsetBefore = params.slidesOffsetBefore.call(swiper);
}
let offsetAfter = params.slidesOffsetAfter;
if (typeof offsetAfter === "function") {
offsetAfter = params.slidesOffsetAfter.call(swiper);
}
const previousSnapGridLength = swiper.snapGrid.length;
const previousSlidesGridLength = swiper.slidesGrid.length;
let spaceBetween = params.spaceBetween;
let slidePosition = -offsetBefore;
let prevSlideSize = 0;
let index = 0;
if (typeof swiperSize === "undefined") {
return;
}
if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) {
spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiperSize;
} else if (typeof spaceBetween === "string") {
spaceBetween = parseFloat(spaceBetween);
}
swiper.virtualSize = -spaceBetween;
slides.forEach((slideEl) => {
if (rtl) {
slideEl.style.marginLeft = "";
} else {
slideEl.style.marginRight = "";
}
slideEl.style.marginBottom = "";
slideEl.style.marginTop = "";
});
if (params.centeredSlides && params.cssMode) {
setCSSProperty(wrapperEl, "--swiper-centered-offset-before", "");
setCSSProperty(wrapperEl, "--swiper-centered-offset-after", "");
}
const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
if (gridEnabled) {
swiper.grid.initSlides(slidesLength);
}
let slideSize;
const shouldResetSlideSize = params.slidesPerView === "auto" && params.breakpoints && Object.keys(params.breakpoints).filter((key) => {
return typeof params.breakpoints[key].slidesPerView !== "undefined";
}).length > 0;
for (let i = 0; i 1) {
snapGrid.push(swiper.virtualSize - swiperSize);
}
}
if (isVirtual && params.loop) {
const size = slidesSizesGrid[0] + spaceBetween;
if (params.slidesPerGroup > 1) {
const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
const groupSize = size * params.slidesPerGroup;
for (let i = 0; i {
if (!params.cssMode || params.loop)
return true;
if (slideIndex === slides.length - 1) {
return false;
}
return true;
}).forEach((slideEl) => {
slideEl.style[key] = `${spaceBetween}px`;
});
}
if (params.centeredSlides && params.centeredSlidesBounds) {
let allSlidesSize = 0;
slidesSizesGrid.forEach((slideSizeValue) => {
allSlidesSize += slideSizeValue + (spaceBetween || 0);
});
allSlidesSize -= spaceBetween;
const maxSnap = allSlidesSize - swiperSize;
snapGrid = snapGrid.map((snap) => {
if (snap maxSnap)
return maxSnap + offsetAfter;
return snap;
});
}
if (params.centerInsufficientSlides) {
let allSlidesSize = 0;
slidesSizesGrid.forEach((slideSizeValue) => {
allSlidesSize += slideSizeValue + (spaceBetween || 0);
});
allSlidesSize -= spaceBetween;
if (allSlidesSize {
snapGrid[snapIndex] = snap - allSlidesOffset;
});
slidesGrid.forEach((snap, snapIndex) => {
slidesGrid[snapIndex] = snap + allSlidesOffset;
});
}
}
Object.assign(swiper, {
slides,
snapGrid,
slidesGrid,
slidesSizesGrid
});
if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
setCSSProperty(wrapperEl, "--swiper-centered-offset-before", `${-snapGrid[0]}px`);
setCSSProperty(wrapperEl, "--swiper-centered-offset-after", `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
const addToSnapGrid = -swiper.snapGrid[0];
const addToSlidesGrid = -swiper.slidesGrid[0];
swiper.snapGrid = swiper.snapGrid.map((v) => v + addToSnapGrid);
swiper.slidesGrid = swiper.slidesGrid.map((v) => v + addToSlidesGrid);
}
if (slidesLength !== previousSlidesLength) {
swiper.emit("slidesLengthChange");
}
if (snapGrid.length !== previousSnapGridLength) {
if (swiper.params.watchOverflow)
swiper.checkOverflow();
swiper.emit("snapGridLengthChange");
}
if (slidesGrid.length !== previousSlidesGridLength) {
swiper.emit("slidesGridLengthChange");
}
if (params.watchSlidesProgress) {
swiper.updateSlidesOffset();
}
if (!isVirtual && !params.cssMode && (params.effect === "slide" || params.effect === "fade")) {
const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
if (slidesLength {
if (isVirtual) {
return swiper.slides[swiper.getSlideIndexByData(index)];
}
return swiper.slides[index];
};
if (swiper.params.slidesPerView !== "auto" && swiper.params.slidesPerView > 1) {
if (swiper.params.centeredSlides) {
(swiper.visibleSlides || []).forEach((slide2) => {
activeSlides.push(slide2);
});
} else {
for (i = 0; i swiper.slides.length && !isVirtual)
break;
activeSlides.push(getSlideByIndex(index));
}
}
} else {
activeSlides.push(getSlideByIndex(swiper.activeIndex));
}
for (i = 0; i newHeight ? height : newHeight;
}
}
if (newHeight || newHeight === 0)
swiper.wrapperEl.style.height = `${newHeight}px`;
}
function updateSlidesOffset() {
const swiper = this;
const slides = swiper.slides;
const minusOffset = swiper.isElement ? swiper.isHorizontal() ? swiper.wrapperEl.offsetLeft : swiper.wrapperEl.offsetTop : 0;
for (let i = 0; i {
slideEl.classList.remove(params.slideVisibleClass);
});
swiper.visibleSlidesIndexes = [];
swiper.visibleSlides = [];
let spaceBetween = params.spaceBetween;
if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) {
spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiper.size;
} else if (typeof spaceBetween === "string") {
spaceBetween = parseFloat(spaceBetween);
}
for (let i = 0; i = 0 && slideBefore 1 && slideAfter = swiper.size;
if (isVisible) {
swiper.visibleSlides.push(slide2);
swiper.visibleSlidesIndexes.push(i);
slides[i].classList.add(params.slideVisibleClass);
}
slide2.progress = rtl ? -slideProgress : slideProgress;
slide2.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
}
}
function updateProgress(translate2) {
const swiper = this;
if (typeof translate2 === "undefined") {
const multiplier = swiper.rtlTranslate ? -1 : 1;
translate2 = swiper && swiper.translate && swiper.translate * multiplier || 0;
}
const params = swiper.params;
const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
let {
progress,
isBeginning,
isEnd,
progressLoop
} = swiper;
const wasBeginning = isBeginning;
const wasEnd = isEnd;
if (translatesDiff === 0) {
progress = 0;
isBeginning = true;
isEnd = true;
} else {
progress = (translate2 - swiper.minTranslate()) / translatesDiff;
const isBeginningRounded = Math.abs(translate2 - swiper.minTranslate()) = 1;
if (isBeginningRounded)
progress = 0;
if (isEndRounded)
progress = 1;
}
if (params.loop) {
const firstSlideIndex = swiper.getSlideIndexByData(0);
const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
const translateAbs = Math.abs(translate2);
if (translateAbs >= firstSlideTranslate) {
progressLoop = (translateAbs - firstSlideTranslate) / translateMax;
} else {
progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
}
if (progressLoop > 1)
progressLoop -= 1;
}
Object.assign(swiper, {
progress,
progressLoop,
isBeginning,
isEnd
});
if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight)
swiper.updateSlidesProgress(translate2);
if (isBeginning && !wasBeginning) {
swiper.emit("reachBeginning toEdge");
}
if (isEnd && !wasEnd) {
swiper.emit("reachEnd toEdge");
}
if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
swiper.emit("fromEdge");
}
swiper.emit("progress", progress);
}
function updateSlidesClasses() {
const swiper = this;
const {
slides,
params,
slidesEl,
activeIndex
} = swiper;
const isVirtual = swiper.virtual && params.virtual.enabled;
const getFilteredSlide = (selector) => {
return elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
};
slides.forEach((slideEl) => {
slideEl.classList.remove(params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
});
let activeSlide;
if (isVirtual) {
if (params.loop) {
let slideIndex = activeIndex - swiper.virtual.slidesBefore;
if (slideIndex = swiper.virtual.slides.length)
slideIndex -= swiper.virtual.slides.length;
activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
} else {
activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
}
} else {
activeSlide = slides[activeIndex];
}
if (activeSlide) {
activeSlide.classList.add(params.slideActiveClass);
let nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
if (params.loop && !nextSlide) {
nextSlide = slides[0];
}
if (nextSlide) {
nextSlide.classList.add(params.slideNextClass);
}
let prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
if (params.loop && !prevSlide === 0) {
prevSlide = slides[slides.length - 1];
}
if (prevSlide) {
prevSlide.classList.add(params.slidePrevClass);
}
}
swiper.emitSlidesClasses();
}
const processLazyPreloader = (swiper, imageEl) => {
if (!swiper || swiper.destroyed || !swiper.params)
return;
const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
const slideEl = imageEl.closest(slideSelector());
if (slideEl) {
const lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
if (lazyEl)
lazyEl.remove();
}
};
const unlazy = (swiper, index) => {
if (!swiper.slides[index])
return;
const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
if (imageEl)
imageEl.removeAttribute("loading");
};
const preload = (swiper) => {
if (!swiper || swiper.destroyed || !swiper.params)
return;
let amount = swiper.params.lazyPreloadPrevNext;
const len = swiper.slides.length;
if (!len || !amount || amount 1) {
const activeColumn = activeIndex;
const preloadColumns = [activeColumn - amount];
preloadColumns.push(...Array.from({
length: amount
}).map((_, i) => {
return activeColumn + slidesPerView + i;
}));
swiper.slides.forEach((slideEl, i) => {
if (preloadColumns.includes(slideEl.column))
unlazy(swiper, i);
});
return;
}
const slideIndexLastInView = activeIndex + slidesPerView - 1;
if (swiper.params.rewind || swiper.params.loop) {
for (let i = activeIndex - amount; i slideIndexLastInView)
unlazy(swiper, realIndex);
}
} else {
for (let i = Math.max(activeIndex - amount, 0); i slideIndexLastInView || i = slidesGrid[i] && translate2 = slidesGrid[i] && translate2 = slidesGrid[i]) {
activeIndex = i;
}
}
if (params.normalizeSlideIndex) {
if (activeIndex {
let realIndex2 = aIndex - swiper.virtual.slidesBefore;
if (realIndex2 = swiper.virtual.slides.length) {
realIndex2 -= swiper.virtual.slides.length;
}
return realIndex2;
};
if (typeof activeIndex === "undefined") {
activeIndex = getActiveIndexByTranslate(swiper);
}
if (snapGrid.indexOf(translate2) >= 0) {
snapIndex = snapGrid.indexOf(translate2);
} else {
const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
}
if (snapIndex >= snapGrid.length)
snapIndex = snapGrid.length - 1;
if (activeIndex === previousIndex) {
if (snapIndex !== previousSnapIndex) {
swiper.snapIndex = snapIndex;
swiper.emit("snapIndexChange");
}
if (swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
swiper.realIndex = getVirtualRealIndex(activeIndex);
}
return;
}
let realIndex;
if (swiper.virtual && params.virtual.enabled && params.loop) {
realIndex = getVirtualRealIndex(activeIndex);
} else if (swiper.slides[activeIndex]) {
realIndex = parseInt(swiper.slides[activeIndex].getAttribute("data-swiper-slide-index") || activeIndex, 10);
} else {
realIndex = activeIndex;
}
Object.assign(swiper, {
previousSnapIndex,
snapIndex,
previousRealIndex,
realIndex,
previousIndex,
activeIndex
});
if (swiper.initialized) {
preload(swiper);
}
swiper.emit("activeIndexChange");
swiper.emit("snapIndexChange");
if (previousRealIndex !== realIndex) {
swiper.emit("realIndexChange");
}
if (swiper.initialized || swiper.params.runCallbacksOnInit) {
swiper.emit("slideChange");
}
}
function updateClickedSlide(e) {
const swiper = this;
const params = swiper.params;
const slide2 = e.closest(`.${params.slideClass}, swiper-slide`);
let slideFound = false;
let slideIndex;
if (slide2) {
for (let i = 0; i minTranslate2)
newTranslate = minTranslate2;
else if (translateBounds && translate2 previousIndex)
dir = "next";
else if (activeIndex = snapGrid.length)
snapIndex = snapGrid.length - 1;
const translate2 = -snapGrid[snapIndex];
if (params.normalizeSlideIndex) {
for (let i = 0; i = normalizedGrid && normalizedTranslate = normalizedGrid && normalizedTranslate = normalizedGrid) {
slideIndex = i;
}
}
}
if (swiper.initialized && slideIndex !== activeIndex) {
if (!swiper.allowSlideNext && (rtl ? translate2 > swiper.translate && translate2 > swiper.minTranslate() : translate2 swiper.translate && translate2 > swiper.maxTranslate()) {
if ((activeIndex || 0) !== slideIndex) {
return false;
}
}
}
if (slideIndex !== (previousIndex || 0) && runCallbacks) {
swiper.emit("beforeSlideChangeStart");
}
swiper.updateProgress(translate2);
let direction;
if (slideIndex > activeIndex)
direction = "next";
else if (slideIndex 0) {
swiper._cssModeVirtualInitialSet = true;
requestAnimationFrame(() => {
wrapperEl[isH ? "scrollLeft" : "scrollTop"] = t;
});
} else {
wrapperEl[isH ? "scrollLeft" : "scrollTop"] = t;
}
if (isVirtual) {
requestAnimationFrame(() => {
swiper.wrapperEl.style.scrollSnapType = "";
swiper._immediateVirtual = false;
});
}
} else {
if (!swiper.support.smoothScroll) {
animateCSSModeScroll({
swiper,
targetPosition: t,
side: isH ? "left" : "top"
});
return true;
}
wrapperEl.scrollTo({
[isH ? "left" : "top"]: t,
behavior: "smooth"
});
}
return true;
}
swiper.setTransition(speed);
swiper.setTranslate(translate2);
swiper.updateActiveIndex(slideIndex);
swiper.updateSlidesClasses();
swiper.emit("beforeTransitionStart", speed, internal);
swiper.transitionStart(runCallbacks, direction);
if (speed === 0) {
swiper.transitionEnd(runCallbacks, direction);
} else if (!swiper.animating) {
swiper.animating = true;
if (!swiper.onSlideToWrapperTransitionEnd) {
swiper.onSlideToWrapperTransitionEnd = function transitionEnd2(e) {
if (!swiper || swiper.destroyed)
return;
if (e.target !== this)
return;
swiper.wrapperEl.removeEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
swiper.onSlideToWrapperTransitionEnd = null;
delete swiper.onSlideToWrapperTransitionEnd;
swiper.transitionEnd(runCallbacks, direction);
};
}
swiper.wrapperEl.addEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
}
return true;
}
function slideToLoop(index = 0, speed = this.params.speed, runCallbacks = true, internal) {
if (typeof index === "string") {
const indexAsNumber = parseInt(index, 10);
index = indexAsNumber;
}
const swiper = this;
let newIndex = index;
if (swiper.params.loop) {
if (swiper.virtual && swiper.params.virtual.enabled) {
newIndex = newIndex + swiper.virtual.slidesBefore;
} else {
newIndex = swiper.getSlideIndexByData(newIndex);
}
}
return swiper.slideTo(newIndex, speed, runCallbacks, internal);
}
function slideNext(speed = this.params.speed, runCallbacks = true, internal) {
const swiper = this;
const {
enabled,
params,
animating
} = swiper;
if (!enabled)
return swiper;
let perGroup = params.slidesPerGroup;
if (params.slidesPerView === "auto" && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
perGroup = Math.max(swiper.slidesPerViewDynamic("current", true), 1);
}
const increment = swiper.activeIndex normalize(val));
let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
if (typeof prevSnap === "undefined" && params.cssMode) {
let prevSnapIndex;
snapGrid.forEach((snap, snapIndex) => {
if (normalizedTranslate >= snap) {
prevSnapIndex = snapIndex;
}
});
if (typeof prevSnapIndex !== "undefined") {
prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
}
}
let prevIndex = 0;
if (typeof prevSnap !== "undefined") {
prevIndex = slidesGrid.indexOf(prevSnap);
if (prevIndex = swiper.snapGrid[snapIndex]) {
const currentSnap = swiper.snapGrid[snapIndex];
const nextSnap = swiper.snapGrid[snapIndex + 1];
if (translate2 - currentSnap > (nextSnap - currentSnap) * threshold) {
index += swiper.params.slidesPerGroup;
}
} else {
const prevSnap = swiper.snapGrid[snapIndex - 1];
const currentSnap = swiper.snapGrid[snapIndex];
if (translate2 - prevSnap swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
swiper.loopFix();
slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
nextTick(() => {
swiper.slideTo(slideToIndex);
});
} else {
swiper.slideTo(slideToIndex);
}
} else if (slideToIndex > swiper.slides.length - slidesPerView) {
swiper.loopFix();
slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
nextTick(() => {
swiper.slideTo(slideToIndex);
});
} else {
swiper.slideTo(slideToIndex);
}
} else {
swiper.slideTo(slideToIndex);
}
}
const slide = {
slideTo,
slideToLoop,
slideNext,
slidePrev,
slideReset,
slideToClosest,
slideToClickedSlide
};
function loopCreate(slideRealIndex) {
const swiper = this;
const {
params,
slidesEl
} = swiper;
if (!params.loop || swiper.virtual && swiper.params.virtual.enabled)
return;
const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
slides.forEach((el, index) => {
el.setAttribute("data-swiper-slide-index", index);
});
swiper.loopFix({
slideRealIndex,
direction: params.centeredSlides ? void 0 : "next"
});
}
function loopFix({
slideRealIndex,
slideTo: slideTo2 = true,
direction,
setTranslate: setTranslate2,
activeSlideIndex,
byController,
byMousewheel
} = {}) {
const swiper = this;
if (!swiper.params.loop)
return;
swiper.emit("beforeLoopFix");
const {
slides,
allowSlidePrev,
allowSlideNext,
slidesEl,
params
} = swiper;
swiper.allowSlidePrev = true;
swiper.allowSlideNext = true;
if (swiper.virtual && params.virtual.enabled) {
if (slideTo2) {
if (!params.centeredSlides && swiper.snapIndex === 0) {
swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
} else if (params.centeredSlides && swiper.snapIndex el.classList.contains(params.slideActiveClass))[0]);
} else {
activeIndex = activeSlideIndex;
}
const isNext = direction === "next" || !direction;
const isPrev = direction === "prev" || !direction;
let slidesPrepended = 0;
let slidesAppended = 0;
if (activeSlideIndex swiper.slides.length - loopedSlides * 2) {
slidesAppended = Math.max(activeSlideIndex - (swiper.slides.length - loopedSlides * 2), params.slidesPerGroup);
for (let i = 0; i {
swiper.slides[index].swiperLoopMoveDOM = true;
slidesEl.prepend(swiper.slides[index]);
swiper.slides[index].swiperLoopMoveDOM = false;
});
}
if (isNext) {
appendSlidesIndexes.forEach((index) => {
swiper.slides[index].swiperLoopMoveDOM = true;
slidesEl.append(swiper.slides[index]);
swiper.slides[index].swiperLoopMoveDOM = false;
});
}
swiper.recalcSlides();
if (params.slidesPerView === "auto") {
swiper.updateSlides();
}
if (params.watchSlidesProgress) {
swiper.updateSlidesOffset();
}
if (slideTo2) {
if (prependSlidesIndexes.length > 0 && isPrev) {
if (typeof slideRealIndex === "undefined") {
const currentSlideTranslate = swiper.slidesGrid[activeIndex];
const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
const diff = newSlideTranslate - currentSlideTranslate;
if (byMousewheel) {
swiper.setTranslate(swiper.translate - diff);
} else {
swiper.slideTo(activeIndex + slidesPrepended, 0, false, true);
if (setTranslate2) {
swiper.touches[swiper.isHorizontal() ? "startX" : "startY"] += diff;
}
}
} else {
if (setTranslate2) {
swiper.slideToLoop(slideRealIndex, 0, false, true);
}
}
} else if (appendSlidesIndexes.length > 0 && isNext) {
if (typeof slideRealIndex === "undefined") {
const currentSlideTranslate = swiper.slidesGrid[activeIndex];
const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
const diff = newSlideTranslate - currentSlideTranslate;
if (byMousewheel) {
swiper.setTranslate(swiper.translate - diff);
} else {
swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
if (setTranslate2) {
swiper.touches[swiper.isHorizontal() ? "startX" : "startY"] += diff;
}
}
} else {
swiper.slideToLoop(slideRealIndex, 0, false, true);
}
}
}
swiper.allowSlidePrev = allowSlidePrev;
swiper.allowSlideNext = allowSlideNext;
if (swiper.controller && swiper.controller.control && !byController) {
const loopParams = {
slideRealIndex,
slideTo: false,
direction,
setTranslate: setTranslate2,
activeSlideIndex,
byController: true
};
if (Array.isArray(swiper.controller.control)) {
swiper.controller.control.forEach((c) => {
if (!c.destroyed && c.params.loop)
c.loopFix(loopParams);
});
} else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {
swiper.controller.control.loopFix(loopParams);
}
}
swiper.emit("loopFix");
}
function loopDestroy() {
const swiper = this;
const {
params,
slidesEl
} = swiper;
if (!params.loop || swiper.virtual && swiper.params.virtual.enabled)
return;
swiper.recalcSlides();
const newSlidesOrder = [];
swiper.slides.forEach((slideEl) => {
const index = typeof slideEl.swiperSlideIndex === "undefined" ? slideEl.getAttribute("data-swiper-slide-index") * 1 : slideEl.swiperSlideIndex;
newSlidesOrder[index] = slideEl;
});
swiper.slides.forEach((slideEl) => {
slideEl.removeAttribute("data-swiper-slide-index");
});
newSlidesOrder.forEach((slideEl) => {
slidesEl.append(slideEl);
});
swiper.recalcSlides();
swiper.slideTo(swiper.realIndex, 0);
}
const loop = {
loopCreate,
loopFix,
loopDestroy
};
function setGrabCursor(moving) {
const swiper = this;
if (!swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode)
return;
const el = swiper.params.touchEventsTarget === "container" ? swiper.el : swiper.wrapperEl;
if (swiper.isElement) {
swiper.__preventObserver__ = true;
}
el.style.cursor = "move";
el.style.cursor = moving ? "grabbing" : "grab";
if (swiper.isElement) {
requestAnimationFrame(() => {
swiper.__preventObserver__ = false;
});
}
}
function unsetGrabCursor() {
const swiper = this;
if (swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
return;
}
if (swiper.isElement) {
swiper.__preventObserver__ = true;
}
swiper[swiper.params.touchEventsTarget === "container" ? "el" : "wrapperEl"].style.cursor = "";
if (swiper.isElement) {
requestAnimationFrame(() => {
swiper.__preventObserver__ = false;
});
}
}
const grabCursor = {
setGrabCursor,
unsetGrabCursor
};
function closestElement(selector, base = this) {
function __closestFrom(el) {
if (!el || el === getDocument() || el === getWindow())
return null;
if (el.assignedSlot)
el = el.assignedSlot;
const found = el.closest(selector);
if (!found && !el.getRootNode) {
return null;
}
return found || __closestFrom(el.getRootNode().host);
}
return __closestFrom(base);
}
function onTouchStart(event2) {
const swiper = this;
const document2 = getDocument();
const window2 = getWindow();
const data = swiper.touchEventsData;
data.evCache.push(event2);
const {
params,
touches,
enabled
} = swiper;
if (!enabled)
return;
if (!params.simulateTouch && event2.pointerType === "mouse")
return;
if (swiper.animating && params.preventInteractionOnTransition) {
return;
}
if (!swiper.animating && params.cssMode && params.loop) {
swiper.loopFix();
}
let e = event2;
if (e.originalEvent)
e = e.originalEvent;
let targetEl = e.target;
if (params.touchEventsTarget === "wrapper") {
if (!swiper.wrapperEl.contains(targetEl))
return;
}
if ("which" in e && e.which === 3)
return;
if ("button" in e && e.button > 0)
return;
if (data.isTouched && data.isMoved)
return;
const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== "";
const eventPath = event2.composedPath ? event2.composedPath() : event2.path;
if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
targetEl = eventPath[0];
}
const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
const isTargetShadow = !!(e.target && e.target.shadowRoot);
if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))) {
swiper.allowClick = true;
return;
}
if (params.swipeHandler) {
if (!targetEl.closest(params.swipeHandler))
return;
}
touches.currentX = e.pageX;
touches.currentY = e.pageY;
const startX = touches.currentX;
const startY = touches.currentY;
const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;
const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
if (edgeSwipeDetection && (startX = window2.innerWidth - edgeSwipeThreshold)) {
if (edgeSwipeDetection === "prevent") {
event2.preventDefault();
} else {
return;
}
}
Object.assign(data, {
isTouched: true,
isMoved: false,
allowTouchCallbacks: true,
isScrolling: void 0,
startMoving: void 0
});
touches.startX = startX;
touches.startY = startY;
data.touchStartTime = now();
swiper.allowClick = true;
swiper.updateSize();
swiper.swipeDirection = void 0;
if (params.threshold > 0)
data.allowThresholdMove = false;
let preventDefault = true;
if (targetEl.matches(data.focusableElements)) {
preventDefault = false;
if (targetEl.nodeName === "SELECT") {
data.isTouched = false;
}
}
if (document2.activeElement && document2.activeElement.matches(data.focusableElements) && document2.activeElement !== targetEl) {
document2.activeElement.blur();
}
const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !targetEl.isContentEditable) {
e.preventDefault();
}
if (params.freeMode && params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {
swiper.freeMode.onTouchStart();
}
swiper.emit("touchStart", e);
}
function onTouchMove(event2) {
const document2 = getDocument();
const swiper = this;
const data = swiper.touchEventsData;
const {
params,
touches,
rtlTranslate: rtl,
enabled
} = swiper;
if (!enabled)
return;
if (!params.simulateTouch && event2.pointerType === "mouse")
return;
let e = event2;
if (e.originalEvent)
e = e.originalEvent;
if (!data.isTouched) {
if (data.startMoving && data.isScrolling) {
swiper.emit("touchMoveOpposite", e);
}
return;
}
const pointerIndex = data.evCache.findIndex((cachedEv) => cachedEv.pointerId === e.pointerId);
if (pointerIndex >= 0)
data.evCache[pointerIndex] = e;
const targetTouch = data.evCache.length > 1 ? data.evCache[0] : e;
const pageX = targetTouch.pageX;
const pageY = targetTouch.pageY;
if (e.preventedByNestedSwiper) {
touches.startX = pageX;
touches.startY = pageY;
return;
}
if (!swiper.allowTouchMove) {
if (!e.target.matches(data.focusableElements)) {
swiper.allowClick = false;
}
if (data.isTouched) {
Object.assign(touches, {
startX: pageX,
startY: pageY,
prevX: swiper.touches.currentX,
prevY: swiper.touches.currentY,
currentX: pageX,
currentY: pageY
});
data.touchStartTime = now();
}
return;
}
if (params.touchReleaseOnEdges && !params.loop) {
if (swiper.isVertical()) {
if (pageY touches.startY && swiper.translate >= swiper.minTranslate()) {
data.isTouched = false;
data.isMoved = false;
return;
}
} else if (pageX touches.startX && swiper.translate >= swiper.minTranslate()) {
return;
}
}
if (document2.activeElement) {
if (e.target === document2.activeElement && e.target.matches(data.focusableElements)) {
data.isMoved = true;
swiper.allowClick = false;
return;
}
}
if (data.allowTouchCallbacks) {
swiper.emit("touchMove", e);
}
if (e.targetTouches && e.targetTouches.length > 1)
return;
touches.currentX = pageX;
touches.currentY = pageY;
const diffX = touches.currentX - touches.startX;
const diffY = touches.currentY - touches.startY;
if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) = 25) {
touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;
data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
}
}
}
if (data.isScrolling) {
swiper.emit("touchMoveOpposite", e);
}
if (typeof data.startMoving === "undefined") {
if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
data.startMoving = true;
}
}
if (data.isScrolling || swiper.zoom && swiper.params.zoom && swiper.params.zoom.enabled && data.evCache.length > 1) {
data.isTouched = false;
return;
}
if (!data.startMoving) {
return;
}
swiper.allowClick = false;
if (!params.cssMode && e.cancelable) {
e.preventDefault();
}
if (params.touchMoveStopPropagation && !params.nested) {
e.stopPropagation();
}
let diff = swiper.isHorizontal() ? diffX : diffY;
let touchesDiff = swiper.isHorizontal() ? touches.currentX - touches.previousX : touches.currentY - touches.previousY;
if (params.oneWayMovement) {
diff = Math.abs(diff) * (rtl ? 1 : -1);
touchesDiff = Math.abs(touchesDiff) * (rtl ? 1 : -1);
}
touches.diff = diff;
diff *= params.touchRatio;
if (rtl) {
diff = -diff;
touchesDiff = -touchesDiff;
}
const prevTouchesDirection = swiper.touchesDirection;
swiper.swipeDirection = diff > 0 ? "prev" : "next";
swiper.touchesDirection = touchesDiff > 0 ? "prev" : "next";
const isLoop = swiper.params.loop && !params.cssMode;
if (!data.isMoved) {
if (isLoop) {
swiper.loopFix({
direction: swiper.swipeDirection
});
}
data.startTranslate = swiper.getTranslate();
swiper.setTransition(0);
if (swiper.animating) {
const evt = new window.CustomEvent("transitionend", {
bubbles: true,
cancelable: true
});
swiper.wrapperEl.dispatchEvent(evt);
}
data.allowMomentumBounce = false;
if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
swiper.setGrabCursor(true);
}
swiper.emit("sliderFirstMove", e);
}
let loopFixed;
if (data.isMoved && prevTouchesDirection !== swiper.touchesDirection && isLoop && Math.abs(diff) >= 1) {
swiper.loopFix({
direction: swiper.swipeDirection,
setTranslate: true
});
loopFixed = true;
}
swiper.emit("sliderMove", e);
data.isMoved = true;
data.currentTranslate = diff + data.startTranslate;
let disableParentSwiper = true;
let resistanceRatio = params.resistanceRatio;
if (params.touchReleaseOnEdges) {
resistanceRatio = 0;
}
if (diff > 0) {
if (isLoop && !loopFixed && data.currentTranslate > (params.centeredSlides ? swiper.minTranslate() - swiper.size / 2 : swiper.minTranslate())) {
swiper.loopFix({
direction: "prev",
setTranslate: true,
activeSlideIndex: 0
});
}
if (data.currentTranslate > swiper.minTranslate()) {
disableParentSwiper = false;
if (params.resistance) {
data.currentTranslate = swiper.minTranslate() - 1 + (-swiper.minTranslate() + data.startTranslate + diff) ** resistanceRatio;
}
}
} else if (diff data.startTranslate) {
data.currentTranslate = data.startTranslate;
}
if (!swiper.allowSlidePrev && !swiper.allowSlideNext) {
data.currentTranslate = data.startTranslate;
}
if (params.threshold > 0) {
if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {
if (!data.allowThresholdMove) {
data.allowThresholdMove = true;
touches.startX = touches.currentX;
touches.startY = touches.currentY;
data.currentTranslate = data.startTranslate;
touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;
return;
}
} else {
data.currentTranslate = data.startTranslate;
return;
}
}
if (!params.followFinger || params.cssMode)
return;
if (params.freeMode && params.freeMode.enabled && swiper.freeMode || params.watchSlidesProgress) {
swiper.updateActiveIndex();
swiper.updateSlidesClasses();
}
if (params.freeMode && params.freeMode.enabled && swiper.freeMode) {
swiper.freeMode.onTouchMove();
}
swiper.updateProgress(data.currentTranslate);
swiper.setTranslate(data.currentTranslate);
}
function onTouchEnd(event2) {
const swiper = this;
const data = swiper.touchEventsData;
const pointerIndex = data.evCache.findIndex((cachedEv) => cachedEv.pointerId === event2.pointerId);
if (pointerIndex >= 0) {
data.evCache.splice(pointerIndex, 1);
}
if (["pointercancel", "pointerout", "pointerleave"].includes(event2.type)) {
const proceed = event2.type === "pointercancel" && (swiper.browser.isSafari || swiper.browser.isWebView);
if (!proceed) {
return;
}
}
const {
params,
touches,
rtlTranslate: rtl,
slidesGrid,
enabled
} = swiper;
if (!enabled)
return;
if (!params.simulateTouch && event2.pointerType === "mouse")
return;
let e = event2;
if (e.originalEvent)
e = e.originalEvent;
if (data.allowTouchCallbacks) {
swiper.emit("touchEnd", e);
}
data.allowTouchCallbacks = false;
if (!data.isTouched) {
if (data.isMoved && params.grabCursor) {
swiper.setGrabCursor(false);
}
data.isMoved = false;
data.startMoving = false;
return;
}
if (params.grabCursor && data.isMoved && data.isTouched && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
swiper.setGrabCursor(false);
}
const touchEndTime = now();
const timeDiff = touchEndTime - data.touchStartTime;
if (swiper.allowClick) {
const pathTree = e.path || e.composedPath && e.composedPath();
swiper.updateClickedSlide(pathTree && pathTree[0] || e.target);
swiper.emit("tap click", e);
if (timeDiff {
if (!swiper.destroyed)
swiper.allowClick = true;
});
if (!data.isTouched || !data.isMoved || !swiper.swipeDirection || touches.diff === 0 || data.currentTranslate === data.startTranslate) {
data.isTouched = false;
data.isMoved = false;
data.startMoving = false;
return;
}
data.isTouched = false;
data.isMoved = false;
data.startMoving = false;
let currentPos;
if (params.followFinger) {
currentPos = rtl ? swiper.translate : -swiper.translate;
} else {
currentPos = -data.currentTranslate;
}
if (params.cssMode) {
return;
}
if (params.freeMode && params.freeMode.enabled) {
swiper.freeMode.onTouchEnd({
currentPos
});
return;
}
let stopIndex = 0;
let groupSize = swiper.slidesSizesGrid[0];
for (let i = 0; i = slidesGrid[i] && currentPos = slidesGrid[i]) {
stopIndex = i;
groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];
}
}
let rewindFirstIndex = null;
let rewindLastIndex = null;
if (params.rewind) {
if (swiper.isBeginning) {
rewindLastIndex = params.virtual && params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
} else if (swiper.isEnd) {
rewindFirstIndex = 0;
}
}
const ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;
const increment = stopIndex params.longSwipesMs) {
if (!params.longSwipes) {
swiper.slideTo(swiper.activeIndex);
return;
}
if (swiper.swipeDirection === "next") {
if (ratio >= params.longSwipesRatio)
swiper.slideTo(params.rewind && swiper.isEnd ? rewindFirstIndex : stopIndex + increment);
else
swiper.slideTo(stopIndex);
}
if (swiper.swipeDirection === "prev") {
if (ratio > 1 - params.longSwipesRatio) {
swiper.slideTo(stopIndex + increment);
} else if (rewindLastIndex !== null && ratio params.longSwipesRatio) {
swiper.slideTo(rewindLastIndex);
} else {
swiper.slideTo(stopIndex);
}
}
} else {
if (!params.shortSwipes) {
swiper.slideTo(swiper.activeIndex);
return;
}
const isNavButtonTarget = swiper.navigation && (e.target === swiper.navigation.nextEl || e.target === swiper.navigation.prevEl);
if (!isNavButtonTarget) {
if (swiper.swipeDirection === "next") {
swiper.slideTo(rewindFirstIndex !== null ? rewindFirstIndex : stopIndex + increment);
}
if (swiper.swipeDirection === "prev") {
swiper.slideTo(rewindLastIndex !== null ? rewindLastIndex : stopIndex);
}
} else if (e.target === swiper.navigation.nextEl) {
swiper.slideTo(stopIndex + increment);
} else {
swiper.slideTo(stopIndex);
}
}
}
function onResize() {
const swiper = this;
const {
params,
el
} = swiper;
if (el && el.offsetWidth === 0)
return;
if (params.breakpoints) {
swiper.setBreakpoint();
}
const {
allowSlideNext,
allowSlidePrev,
snapGrid
} = swiper;
const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
swiper.allowSlideNext = true;
swiper.allowSlidePrev = true;
swiper.updateSize();
swiper.updateSlides();
swiper.updateSlidesClasses();
const isVirtualLoop = isVirtual && params.loop;
if ((params.slidesPerView === "auto" || params.slidesPerView > 1) && swiper.isEnd && !swiper.isBeginning && !swiper.params.centeredSlides && !isVirtualLoop) {
swiper.slideTo(swiper.slides.length - 1, 0, false, true);
} else {
if (swiper.params.loop && !isVirtual) {
swiper.slideToLoop(swiper.realIndex, 0, false, true);
} else {
swiper.slideTo(swiper.activeIndex, 0, false, true);
}
}
if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
clearTimeout(swiper.autoplay.resizeTimeout);
swiper.autoplay.resizeTimeout = setTimeout(() => {
if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
swiper.autoplay.resume();
}
}, 500);
}
swiper.allowSlidePrev = allowSlidePrev;
swiper.allowSlideNext = allowSlideNext;
if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) {
swiper.checkOverflow();
}
}
function onClick(e) {
const swiper = this;
if (!swiper.enabled)
return;
if (!swiper.allowClick) {
if (swiper.params.preventClicks)
e.preventDefault();
if (swiper.params.preventClicksPropagation && swiper.animating) {
e.stopPropagation();
e.stopImmediatePropagation();
}
}
}
function onScroll() {
const swiper = this;
const {
wrapperEl,
rtlTranslate,
enabled
} = swiper;
if (!enabled)
return;
swiper.previousTranslate = swiper.translate;
if (swiper.isHorizontal()) {
swiper.translate = -wrapperEl.scrollLeft;
} else {
swiper.translate = -wrapperEl.scrollTop;
}
if (swiper.translate === 0)
swiper.translate = 0;
swiper.updateActiveIndex();
swiper.updateSlidesClasses();
let newProgress;
const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
if (translatesDiff === 0) {
newProgress = 0;
} else {
newProgress = (swiper.translate - swiper.minTranslate()) / translatesDiff;
}
if (newProgress !== swiper.progress) {
swiper.updateProgress(rtlTranslate ? -swiper.translate : swiper.translate);
}
swiper.emit("setTranslate", swiper.translate, false);
}
function onLoad(e) {
const swiper = this;
processLazyPreloader(swiper, e.target);
if (swiper.params.cssMode || swiper.params.slidesPerView !== "auto" && !swiper.params.autoHeight) {
return;
}
swiper.update();
}
let dummyEventAttached = false;
function dummyEventListener() {
}
const events = (swiper, method) => {
const document2 = getDocument();
const {
params,
el,
wrapperEl,
device
} = swiper;
const capture = !!params.nested;
const domMethod = method === "on" ? "addEventListener" : "removeEventListener";
const swiperMethod = method;
el[domMethod]("pointerdown", swiper.onTouchStart, {
passive: false
});
document2[domMethod]("pointermove", swiper.onTouchMove, {
passive: false,
capture
});
document2[domMethod]("pointerup", swiper.onTouchEnd, {
passive: true
});
document2[domMethod]("pointercancel", swiper.onTouchEnd, {
passive: true
});
document2[domMethod]("pointerout", swiper.onTouchEnd, {
passive: true
});
document2[domMethod]("pointerleave", swiper.onTouchEnd, {
passive: true
});
if (params.preventClicks || params.preventClicksPropagation) {
el[domMethod]("click", swiper.onClick, true);
}
if (params.cssMode) {
wrapperEl[domMethod]("scroll", swiper.onScroll);
}
if (params.updateOnWindowResize) {
swiper[swiperMethod](device.ios || device.android ? "resize orientationchange observerUpdate" : "resize observerUpdate", onResize, true);
} else {
swiper[swiperMethod]("observerUpdate", onResize, true);
}
el[domMethod]("load", swiper.onLoad, {
capture: true
});
};
function attachEvents() {
const swiper = this;
const document2 = getDocument();
const {
params
} = swiper;
swiper.onTouchStart = onTouchStart.bind(swiper);
swiper.onTouchMove = onTouchMove.bind(swiper);
swiper.onTouchEnd = onTouchEnd.bind(swiper);
if (params.cssMode) {
swiper.onScroll = onScroll.bind(swiper);
}
swiper.onClick = onClick.bind(swiper);
swiper.onLoad = onLoad.bind(swiper);
if (!dummyEventAttached) {
document2.addEventListener("touchstart", dummyEventListener);
dummyEventAttached = true;
}
events(swiper, "on");
}
function detachEvents() {
const swiper = this;
events(swiper, "off");
}
const events$1 = {
attachEvents,
detachEvents
};
const isGridEnabled = (swiper, params) => {
return swiper.grid && params.grid && params.grid.rows > 1;
};
function setBreakpoint() {
const swiper = this;
const {
realIndex,
initialized,
params,
el
} = swiper;
const breakpoints2 = params.breakpoints;
if (!breakpoints2 || breakpoints2 && Object.keys(breakpoints2).length === 0)
return;
const breakpoint = swiper.getBreakpoint(breakpoints2, swiper.params.breakpointsBase, swiper.el);
if (!breakpoint || swiper.currentBreakpoint === breakpoint)
return;
const breakpointOnlyParams = breakpoint in breakpoints2 ? breakpoints2[breakpoint] : void 0;
const breakpointParams = breakpointOnlyParams || swiper.originalParams;
const wasMultiRow = isGridEnabled(swiper, params);
const isMultiRow = isGridEnabled(swiper, breakpointParams);
const wasEnabled = params.enabled;
if (wasMultiRow && !isMultiRow) {
el.classList.remove(`${params.containerModifierClass}grid`, `${params.containerModifierClass}grid-column`);
swiper.emitContainerClasses();
} else if (!wasMultiRow && isMultiRow) {
el.classList.add(`${params.containerModifierClass}grid`);
if (breakpointParams.grid.fill && breakpointParams.grid.fill === "column" || !breakpointParams.grid.fill && params.grid.fill === "column") {
el.classList.add(`${params.containerModifierClass}grid-column`);
}
swiper.emitContainerClasses();
}
["navigation", "pagination", "scrollbar"].forEach((prop) => {
if (typeof breakpointParams[prop] === "undefined")
return;
const wasModuleEnabled = params[prop] && params[prop].enabled;
const isModuleEnabled = breakpointParams[prop] && breakpointParams[prop].enabled;
if (wasModuleEnabled && !isModuleEnabled) {
swiper[prop].disable();
}
if (!wasModuleEnabled && isModuleEnabled) {
swiper[prop].enable();
}
});
const directionChanged = breakpointParams.direction && breakpointParams.direction !== params.direction;
const needsReLoop = params.loop && (breakpointParams.slidesPerView !== params.slidesPerView || directionChanged);
if (directionChanged && initialized) {
swiper.changeDirection();
}
extend(swiper.params, breakpointParams);
const isEnabled = swiper.params.enabled;
Object.assign(swiper, {
allowTouchMove: swiper.params.allowTouchMove,
allowSlideNext: swiper.params.allowSlideNext,
allowSlidePrev: swiper.params.allowSlidePrev
});
if (wasEnabled && !isEnabled) {
swiper.disable();
} else if (!wasEnabled && isEnabled) {
swiper.enable();
}
swiper.currentBreakpoint = breakpoint;
swiper.emit("_beforeBreakpoint", breakpointParams);
if (needsReLoop && initialized) {
swiper.loopDestroy();
swiper.loopCreate(realIndex);
swiper.updateSlides();
}
swiper.emit("breakpoint", breakpointParams);
}
function getBreakpoint(breakpoints2, base = "window", containerEl) {
if (!breakpoints2 || base === "container" && !containerEl)
return void 0;
let breakpoint = false;
const window2 = getWindow();
const currentHeight = base === "window" ? window2.innerHeight : containerEl.clientHeight;
const points = Object.keys(breakpoints2).map((point) => {
if (typeof point === "string" && point.indexOf("@") === 0) {
const minRatio = parseFloat(point.substr(1));
const value = currentHeight * minRatio;
return {
value,
point
};
}
return {
value: point,
point
};
});
points.sort((a, b) => parseInt(a.value, 10) - parseInt(b.value, 10));
for (let i = 0; i {
if (typeof item === "object") {
Object.keys(item).forEach((classNames) => {
if (item[classNames]) {
resultClasses.push(prefix + classNames);
}
});
} else if (typeof item === "string") {
resultClasses.push(prefix + item);
}
});
return resultClasses;
}
function addClasses() {
const swiper = this;
const {
classNames,
params,
rtl,
el,
device
} = swiper;
const suffixes = prepareClasses(["initialized", params.direction, {
"free-mode": swiper.params.freeMode && params.freeMode.enabled
}, {
"autoheight": params.autoHeight
}, {
"rtl": rtl
}, {
"grid": params.grid && params.grid.rows > 1
}, {
"grid-column": params.grid && params.grid.rows > 1 && params.grid.fill === "column"
}, {
"android": device.android
}, {
"ios": device.ios
}, {
"css-mode": params.cssMode
}, {
"centered": params.cssMode && params.centeredSlides
}, {
"watch-progress": params.watchSlidesProgress
}], params.containerModifierClass);
classNames.push(...suffixes);
el.classList.add(...classNames);
swiper.emitContainerClasses();
}
function removeClasses() {
const swiper = this;
const {
el,
classNames
} = swiper;
el.classList.remove(...classNames);
swiper.emitContainerClasses();
}
const classes = {
addClasses,
removeClasses
};
function checkOverflow() {
const swiper = this;
const {
isLocked: wasLocked,
params
} = swiper;
const {
slidesOffsetBefore
} = params;
if (slidesOffsetBefore) {
const lastSlideIndex = swiper.slides.length - 1;
const lastSlideRightEdge = swiper.slidesGrid[lastSlideIndex] + swiper.slidesSizesGrid[lastSlideIndex] + slidesOffsetBefore * 2;
swiper.isLocked = swiper.size > lastSlideRightEdge;
} else {
swiper.isLocked = swiper.snapGrid.length === 1;
}
if (params.allowSlideNext === true) {
swiper.allowSlideNext = !swiper.isLocked;
}
if (params.allowSlidePrev === true) {
swiper.allowSlidePrev = !swiper.isLocked;
}
if (wasLocked && wasLocked !== swiper.isLocked) {
swiper.isEnd = false;
}
if (wasLocked !== swiper.isLocked) {
swiper.emit(swiper.isLocked ? "lock" : "unlock");
}
}
const checkOverflow$1 = {
checkOverflow
};
const defaults = {
init: true,
direction: "horizontal",
oneWayMovement: false,
touchEventsTarget: "wrapper",
initialSlide: 0,
speed: 300,
cssMode: false,
updateOnWindowResize: true,
resizeObserver: true,
nested: false,
createElements: false,
enabled: true,
focusableElements: "input, select, option, textarea, button, video, label",
// Overrides
width: null,
height: null,
//
preventInteractionOnTransition: false,
// ssr
userAgent: null,
url: null,
// To support iOS's swipe-to-go-back gesture (when being used in-app).
edgeSwipeDetection: false,
edgeSwipeThreshold: 20,
// Autoheight
autoHeight: false,
// Set wrapper width
setWrapperSize: false,
// Virtual Translate
virtualTranslate: false,
// Effects
effect: "slide",
// 'slide' or 'fade' or 'cube' or 'coverflow' or 'flip'
// Breakpoints
breakpoints: void 0,
breakpointsBase: "window",
// Slides grid
spaceBetween: 0,
slidesPerView: 1,
slidesPerGroup: 1,
slidesPerGroupSkip: 0,
slidesPerGroupAuto: false,
centeredSlides: false,
centeredSlidesBounds: false,
slidesOffsetBefore: 0,
// in px
slidesOffsetAfter: 0,
// in px
normalizeSlideIndex: true,
centerInsufficientSlides: false,
// Disable swiper and hide navigation when container not overflow
watchOverflow: true,
// Round length
roundLengths: false,
// Touches
touchRatio: 1,
touchAngle: 45,
simulateTouch: true,
shortSwipes: true,
longSwipes: true,
longSwipesRatio: 0.5,
longSwipesMs: 300,
followFinger: true,
allowTouchMove: true,
threshold: 5,
touchMoveStopPropagation: false,
touchStartPreventDefault: true,
touchStartForcePreventDefault: false,
touchReleaseOnEdges: false,
// Unique Navigation Elements
uniqueNavElements: true,
// Resistance
resistance: true,
resistanceRatio: 0.85,
// Progress
watchSlidesProgress: false,
// Cursor
grabCursor: false,
// Clicks
preventClicks: true,
preventClicksPropagation: true,
slideToClickedSlide: false,
// loop
loop: false,
loopedSlides: null,
loopPreventsSliding: true,
// rewind
rewind: false,
// Swiping/no swiping
allowSlidePrev: true,
allowSlideNext: true,
swipeHandler: null,
// '.swipe-handler',
noSwiping: true,
noSwipingClass: "swiper-no-swiping",
noSwipingSelector: null,
// Passive Listeners
passiveListeners: true,
maxBackfaceHiddenSlides: 10,
// NS
containerModifierClass: "swiper-",
// NEW
slideClass: "swiper-slide",
slideActiveClass: "swiper-slide-active",
slideVisibleClass: "swiper-slide-visible",
slideNextClass: "swiper-slide-next",
slidePrevClass: "swiper-slide-prev",
wrapperClass: "swiper-wrapper",
lazyPreloaderClass: "swiper-lazy-preloader",
lazyPreloadPrevNext: 0,
// Callbacks
runCallbacksOnInit: true,
// Internals
_emitClasses: false
};
function moduleExtendParams(params, allModulesParams) {
return function extendParams(obj = {}) {
const moduleParamName = Object.keys(obj)[0];
const moduleParams = obj[moduleParamName];
if (typeof moduleParams !== "object" || moduleParams === null) {
extend(allModulesParams, obj);
return;
}
if (["navigation", "pagination", "scrollbar"].indexOf(moduleParamName) >= 0 && params[moduleParamName] === true) {
params[moduleParamName] = {
auto: true
};
}
if (!(moduleParamName in params && "enabled" in moduleParams)) {
extend(allModulesParams, obj);
return;
}
if (params[moduleParamName] === true) {
params[moduleParamName] = {
enabled: true
};
}
if (typeof params[moduleParamName] === "object" && !("enabled" in params[moduleParamName])) {
params[moduleParamName].enabled = true;
}
if (!params[moduleParamName])
params[moduleParamName] = {
enabled: false
};
extend(allModulesParams, obj);
};
}
const prototypes = {
eventsEmitter,
update,
translate,
transition,
slide,
loop,
grabCursor,
events: events$1,
breakpoints,
checkOverflow: checkOverflow$1,
classes
};
const extendedDefaults = {};
class Swiper {
constructor(...args) {
let el;
let params;
if (args.length === 1 && args[0].constructor && Object.prototype.toString.call(args[0]).slice(8, -1) === "Object") {
params = args[0];
} else {
[el, params] = args;
}
if (!params)
params = {};
params = extend({}, params);
if (el && !params.el)
params.el = el;
const document2 = getDocument();
if (params.el && typeof params.el === "string" && document2.querySelectorAll(params.el).length > 1) {
const swipers = [];
document2.querySelectorAll(params.el).forEach((containerEl) => {
const newParams = extend({}, params, {
el: containerEl
});
swipers.push(new Swiper(newParams));
});
return swipers;
}
const swiper = this;
swiper.__swiper__ = true;
swiper.support = getSupport();
swiper.device = getDevice({
userAgent: params.userAgent
});
swiper.browser = getBrowser();
swiper.eventsListeners = {};
swiper.eventsAnyListeners = [];
swiper.modules = [...swiper.__modules__];
if (params.modules && Array.isArray(params.modules)) {
swiper.modules.push(...params.modules);
}
const allModulesParams = {};
swiper.modules.forEach((mod) => {
mod({
params,
swiper,
extendParams: moduleExtendParams(params, allModulesParams),
on: swiper.on.bind(swiper),
once: swiper.once.bind(swiper),
off: swiper.off.bind(swiper),
emit: swiper.emit.bind(swiper)
});
});
const swiperParams = extend({}, defaults, allModulesParams);
swiper.params = extend({}, swiperParams, extendedDefaults, params);
swiper.originalParams = extend({}, swiper.params);
swiper.passedParams = extend({}, params);
if (swiper.params && swiper.params.on) {
Object.keys(swiper.params.on).forEach((eventName) => {
swiper.on(eventName, swiper.params.on[eventName]);
});
}
if (swiper.params && swiper.params.onAny) {
swiper.onAny(swiper.params.onAny);
}
Object.assign(swiper, {
enabled: swiper.params.enabled,
el,
// Classes
classNames: [],
// Slides
slides: [],
slidesGrid: [],
snapGrid: [],
slidesSizesGrid: [],
// isDirection
isHorizontal() {
return swiper.params.direction === "horizontal";
},
isVertical() {
return swiper.params.direction === "vertical";
},
// Indexes
activeIndex: 0,
realIndex: 0,
//
isBeginning: true,
isEnd: false,
// Props
translate: 0,
previousTranslate: 0,
progress: 0,
velocity: 0,
animating: false,
cssOverflowAdjustment() {
return Math.trunc(this.translate / 2 ** 23) * 2 ** 23;
},
// Locks
allowSlideNext: swiper.params.allowSlideNext,
allowSlidePrev: swiper.params.allowSlidePrev,
// Touch Events
touchEventsData: {
isTouched: void 0,
isMoved: void 0,
allowTouchCallbacks: void 0,
touchStartTime: void 0,
isScrolling: void 0,
currentTranslate: void 0,
startTranslate: void 0,
allowThresholdMove: void 0,
// Form elements to match
focusableElements: swiper.params.focusableElements,
// Last click time
lastClickTime: 0,
clickTimeout: void 0,
// Velocities
velocities: [],
allowMomentumBounce: void 0,
startMoving: void 0,
evCache: []
},
// Clicks
allowClick: true,
// Touches
allowTouchMove: swiper.params.allowTouchMove,
touches: {
startX: 0,
startY: 0,
currentX: 0,
currentY: 0,
diff: 0
},
// Images
imagesToLoad: [],
imagesLoaded: 0
});
swiper.emit("_swiper");
if (swiper.params.init) {
swiper.init();
}
return swiper;
}
getSlideIndex(slideEl) {
const {
slidesEl,
params
} = this;
const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
const firstSlideIndex = elementIndex(slides[0]);
return elementIndex(slideEl) - firstSlideIndex;
}
getSlideIndexByData(index) {
return this.getSlideIndex(this.slides.filter((slideEl) => slideEl.getAttribute("data-swiper-slide-index") * 1 === index)[0]);
}
recalcSlides() {
const swiper = this;
const {
slidesEl,
params
} = swiper;
swiper.slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
}
enable() {
const swiper = this;
if (swiper.enabled)
return;
swiper.enabled = true;
if (swiper.params.grabCursor) {
swiper.setGrabCursor();
}
swiper.emit("enable");
}
disable() {
const swiper = this;
if (!swiper.enabled)
return;
swiper.enabled = false;
if (swiper.params.grabCursor) {
swiper.unsetGrabCursor();
}
swiper.emit("disable");
}
setProgress(progress, speed) {
const swiper = this;
progress = Math.min(Math.max(progress, 0), 1);
const min = swiper.minTranslate();
const max = swiper.maxTranslate();
const current = (max - min) * progress + min;
swiper.translateTo(current, typeof speed === "undefined" ? 0 : speed);
swiper.updateActiveIndex();
swiper.updateSlidesClasses();
}
emitContainerClasses() {
const swiper = this;
if (!swiper.params._emitClasses || !swiper.el)
return;
const cls = swiper.el.className.split(" ").filter((className) => {
return className.indexOf("swiper") === 0 || className.indexOf(swiper.params.containerModifierClass) === 0;
});
swiper.emit("_containerClasses", cls.join(" "));
}
getSlideClasses(slideEl) {
const swiper = this;
if (swiper.destroyed)
return "";
return slideEl.className.split(" ").filter((className) => {
return className.indexOf("swiper-slide") === 0 || className.indexOf(swiper.params.slideClass) === 0;
}).join(" ");
}
emitSlidesClasses() {
const swiper = this;
if (!swiper.params._emitClasses || !swiper.el)
return;
const updates = [];
swiper.slides.forEach((slideEl) => {
const classNames = swiper.getSlideClasses(slideEl);
updates.push({
slideEl,
classNames
});
swiper.emit("_slideClass", slideEl, classNames);
});
swiper.emit("_slideClasses", updates);
}
slidesPerViewDynamic(view = "current", exact = false) {
const swiper = this;
const {
params,
slides,
slidesGrid,
slidesSizesGrid,
size: swiperSize,
activeIndex
} = swiper;
let spv = 1;
if (params.centeredSlides) {
let slideSize = slides[activeIndex] ? slides[activeIndex].swiperSlideSize : 0;
let breakLoop;
for (let i = activeIndex + 1; i swiperSize)
breakLoop = true;
}
}
for (let i = activeIndex - 1; i >= 0; i -= 1) {
if (slides[i] && !breakLoop) {
slideSize += slides[i].swiperSlideSize;
spv += 1;
if (slideSize > swiperSize)
breakLoop = true;
}
}
} else {
if (view === "current") {
for (let i = activeIndex + 1; i = 0; i -= 1) {
const slideInView = slidesGrid[activeIndex] - slidesGrid[i] {
if (imageEl.complete) {
processLazyPreloader(swiper, imageEl);
}
});
swiper.updateSize();
swiper.updateSlides();
swiper.updateProgress();
swiper.updateSlidesClasses();
function setTranslate2() {
const translateValue = swiper.rtlTranslate ? swiper.translate * -1 : swiper.translate;
const newTranslate = Math.min(Math.max(translateValue, swiper.maxTranslate()), swiper.minTranslate());
swiper.setTranslate(newTranslate);
swiper.updateActiveIndex();
swiper.updateSlidesClasses();
}
let translated;
if (params.freeMode && params.freeMode.enabled && !params.cssMode) {
setTranslate2();
if (params.autoHeight) {
swiper.updateAutoHeight();
}
} else {
if ((params.slidesPerView === "auto" || params.slidesPerView > 1) && swiper.isEnd && !params.centeredSlides) {
const slides = swiper.virtual && params.virtual.enabled ? swiper.virtual.slides : swiper.slides;
translated = swiper.slideTo(slides.length - 1, 0, false, true);
} else {
translated = swiper.slideTo(swiper.activeIndex, 0, false, true);
}
if (!translated) {
setTranslate2();
}
}
if (params.watchOverflow && snapGrid !== swiper.snapGrid) {
swiper.checkOverflow();
}
swiper.emit("update");
}
changeDirection(newDirection, needUpdate = true) {
const swiper = this;
const currentDirection = swiper.params.direction;
if (!newDirection) {
newDirection = currentDirection === "horizontal" ? "vertical" : "horizontal";
}
if (newDirection === currentDirection || newDirection !== "horizontal" && newDirection !== "vertical") {
return swiper;
}
swiper.el.classList.remove(`${swiper.params.containerModifierClass}${currentDirection}`);
swiper.el.classList.add(`${swiper.params.containerModifierClass}${newDirection}`);
swiper.emitContainerClasses();
swiper.params.direction = newDirection;
swiper.slides.forEach((slideEl) => {
if (newDirection === "vertical") {
slideEl.style.width = "";
} else {
slideEl.style.height = "";
}
});
swiper.emit("changeDirection");
if (needUpdate)
swiper.update();
return swiper;
}
changeLanguageDirection(direction) {
const swiper = this;
if (swiper.rtl && direction === "rtl" || !swiper.rtl && direction === "ltr")
return;
swiper.rtl = direction === "rtl";
swiper.rtlTranslate = swiper.params.direction === "horizontal" && swiper.rtl;
if (swiper.rtl) {
swiper.el.classList.add(`${swiper.params.containerModifierClass}rtl`);
swiper.el.dir = "rtl";
} else {
swiper.el.classList.remove(`${swiper.params.containerModifierClass}rtl`);
swiper.el.dir = "ltr";
}
swiper.update();
}
mount(element) {
const swiper = this;
if (swiper.mounted)
return true;
let el = element || swiper.params.el;
if (typeof el === "string") {
el = document.querySelector(el);
}
if (!el) {
return false;
}
el.swiper = swiper;
if (el.shadowEl) {
swiper.isElement = true;
}
const getWrapperSelector = () => {
return `.${(swiper.params.wrapperClass || "").trim().split(" ").join(".")}`;
};
const getWrapper = () => {
if (el && el.shadowRoot && el.shadowRoot.querySelector) {
const res = el.shadowRoot.querySelector(getWrapperSelector());
return res;
}
return elementChildren(el, getWrapperSelector())[0];
};
let wrapperEl = getWrapper();
if (!wrapperEl && swiper.params.createElements) {
wrapperEl = createElement("div", swiper.params.wrapperClass);
el.append(wrapperEl);
elementChildren(el, `.${swiper.params.slideClass}`).forEach((slideEl) => {
wrapperEl.append(slideEl);
});
}
Object.assign(swiper, {
el,
wrapperEl,
slidesEl: swiper.isElement ? el : wrapperEl,
mounted: true,
// RTL
rtl: el.dir.toLowerCase() === "rtl" || elementStyle(el, "direction") === "rtl",
rtlTranslate: swiper.params.direction === "horizontal" && (el.dir.toLowerCase() === "rtl" || elementStyle(el, "direction") === "rtl"),
wrongRTL: elementStyle(wrapperEl, "display") === "-webkit-box"
});
return true;
}
init(el) {
const swiper = this;
if (swiper.initialized)
return swiper;
const mounted = swiper.mount(el);
if (mounted === false)
return swiper;
swiper.emit("beforeInit");
if (swiper.params.breakpoints) {
swiper.setBreakpoint();
}
swiper.addClasses();
swiper.updateSize();
swiper.updateSlides();
if (swiper.params.watchOverflow) {
swiper.checkOverflow();
}
if (swiper.params.grabCursor && swiper.enabled) {
swiper.setGrabCursor();
}
if (swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
swiper.slideTo(swiper.params.initialSlide + swiper.virtual.slidesBefore, 0, swiper.params.runCallbacksOnInit, false, true);
} else {
swiper.slideTo(swiper.params.initialSlide, 0, swiper.params.runCallbacksOnInit, false, true);
}
if (swiper.params.loop) {
swiper.loopCreate();
}
swiper.attachEvents();
[...swiper.el.querySelectorAll('[loading="lazy"]')].forEach((imageEl) => {
if (imageEl.complete) {
processLazyPreloader(swiper, imageEl);
} else {
imageEl.addEventListener("load", (e) => {
processLazyPreloader(swiper, e.target);
});
}
});
preload(swiper);
swiper.initialized = true;
preload(swiper);
swiper.emit("init");
swiper.emit("afterInit");
return swiper;
}
destroy(deleteInstance = true, cleanStyles = true) {
const swiper = this;
const {
params,
el,
wrapperEl,
slides
} = swiper;
if (typeof swiper.params === "undefined" || swiper.destroyed) {
return null;
}
swiper.emit("beforeDestroy");
swiper.initialized = false;
swiper.detachEvents();
if (params.loop) {
swiper.loopDestroy();
}
if (cleanStyles) {
swiper.removeClasses();
el.removeAttribute("style");
wrapperEl.removeAttribute("style");
if (slides && slides.length) {
slides.forEach((slideEl) => {
slideEl.classList.remove(params.slideVisibleClass, params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
slideEl.removeAttribute("style");
slideEl.removeAttribute("data-swiper-slide-index");
});
}
}
swiper.emit("destroy");
Object.keys(swiper.eventsListeners).forEach((eventName) => {
swiper.off(eventName);
});
if (deleteInstance !== false) {
swiper.el.swiper = null;
deleteProps(swiper);
}
swiper.destroyed = true;
return null;
}
static extendDefaults(newDefaults) {
extend(extendedDefaults, newDefaults);
}
static get extendedDefaults() {
return extendedDefaults;
}
static get defaults() {
return defaults;
}
static installModule(mod) {
if (!Swiper.prototype.__modules__)
Swiper.prototype.__modules__ = [];
const modules = Swiper.prototype.__modules__;
if (typeof mod === "function" && modules.indexOf(mod) Swiper.installModule(m));
return Swiper;
}
Swiper.installModule(module);
return Swiper;
}
}
Object.keys(prototypes).forEach((prototypeGroup) => {
Object.keys(prototypes[prototypeGroup]).forEach((protoMethod) => {
Swiper.prototype[protoMethod] = prototypes[prototypeGroup][protoMethod];
});
});
Swiper.use([Resize, Observer]);
function Virtual({
swiper,
extendParams,
on,
emit
}) {
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(slide2, 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, slide2, 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 = slide2;
}
if (params.cache)
swiper.virtual.cache[index] = slideEl;
return slideEl;
}
function update2(force) {
const {
slidesPerView,
slidesPerGroup,
centeredSlides,
loop: isLoop
} = swiper.params;
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 = swiper.activeIndex || 0;
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 {
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 {
let slideIndex = index;
if (index = slides.length) {
slideIndex = slideIndex - slides.length;
}
return slideIndex;
};
if (force) {
swiper.slidesEl.querySelectorAll(`.${swiper.params.slideClass}, swiper-slide`).forEach((slideEl) => {
slideEl.remove();
});
} else {
for (let i = previousFrom; i to) {
const slideIndex = getSlideIndex(i);
swiper.slidesEl.querySelectorAll(`.${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 = from && i previousTo)
appendIndexes.push(slideIndex);
if (i {
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 {
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;
}
update2(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) {
swiper.virtual.slides.splice(slidesIndexes[i], 1);
if (swiper.params.virtual.cache) {
delete swiper.virtual.cache[slidesIndexes[i]];
}
if (slidesIndexes[i] {
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;
if (!swiper.params.initialSlide) {
update2();
}
});
on("setTranslate", () => {
if (!swiper.params.virtual.enabled)
return;
if (swiper.params.cssMode && !swiper._immediateVirtual) {
clearTimeout(cssModeTimeout);
cssModeTimeout = setTimeout(() => {
update2();
}, 100);
} else {
update2();
}
});
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: update2
});
}
function Keyboard({
swiper,
extendParams,
on,
emit
}) {
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 = 0 && point[0] = 0 && point[1] {
if (swiper.params.keyboard.enabled) {
enable();
}
});
on("destroy", () => {
if (swiper.keyboard.enabled) {
disable();
}
});
Object.assign(swiper.keyboard, {
enable,
disable
});
}
function Mousewheel({
swiper,
extendParams,
on,
emit
}) {
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 = 6 && now() - lastScrollTime 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 = 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 = swiper.minTranslate())
position = swiper.minTranslate();
if (position = 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 = 1 && newEvent.delta 0 ? 0.8 : 0.2;
lastEventBeforeSnap = newEvent;
recentWheelEvents.splice(0);
timeout = nextTick(() => {
swiper.slideToClosest(swiper.params.speed, true, void 0, snapToThreshold);
}, 0);
}
if (!timeout) {
timeout = nextTick(() => {
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.autoplayDisableOnInteraction)
swiper.autoplay.stop();
if (position === swiper.minTranslate() || position === swiper.maxTranslate())
return true;
}
}
if (e.preventDefault)
e.preventDefault();
else
e.returnValue = false;
return false;
}
function events2(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;
events2("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;
events2("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
});
}
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;
}
function Navigation({
swiper,
extendParams,
on,
emit
}) {
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
};
const makeElementsArray = (el) => {
if (!Array.isArray(el))
el = [el].filter((e) => !!e);
return el;
};
function getEl(el) {
let res;
if (el && typeof el === "string" && swiper.isElement) {
res = swiper.el.shadowRoot.querySelector(el);
if (res)
return res;
}
if (el) {
if (typeof el === "string")
res = [...document.querySelectorAll(el)];
if (swiper.params.uniqueNavElements && typeof el === "string" && res.length > 1 && swiper.el.querySelectorAll(el).length === 1) {
res = swiper.el.querySelector(el);
}
}
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 update2() {
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();
update2();
}
});
on("toEdge fromEdge lock unlock", () => {
update2();
});
on("destroy", () => {
destroy();
});
on("enable disable", () => {
let {
nextEl,
prevEl
} = swiper.navigation;
nextEl = makeElementsArray(nextEl);
prevEl = makeElementsArray(prevEl);
[...nextEl, ...prevEl].filter((el) => !!el).forEach((el) => el.classList[swiper.enabled ? "remove" : "add"](swiper.params.navigation.lockClass));
});
on("click", (_s, e) => {
let {
nextEl,
prevEl
} = swiper.navigation;
nextEl = makeElementsArray(nextEl);
prevEl = makeElementsArray(prevEl);
const targetEl = e.target;
if (swiper.params.navigation.hideOnClick && !prevEl.includes(targetEl) && !nextEl.includes(targetEl)) {
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();
update2();
};
const disable = () => {
swiper.el.classList.add(...swiper.params.navigation.navigationDisabledClass.split(" "));
destroy();
};
Object.assign(swiper.navigation, {
enable,
disable,
update: update2,
init,
destroy
});
}
function classesToSelector(classes2 = "") {
return `.${classes2.trim().replace(/([\.:!+\/])/g, "\\$1").replace(/ /g, ".")}`;
}
function Pagination({
swiper,
extendParams,
on,
emit
}) {
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;
const makeElementsArray = (el) => {
if (!Array.isArray(el))
el = [el].filter((e) => !!e);
return el;
};
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 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 newSlideIndex = swiper.getSlideIndexByData(index);
const currentSlideIndex = swiper.getSlideIndexByData(swiper.realIndex);
if (newSlideIndex > swiper.slides.length - swiper.loopedSlides) {
swiper.loopFix({
direction: newSlideIndex > currentSlideIndex ? "next" : "prev",
activeSlideIndex: newSlideIndex,
slideTo: false
});
}
swiper.slideToLoop(index);
} else {
swiper.slideTo(index);
}
}
function update2() {
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 {
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 {
bulletEl.setAttribute("part", bulletIndex === current ? "bullet-active" : "bullet");
});
}
if (params.dynamicBullets) {
const firstDisplayedBullet = bullets[firstIndex];
const lastDisplayedBullet = bullets[lastIndex];
for (let i = firstIndex; i {
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.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 `;
}
}
}
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.shadowRoot.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.filter((subEl) => {
if (elementParents(subEl, ".swiper")[0] !== swiper.el)
return false;
return true;
})[0];
}
}
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);
}
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 {
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.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();
update2();
}
});
on("activeIndexChange", () => {
if (typeof swiper.snapIndex === "undefined") {
update2();
}
});
on("snapIndexChange", () => {
update2();
});
on("snapGridLengthChange", () => {
render();
update2();
});
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", () => {
update2();
});
on("click", (_s, e) => {
const targetEl = e.target;
let {
el
} = swiper.pagination;
if (!Array.isArray(el))
el = [el].filter((element) => !!element);
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();
update2();
};
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: update2,
init,
destroy
});
}
function Scrollbar({
swiper,
extendParams,
on,
emit
}) {
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 setTranslate2() {
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 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 setTransition2(duration) {
if (!swiper.params.scrollbar.el || !swiper.scrollbar.el)
return;
swiper.scrollbar.dragEl.style.transitionDuration = `${duration}ms`;
}
function updateSize2() {
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.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 events2(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;
events2("on");
}
function disableDraggable() {
if (!swiper.params.scrollbar.el || !swiper.scrollbar.el)
return;
events2("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.shadowRoot.querySelector(params.el);
}
if (!el && typeof params.el === "string") {
el = document2.querySelectorAll(params.el);
} 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(`.${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"](swiper.params.scrollbar.lockClass);
}
}
function destroy() {
const params = swiper.params.scrollbar;
const el = swiper.scrollbar.el;
if (el) {
el.classList.remove(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
}
disableDraggable();
}
on("init", () => {
if (swiper.params.scrollbar.enabled === false) {
disable();
} else {
init();
updateSize2();
setTranslate2();
}
});
on("update resize observerUpdate lock unlock", () => {
updateSize2();
});
on("setTranslate", () => {
setTranslate2();
});
on("setTransition", (_s, duration) => {
setTransition2(duration);
});
on("enable disable", () => {
const {
el
} = swiper.scrollbar;
if (el) {
el.classList[swiper.enabled ? "remove" : "add"](swiper.params.scrollbar.lockClass);
}
});
on("destroy", () => {
destroy();
});
const enable = () => {
swiper.el.classList.remove(swiper.params.scrollbar.scrollbarDisabledClass);
if (swiper.scrollbar.el) {
swiper.scrollbar.el.classList.remove(swiper.params.scrollbar.scrollbarDisabledClass);
}
init();
updateSize2();
setTranslate2();
};
const disable = () => {
swiper.el.classList.add(swiper.params.scrollbar.scrollbarDisabledClass);
if (swiper.scrollbar.el) {
swiper.scrollbar.el.classList.add(swiper.params.scrollbar.scrollbarDisabledClass);
}
destroy();
};
Object.assign(swiper.scrollbar, {
enable,
disable,
updateSize: updateSize2,
setTranslate: setTranslate2,
init,
destroy
});
}
function Parallax({
swiper,
extendParams,
on
}) {
extendParams({
parallax: {
enabled: false
}
});
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 setTranslate2 = () => {
const {
el,
slides,
progress,
snapGrid
} = swiper;
elementChildren(el, "[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]").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("[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale], [data-swiper-parallax-rotate]").forEach((subEl) => {
setTransform(subEl, slideProgress);
});
});
};
const setTransition2 = (duration = swiper.params.speed) => {
const {
el
} = swiper;
el.querySelectorAll("[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]").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;
setTranslate2();
});
on("setTranslate", () => {
if (!swiper.params.parallax.enabled)
return;
setTranslate2();
});
on("setTransition", (_swiper, duration) => {
if (!swiper.params.parallax.enabled)
return;
setTransition2(duration);
});
}
function Zoom({
swiper,
extendParams,
on,
emit
}) {
const window2 = getWindow();
extendParams({
zoom: {
enabled: false,
maxRatio: 3,
minRatio: 1,
toggle: true,
containerClass: "swiper-zoom-container",
zoomedSlideClass: "swiper-slide-zoomed"
}
});
swiper.zoom = {
enabled: false
};
let currentScale = 1;
let isScaling = false;
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 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.el.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 cachedEv.pointerId === e.pointerId);
if (pointerIndex >= 0)
evCache[pointerIndex] = e;
if (evCache.length gesture.maxRatio) {
zoom.scale = gesture.maxRatio - 1 + (zoom.scale - gesture.maxRatio + 1) ** 0.5;
}
if (zoom.scale 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 0 ? evCache[0] : e;
image.touchesStart.x = event2.pageX;
image.touchesStart.y = event2.pageY;
}
function onTouchMove2(e) {
if (!eventWithinSlide(e) || !eventWithinZoomContainer(e))
return;
const zoom = swiper.zoom;
if (!gesture.imageEl)
return;
if (!image.isTouched || !gesture.slideEl)
return;
if (!image.isMoved) {
image.width = gesture.imageEl.offsetWidth;
image.height = gesture.imageEl.offsetHeight;
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;
if (scaledWidth 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)) {
image.isTouched = false;
return;
}
if (!swiper.isHorizontal() && (Math.floor(image.minY) === Math.floor(image.startY) && image.touchesCurrent.y image.touchesStart.y)) {
image.isTouched = false;
return;
}
}
if (e.cancelable) {
e.preventDefault();
}
e.stopPropagation();
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.maxX) {
image.currentX = image.maxX - 1 + (image.currentX - image.maxX + 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) translateMaxX) {
translateX = translateMaxX;
}
if (translateY translateMaxY) {
translateY = translateMaxY;
}
} else {
translateX = 0;
translateY = 0;
}
if (forceZoomRatio && zoom.scale === 1) {
gesture.originX = 0;
gesture.originY = 0;
}
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;
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;
}
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", onTouchMove2, 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", onTouchMove2, activeListenerWithCapture);
}
on("init", () => {
if (swiper.params.zoom.enabled) {
enable();
}
});
on("destroy", () => {
disable();
});
on("touchStart", (_s, e) => {
if (!swiper.zoom.enabled)
return;
onTouchStart2(e);
});
on("touchEnd", (_s, e) => {
if (!swiper.zoom.enabled)
return;
onTouchEnd2(e);
});
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
});
}
function Controller({
swiper,
extendParams,
on
}) {
extendParams({
controller: {
control: void 0,
inverse: false,
by: "slide"
// or 'container'
}
});
swiper.controller = {
control: void 0
};
function LinearSpline(x, y) {
const binarySearch = function search() {
let maxIndex;
let minIndex;
let guess;
return (array, val) => {
minIndex = -1;
maxIndex = array.length;
while (maxIndex - minIndex > 1) {
guess = maxIndex + minIndex >> 1;
if (array[guess] {
c.updateAutoHeight();
});
}
elementTransitionEnd(c.wrapperEl, () => {
if (!controlled)
return;
c.transitionEnd();
});
}
}
if (Array.isArray(controlled)) {
for (i = 0; i {
if (typeof window !== "undefined" && // eslint-disable-line
(typeof swiper.params.controller.control === "string" || swiper.params.controller.control instanceof HTMLElement)) {
const controlElement = document.querySelector(swiper.params.controller.control);
if (controlElement && controlElement.swiper) {
swiper.controller.control = controlElement.swiper;
} else if (controlElement) {
const onControllerSwiper = (e) => {
swiper.controller.control = e.detail[0];
swiper.update();
controlElement.removeEventListener("init", onControllerSwiper);
};
controlElement.addEventListener("init", onControllerSwiper);
}
return;
}
swiper.controller.control = swiper.params.controller.control;
});
on("update", () => {
removeSpline();
});
on("resize", () => {
removeSpline();
});
on("observerUpdate", () => {
removeSpline();
});
on("setTranslate", (_s, translate2, byController) => {
if (!swiper.controller.control || swiper.controller.control.destroyed)
return;
swiper.controller.setTranslate(translate2, 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: setTranslate2,
setTransition: setTransition2
});
}
function A11y({
swiper,
extendParams,
on
}) {
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,
itemRoleDescriptionMessage: null,
slideRole: "group",
id: null
}
});
swiper.a11y = {
clicked: false
};
let liveRegion = null;
function notify(message) {
const notification = liveRegion;
if (notification.length === 0)
return;
notification.innerHTML = "";
notification.innerHTML = message;
}
const makeElementsArray = (el) => {
if (!Array.isArray(el))
el = [el].filter((e) => !!e);
return el;
};
function getRandomNumber(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.nextEl && targetEl === swiper.navigation.nextEl) {
if (!(swiper.isEnd && !swiper.params.loop)) {
swiper.slideNext();
}
if (swiper.isEnd) {
notify(params.lastSlideMessage);
} else {
notify(params.nextSlideMessage);
}
}
if (swiper.navigation && swiper.navigation.prevEl && targetEl === swiper.navigation.prevEl) {
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 = () => {
swiper.a11y.clicked = true;
};
const handlePointerUp = () => {
requestAnimationFrame(() => {
requestAnimationFrame(() => {
if (!swiper.destroyed) {
swiper.a11y.clicked = false;
}
});
});
};
const handleFocus = (e) => {
if (swiper.a11y.clicked)
return;
const slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);
if (!slideEl || !swiper.slides.includes(slideEl))
return;
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;
}
swiper.slideTo(swiper.slides.indexOf(slideEl), 0);
};
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;
if (swiper.isElement) {
swiper.el.shadowEl.append(liveRegion);
} else {
swiper.el.append(liveRegion);
}
const containerEl = swiper.el;
if (params.containerRoleDescriptionMessage) {
addElRoleDescription(containerEl, params.containerRoleDescriptionMessage);
}
if (params.containerMessage) {
addElLabel(containerEl, params.containerMessage);
}
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 = Array.isArray(swiper.pagination.el) ? swiper.pagination.el : [swiper.pagination.el];
paginationEl.forEach((el) => {
el.addEventListener("keydown", onEnterOrSpaceKey);
});
}
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 = Array.isArray(swiper.pagination.el) ? swiper.pagination.el : [swiper.pagination.el];
paginationEl.forEach((el) => {
el.removeEventListener("keydown", onEnterOrSpaceKey);
});
}
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();
});
}
function History({
swiper,
extendParams,
on
}) {
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 slide2 = swiper.slides[index];
let value = slugify(slide2.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 {
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);
}
});
}
function HashNavigation({
swiper,
extendParams,
emit,
on
}) {
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.filter((slideEl) => slideEl.getAttribute("data-hash") === hash)[0];
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();
}
});
}
function Autoplay({
swiper,
extendParams,
on,
emit,
params
}) {
swiper.autoplay = {
running: false,
paused: false,
timeLeft: 0
};
extendParams({
autoplay: {
enabled: false,
delay: 3e3,
waitForTransition: true,
disableOnInteraction: true,
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;
function onTransitionEnd(e) {
if (!swiper || swiper.destroyed || !swiper.wrapperEl)
return;
if (e.target !== swiper.wrapperEl)
return;
swiper.wrapperEl.removeEventListener("transitionend", onTransitionEnd);
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.filter((slideEl) => slideEl.classList.contains("swiper-slide-active"))[0];
} 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 = () => {
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 {
if (swiper.isEnd && autoplayTimeLeft {
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;
pause(true);
};
const onPointerLeave = (e) => {
if (e.pointerType !== "mouse")
return;
if (swiper.autoplay.paused) {
resume();
}
};
const attachMouseEvents = () => {
if (swiper.params.autoplay.pauseOnMouseEnter) {
swiper.el.addEventListener("pointerenter", onPointerEnter);
swiper.el.addEventListener("pointerleave", onPointerLeave);
}
};
const detachMouseEvents = () => {
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();
autoplayStartTime = (/* @__PURE__ */ new Date()).getTime();
start();
}
});
on("destroy", () => {
detachMouseEvents();
detachDocumentEvents();
if (swiper.autoplay.running) {
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
});
}
function Thumb({
swiper,
extendParams,
on
}) {
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) {
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 update2(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 {
slideEl.classList.add(thumbActiveClass);
});
}
} else {
for (let i = 0; i slideEl.getAttribute("data-swiper-slide-index") === `${swiper.realIndex}`)[0];
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) 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();
update2(true);
} else if (thumbsElement) {
const onThumbsSwiper = (e) => {
thumbs.swiper = e.detail[0];
thumbsElement.removeEventListener("init", onThumbsSwiper);
init();
update2(true);
thumbs.swiper.update();
swiper.update();
};
thumbsElement.addEventListener("init", onThumbsSwiper);
}
return thumbsElement;
};
const watchForThumbsToAppear = () => {
if (swiper.destroyed)
return;
const thumbsElement = getThumbsElementAndInit();
if (!thumbsElement) {
requestAnimationFrame(watchForThumbsToAppear);
}
};
requestAnimationFrame(watchForThumbsToAppear);
} else {
init();
update2(true);
}
});
on("slideChange update resize observerUpdate", () => {
update2();
});
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: update2
});
}
function freeMode({
swiper,
extendParams,
emit,
once
}) {
extendParams({
freeMode: {
enabled: false,
momentum: true,
momentumRatio: 1,
momentumBounce: true,
momentumBounceRatio: 1,
momentumVelocityRatio: 1,
sticky: false,
minimumVelocity: 0.02
}
});
function onTouchStart2() {
if (swiper.params.cssMode)
return;
const translate2 = swiper.getTranslate();
swiper.setTranslate(translate2);
swiper.setTransition(0);
swiper.touchEventsData.velocities.length = 0;
swiper.freeMode.onTouchEnd({
currentPos: swiper.rtl ? swiper.translate : -swiper.translate
});
}
function onTouchMove2() {
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 onTouchEnd2({
currentPos
}) {
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.maxTranslate()) {
if (swiper.slides.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) 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.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 -newPosition) {
nextSlide = j;
break;
}
}
if (Math.abs(snapGrid[nextSlide] - newPosition) {
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 {
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) {
swiper.updateProgress();
swiper.updateActiveIndex();
swiper.updateSlidesClasses();
}
}
Object.assign(swiper, {
freeMode: {
onTouchStart: onTouchStart2,
onTouchMove: onTouchMove2,
onTouchEnd: onTouchEnd2
}
});
}
function Grid({
swiper,
extendParams
}) {
extendParams({
grid: {
rows: 1,
fill: "column"
}
});
let slidesNumberEvenToRows;
let slidesPerRow;
let numFullColumns;
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 = (slidesLength) => {
const {
slidesPerView
} = swiper.params;
const {
rows,
fill
} = swiper.params.grid;
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 updateSlide = (i, slide2, slidesLength, getDirectionLabel) => {
const {
slidesPerGroup
} = swiper.params;
const spaceBetween = getSpaceBetween();
const {
rows,
fill
} = swiper.params.grid;
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;
slide2.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;
}
slide2.row = row;
slide2.column = column;
slide2.style[getDirectionLabel("margin-top")] = row !== 0 ? spaceBetween && `${spaceBetween}px` : "";
};
const updateWrapperSize = (slideSize, snapGrid, getDirectionLabel) => {
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;
swiper.wrapperEl.style[getDirectionLabel("width")] = `${swiper.virtualSize + spaceBetween}px`;
if (centeredSlides) {
const newSlidesGrid = [];
for (let i = 0; i {
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 {
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 = 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 index ? activeIndexBuffer + slides.length : activeIndexBuffer;
} else {
slidesEl.append(slides);
}
for (let i = 0; i {
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;
setTranslate2();
});
on("setTransition", (_s, duration) => {
if (swiper.params.effect !== effect)
return;
setTransition2(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) {
setTranslate2();
requireUpdateOnVirtual = false;
}
});
});
}
function effectTarget(effectParams, slideEl) {
const transformEl = getSlideTransformEl(slideEl);
if (transformEl !== slideEl) {
transformEl.style.backfaceVisibility = "hidden";
transformEl.style["-webkit-backface-visibility"] = "hidden";
}
return transformEl;
}
function effectVirtualTransitionEnd({
swiper,
duration,
transformElements,
allSlides
}) {
const {
activeIndex
} = swiper;
const getSlide = (el) => {
if (!el.parentElement) {
const slide2 = swiper.slides.filter((slideEl) => slideEl.shadowEl && slideEl.shadowEl === el.parentNode)[0];
return slide2;
}
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);
});
});
}
}
function EffectFade({
swiper,
extendParams,
on
}) {
extendParams({
fadeEffect: {
crossFade: false
}
});
const setTranslate2 = () => {
const {
slides
} = swiper;
const params = swiper.params.fadeEffect;
for (let i = 0; i {
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: setTranslate2,
setTransition: setTransition2,
overwriteParams: () => ({
slidesPerView: 1,
slidesPerGroup: 1,
watchSlidesProgress: true,
spaceBetween: 0,
virtualTranslate: !swiper.params.cssMode
})
});
}
function EffectCube({
swiper,
extendParams,
on
}) {
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-${isHorizontal ? "left" : "top"}`);
slideEl.append(shadowBefore);
}
if (!shadowAfter) {
shadowAfter = createElement("div", `swiper-slide-shadow-${isHorizontal ? "right" : "bottom"}`);
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 setTranslate2 = () => {
const {
el,
wrapperEl,
slides,
width: swiperWidth,
height: swiperHeight,
rtlTranslate: rtl,
size: swiperSize,
browser: browser2
} = 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.slidesEl.querySelector(".swiper-cube-shadow");
if (!cubeShadowEl) {
cubeShadowEl = createElement("div", "swiper-cube-shadow");
swiper.slidesEl.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 -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(90deg) 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(-90deg)`;
}
}
const zFactor = (browser2.isSafari || browser2.isWebView) && browser2.needPerspectiveFix ? -swiperSize / 2 : 0;
wrapperEl.style.transform = `translate3d(0px,0,${zFactor}px) rotateX(${swiper.isHorizontal() ? 0 : wrapperRotate}deg) rotateY(${swiper.isHorizontal() ? -wrapperRotate : 0}deg)`;
wrapperEl.style.setProperty("--swiper-cube-translate-z", `${zFactor}px`);
};
const setTransition2 = (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: setTranslate2,
setTransition: setTransition2,
recreateShadows,
getEffectParams: () => swiper.params.cubeEffect,
perspective: () => true,
overwriteParams: () => ({
slidesPerView: 1,
slidesPerGroup: 1,
watchSlidesProgress: true,
resistanceRatio: 0,
spaceBetween: 0,
centeredSlides: false,
virtualTranslate: true
})
});
}
function createShadow(params, slideEl, side) {
const shadowClass = `swiper-slide-shadow${side ? `-${side}` : ""}`;
const shadowContainer = getSlideTransformEl(slideEl);
let shadowEl = shadowContainer.querySelector(`.${shadowClass}`);
if (!shadowEl) {
shadowEl = createElement("div", `swiper-slide-shadow${side ? `-${side}` : ""}`);
shadowContainer.append(shadowEl);
}
return shadowEl;
}
function EffectFlip({
swiper,
extendParams,
on
}) {
extendParams({
flipEffect: {
slideShadows: true,
limitRotation: true
}
});
const createSlideShadows = (slideEl, progress, params) => {
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(params, slideEl, swiper.isHorizontal() ? "left" : "top");
}
if (!shadowAfter) {
shadowAfter = createShadow(params, 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 = () => {
const params = 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, params);
});
};
const setTranslate2 = () => {
const {
slides,
rtlTranslate: rtl
} = swiper;
const params = swiper.params.flipEffect;
for (let i = 0; i {
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: setTranslate2,
setTransition: setTransition2,
recreateShadows,
getEffectParams: () => swiper.params.flipEffect,
perspective: () => true,
overwriteParams: () => ({
slidesPerView: 1,
slidesPerGroup: 1,
watchSlidesProgress: true,
spaceBetween: 0,
virtualTranslate: !swiper.params.cssMode
})
});
}
function EffectCoverflow({
swiper,
extendParams,
on
}) {
extendParams({
coverflowEffect: {
rotate: 50,
stretch: 0,
depth: 100,
scale: 1,
modifier: 1,
slideShadows: true
}
});
const setTranslate2 = () => {
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 translate2 = params.depth;
for (let i = 0, length = slides.length; i 0 ? offsetMultiplier : 0;
if (shadowAfterEl)
shadowAfterEl.style.opacity = -offsetMultiplier > 0 ? -offsetMultiplier : 0;
}
}
};
const setTransition2 = (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: setTranslate2,
setTransition: setTransition2,
perspective: () => true,
overwriteParams: () => ({
watchSlidesProgress: true
})
});
}
function EffectCreative({
swiper,
extendParams,
on
}) {
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 setTranslate2 = () => {
const {
slides,
wrapperEl,
slidesSizesGrid
} = swiper;
const params = swiper.params.creativeEffect;
const {
progressMultiplier: multiplier
} = params;
const isCenteredSlides = swiper.params.centeredSlides;
if (isCenteredSlides) {
const margin = slidesSizesGrid[0] / 2 - swiper.params.slidesOffsetBefore || 0;
wrapperEl.style.transform = `translateX(calc(50% - ${margin}px))`;
}
for (let i = 0; i 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) => {
r[index] = data.rotate[index] * Math.abs(progress * multiplier);
});
slideEl.style.zIndex = -Math.abs(Math.round(slideProgress)) + slides.length;
const translateString = t.join(", ");
const rotateString = `rotateX(${r[0]}deg) rotateY(${r[1]}deg) rotateZ(${r[2]}deg)`;
const scaleString = originalProgress {
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: setTranslate2,
setTransition: setTransition2,
perspective: () => swiper.params.creativeEffect.perspective,
overwriteParams: () => ({
watchSlidesProgress: true,
virtualTranslate: !swiper.params.cssMode
})
});
}
function EffectCards({
swiper,
extendParams,
on
}) {
extendParams({
cardsEffect: {
slideShadows: true,
rotate: true,
perSlideRotate: 2,
perSlideOffset: 8
}
});
const setTranslate2 = () => {
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 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 {
tX = `${tX}px`;
}
if (!swiper.isHorizontal()) {
const prevY = tY;
tY = tX;
tX = prevY;
}
const scaleString = progress {
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: setTranslate2,
setTransition: setTransition2,
perspective: () => true,
overwriteParams: () => ({
watchSlidesProgress: true,
virtualTranslate: !swiper.params.cssMode
})
});
}
document.addEventListener("DOMContentLoaded", () => {
const infoSwiper = () => {
new Swiper(".tmpl_hh_info .swiper", {
loop: true,
modules: [Pagination, Autoplay],
slidesPerView: 1,
spaceBetween: 32,
slidesPerGroup: 1,
autoHeight: true,
autoplay: {
delay: 3e3,
disableOnInteraction: false
},
pagination: {
el: ".tmpl_hh_info .swiper-pagination",
clickable: true,
bulletClass: "tmpl_hh_swiper__pagination-bullet",
bulletActiveClass: "tmpl_hh_swiper__pagination-bullet-active"
},
// when window width is >=
breakpoints: {
500: {
slidesPerView: 1.5,
slidesPerGroup: 1,
spaceBetween: 20
},
655: {
slidesPerView: 2,
slidesPerGroup: 2,
spaceBetween: 20
},
1339: {
slidesPerView: 2,
slidesPerGroup: 2,
spaceBetween: 40
}
}
});
};
try {
customTitle();
infoSwiper();
} catch (error) {
console.log(error);
}
});
//
} catch (e) {console.error(e);}};
Ключевые навыки
- Python
- FastAPI
- Apache Kafka
- RabbitMQ
- PostgreSQL
- Redis
- REST API