Эксперт-разработчик Java
ПАО БАНК УРАЛСИБМоскваHH.ru
Описание вакансии
Мы ищем разработчика в команду, которая занимается разработкой полностью обновленного онлайн-банка. Да, мы банк, но с минимумом бюрократии, и мы делаем современное, а главное удобное для пользователей приложение. Если ты хочешь принять участие в решении сложных задач, не боишься масштабных проектов, а также жаждешь новых вызовов – присоединяйся!
Чем предстоит заниматься
- развивать и поддерживать функционал онлайн-банка
- участвовать в определении направления развития архитектуры микросервисов и дальнейшем выборе технологий
- повышать надежность и качество системы
Наши ожидания
- хорошо знаешь Java 17+, Spring Boot, SQL
- умеешь разбираться в чужом коде
- знаешь, как писать Unit-тесты
- имеешь опыт работы с системой контроля версий Git
- возможно, имеешь опыт работы с Spring Cloud
- понимаешь принципы работы Docker и Kubernetes
- работал по гибким методологиям (Agile-фреймворки)
- участвовал в разработке продуктов с большой нагрузкой
- любишь делиться знаниями через code-review и работу в паре
- знаешь основные алгоритмы, структуры данных, понимаешь шаблоны проектирования
- знаешь и понимаешь HTTP, REST, REST Maturity Level
Мы предлагаем
- официальное трудоустройство с первого дня работы
- стабильный белый оклад и систему премирования
- новый и современный офис у метро Калужская (возможен гибридный формат работы)
- позитивную и заряженную команду профессионалов и адекватное руководство
- среду для твоего развития через новые и сложные задачи
- участие в разработке уникальных продуктов, которыми будут пользоваться миллионы клиентов (в том числе и мы)
- возможность влиять на рабочие процессы, улучшать их и делать удобными для себя и окружающих
- работу в среде, где приветствуется инициативность и поощряется нестандартный подход
- возможность профессионального и карьерного роста (у нас есть внутреннее обучение, возможность посещать конференции, митапы, хакатоны)
- ежегодный отпуск, оплачиваемый больничный, ДМС после испытательного срока
- льготные условия по кредитной карте, кредиту и ипотеке
- особые предложения от крупнейших застройщиков России
- скидки до 70% на покупки от 500 лидеров рынка через корпоративный агрегатор
Хочешь стать частью команды Банка Уралсиб? Откликайся прямо сейчас!
Наша вакансия тебе подойдет, если ты ищешь:
Java-разработчик, бэкенд-разработчик
Почему именно Банк Уралсиб
Всё необходимое
Техника и нужный софт для комфортной работы
Программа «Приведи друга»
Принесёт тебе денежный бонус за каждого нового коллегу
Активная корпоративная жизнь вне работы
Мероприятия, конкурсы и спортивные активности для увлекательного досуга
Профессиональное развитие
Курсы, обучение, участие в конференциях
Забота о здоровье
Программа ДМС, дополнительный оплачиваемый выходной день за достижения в работе
Современные технологии
Работаем с актуальными технологиями и не боимся пробовать новое
Присоединяйся к команде Уралсиба
Откликнуться
Публичное акционерное общество «БАНК УРАЛСИБ»
window.jqueryMigrateLTROnLoad = function() {try {
jQuery.UNSAFE_restoreLegacyHtmlPrefilter();
;
//
var __accessCheck = (obj, member, msg) => {
if (!member.has(obj))
throw TypeError("Cannot " + msg);
};
var __privateGet = (obj, member, getter) => {
__accessCheck(obj, member, "read from private field");
return getter ? getter.call(obj) : member.get(obj);
};
var __privateAdd = (obj, member, value) => {
if (member.has(obj))
throw TypeError("Cannot add the same private member more than once");
member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
};
var _hrefs, _blockVac;
(function polyfill() {
const relList = document.createElement("link").relList;
if (relList && relList.supports && relList.supports("modulepreload")) {
return;
}
for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
processPreload(link);
}
new MutationObserver((mutations) => {
for (const mutation of mutations) {
if (mutation.type !== "childList") {
continue;
}
for (const node of mutation.addedNodes) {
if (node.tagName === "LINK" && node.rel === "modulepreload")
processPreload(node);
}
}
}).observe(document, { childList: true, subtree: true });
function getFetchOpts(link) {
const fetchOpts = {};
if (link.integrity)
fetchOpts.integrity = link.integrity;
if (link.referrerPolicy)
fetchOpts.referrerPolicy = link.referrerPolicy;
if (link.crossOrigin === "use-credentials")
fetchOpts.credentials = "include";
else if (link.crossOrigin === "anonymous")
fetchOpts.credentials = "omit";
else
fetchOpts.credentials = "same-origin";
return fetchOpts;
}
function processPreload(link) {
if (link.ep)
return;
link.ep = true;
const fetchOpts = getFetchOpts(link);
fetch(link.href, fetchOpts);
}
})();
const index$1 = "";
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 makeReactive(obj) {
const proto = obj.__proto__;
Object.defineProperty(obj, "__proto__", {
get() {
return proto;
},
set(value) {
proto.__proto__ = value;
}
});
}
class Dom7 extends Array {
constructor(items) {
if (typeof items === "number") {
super(items);
} else {
super(...items || []);
makeReactive(this);
}
}
}
function arrayFlat(arr = []) {
const res = [];
arr.forEach((el) => {
if (Array.isArray(el)) {
res.push(...arrayFlat(el));
} else {
res.push(el);
}
});
return res;
}
function arrayFilter(arr, callback) {
return Array.prototype.filter.call(arr, callback);
}
function arrayUnique(arr) {
const uniqueArray = [];
for (let i = 0; i = 0 && html2.indexOf(">") >= 0) {
let toCreate = "div";
if (html2.indexOf("- c.split(" ")));
this.forEach((el) => {
el.classList.add(...classNames);
});
return this;
}
function removeClass(...classes2) {
const classNames = arrayFlat(classes2.map((c) => c.split(" ")));
this.forEach((el) => {
el.classList.remove(...classNames);
});
return this;
}
function toggleClass(...classes2) {
const classNames = arrayFlat(classes2.map((c) => c.split(" ")));
this.forEach((el) => {
classNames.forEach((className) => {
el.classList.toggle(className);
});
});
}
function hasClass(...classes2) {
const classNames = arrayFlat(classes2.map((c) => c.split(" ")));
return arrayFilter(this, (el) => {
return classNames.filter((className) => el.classList.contains(className)).length > 0;
}).length > 0;
}
function attr(attrs, value) {
if (arguments.length === 1 && typeof attrs === "string") {
if (this[0])
return this[0].getAttribute(attrs);
return void 0;
}
for (let i = 0; i = 0; k -= 1) {
const handler = handlers[k];
if (listener && handler.listener === listener) {
el.removeEventListener(event, handler.proxyListener, capture);
handlers.splice(k, 1);
} else if (listener && handler.listener && handler.listener.dom7proxy && handler.listener.dom7proxy === listener) {
el.removeEventListener(event, handler.proxyListener, capture);
handlers.splice(k, 1);
} else if (!listener) {
el.removeEventListener(event, handler.proxyListener, capture);
handlers.splice(k, 1);
}
}
}
}
}
return this;
}
function trigger(...args) {
const window2 = getWindow();
const events2 = args[0].split(" ");
const eventData = args[1];
for (let i = 0; i dataIndex > 0);
el.dispatchEvent(evt);
el.dom7EventData = [];
delete el.dom7EventData;
}
}
}
return this;
}
function transitionEnd$1(callback) {
const dom = this;
function fireCallBack(e) {
if (e.target !== this)
return;
callback.call(this, e);
dom.off("transitionend", fireCallBack);
}
if (callback) {
dom.on("transitionend", fireCallBack);
}
return this;
}
function outerWidth(includeMargins) {
if (this.length > 0) {
if (includeMargins) {
const styles2 = this.styles();
return this[0].offsetWidth + parseFloat(styles2.getPropertyValue("margin-right")) + parseFloat(styles2.getPropertyValue("margin-left"));
}
return this[0].offsetWidth;
}
return null;
}
function outerHeight(includeMargins) {
if (this.length > 0) {
if (includeMargins) {
const styles2 = this.styles();
return this[0].offsetHeight + parseFloat(styles2.getPropertyValue("margin-top")) + parseFloat(styles2.getPropertyValue("margin-bottom"));
}
return this[0].offsetHeight;
}
return null;
}
function offset() {
if (this.length > 0) {
const window2 = getWindow();
const document2 = getDocument();
const el = this[0];
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
};
}
return null;
}
function styles() {
const window2 = getWindow();
if (this[0])
return window2.getComputedStyle(this[0], null);
return {};
}
function css(props, value) {
const window2 = getWindow();
let i;
if (arguments.length === 1) {
if (typeof props === "string") {
if (this[0])
return window2.getComputedStyle(this[0], null).getPropertyValue(props);
} else {
for (i = 0; i {
callback.apply(el, [el, index2]);
});
return this;
}
function filter(callback) {
const result = arrayFilter(this, callback);
return $(result);
}
function html(html2) {
if (typeof html2 === "undefined") {
return this[0] ? this[0].innerHTML : null;
}
for (let i = 0; i length - 1) {
return $([]);
}
if (index2 = 0; j -= 1) {
this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);
}
} else if (newChild instanceof Dom7) {
for (j = 0; j 0) {
if (selector) {
if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) {
return $([this[0].nextElementSibling]);
}
return $([]);
}
if (this[0].nextElementSibling)
return $([this[0].nextElementSibling]);
return $([]);
}
return $([]);
}
function nextAll(selector) {
const nextEls = [];
let el = this[0];
if (!el)
return $([]);
while (el.nextElementSibling) {
const next2 = el.nextElementSibling;
if (selector) {
if ($(next2).is(selector))
nextEls.push(next2);
} else
nextEls.push(next2);
el = next2;
}
return $(nextEls);
}
function prev(selector) {
if (this.length > 0) {
const el = this[0];
if (selector) {
if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) {
return $([el.previousElementSibling]);
}
return $([]);
}
if (el.previousElementSibling)
return $([el.previousElementSibling]);
return $([]);
}
return $([]);
}
function prevAll(selector) {
const prevEls = [];
let el = this[0];
if (!el)
return $([]);
while (el.previousElementSibling) {
const prev2 = el.previousElementSibling;
if (selector) {
if ($(prev2).is(selector))
prevEls.push(prev2);
} else
prevEls.push(prev2);
el = prev2;
}
return $(prevEls);
}
function parent(selector) {
const parents2 = [];
for (let i = 0; i {
Object.defineProperty($.fn, methodName, {
value: Methods[methodName],
writable: true
});
});
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);
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();
}
let support;
function calcSupport() {
const window2 = getWindow();
const document2 = getDocument();
return {
smoothScroll: document2.documentElement && "scrollBehavior" in document2.documentElement.style,
touch: !!("ontouchstart" in window2 || window2.DocumentTouch && document2 instanceof window2.DocumentTouch),
passiveListener: function checkPassiveListener() {
let supportsPassive = false;
try {
const opts = Object.defineProperty({}, "passive", {
// eslint-disable-next-line
get() {
supportsPassive = true;
}
});
window2.addEventListener("testPassiveListener", null, opts);
} catch (e) {
}
return supportsPassive;
}(),
gestures: function checkGestures() {
return "ongesturestart" in window2;
}()
};
}
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();
function isSafari() {
const ua = window2.navigator.userAgent.toLowerCase();
return ua.indexOf("safari") >= 0 && ua.indexOf("chrome") {
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");
};
on2("init", () => {
if (swiper.params.resizeObserver && typeof window2.ResizeObserver !== "undefined") {
createObserver();
return;
}
window2.addEventListener("resize", resizeHandler);
window2.addEventListener("orientationchange", orientationChangeHandler);
});
on2("destroy", () => {
removeObserver();
window2.removeEventListener("resize", resizeHandler);
window2.removeEventListener("orientationchange", orientationChangeHandler);
});
}
function Observer({
swiper,
extendParams,
on: on2,
emit
}) {
const observers = [];
const window2 = getWindow();
const attach = (target, options = {}) => {
const ObserverFunc = window2.MutationObserver || window2.WebkitMutationObserver;
const observer = new ObserverFunc((mutations) => {
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 = swiper.$el.parents();
for (let i = 0; i {
observers.forEach((observer) => {
observer.disconnect();
});
observers.splice(0, observers.length);
};
extendParams({
observer: false,
observeParents: false,
observeSlideChildren: false
});
on2("init", init);
on2("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((event) => {
if (!self.eventsListeners[event])
self.eventsListeners[event] = [];
self.eventsListeners[event][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(index2, 1);
}
return self;
},
off(events2, handler) {
const self = this;
if (!self.eventsListeners || self.destroyed)
return self;
if (!self.eventsListeners)
return self;
events2.split(" ").forEach((event) => {
if (typeof handler === "undefined") {
self.eventsListeners[event] = [];
} else if (self.eventsListeners[event]) {
self.eventsListeners[event].forEach((eventHandler, index2) => {
if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
self.eventsListeners[event].splice(index2, 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((event) => {
if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
self.eventsAnyListeners.forEach((eventHandler) => {
eventHandler.apply(context, [event, ...data]);
});
}
if (self.eventsListeners && self.eventsListeners[event]) {
self.eventsListeners[event].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[0].clientWidth;
}
if (typeof swiper.params.height !== "undefined" && swiper.params.height !== null) {
height = swiper.params.height;
} else {
height = $el[0].clientHeight;
}
if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
return;
}
width = width - parseInt($el.css("padding-left") || 0, 10) - parseInt($el.css("padding-right") || 0, 10);
height = height - parseInt($el.css("padding-top") || 0, 10) - parseInt($el.css("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,
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 = $wrapperEl.children(`.${swiper.params.slideClass}`);
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 index2 = 0;
if (typeof swiperSize === "undefined") {
return;
}
if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) {
spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiperSize;
}
swiper.virtualSize = -spaceBetween;
if (rtl)
slides.css({
marginLeft: "",
marginBottom: "",
marginTop: ""
});
else
slides.css({
marginRight: "",
marginBottom: "",
marginTop: ""
});
if (params.centeredSlides && params.cssMode) {
setCSSProperty(swiper.wrapperEl, "--swiper-centered-offset-before", "");
setCSSProperty(swiper.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 (snapGrid.length === 0)
snapGrid = [0];
if (params.spaceBetween !== 0) {
const key = swiper.isHorizontal() && rtl ? "marginLeft" : getDirectionLabel("marginRight");
slides.filter((_, slideIndex) => {
if (!params.cssMode)
return true;
if (slideIndex === slides.length - 1) {
return false;
}
return true;
}).css({
[key]: `${spaceBetween}px`
});
}
if (params.centeredSlides && params.centeredSlidesBounds) {
let allSlidesSize = 0;
slidesSizesGrid.forEach((slideSizeValue) => {
allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);
});
allSlidesSize -= params.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 + (params.spaceBetween ? params.spaceBetween : 0);
});
allSlidesSize -= params.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(swiper.wrapperEl, "--swiper-centered-offset-before", `${-snapGrid[0]}px`);
setCSSProperty(swiper.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.hasClass(backFaceHiddenClass);
if (slidesLength {
if (isVirtual) {
return swiper.slides.filter((el) => parseInt(el.getAttribute("data-swiper-slide-index"), 10) === index2)[0];
}
return swiper.slides.eq(index2)[0];
};
if (swiper.params.slidesPerView !== "auto" && swiper.params.slidesPerView > 1) {
if (swiper.params.centeredSlides) {
(swiper.visibleSlides || $([])).each((slide2) => {
activeSlides.push(slide2);
});
} else {
for (i = 0; i swiper.slides.length && !isVirtual)
break;
activeSlides.push(getSlideByIndex(index2));
}
}
} else {
activeSlides.push(getSlideByIndex(swiper.activeIndex));
}
for (i = 0; i newHeight ? height : newHeight;
}
}
if (newHeight || newHeight === 0)
swiper.$wrapperEl.css("height", `${newHeight}px`);
}
function updateSlidesOffset() {
const swiper = this;
const slides = swiper.slides;
for (let i = 0; i = 0 && slideBefore 1 && slideAfter = swiper.size;
if (isVisible) {
swiper.visibleSlides.push(slide2);
swiper.visibleSlidesIndexes.push(i);
slides.eq(i).addClass(params.slideVisibleClass);
}
slide2.progress = rtl ? -slideProgress : slideProgress;
slide2.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
}
swiper.visibleSlides = $(swiper.visibleSlides);
}
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
} = swiper;
const wasBeginning = isBeginning;
const wasEnd = isEnd;
if (translatesDiff === 0) {
progress = 0;
isBeginning = true;
isEnd = true;
} else {
progress = (translate2 - swiper.minTranslate()) / translatesDiff;
isBeginning = progress = 1;
}
Object.assign(swiper, {
progress,
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,
$wrapperEl,
activeIndex,
realIndex
} = swiper;
const isVirtual = swiper.virtual && params.virtual.enabled;
slides.removeClass(`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`);
let activeSlide;
if (isVirtual) {
activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index="${activeIndex}"]`);
} else {
activeSlide = slides.eq(activeIndex);
}
activeSlide.addClass(params.slideActiveClass);
if (params.loop) {
if (activeSlide.hasClass(params.slideDuplicateClass)) {
$wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
} else {
$wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
}
}
let nextSlide = activeSlide.nextAll(`.${params.slideClass}`).eq(0).addClass(params.slideNextClass);
if (params.loop && nextSlide.length === 0) {
nextSlide = slides.eq(0);
nextSlide.addClass(params.slideNextClass);
}
let prevSlide = activeSlide.prevAll(`.${params.slideClass}`).eq(0).addClass(params.slidePrevClass);
if (params.loop && prevSlide.length === 0) {
prevSlide = slides.eq(-1);
prevSlide.addClass(params.slidePrevClass);
}
if (params.loop) {
if (nextSlide.hasClass(params.slideDuplicateClass)) {
$wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${nextSlide.attr("data-swiper-slide-index")}"]`).addClass(params.slideDuplicateNextClass);
} else {
$wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${nextSlide.attr("data-swiper-slide-index")}"]`).addClass(params.slideDuplicateNextClass);
}
if (prevSlide.hasClass(params.slideDuplicateClass)) {
$wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${prevSlide.attr("data-swiper-slide-index")}"]`).addClass(params.slideDuplicatePrevClass);
} else {
$wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${prevSlide.attr("data-swiper-slide-index")}"]`).addClass(params.slideDuplicatePrevClass);
}
}
swiper.emitSlidesClasses();
}
function updateActiveIndex(newActiveIndex) {
const swiper = this;
const translate2 = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
const {
slidesGrid,
snapGrid,
params,
activeIndex: previousIndex,
realIndex: previousRealIndex,
snapIndex: previousSnapIndex
} = swiper;
let activeIndex = newActiveIndex;
let snapIndex;
if (typeof activeIndex === "undefined") {
for (let i = 0; i = slidesGrid[i] && translate2 = slidesGrid[i] && translate2 = slidesGrid[i]) {
activeIndex = i;
}
}
if (params.normalizeSlideIndex) {
if (activeIndex = 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");
}
return;
}
const realIndex = parseInt(swiper.slides.eq(activeIndex).attr("data-swiper-slide-index") || activeIndex, 10);
Object.assign(swiper, {
snapIndex,
realIndex,
previousIndex,
activeIndex
});
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}`)[0];
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 && 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 {
swiper.wrapperEl.style.scrollSnapType = "";
swiper._swiperImmediateVirtual = 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[0].removeEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
swiper.$wrapperEl[0].removeEventListener("webkitTransitionEnd", swiper.onSlideToWrapperTransitionEnd);
swiper.onSlideToWrapperTransitionEnd = null;
delete swiper.onSlideToWrapperTransitionEnd;
swiper.transitionEnd(runCallbacks, direction);
};
}
swiper.$wrapperEl[0].addEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
swiper.$wrapperEl[0].addEventListener("webkitTransitionEnd", swiper.onSlideToWrapperTransitionEnd);
}
return true;
}
function slideToLoop(index2 = 0, speed = this.params.speed, runCallbacks = true, internal) {
if (typeof index2 === "string") {
const indexAsNumber = parseInt(index2, 10);
const isValidNumber = isFinite(indexAsNumber);
if (!isValidNumber) {
throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index2}] given.`);
}
index2 = indexAsNumber;
}
const swiper = this;
let newIndex = index2;
if (swiper.params.loop) {
newIndex += swiper.loopedSlides;
}
return swiper.slideTo(newIndex, speed, runCallbacks, internal);
}
function slideNext(speed = this.params.speed, runCallbacks = true, internal) {
const swiper = this;
const {
animating,
enabled,
params
} = 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) {
index2 += 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 = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
nextTick(() => {
swiper.slideTo(slideToIndex);
});
} else {
swiper.slideTo(slideToIndex);
}
} else if (slideToIndex > swiper.slides.length - slidesPerView) {
swiper.loopFix();
slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
nextTick(() => {
swiper.slideTo(slideToIndex);
});
} else {
swiper.slideTo(slideToIndex);
}
} else {
swiper.slideTo(slideToIndex);
}
}
const slide = {
slideTo,
slideToLoop,
slideNext,
slidePrev,
slideReset,
slideToClosest,
slideToClickedSlide
};
function loopCreate() {
const swiper = this;
const document2 = getDocument();
const {
params,
$wrapperEl
} = swiper;
const $selector = $wrapperEl.children().length > 0 ? $($wrapperEl.children()[0].parentNode) : $wrapperEl;
$selector.children(`.${params.slideClass}.${params.slideDuplicateClass}`).remove();
let slides = $selector.children(`.${params.slideClass}`);
if (params.loopFillGroupWithBlank) {
const blankSlidesNum = params.slidesPerGroup - slides.length % params.slidesPerGroup;
if (blankSlidesNum !== params.slidesPerGroup) {
for (let i = 0; i slides.length && swiper.params.loopedSlidesLimit) {
swiper.loopedSlides = slides.length;
}
const prependSlides = [];
const appendSlides = [];
slides.each((el, index2) => {
const slide2 = $(el);
slide2.attr("data-swiper-slide-index", index2);
});
for (let i = 0; i = 0; i -= 1) {
$selector.prepend($(prependSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
}
}
function loopFix() {
const swiper = this;
swiper.emit("beforeLoopFix");
const {
activeIndex,
slides,
loopedSlides,
allowSlidePrev,
allowSlideNext,
snapGrid,
rtlTranslate: rtl
} = swiper;
let newIndex;
swiper.allowSlidePrev = true;
swiper.allowSlideNext = true;
const snapTranslate = -snapGrid[activeIndex];
const diff = snapTranslate - swiper.getTranslate();
if (activeIndex = slides.length - loopedSlides) {
newIndex = -slides.length + activeIndex + loopedSlides;
newIndex += loopedSlides;
const slideChanged = swiper.slideTo(newIndex, 0, false, true);
if (slideChanged && diff !== 0) {
swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
}
}
swiper.allowSlidePrev = allowSlidePrev;
swiper.allowSlideNext = allowSlideNext;
swiper.emit("loopFix");
}
function loopDestroy() {
const swiper = this;
const {
$wrapperEl,
params,
slides
} = swiper;
$wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass},.${params.slideClass}.${params.slideBlankClass}`).remove();
slides.removeAttr("data-swiper-slide-index");
}
const loop = {
loopCreate,
loopFix,
loopDestroy
};
function setGrabCursor(moving) {
const swiper = this;
if (swiper.support.touch || !swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode)
return;
const el = swiper.params.touchEventsTarget === "container" ? swiper.el : swiper.wrapperEl;
el.style.cursor = "move";
el.style.cursor = moving ? "grabbing" : "grab";
}
function unsetGrabCursor() {
const swiper = this;
if (swiper.support.touch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
return;
}
swiper[swiper.params.touchEventsTarget === "container" ? "el" : "wrapperEl"].style.cursor = "";
}
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(event) {
const swiper = this;
const document2 = getDocument();
const window2 = getWindow();
const data = swiper.touchEventsData;
const {
params,
touches,
enabled
} = swiper;
if (!enabled)
return;
if (swiper.animating && params.preventInteractionOnTransition) {
return;
}
if (!swiper.animating && params.cssMode && params.loop) {
swiper.loopFix();
}
let e = event;
if (e.originalEvent)
e = e.originalEvent;
let $targetEl = $(e.target);
if (params.touchEventsTarget === "wrapper") {
if (!$targetEl.closest(swiper.wrapperEl).length)
return;
}
data.isTouchEvent = e.type === "touchstart";
if (!data.isTouchEvent && "which" in e && e.which === 3)
return;
if (!data.isTouchEvent && "button" in e && e.button > 0)
return;
if (data.isTouched && data.isMoved)
return;
const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== "";
const eventPath = event.composedPath ? event.composedPath() : event.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[0]) : $targetEl.closest(noSwipingSelector)[0])) {
swiper.allowClick = true;
return;
}
if (params.swipeHandler) {
if (!$targetEl.closest(params.swipeHandler)[0])
return;
}
touches.currentX = e.type === "touchstart" ? e.targetTouches[0].pageX : e.pageX;
touches.currentY = e.type === "touchstart" ? e.targetTouches[0].pageY : 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") {
event.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;
if (e.type !== "touchstart") {
let preventDefault = true;
if ($targetEl.is(data.focusableElements)) {
preventDefault = false;
if ($targetEl[0].nodeName === "SELECT") {
data.isTouched = false;
}
}
if (document2.activeElement && $(document2.activeElement).is(data.focusableElements) && document2.activeElement !== $targetEl[0]) {
document2.activeElement.blur();
}
const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !$targetEl[0].isContentEditable) {
e.preventDefault();
}
}
if (swiper.params.freeMode && swiper.params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {
swiper.freeMode.onTouchStart();
}
swiper.emit("touchStart", e);
}
function onTouchMove(event) {
const document2 = getDocument();
const swiper = this;
const data = swiper.touchEventsData;
const {
params,
touches,
rtlTranslate: rtl,
enabled
} = swiper;
if (!enabled)
return;
let e = event;
if (e.originalEvent)
e = e.originalEvent;
if (!data.isTouched) {
if (data.startMoving && data.isScrolling) {
swiper.emit("touchMoveOpposite", e);
}
return;
}
if (data.isTouchEvent && e.type !== "touchmove")
return;
const targetTouch = e.type === "touchmove" && e.targetTouches && (e.targetTouches[0] || e.changedTouches[0]);
const pageX = e.type === "touchmove" ? targetTouch.pageX : e.pageX;
const pageY = e.type === "touchmove" ? targetTouch.pageY : e.pageY;
if (e.preventedByNestedSwiper) {
touches.startX = pageX;
touches.startY = pageY;
return;
}
if (!swiper.allowTouchMove) {
if (!$(e.target).is(data.focusableElements)) {
swiper.allowClick = false;
}
if (data.isTouched) {
Object.assign(touches, {
startX: pageX,
startY: pageY,
currentX: pageX,
currentY: pageY
});
data.touchStartTime = now();
}
return;
}
if (data.isTouchEvent && 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 (data.isTouchEvent && document2.activeElement) {
if (e.target === document2.activeElement && $(e.target).is(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) {
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();
}
if (!data.isMoved) {
if (params.loop && !params.cssMode) {
swiper.loopFix();
}
data.startTranslate = swiper.getTranslate();
swiper.setTransition(0);
if (swiper.animating) {
swiper.$wrapperEl.trigger("webkitTransitionEnd transitionend");
}
data.allowMomentumBounce = false;
if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
swiper.setGrabCursor(true);
}
swiper.emit("sliderFirstMove", e);
}
swiper.emit("sliderMove", e);
data.isMoved = true;
let diff = swiper.isHorizontal() ? diffX : diffY;
touches.diff = diff;
diff *= params.touchRatio;
if (rtl)
diff = -diff;
swiper.swipeDirection = diff > 0 ? "prev" : "next";
data.currentTranslate = diff + data.startTranslate;
let disableParentSwiper = true;
let resistanceRatio = params.resistanceRatio;
if (params.touchReleaseOnEdges) {
resistanceRatio = 0;
}
if (diff > 0 && 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 (swiper.params.freeMode && params.freeMode.enabled && swiper.freeMode) {
swiper.freeMode.onTouchMove();
}
swiper.updateProgress(data.currentTranslate);
swiper.setTranslate(data.currentTranslate);
}
function onTouchEnd(event) {
const swiper = this;
const data = swiper.touchEventsData;
const {
params,
touches,
rtlTranslate: rtl,
slidesGrid,
enabled
} = swiper;
if (!enabled)
return;
let e = event;
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 (swiper.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 = swiper.params.virtual && swiper.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;
swiper.allowSlideNext = true;
swiper.allowSlidePrev = true;
swiper.updateSize();
swiper.updateSlides();
swiper.updateSlidesClasses();
if ((params.slidesPerView === "auto" || params.slidesPerView > 1) && swiper.isEnd && !swiper.isBeginning && !swiper.params.centeredSlides) {
swiper.slideTo(swiper.slides.length - 1, 0, false, true);
} else {
swiper.slideTo(swiper.activeIndex, 0, false, true);
}
if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
swiper.autoplay.run();
}
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);
}
let dummyEventAttached = false;
function dummyEventListener() {
}
const events = (swiper, method) => {
const document2 = getDocument();
const {
params,
touchEvents,
el,
wrapperEl,
device,
support: support2
} = swiper;
const capture = !!params.nested;
const domMethod = method === "on" ? "addEventListener" : "removeEventListener";
const swiperMethod = method;
if (!support2.touch) {
el[domMethod](touchEvents.start, swiper.onTouchStart, false);
document2[domMethod](touchEvents.move, swiper.onTouchMove, capture);
document2[domMethod](touchEvents.end, swiper.onTouchEnd, false);
} else {
const passiveListener = touchEvents.start === "touchstart" && support2.passiveListener && params.passiveListeners ? {
passive: true,
capture: false
} : false;
el[domMethod](touchEvents.start, swiper.onTouchStart, passiveListener);
el[domMethod](touchEvents.move, swiper.onTouchMove, support2.passiveListener ? {
passive: false,
capture
} : capture);
el[domMethod](touchEvents.end, swiper.onTouchEnd, passiveListener);
if (touchEvents.cancel) {
el[domMethod](touchEvents.cancel, swiper.onTouchEnd, passiveListener);
}
}
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);
}
};
function attachEvents() {
const swiper = this;
const document2 = getDocument();
const {
params,
support: support2
} = 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);
if (support2.touch && !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 {
activeIndex,
initialized,
loopedSlides = 0,
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.removeClass(`${params.containerModifierClass}grid ${params.containerModifierClass}grid-column`);
swiper.emitContainerClasses();
} else if (!wasMultiRow && isMultiRow) {
$el.addClass(`${params.containerModifierClass}grid`);
if (breakpointParams.grid.fill && breakpointParams.grid.fill === "column" || !breakpointParams.grid.fill && params.grid.fill === "column") {
$el.addClass(`${params.containerModifierClass}grid-column`);
}
swiper.emitContainerClasses();
}
["navigation", "pagination", "scrollbar"].forEach((prop) => {
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();
swiper.updateSlides();
swiper.slideTo(activeIndex - loopedSlides + swiper.loopedSlides, 0, false);
}
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,
support: support2
} = swiper;
const suffixes = prepareClasses(["initialized", params.direction, {
"pointer-events": !support2.touch
}, {
"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.addClass([...classNames].join(" "));
swiper.emitContainerClasses();
}
function removeClasses() {
const swiper = this;
const {
$el,
classNames
} = swiper;
$el.removeClass(classNames.join(" "));
swiper.emitContainerClasses();
}
const classes = {
addClasses,
removeClasses
};
function loadImage(imageEl, src, srcset, sizes, checkForComplete, callback) {
const window2 = getWindow();
let image;
function onReady() {
if (callback)
callback();
}
const isPicture = $(imageEl).parent("picture")[0];
if (!isPicture && (!imageEl.complete || !checkForComplete)) {
if (src) {
image = new window2.Image();
image.onload = onReady;
image.onerror = onReady;
if (sizes) {
image.sizes = sizes;
}
if (srcset) {
image.srcset = srcset;
}
if (src) {
image.src = src;
}
} else {
onReady();
}
} else {
onReady();
}
}
function preloadImages() {
const swiper = this;
swiper.imagesToLoad = swiper.$el.find("img");
function onReady() {
if (typeof swiper === "undefined" || swiper === null || !swiper || swiper.destroyed)
return;
if (swiper.imagesLoaded !== void 0)
swiper.imagesLoaded += 1;
if (swiper.imagesLoaded === swiper.imagesToLoad.length) {
if (swiper.params.updateOnImagesReady)
swiper.update();
swiper.emit("imagesReady");
}
}
for (let i = 0; i 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",
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: 0,
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,
// Images
preloadImages: true,
updateOnImagesReady: true,
// loop
loop: false,
loopAdditionalSlides: 0,
loopedSlides: null,
loopedSlidesLimit: true,
loopFillGroupWithBlank: false,
loopPreventsSlide: 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",
slideBlankClass: "swiper-slide-invisible-blank",
slideActiveClass: "swiper-slide-active",
slideDuplicateActiveClass: "swiper-slide-duplicate-active",
slideVisibleClass: "swiper-slide-visible",
slideDuplicateClass: "swiper-slide-duplicate",
slideNextClass: "swiper-slide-next",
slideDuplicateNextClass: "swiper-slide-duplicate-next",
slidePrevClass: "swiper-slide-prev",
slideDuplicatePrevClass: "swiper-slide-duplicate-prev",
wrapperClass: "swiper-wrapper",
// 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,
images
};
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;
if (params.el && $(params.el).length > 1) {
const swipers = [];
$(params.el).each((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({
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);
}
swiper.$ = $;
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,
// Locks
allowSlideNext: swiper.params.allowSlideNext,
allowSlidePrev: swiper.params.allowSlidePrev,
// Touch Events
touchEvents: function touchEvents() {
const touch = ["touchstart", "touchmove", "touchend", "touchcancel"];
const desktop = ["pointerdown", "pointermove", "pointerup"];
swiper.touchEventsTouch = {
start: touch[0],
move: touch[1],
end: touch[2],
cancel: touch[3]
};
swiper.touchEventsDesktop = {
start: desktop[0],
move: desktop[1],
end: desktop[2]
};
return swiper.support.touch || !swiper.params.simulateTouch ? swiper.touchEventsTouch : swiper.touchEventsDesktop;
}(),
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: now(),
clickTimeout: void 0,
// Velocities
velocities: [],
allowMomentumBounce: void 0,
isTouchEvent: void 0,
startMoving: void 0
},
// 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;
}
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.each((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].swiperSlideSize;
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] 1) && swiper.isEnd && !swiper.params.centeredSlides) {
translated = swiper.slideTo(swiper.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.removeClass(`${swiper.params.containerModifierClass}${currentDirection}`).addClass(`${swiper.params.containerModifierClass}${newDirection}`);
swiper.emitContainerClasses();
swiper.params.direction = newDirection;
swiper.slides.each((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.addClass(`${swiper.params.containerModifierClass}rtl`);
swiper.el.dir = "rtl";
} else {
swiper.$el.removeClass(`${swiper.params.containerModifierClass}rtl`);
swiper.el.dir = "ltr";
}
swiper.update();
}
mount(el) {
const swiper = this;
if (swiper.mounted)
return true;
const $el = $(el || swiper.params.el);
el = $el[0];
if (!el) {
return false;
}
el.swiper = swiper;
const getWrapperSelector = () => {
return `.${(swiper.params.wrapperClass || "").trim().split(" ").join(".")}`;
};
const getWrapper = () => {
if (el && el.shadowRoot && el.shadowRoot.querySelector) {
const res = $(el.shadowRoot.querySelector(getWrapperSelector()));
res.children = (options) => $el.children(options);
return res;
}
if (!$el.children) {
return $($el).children(getWrapperSelector());
}
return $el.children(getWrapperSelector());
};
let $wrapperEl = getWrapper();
if ($wrapperEl.length === 0 && swiper.params.createElements) {
const document2 = getDocument();
const wrapper = document2.createElement("div");
$wrapperEl = $(wrapper);
wrapper.className = swiper.params.wrapperClass;
$el.append(wrapper);
$el.children(`.${swiper.params.slideClass}`).each((slideEl) => {
$wrapperEl.append(slideEl);
});
}
Object.assign(swiper, {
$el,
el,
$wrapperEl,
wrapperEl: $wrapperEl[0],
mounted: true,
// RTL
rtl: el.dir.toLowerCase() === "rtl" || $el.css("direction") === "rtl",
rtlTranslate: swiper.params.direction === "horizontal" && (el.dir.toLowerCase() === "rtl" || $el.css("direction") === "rtl"),
wrongRTL: $wrapperEl.css("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();
if (swiper.params.loop) {
swiper.loopCreate();
}
swiper.updateSize();
swiper.updateSlides();
if (swiper.params.watchOverflow) {
swiper.checkOverflow();
}
if (swiper.params.grabCursor && swiper.enabled) {
swiper.setGrabCursor();
}
if (swiper.params.preloadImages) {
swiper.preloadImages();
}
if (swiper.params.loop) {
swiper.slideTo(swiper.params.initialSlide + swiper.loopedSlides, 0, swiper.params.runCallbacksOnInit, false, true);
} else {
swiper.slideTo(swiper.params.initialSlide, 0, swiper.params.runCallbacksOnInit, false, true);
}
swiper.attachEvents();
swiper.initialized = true;
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.removeAttr("style");
$wrapperEl.removeAttr("style");
if (slides && slides.length) {
slides.removeClass([params.slideVisibleClass, params.slideActiveClass, params.slideNextClass, params.slidePrevClass].join(" ")).removeAttr("style").removeAttr("data-swiper-slide-index");
}
}
swiper.emit("destroy");
Object.keys(swiper.eventsListeners).forEach((eventName) => {
swiper.off(eventName);
});
if (deleteInstance !== false) {
swiper.$el[0].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 createElementIfNotDefined(swiper, originalParams, params, checkProps) {
const document2 = getDocument();
if (swiper.params.createElements) {
Object.keys(checkProps).forEach((key) => {
if (!params[key] && params.auto === true) {
let element = swiper.$el.children(`.${checkProps[key]}`)[0];
if (!element) {
element = document2.createElement("div");
element.className = checkProps[key];
swiper.$el.append(element);
}
params[key] = element;
originalParams[key] = element;
}
});
}
return params;
}
function classesToSelector(classes2 = "") {
return `.${classes2.trim().replace(/([\.:!\/])/g, "\\$1").replace(/ /g, ".")}`;
}
function Pagination({
swiper,
extendParams,
on: on2,
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,
$el: null,
bullets: []
};
let bulletSize;
let dynamicBulletIndex = 0;
function isPaginationDisabled() {
return !swiper.params.pagination.el || !swiper.pagination.el || !swiper.pagination.$el || swiper.pagination.$el.length === 0;
}
function setSideBullets($bulletEl, position) {
const {
bulletActiveClass
} = swiper.params.pagination;
$bulletEl[position]().addClass(`${bulletActiveClass}-${position}`)[position]().addClass(`${bulletActiveClass}-${position}-${position}`);
}
function update2() {
const rtl = swiper.rtl;
const params = swiper.params.pagination;
if (isPaginationDisabled())
return;
const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;
const $el = swiper.pagination.$el;
let current;
const total = swiper.params.loop ? Math.ceil((slidesLength - swiper.loopedSlides * 2) / swiper.params.slidesPerGroup) : swiper.snapGrid.length;
if (swiper.params.loop) {
current = Math.ceil((swiper.activeIndex - swiper.loopedSlides) / swiper.params.slidesPerGroup);
if (current > slidesLength - 1 - swiper.loopedSlides * 2) {
current -= slidesLength - swiper.loopedSlides * 2;
}
if (current > total - 1)
current -= total;
if (current 0) {
const bullets = swiper.pagination.bullets;
let firstIndex;
let lastIndex;
let midIndex;
if (params.dynamicBullets) {
bulletSize = bullets.eq(0)[swiper.isHorizontal() ? "outerWidth" : "outerHeight"](true);
$el.css(swiper.isHorizontal() ? "width" : "height", `${bulletSize * (params.dynamicMainBullets + 4)}px`);
if (params.dynamicMainBullets > 1 && swiper.previousIndex !== void 0) {
dynamicBulletIndex += current - (swiper.previousIndex - swiper.loopedSlides || 0);
if (dynamicBulletIndex > params.dynamicMainBullets - 1) {
dynamicBulletIndex = params.dynamicMainBullets - 1;
} else if (dynamicBulletIndex `${params.bulletActiveClass}${suffix}`).join(" "));
if ($el.length > 1) {
bullets.each((bullet) => {
const $bullet = $(bullet);
const bulletIndex = $bullet.index();
if (bulletIndex === current) {
$bullet.addClass(params.bulletActiveClass);
}
if (params.dynamicBullets) {
if (bulletIndex >= firstIndex && bulletIndex = bullets.length) {
for (let i = params.dynamicMainBullets; i >= 0; i -= 1) {
bullets.eq(bullets.length - i).addClass(`${params.bulletActiveClass}-main`);
}
bullets.eq(bullets.length - params.dynamicMainBullets - 1).addClass(`${params.bulletActiveClass}-prev`);
} else {
setSideBullets($firstDisplayedBullet, "prev");
setSideBullets($lastDisplayedBullet, "next");
}
} else {
setSideBullets($firstDisplayedBullet, "prev");
setSideBullets($lastDisplayedBullet, "next");
}
}
}
if (params.dynamicBullets) {
const dynamicBulletsLength = Math.min(bullets.length, params.dynamicMainBullets + 4);
const bulletsOffset = (bulletSize * dynamicBulletsLength - bulletSize) / 2 - midIndex * bulletSize;
const offsetProp = rtl ? "right" : "left";
bullets.css(swiper.isHorizontal() ? offsetProp : "top", `${bulletsOffset}px`);
}
}
if (params.type === "fraction") {
$el.find(classesToSelector(params.currentClass)).text(params.formatFractionCurrent(current + 1));
$el.find(classesToSelector(params.totalClass)).text(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;
}
$el.find(classesToSelector(params.progressbarFillClass)).transform(`translate3d(0,0,0) scaleX(${scaleX}) scaleY(${scaleY})`).transition(swiper.params.speed);
}
if (params.type === "custom" && params.renderCustom) {
$el.html(params.renderCustom(swiper, current + 1, total));
emit("paginationRender", $el[0]);
} else {
emit("paginationUpdate", $el[0]);
}
if (swiper.params.watchOverflow && swiper.enabled) {
$el[swiper.isLocked ? "addClass" : "removeClass"](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;
const $el = swiper.pagination.$el;
let paginationHTML = "";
if (params.type === "bullets") {
let numberOfBullets = swiper.params.loop ? Math.ceil((slidesLength - swiper.loopedSlides * 2) / swiper.params.slidesPerGroup) : swiper.snapGrid.length;
if (swiper.params.freeMode && swiper.params.freeMode.enabled && !swiper.params.loop && numberOfBullets > slidesLength) {
numberOfBullets = slidesLength;
}
for (let i = 0; i `;
}
}
$el.html(paginationHTML);
swiper.pagination.bullets = $el.find(classesToSelector(params.bulletClass));
}
if (params.type === "fraction") {
if (params.renderFraction) {
paginationHTML = params.renderFraction.call(swiper, params.currentClass, params.totalClass);
} else {
paginationHTML = ` / `;
}
$el.html(paginationHTML);
}
if (params.type === "progressbar") {
if (params.renderProgressbar) {
paginationHTML = params.renderProgressbar.call(swiper, params.progressbarFillClass);
} else {
paginationHTML = ``;
}
$el.html(paginationHTML);
}
if (params.type !== "custom") {
emit("paginationRender", swiper.pagination.$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 = $(params.el);
if ($el.length === 0)
return;
if (swiper.params.uniqueNavElements && typeof params.el === "string" && $el.length > 1) {
$el = swiper.$el.find(params.el);
if ($el.length > 1) {
$el = $el.filter((el) => {
if ($(el).parents(".swiper")[0] !== swiper.el)
return false;
return true;
});
}
}
if (params.type === "bullets" && params.clickable) {
$el.addClass(params.clickableClass);
}
$el.addClass(params.modifierClass + params.type);
$el.addClass(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
if (params.type === "bullets" && params.dynamicBullets) {
$el.addClass(`${params.modifierClass}${params.type}-dynamic`);
dynamicBulletIndex = 0;
if (params.dynamicMainBullets {
if (swiper.params.pagination.enabled === false) {
disable();
} else {
init();
render();
update2();
}
});
on2("activeIndexChange", () => {
if (swiper.params.loop) {
update2();
} else if (typeof swiper.snapIndex === "undefined") {
update2();
}
});
on2("snapIndexChange", () => {
if (!swiper.params.loop) {
update2();
}
});
on2("slidesLengthChange", () => {
if (swiper.params.loop) {
render();
update2();
}
});
on2("snapGridLengthChange", () => {
if (!swiper.params.loop) {
render();
update2();
}
});
on2("destroy", () => {
destroy();
});
on2("enable disable", () => {
const {
$el
} = swiper.pagination;
if ($el) {
$el[swiper.enabled ? "removeClass" : "addClass"](swiper.params.pagination.lockClass);
}
});
on2("lock unlock", () => {
update2();
});
on2("click", (_s, e) => {
const targetEl = e.target;
const {
$el
} = swiper.pagination;
if (swiper.params.pagination.el && swiper.params.pagination.hideOnClick && $el && $el.length > 0 && !$(targetEl).hasClass(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.hasClass(swiper.params.pagination.hiddenClass);
if (isHidden === true) {
emit("paginationShow");
} else {
emit("paginationHide");
}
$el.toggleClass(swiper.params.pagination.hiddenClass);
}
});
const enable = () => {
swiper.$el.removeClass(swiper.params.pagination.paginationDisabledClass);
if (swiper.pagination.$el) {
swiper.pagination.$el.removeClass(swiper.params.pagination.paginationDisabledClass);
}
init();
render();
update2();
};
const disable = () => {
swiper.$el.addClass(swiper.params.pagination.paginationDisabledClass);
if (swiper.pagination.$el) {
swiper.pagination.$el.addClass(swiper.params.pagination.paginationDisabledClass);
}
destroy();
};
Object.assign(swiper.pagination, {
enable,
disable,
render,
update: update2,
init,
destroy
});
}
class Sliders {
constructor() {
this.initSliders();
}
initSliders() {
function initFooterBenefitsSwiper() {
if (window.innerWidth = 700 && swiperFooterBenefitsInstance) {
swiperFooterBenefitsInstance.destroy(true, true);
swiperFooterBenefitsInstance = null;
} else if (window.innerWidth {
item.addEventListener("click", (event) => {
event.preventDefault();
this.goToVac();
});
});
}
goToVac() {
if (__privateGet(this, _blockVac)) {
__privateGet(this, _blockVac).scrollIntoView({ behavior: "smooth" });
} else {
window.scrollTo({ top: 0, behavior: "smooth" });
}
}
}
_hrefs = new WeakMap();
_blockVac = new WeakMap();
window.addEventListener("DOMContentLoaded", () => {
new Sliders();
new Hrefs();
});
//
} catch (e) {console.error(e);}};
Ключевые навыки
- Java
- Spring Framework
- REST
- SQL
- Spring Boot