Product manager
Т-Банк. ИТ. Управление продуктами и проектамиСанкт-ПетербургHH.ru
Описание вакансии
В Т-Банке продуктовые команды разрабатывают более 50 продуктов для миллионов клиентов. Мы развиваем финансовые продукты, такие как банковские карты, кредиты, вклады и счета, оплату онлайн-покупок, и нефинансовые — от подписок до бронирования авиабилетов и отелей.
Мы быстро развиваемся и ищем продакт-менеджеров в разные направления.
Что вас ждет:
— Работа в продуктовых командах вместе с продуктовыми и бизнес-аналитиками, ML, дизайнерами и разработчиками. Команда вовлечена в процесс генерации гипотез и замотивирована быстро их проверять.
— Множество данных, развитая культура тестирования и data-driven-, informed- и inspired-подходы к принятию решений.
— Работа над MLP вместо MVP. Делаем так, чтобы продукт не только был жизнеспособным, но и нравился пользователям: был удобным, функциональным и надежным.
— Минимум инструкций сверху. Мы не ограничиваем фреймворками, KPI и мнениями топов. Решайте сами, как работать, — мы смотрим на результат.
— Обучение за счет компании, сильное комьюнити продактов, опытные менторы, внутренняя база знаний, материалы докладов и интервью.
— Постоянное развитие продуктовой культуры. Используем собственную платформу для A/B-тестирования, инструменты для работы с данными и сбора фидбэка, проведения качественных и аналитических исследований.
— Гибкая оргструктура. Если почувствуете, что сделали все в своем продукте, рядом будет ждать другой продукт, проект или молодой продакт, которого надо взять под крыло.
Обязанности:
- Формировать и защищать видение, цели и планы по продукту
- Координировать кросс-функциональную команду
- Генерировать гипотезы на основе пользовательских исследований, аналитики, конкурентного анализа и брейншторма
- Проводить глубинные исследования с пользователями
- Принимать решения на основе данных, используя data-driven-подход
- Ставить задачи команде разработки и смежным направлениям, контролировать их выполнение
- Формировать и собирать бизнес-требования
- Отвечать за приоритизацию бэклога
Требования:
- У вас есть опыт работы продакт-менеджером от 3 лет
- Проводили качественные и количественные исследования
- Управляли кросс-функциональными командами
- Умеете принимать решения на основе данных, используя data-driven-подход
- Разбираетесь в экономике продукта, видите точки роста
- Разбираетесь в product discovery, умеете проводить качественные и количественные исследования и работать с аналитикой
- Умеете выстраивать процессы и приоритизировать
- Умеете управлять проектами по Agile, писать требования, управлять бэклогом и сроками
- Мыслите стратегически, умеете смотреть на проблему сверху, разрабатывать решения на долгосрочную перспективу и доносить видение до команды
- Умеете коммуницировать, договариваться и аргументировать свою точку зрения
Условия:
- Работу в офисе или гибридный формат — по договоренности с руководителем
- Возможность работы в аккредитованной ИТ-компании
- ДМС со стоматологией, включая чекапы, компенсацию покупки лекарств и льготные условия страхования для близких. Еще — страховка от несчастных случаев и болезней
- Рост по карьерному треку: проходите курсы по софт- и хард-скиллам, развивайтесь с поддержкой ментора и повышайте уровень с матрицей компетенций и регулярным ревью
- Сильное комьюнити. Вы будете работать с экспертами в своей области, сможете делиться знаниями и выступать на конференциях, посещать митапы и писать статьи
- Онлайн-консультации с психологами, юристами, специалистами по финансам и здоровому образу жизни
- Компенсацию затрат на спортивные абонементы, приложение Т-Спорта для онлайн-занятий и командные тренировки с коллегами
- 3 дополнительных дня к отпуску — можно использовать для отдыха или получить компенсацию
- Специальные тарифы на продукты Т-Банка и широкую программу скидок от партнеров
- Достойную зарплату — обсудим ее на собеседовании
Т-Банк — это
Работа в Т-Банке — это
-
Продукты, которые любят
Создаем продукты, которыми пользуемся мы сами, наши близкие
и десятки миллионов клиентов
-
Свобода действий
Болеем за задачи и не ограничиваем свободу действий.
Каждый может повлиять на продукт и достичь
сверхрезультатов
-
Рост и развитие
Помогаем вырасти: поощряем инициативу и подсказываем, как
выстроить карьерный трек. Еще у нас есть внутренние курсы
по софт- и хард-скиллам
-
Общие цели
Работаем сообща и вместе ищем решения. Брейнштормим идеи
и объединяемся, чтобы достичь большего
-
Сильное комьюнити
Вы окажетесь среди профессионалов.
Это опытные сотрудники, у которых можно учиться, и младшие
коллеги, которых вы сможете менторить
-
Понятные задачи
и цели
Знаем, какую задачу решаем и зачем. Видим картину целиком
и опираемся на логику и факты
АКЦИОНЕРНОЕ ОБЩЕСТВО «Т-БАНК»
window.jqueryMigrateLTROnLoad = function() {try {
jQuery.UNSAFE_restoreLegacyHtmlPrefilter();
;
//
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
(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]);
class InitSlider {
constructor(props) {
__publicField(this, "classSlider", "");
__publicField(this, "settingsSlider", {});
__publicField(this, "slider", null);
this.classSlider = props.classSlider;
this.settingsSlider = props.settingsSlider;
this.checkSlider();
if (this.settingsSlider.destroySize) {
this.checkResizeSlider();
}
}
checkSlider() {
if (window.matchMedia(this.settingsSlider.destroySize).matches && this.settingsSlider.destroySize) {
if (this.slider) {
try {
this.destroySlider();
} catch (e) {
console.log(e);
}
}
return 1;
} else {
if (!this.slider) {
this.initSlider();
}
}
}
checkResizeSlider() {
window.addEventListener("resize", () => {
this.checkSlider();
});
}
initSlider() {
this.slider = new Swiper(this.classSlider, this.settingsSlider) || null;
}
destroySlider() {
var _a, _b;
this.slider.destroy();
this.slider = null;
(_a = document.querySelectorAll(`${this.classSlider}__slider`)) == null ? void 0 : _a.forEach((i) => {
i.removeAttribute("style");
});
(_b = document.querySelector(`${this.classSlider}__wrapper`)) == null ? void 0 : _b.removeAttribute("style");
}
}
const listSliders = [
{
classSlider: ".tmpl-hh-footer__cards",
settingsSlider: {
modules: [],
speed: 800,
breakpoints: {
0: {
allowTouchMove: true,
enabled: true,
spaceBetween: 12,
slidesPerView: "auto",
slidesOffsetBefore: 16,
slidesOffsetAfter: 16
},
700: {
enabled: false
}
}
}
}
];
const initSliders = () => {
listSliders.map((i) => {
new InitSlider(i);
});
};
window.addEventListener("DOMContentLoaded", () => {
initSliders();
});
//
} catch (e) {console.error(e);}};
Ключевые навыки
- A/B тесты
- Unit-экономика
- CustDev
- Продуктовые метрики