import { C as setInnerHTML, S as setCSSProperty, _ as getTranslate, a as elementIndex, b as nextTick, c as elementOffset, g as getSlideTransformEl, h as getRotateFix, i as elementChildren, l as elementOuterSize, n as createElement, p as elementTransitionEnd, t as classesToTokens, u as elementParents, v as isObject, x as now, y as makeElementsArray } from "./utils-Dd8GX6FD.js";
//#region node_modules/swiper/modules/virtual.mjs
var Virtual = ({ swiper, extendParams, on, emit }) => {
	extendParams({ virtual: {
		enabled: false,
		slides: [],
		cache: true,
		slidesPerViewAutoSlideSize: 320,
		renderSlide: null,
		renderExternal: null,
		renderExternalUpdate: true,
		addSlidesBefore: 0,
		addSlidesAfter: 0
	} });
	let cssModeTimeout;
	swiper.virtual = {
		cache: {},
		from: 0,
		to: 0,
		slides: [],
		offset: 0,
		slidesGrid: []
	};
	function getParams() {
		return swiper.params.virtual;
	}
	let tempDOM;
	const getTempDOM = () => tempDOM ??= document.createElement("div");
	function renderSlide(slide, index) {
		const params = getParams();
		if (params.cache && swiper.virtual.cache[index]) return swiper.virtual.cache[index];
		let slideEl;
		if (params.renderSlide) {
			const rendered = params.renderSlide.call(swiper, slide, index);
			if (typeof rendered === "string") {
				const el = getTempDOM();
				setInnerHTML(el, rendered);
				slideEl = el.children[0];
			} else slideEl = rendered;
		} else if (swiper.isElement) slideEl = createElement("swiper-slide");
		else slideEl = createElement("div", swiper.params.slideClass);
		slideEl.setAttribute("data-swiper-slide-index", String(index));
		if (!params.renderSlide) setInnerHTML(slideEl, slide);
		if (params.cache) swiper.virtual.cache[index] = slideEl;
		return slideEl;
	}
	function update(force, beforeInit, forceActiveIndex) {
		const { slidesPerGroup, centeredSlides, slidesPerView, loop: isLoop, initialSlide } = swiper.params;
		if (beforeInit && !isLoop && (initialSlide ?? 0) > 0) return;
		const { addSlidesBefore, addSlidesAfter, slidesPerViewAutoSlideSize } = getParams();
		const { from: previousFrom, to: previousTo, slides, slidesGrid: previousSlidesGrid, offset: previousOffset } = swiper.virtual;
		if (!swiper.params.cssMode) swiper.updateActiveIndex();
		const activeIndex = typeof forceActiveIndex === "undefined" ? swiper.activeIndex || 0 : forceActiveIndex;
		let offsetProp;
		if (swiper.rtlTranslate) offsetProp = "right";
		else offsetProp = swiper.isHorizontal() ? "left" : "top";
		let slidesPerViewNumeric;
		if (slidesPerView === "auto") if (slidesPerViewAutoSlideSize) {
			let swiperSize = swiper.size;
			if (!swiperSize) swiperSize = swiper.isHorizontal() ? swiper.el.getBoundingClientRect().width : swiper.el.getBoundingClientRect().height;
			slidesPerViewNumeric = Math.max(1, Math.ceil(swiperSize / slidesPerViewAutoSlideSize));
		} else slidesPerViewNumeric = 1;
		else slidesPerViewNumeric = slidesPerView ?? 1;
		const groupSize = slidesPerGroup ?? 1;
		let slidesAfter;
		let slidesBefore;
		if (centeredSlides) {
			slidesAfter = Math.floor(slidesPerViewNumeric / 2) + groupSize + addSlidesAfter;
			slidesBefore = Math.floor(slidesPerViewNumeric / 2) + groupSize + addSlidesBefore;
		} else {
			slidesAfter = slidesPerViewNumeric + (groupSize - 1) + addSlidesAfter;
			slidesBefore = (isLoop ? slidesPerViewNumeric : groupSize) + addSlidesBefore;
		}
		let from = activeIndex - slidesBefore;
		let to = activeIndex + slidesAfter;
		if (!isLoop) {
			from = Math.max(from, 0);
			to = Math.min(to, slides.length - 1);
		}
		let offset = (swiper.slidesGrid[from] || 0) - (swiper.slidesGrid[0] || 0);
		if (isLoop && activeIndex >= slidesBefore) {
			from -= slidesBefore;
			if (!centeredSlides) offset += swiper.slidesGrid[0];
		} else if (isLoop && activeIndex < slidesBefore) {
			from = -slidesBefore;
			if (centeredSlides) offset += swiper.slidesGrid[0];
		}
		Object.assign(swiper.virtual, {
			from,
			to,
			offset,
			slidesGrid: swiper.slidesGrid,
			slidesBefore,
			slidesAfter
		});
		function onRendered() {
			swiper.updateSlides();
			swiper.updateProgress();
			swiper.updateSlidesClasses();
			emit("virtualUpdate");
		}
		if (previousFrom === from && previousTo === to && !force) {
			if (swiper.slidesGrid !== previousSlidesGrid && offset !== previousOffset) swiper.slides.forEach((slideEl) => {
				slideEl.style.setProperty(offsetProp, `${offset - Math.abs(swiper.cssOverflowAdjustment())}px`);
			});
			swiper.updateProgress();
			emit("virtualUpdate");
			return;
		}
		const virtualParams = getParams();
		if (virtualParams.renderExternal) {
			const slidesToRender = [];
			for (let i = from; i <= to; i += 1) slidesToRender.push(slides[i]);
			virtualParams.renderExternal.call(swiper, {
				offset,
				from,
				to,
				slides: slidesToRender
			});
			if (virtualParams.renderExternalUpdate) onRendered();
			else emit("virtualUpdate");
			return;
		}
		const prependIndexes = [];
		const appendIndexes = [];
		const getSlideIndex = (index) => {
			let slideIndex = index;
			if (index < 0) slideIndex = slides.length + index;
			else if (slideIndex >= slides.length) slideIndex = slideIndex - slides.length;
			return slideIndex;
		};
		if (force) swiper.slides.filter((el) => el.matches(`.${swiper.params.slideClass}, swiper-slide`)).forEach((slideEl) => {
			slideEl.remove();
		});
		else for (let i = previousFrom; i <= previousTo; i += 1) if (i < from || i > to) {
			const slideIndex = getSlideIndex(i);
			swiper.slides.filter((el) => el.matches(`.${swiper.params.slideClass}[data-swiper-slide-index="${slideIndex}"], swiper-slide[data-swiper-slide-index="${slideIndex}"]`)).forEach((slideEl) => {
				slideEl.remove();
			});
		}
		const loopFrom = isLoop ? -slides.length : 0;
		const loopTo = isLoop ? slides.length * 2 : slides.length;
		for (let i = loopFrom; i < loopTo; i += 1) if (i >= from && i <= to) {
			const slideIndex = getSlideIndex(i);
			if (typeof previousTo === "undefined" || force) appendIndexes.push(slideIndex);
			else {
				if (i > previousTo) appendIndexes.push(slideIndex);
				if (i < previousFrom) prependIndexes.push(slideIndex);
			}
		}
		appendIndexes.forEach((index) => {
			swiper.slidesEl.append(renderSlide(slides[index], index));
		});
		if (isLoop) for (let i = prependIndexes.length - 1; i >= 0; i -= 1) {
			const index = prependIndexes[i];
			swiper.slidesEl.prepend(renderSlide(slides[index], index));
		}
		else {
			prependIndexes.sort((a, b) => b - a);
			prependIndexes.forEach((index) => {
				swiper.slidesEl.prepend(renderSlide(slides[index], index));
			});
		}
		elementChildren(swiper.slidesEl, ".swiper-slide, swiper-slide").forEach((slideEl) => {
			slideEl.style.setProperty(offsetProp, `${offset - Math.abs(swiper.cssOverflowAdjustment())}px`);
		});
		onRendered();
	}
	function appendSlide(slides) {
		if (slides !== null && typeof slides === "object" && "length" in slides) {
			const arr = slides;
			for (let i = 0; i < arr.length; i += 1) if (arr[i]) swiper.virtual.slides.push(arr[i]);
		} else swiper.virtual.slides.push(slides);
		update(true);
	}
	function prependSlide(slides) {
		const activeIndex = swiper.activeIndex;
		let newActiveIndex = activeIndex + 1;
		let numberOfNewSlides = 1;
		if (Array.isArray(slides)) {
			for (let i = 0; i < slides.length; i += 1) if (slides[i]) swiper.virtual.slides.unshift(slides[i]);
			newActiveIndex = activeIndex + slides.length;
			numberOfNewSlides = slides.length;
		} else swiper.virtual.slides.unshift(slides);
		if (getParams().cache) {
			const cache = swiper.virtual.cache;
			const newCache = {};
			Object.keys(cache).forEach((cachedIndex) => {
				const cachedEl = cache[Number(cachedIndex)];
				const cachedElIndex = cachedEl.getAttribute("data-swiper-slide-index");
				if (cachedElIndex) cachedEl.setAttribute("data-swiper-slide-index", String(parseInt(cachedElIndex, 10) + numberOfNewSlides));
				newCache[parseInt(cachedIndex, 10) + numberOfNewSlides] = cachedEl;
			});
			swiper.virtual.cache = newCache;
		}
		update(true);
		swiper.slideTo(newActiveIndex, 0);
	}
	function removeSlide(slidesIndexes) {
		if (typeof slidesIndexes === "undefined" || slidesIndexes === null) return;
		let activeIndex = swiper.activeIndex;
		const shiftCacheDownFrom = (removedIndex) => {
			Object.keys(swiper.virtual.cache).forEach((key) => {
				const numericKey = Number(key);
				if (numericKey > removedIndex) {
					const shifted = swiper.virtual.cache[numericKey];
					swiper.virtual.cache[numericKey - 1] = shifted;
					shifted.setAttribute("data-swiper-slide-index", String(numericKey - 1));
					delete swiper.virtual.cache[numericKey];
				}
			});
		};
		if (Array.isArray(slidesIndexes)) for (let i = slidesIndexes.length - 1; i >= 0; i -= 1) {
			if (getParams().cache) {
				delete swiper.virtual.cache[slidesIndexes[i]];
				shiftCacheDownFrom(slidesIndexes[i]);
			}
			swiper.virtual.slides.splice(slidesIndexes[i], 1);
			if (slidesIndexes[i] < activeIndex) activeIndex -= 1;
			activeIndex = Math.max(activeIndex, 0);
		}
		else {
			if (getParams().cache) {
				delete swiper.virtual.cache[slidesIndexes];
				shiftCacheDownFrom(slidesIndexes);
			}
			swiper.virtual.slides.splice(slidesIndexes, 1);
			if (slidesIndexes < activeIndex) activeIndex -= 1;
			activeIndex = Math.max(activeIndex, 0);
		}
		update(true);
		swiper.slideTo(activeIndex, 0);
	}
	function removeAllSlides() {
		swiper.virtual.slides = [];
		if (getParams().cache) swiper.virtual.cache = {};
		update(true);
		swiper.slideTo(0, 0);
	}
	on("beforeInit", () => {
		if (!getParams().enabled) return;
		let domSlidesAssigned = false;
		const passedVirtual = swiper.passedParams.virtual;
		if (!passedVirtual || typeof passedVirtual !== "object" || passedVirtual.slides === void 0) {
			const slides = [...swiper.slidesEl.children].filter((el) => el.matches(`.${swiper.params.slideClass}, swiper-slide`));
			if (slides && slides.length) {
				swiper.virtual.slides = [...slides];
				domSlidesAssigned = true;
				slides.forEach((slideEl, slideIndex) => {
					slideEl.setAttribute("data-swiper-slide-index", String(slideIndex));
					swiper.virtual.cache[slideIndex] = slideEl;
					slideEl.remove();
				});
			}
		}
		if (!domSlidesAssigned) swiper.virtual.slides = getParams().slides;
		swiper.classNames.push(`${swiper.params.containerModifierClass}virtual`);
		swiper.params.watchSlidesProgress = true;
		swiper.originalParams.watchSlidesProgress = true;
		update(false, true);
	});
	on("setTranslate", () => {
		if (!getParams().enabled) return;
		if (swiper.params.cssMode && !swiper._immediateVirtual) {
			clearTimeout(cssModeTimeout);
			cssModeTimeout = setTimeout(() => {
				update();
			}, 100);
		} else update();
	});
	on("init update resize", () => {
		if (!getParams().enabled) return;
		if (swiper.params.cssMode) setCSSProperty(swiper.wrapperEl, "--swiper-virtual-size", `${swiper.virtualSize}px`);
	});
	Object.assign(swiper.virtual, {
		appendSlide,
		prependSlide,
		removeSlide,
		removeAllSlides,
		update
	});
};
//#endregion
//#region node_modules/swiper/modules/keyboard.mjs
var Keyboard = ({ swiper, extendParams, on, emit }) => {
	extendParams({ keyboard: {
		enabled: false,
		onlyInViewport: true,
		pageUpDown: true,
		speed: void 0
	} });
	function getParams() {
		return swiper.params.keyboard;
	}
	function handle(event) {
		if (!swiper.enabled) return;
		const { rtlTranslate: rtl } = swiper;
		const e = "originalEvent" in event && event.originalEvent ? event.originalEvent : event;
		const kc = e.keyCode || e.charCode;
		const params = getParams();
		const pageUpDown = !!params.pageUpDown;
		const isPageUp = pageUpDown && kc === 33;
		const isPageDown = pageUpDown && kc === 34;
		const isArrowLeft = kc === 37;
		const isArrowRight = kc === 39;
		const isArrowUp = kc === 38;
		const isArrowDown = kc === 40;
		if (!swiper.allowSlideNext && (swiper.isHorizontal() && isArrowRight || swiper.isVertical() && isArrowDown || isPageDown)) return false;
		if (!swiper.allowSlidePrev && (swiper.isHorizontal() && isArrowLeft || swiper.isVertical() && isArrowUp || isPageUp)) return false;
		if (e.shiftKey || e.altKey || e.ctrlKey || e.metaKey) return;
		const activeElement = document.activeElement;
		if (activeElement && (activeElement.isContentEditable || activeElement.nodeName && (activeElement.nodeName.toLowerCase() === "input" || activeElement.nodeName.toLowerCase() === "textarea"))) return;
		if (params.onlyInViewport && (isPageUp || isPageDown || isArrowLeft || isArrowRight || isArrowUp || isArrowDown)) {
			let inView = false;
			if (elementParents(swiper.el, `.${swiper.params.slideClass}, swiper-slide`).length > 0 && elementParents(swiper.el, `.${swiper.params.slideActiveClass}`).length === 0) return;
			const el = swiper.el;
			const swiperWidth = el.clientWidth;
			const swiperHeight = el.clientHeight;
			const windowWidth = window.innerWidth;
			const windowHeight = window.innerHeight;
			const swiperOffset = elementOffset(el);
			if (rtl) swiperOffset.left -= el.scrollLeft;
			const swiperCoord = [
				[swiperOffset.left, swiperOffset.top],
				[swiperOffset.left + swiperWidth, swiperOffset.top],
				[swiperOffset.left, swiperOffset.top + swiperHeight],
				[swiperOffset.left + swiperWidth, swiperOffset.top + swiperHeight]
			];
			for (let i = 0; i < swiperCoord.length; i += 1) {
				const point = swiperCoord[i];
				if (point[0] >= 0 && point[0] <= windowWidth && point[1] >= 0 && point[1] <= windowHeight) {
					if (point[0] === 0 && point[1] === 0) continue;
					inView = true;
				}
			}
			if (!inView) return void 0;
		}
		const speed = params.speed;
		if (swiper.isHorizontal()) {
			if (isPageUp || isPageDown || isArrowLeft || isArrowRight) {
				if (e.cancelable) e.preventDefault();
			}
			if ((isPageDown || isArrowRight) && !rtl || (isPageUp || isArrowLeft) && rtl) swiper.slideNext(speed);
			if ((isPageUp || isArrowLeft) && !rtl || (isPageDown || isArrowRight) && rtl) swiper.slidePrev(speed);
		} else {
			if (isPageUp || isPageDown || isArrowUp || isArrowDown) {
				if (e.cancelable) e.preventDefault();
			}
			if (isPageDown || isArrowDown) swiper.slideNext(speed);
			if (isPageUp || isArrowUp) swiper.slidePrev(speed);
		}
		emit("keyPress", kc);
	}
	function enable() {
		if (swiper.keyboard.enabled) return;
		document.addEventListener("keydown", handle);
		swiper.keyboard.enabled = true;
	}
	function disable() {
		if (!swiper.keyboard.enabled) return;
		document.removeEventListener("keydown", handle);
		swiper.keyboard.enabled = false;
	}
	swiper.keyboard = {
		enabled: false,
		enable,
		disable
	};
	on("init", () => {
		if (getParams().enabled) enable();
	});
	on("destroy", () => {
		if (swiper.keyboard.enabled) disable();
	});
};
//#endregion
//#region node_modules/swiper/modules/mousewheel.mjs
var Mousewheel = ({ swiper, extendParams, on, emit }) => {
	extendParams({ mousewheel: {
		enabled: false,
		releaseOnEdges: false,
		invert: false,
		forceToAxis: false,
		sensitivity: 1,
		eventsTarget: "container",
		thresholdDelta: null,
		thresholdTime: null,
		noMousewheelClass: "swiper-no-mousewheel"
	} });
	let timeout;
	let lastScrollTime = now();
	let lastEventBeforeSnap;
	let mouseEntered = false;
	const recentWheelEvents = [];
	function getParams() {
		return swiper.params.mousewheel;
	}
	function normalize(e) {
		const PIXEL_STEP = 10;
		const LINE_HEIGHT = 40;
		const PAGE_HEIGHT = 800;
		const ev = e;
		let sX = 0;
		let sY = 0;
		let pX = 0;
		let pY = 0;
		if (ev.detail !== void 0) sY = ev.detail;
		if (ev.wheelDelta !== void 0) sY = -ev.wheelDelta / 120;
		if (ev.wheelDeltaY !== void 0) sY = -ev.wheelDeltaY / 120;
		if (ev.wheelDeltaX !== void 0) sX = -ev.wheelDeltaX / 120;
		if (ev.axis !== void 0 && ev.HORIZONTAL_AXIS !== void 0 && ev.axis === ev.HORIZONTAL_AXIS) {
			sX = sY;
			sY = 0;
		}
		pX = sX * PIXEL_STEP;
		pY = sY * PIXEL_STEP;
		if (ev.deltaY !== void 0) pY = ev.deltaY;
		if (ev.deltaX !== void 0) pX = ev.deltaX;
		if (ev.shiftKey && !pX) {
			pX = pY;
			pY = 0;
		}
		if ((pX || pY) && ev.deltaMode) if (ev.deltaMode === 1) {
			pX *= LINE_HEIGHT;
			pY *= LINE_HEIGHT;
		} else {
			pX *= PAGE_HEIGHT;
			pY *= PAGE_HEIGHT;
		}
		if (pX && !sX) sX = pX < 1 ? -1 : 1;
		if (pY && !sY) sY = pY < 1 ? -1 : 1;
		return {
			spinX: sX,
			spinY: sY,
			pixelX: pX,
			pixelY: pY
		};
	}
	function handleMouseEnter() {
		if (!swiper.enabled) return;
		mouseEntered = true;
	}
	function handleMouseLeave() {
		if (!swiper.enabled) return;
		mouseEntered = false;
	}
	function animateSlider(newEvent) {
		const params = getParams();
		if (params.thresholdDelta && newEvent.delta < params.thresholdDelta) return false;
		if (params.thresholdTime && now() - lastScrollTime < params.thresholdTime) return false;
		if (newEvent.delta >= 6 && now() - lastScrollTime < 60) return true;
		if (newEvent.direction < 0) {
			if ((!swiper.isEnd || swiper.params.loop) && !swiper.animating) {
				swiper.slideNext();
				emit("scroll", newEvent.raw);
			}
		} else if ((!swiper.isBeginning || swiper.params.loop) && !swiper.animating) {
			swiper.slidePrev();
			emit("scroll", newEvent.raw);
		}
		lastScrollTime = new window.Date().getTime();
		return false;
	}
	function releaseScroll(newEvent) {
		const params = getParams();
		if (newEvent.direction < 0) {
			if (swiper.isEnd && !swiper.params.loop && params.releaseOnEdges) return true;
		} else if (swiper.isBeginning && !swiper.params.loop && params.releaseOnEdges) return true;
		return false;
	}
	function handle(event) {
		let e = "originalEvent" in event && event.originalEvent ? event.originalEvent : event;
		let disableParentSwiper = true;
		if (!swiper.enabled) return false;
		const params = getParams();
		if (event.target.closest(`.${params.noMousewheelClass}`)) return false;
		if (swiper.params.cssMode) e.preventDefault();
		let targetEl = swiper.el;
		if (params.eventsTarget !== "container") targetEl = document.querySelector(params.eventsTarget);
		const targetElContainsTarget = targetEl && targetEl.contains(e.target);
		if (!mouseEntered && !targetElContainsTarget && !params.releaseOnEdges) return true;
		let delta = 0;
		const rtlFactor = swiper.rtlTranslate ? -1 : 1;
		const data = normalize(e);
		if (params.forceToAxis) if (swiper.isHorizontal()) if (Math.abs(data.pixelX) > Math.abs(data.pixelY)) delta = -data.pixelX * rtlFactor;
		else return true;
		else if (Math.abs(data.pixelY) > Math.abs(data.pixelX)) delta = -data.pixelY;
		else return true;
		else delta = Math.abs(data.pixelX) > Math.abs(data.pixelY) ? -data.pixelX * rtlFactor : -data.pixelY;
		if (delta === 0) return true;
		if (params.invert) delta = -delta;
		let positions = swiper.getTranslate() + delta * (params.sensitivity ?? 1);
		if (positions >= swiper.minTranslate()) positions = swiper.minTranslate();
		if (positions <= swiper.maxTranslate()) positions = swiper.maxTranslate();
		disableParentSwiper = swiper.params.loop ? true : !(positions === swiper.minTranslate() || positions === swiper.maxTranslate());
		if (disableParentSwiper && swiper.params.nested) e.stopPropagation();
		const freeModeParams = swiper.params.freeMode;
		if (!swiper.params.freeMode || !freeModeParams?.enabled) {
			const newEvent = {
				time: now(),
				delta: Math.abs(delta),
				direction: Math.sign(delta),
				raw: event
			};
			if (recentWheelEvents.length >= 2) recentWheelEvents.shift();
			const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : void 0;
			recentWheelEvents.push(newEvent);
			if (prevEvent) {
				if (newEvent.direction !== prevEvent.direction || newEvent.delta > prevEvent.delta || newEvent.time > prevEvent.time + 150) animateSlider(newEvent);
			} else animateSlider(newEvent);
			if (releaseScroll(newEvent)) return true;
		} else {
			const newEvent = {
				time: now(),
				delta: Math.abs(delta),
				direction: Math.sign(delta)
			};
			const ignoreWheelEvents = lastEventBeforeSnap && newEvent.time < lastEventBeforeSnap.time + 500 && newEvent.delta <= lastEventBeforeSnap.delta && newEvent.direction === lastEventBeforeSnap.direction;
			if (!ignoreWheelEvents) {
				lastEventBeforeSnap = void 0;
				let position = swiper.getTranslate() + delta * (params.sensitivity ?? 1);
				const wasBeginning = swiper.isBeginning;
				const wasEnd = swiper.isEnd;
				if (position >= swiper.minTranslate()) position = swiper.minTranslate();
				if (position <= swiper.maxTranslate()) position = swiper.maxTranslate();
				swiper.setTransition(0);
				swiper.setTranslate(position);
				swiper.updateProgress();
				swiper.updateActiveIndex();
				swiper.updateSlidesClasses();
				if (!wasBeginning && swiper.isBeginning || !wasEnd && swiper.isEnd) swiper.updateSlidesClasses();
				if (swiper.params.loop) swiper.loopFix({
					direction: newEvent.direction < 0 ? "next" : "prev",
					byMousewheel: true
				});
				if (freeModeParams?.sticky) {
					clearTimeout(timeout);
					timeout = void 0;
					if (recentWheelEvents.length >= 15) recentWheelEvents.shift();
					const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : void 0;
					const firstEvent = recentWheelEvents[0];
					recentWheelEvents.push(newEvent);
					if (prevEvent && (newEvent.delta > prevEvent.delta || newEvent.direction !== prevEvent.direction)) recentWheelEvents.splice(0);
					else if (recentWheelEvents.length >= 15 && firstEvent && newEvent.time - firstEvent.time < 500 && firstEvent.delta - newEvent.delta >= 1 && newEvent.delta <= 6) {
						const snapToThreshold = delta > 0 ? .8 : .2;
						lastEventBeforeSnap = newEvent;
						recentWheelEvents.splice(0);
						timeout = nextTick(() => {
							if (swiper.destroyed || !swiper.params) return;
							swiper.slideToClosest(swiper.params.speed, true, void 0, snapToThreshold);
						}, 0);
					}
					if (!timeout) timeout = nextTick(() => {
						if (swiper.destroyed || !swiper.params) return;
						const snapToThreshold = .5;
						lastEventBeforeSnap = newEvent;
						recentWheelEvents.splice(0);
						swiper.slideToClosest(swiper.params.speed, true, void 0, snapToThreshold);
					}, 500);
				}
				if (!ignoreWheelEvents) emit("scroll", e);
				const autoplayParams = swiper.params.autoplay;
				if (swiper.params.autoplay && autoplayParams?.disableOnInteraction) swiper.autoplay.stop();
				if (params.releaseOnEdges && (position === swiper.minTranslate() || position === swiper.maxTranslate())) return true;
			}
		}
		if (e.cancelable) e.preventDefault();
		return false;
	}
	function events(method) {
		const params = getParams();
		let targetEl = swiper.el;
		if (params.eventsTarget !== "container") targetEl = document.querySelector(params.eventsTarget);
		targetEl[method]("mouseenter", handleMouseEnter);
		targetEl[method]("mouseleave", handleMouseLeave);
		targetEl[method]("wheel", handle);
	}
	function enable() {
		if (swiper.params.cssMode) {
			swiper.wrapperEl.removeEventListener("wheel", handle);
			return true;
		}
		if (swiper.mousewheel.enabled) return false;
		events("addEventListener");
		swiper.mousewheel.enabled = true;
		return true;
	}
	function disable() {
		if (swiper.params.cssMode) {
			swiper.wrapperEl.addEventListener("wheel", handle);
			return true;
		}
		if (!swiper.mousewheel.enabled) return false;
		events("removeEventListener");
		swiper.mousewheel.enabled = false;
		return true;
	}
	on("init", () => {
		const params = getParams();
		if (!params.enabled && swiper.params.cssMode) disable();
		if (params.enabled) enable();
	});
	swiper.mousewheel = {
		enabled: false,
		enable,
		disable
	};
	on("destroy", () => {
		if (swiper.params.cssMode) enable();
		if (swiper.mousewheel.enabled) disable();
	});
};
//#endregion
//#region node_modules/swiper/shared/create-element-if-not-defined.mjs
function createElementIfNotDefined(swiper, originalParams, params, checkProps) {
	const target = params ?? {};
	const original = originalParams ?? {};
	if (swiper.params.createElements) Object.keys(checkProps).forEach((key) => {
		if (!target[key] && target.auto === true) {
			let element = elementChildren(swiper.el, `.${checkProps[key]}`)[0];
			if (!element) {
				element = createElement("div", checkProps[key]);
				element.className = checkProps[key];
				swiper.el.append(element);
			}
			target[key] = element;
			original[key] = element;
		}
	});
	return target;
}
//#endregion
//#region node_modules/swiper/modules/navigation.mjs
var arrowSvg = `<svg class="swiper-navigation-icon" width="11" height="20" viewBox="0 0 11 20" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M0.38296 20.0762C0.111788 19.805 0.111788 19.3654 0.38296 19.0942L9.19758 10.2796L0.38296 1.46497C0.111788 1.19379 0.111788 0.754138 0.38296 0.482966C0.654131 0.211794 1.09379 0.211794 1.36496 0.482966L10.4341 9.55214C10.8359 9.9539 10.8359 10.6053 10.4341 11.007L1.36496 20.0762C1.09379 20.3474 0.654131 20.3474 0.38296 20.0762Z" fill="currentColor"/></svg>`;
var Navigation = ({ swiper, extendParams, on, emit }) => {
	extendParams({ navigation: {
		nextEl: null,
		prevEl: null,
		addIcons: true,
		hideOnClick: false,
		disabledClass: "swiper-button-disabled",
		hiddenClass: "swiper-button-hidden",
		lockClass: "swiper-button-lock",
		navigationDisabledClass: "swiper-navigation-disabled"
	} });
	swiper.navigation = {
		nextEl: null,
		prevEl: null,
		arrowSvg
	};
	function getParams() {
		return swiper.params.navigation;
	}
	function getEl(el) {
		let res;
		if (el && typeof el === "string" && swiper.isElement) {
			res = swiper.el.querySelector(el) || swiper.hostEl.querySelector(el);
			if (res) return res;
		}
		if (el) {
			if (typeof el === "string") res = [...document.querySelectorAll(el)];
			if (swiper.params.uniqueNavElements && typeof el === "string" && res && res.length > 1 && swiper.el.querySelectorAll(el).length === 1) res = swiper.el.querySelector(el);
			else if (res && res.length === 1) res = res[0];
		}
		if (el && !res) return el;
		return res;
	}
	function toggleEl(el, disabled) {
		const params = getParams();
		makeElementsArray(el).forEach((subEl) => {
			if (subEl) {
				subEl.classList[disabled ? "add" : "remove"](...params.disabledClass.split(" "));
				if (subEl.tagName === "BUTTON") subEl.disabled = disabled;
				if (swiper.params.watchOverflow && swiper.enabled) subEl.classList[swiper.isLocked ? "add" : "remove"](params.lockClass);
			}
		});
	}
	function update() {
		const { nextEl, prevEl } = swiper.navigation;
		if (swiper.params.loop) {
			toggleEl(prevEl, false);
			toggleEl(nextEl, false);
			return;
		}
		toggleEl(prevEl, swiper.isBeginning && !swiper.params.rewind);
		toggleEl(nextEl, swiper.isEnd && !swiper.params.rewind);
	}
	function onPrevClick(e) {
		e.preventDefault();
		if (swiper.isBeginning && !swiper.params.loop && !swiper.params.rewind) return;
		swiper.slidePrev();
		emit("navigationPrev");
	}
	function onNextClick(e) {
		e.preventDefault();
		if (swiper.isEnd && !swiper.params.loop && !swiper.params.rewind) return;
		swiper.slideNext();
		emit("navigationNext");
	}
	function init() {
		swiper.params.navigation = createElementIfNotDefined(swiper, swiper.originalParams.navigation, swiper.params.navigation, {
			nextEl: "swiper-button-next",
			prevEl: "swiper-button-prev"
		});
		const params = getParams();
		if (!(params.nextEl || params.prevEl)) return;
		const nextEl = getEl(params.nextEl);
		const prevEl = getEl(params.prevEl);
		Object.assign(swiper.navigation, {
			nextEl,
			prevEl
		});
		const nextEls = makeElementsArray(nextEl);
		const prevEls = makeElementsArray(prevEl);
		const initButton = (el, dir) => {
			if (el) {
				if (params.addIcons && el.matches(".swiper-button-next,.swiper-button-prev") && !el.querySelector("svg")) {
					const tempEl = document.createElement("div");
					setInnerHTML(tempEl, arrowSvg);
					const svgEl = tempEl.querySelector("svg");
					if (svgEl) el.appendChild(svgEl);
					tempEl.remove();
				}
				el.addEventListener("click", dir === "next" ? onNextClick : onPrevClick);
			}
			if (!swiper.enabled && el) el.classList.add(...params.lockClass.split(" "));
		};
		nextEls.forEach((el) => initButton(el, "next"));
		prevEls.forEach((el) => initButton(el, "prev"));
	}
	function destroy() {
		const params = getParams();
		const { nextEl, prevEl } = swiper.navigation;
		const nextEls = makeElementsArray(nextEl);
		const prevEls = makeElementsArray(prevEl);
		const destroyButton = (el, dir) => {
			el.removeEventListener("click", dir === "next" ? onNextClick : onPrevClick);
			el.classList.remove(...params.disabledClass.split(" "));
		};
		nextEls.forEach((el) => destroyButton(el, "next"));
		prevEls.forEach((el) => destroyButton(el, "prev"));
	}
	on("init", () => {
		if (getParams().enabled === false) disable();
		else {
			init();
			update();
		}
	});
	on("toEdge fromEdge lock unlock", () => {
		update();
	});
	on("destroy", () => {
		destroy();
	});
	on("enable disable", () => {
		const params = getParams();
		const { nextEl, prevEl } = swiper.navigation;
		const nextEls = makeElementsArray(nextEl);
		const prevEls = makeElementsArray(prevEl);
		if (swiper.enabled) {
			update();
			return;
		}
		[...nextEls, ...prevEls].filter((el) => !!el).forEach((el) => el.classList.add(params.lockClass));
	});
	on("click", (_s, e) => {
		const params = getParams();
		const { nextEl, prevEl } = swiper.navigation;
		const nextEls = makeElementsArray(nextEl);
		const prevEls = makeElementsArray(prevEl);
		const targetEl = e.target;
		let targetIsButton = prevEls.includes(targetEl) || nextEls.includes(targetEl);
		if (swiper.isElement && !targetIsButton) {
			const path = e.composedPath ? e.composedPath() : [];
			if (path.length) targetIsButton = path.find((pathEl) => nextEls.includes(pathEl) || prevEls.includes(pathEl));
		}
		if (params.hideOnClick && !targetIsButton) {
			if (swiper.pagination && swiper.params.pagination && swiper.params.pagination.clickable && (swiper.pagination.el === targetEl || swiper.pagination.el.contains(targetEl))) return;
			let isHidden;
			if (nextEls.length) isHidden = nextEls[0].classList.contains(params.hiddenClass);
			else if (prevEls.length) isHidden = prevEls[0].classList.contains(params.hiddenClass);
			if (isHidden === true) emit("navigationShow");
			else emit("navigationHide");
			[...nextEls, ...prevEls].filter((el) => !!el).forEach((el) => el.classList.toggle(params.hiddenClass));
		}
	});
	const enable = () => {
		const params = getParams();
		swiper.el.classList.remove(...params.navigationDisabledClass.split(" "));
		init();
		update();
	};
	const disable = () => {
		const params = getParams();
		swiper.el.classList.add(...params.navigationDisabledClass.split(" "));
		destroy();
	};
	Object.assign(swiper.navigation, {
		enable,
		disable,
		update,
		init,
		destroy
	});
};
//#endregion
//#region node_modules/swiper/shared/classes-to-selector.mjs
function classesToSelector(classes = "") {
	return `.${classes.trim().replace(/([.:!+/()[\]#>~*^$|=,'"@{}\\])/g, "\\$1").replace(/ /g, ".")}`;
}
//#endregion
//#region node_modules/swiper/modules/pagination.mjs
var isVirtualEnabled$2 = (swiper) => !!swiper.virtual && !!swiper.params.virtual?.enabled;
var isFreeModeEnabled = (swiper) => !!swiper.params.freeMode?.enabled;
var Pagination = ({ swiper, extendParams, on, emit }) => {
	const pfx = "swiper-pagination";
	extendParams({ pagination: {
		el: null,
		bulletElement: "span",
		clickable: false,
		hideOnClick: false,
		renderBullet: null,
		renderProgressbar: null,
		renderFraction: null,
		renderCustom: null,
		progressbarOpposite: false,
		type: "bullets",
		dynamicBullets: false,
		dynamicMainBullets: 1,
		formatFractionCurrent: (number) => number,
		formatFractionTotal: (number) => number,
		bulletClass: `${pfx}-bullet`,
		bulletActiveClass: `${pfx}-bullet-active`,
		modifierClass: `${pfx}-`,
		currentClass: `${pfx}-current`,
		totalClass: `${pfx}-total`,
		hiddenClass: `${pfx}-hidden`,
		progressbarFillClass: `${pfx}-progressbar-fill`,
		progressbarOppositeClass: `${pfx}-progressbar-opposite`,
		clickableClass: `${pfx}-clickable`,
		lockClass: `${pfx}-lock`,
		horizontalClass: `${pfx}-horizontal`,
		verticalClass: `${pfx}-vertical`,
		paginationDisabledClass: `${pfx}-disabled`
	} });
	swiper.pagination = {
		el: null,
		bullets: []
	};
	let bulletSize;
	let dynamicBulletIndex = 0;
	function getParams() {
		return swiper.params.pagination;
	}
	function isPaginationDisabled() {
		return !getParams().el || !swiper.pagination.el || Array.isArray(swiper.pagination.el) && swiper.pagination.el.length === 0;
	}
	function setSideBullets(bulletEl, position) {
		const { bulletActiveClass } = getParams();
		if (!bulletEl) return;
		let current = bulletEl[`${position === "prev" ? "previous" : "next"}ElementSibling`];
		if (current) {
			current.classList.add(`${bulletActiveClass}-${position}`);
			current = current[`${position === "prev" ? "previous" : "next"}ElementSibling`];
			if (current) current.classList.add(`${bulletActiveClass}-${position}-${position}`);
		}
	}
	function getMoveDirection(prevIndex, nextIndex, length) {
		prevIndex = prevIndex % length;
		nextIndex = nextIndex % length;
		if (nextIndex === prevIndex + 1) return "next";
		else if (nextIndex === prevIndex - 1) return "previous";
	}
	function onBulletClick(e) {
		const bulletEl = e.target.closest(classesToSelector(getParams().bulletClass));
		if (!bulletEl) return;
		e.preventDefault();
		const index = (elementIndex(bulletEl) ?? 0) * (swiper.params.slidesPerGroup ?? 1);
		if (swiper.params.loop) {
			if (swiper.realIndex === index) return;
			const moveDirection = getMoveDirection(swiper.realIndex, index, swiper.slides.length);
			if (moveDirection === "next") swiper.slideNext();
			else if (moveDirection === "previous") swiper.slidePrev();
			else swiper.slideToLoop(index);
		} else swiper.slideTo(index);
	}
	function update() {
		const rtl = swiper.rtl;
		const params = getParams();
		if (isPaginationDisabled()) return;
		const els = makeElementsArray(swiper.pagination.el);
		let current;
		let previousIndex;
		const slidesLength = isVirtualEnabled$2(swiper) ? swiper.virtual.slides.length : swiper.slides.length;
		const total = swiper.params.loop ? Math.ceil(slidesLength / (swiper.params.slidesPerGroup ?? 1)) : swiper.snapGrid.length;
		if (swiper.params.loop) {
			previousIndex = swiper.previousRealIndex || 0;
			current = (swiper.params.slidesPerGroup ?? 1) > 1 ? Math.floor(swiper.realIndex / (swiper.params.slidesPerGroup ?? 1)) : swiper.realIndex;
		} else if (typeof swiper.snapIndex !== "undefined") {
			current = swiper.snapIndex;
			previousIndex = swiper.previousSnapIndex;
		} else {
			previousIndex = swiper.previousIndex || 0;
			current = swiper.activeIndex || 0;
		}
		if (params.type === "bullets" && swiper.pagination.bullets && swiper.pagination.bullets.length > 0) {
			const bullets = swiper.pagination.bullets;
			let firstIndex = 0;
			let lastIndex = 0;
			let midIndex = 0;
			if (params.dynamicBullets) {
				bulletSize = elementOuterSize(bullets[0], swiper.isHorizontal() ? "width" : "height");
				const dim = swiper.isHorizontal() ? "width" : "height";
				els.forEach((subEl) => {
					subEl.style[dim] = `${(bulletSize ?? 0) * (params.dynamicMainBullets + 4)}px`;
				});
				if (params.dynamicMainBullets > 1 && previousIndex !== void 0) {
					dynamicBulletIndex += current - (previousIndex || 0);
					if (dynamicBulletIndex > params.dynamicMainBullets - 1) dynamicBulletIndex = params.dynamicMainBullets - 1;
					else if (dynamicBulletIndex < 0) dynamicBulletIndex = 0;
				}
				firstIndex = Math.max(current - dynamicBulletIndex, 0);
				lastIndex = firstIndex + (Math.min(bullets.length, params.dynamicMainBullets) - 1);
				midIndex = (lastIndex + firstIndex) / 2;
			}
			bullets.forEach((bulletEl) => {
				const classesToRemove = [
					"",
					"-next",
					"-next-next",
					"-prev",
					"-prev-prev",
					"-main"
				].map((suffix) => `${params.bulletActiveClass}${suffix}`).flatMap((s) => typeof s === "string" && s.includes(" ") ? s.split(" ") : [s]);
				bulletEl.classList.remove(...classesToRemove);
			});
			if (els.length > 1) bullets.forEach((bullet) => {
				const bulletIndex = elementIndex(bullet);
				if (bulletIndex === current) bullet.classList.add(...params.bulletActiveClass.split(" "));
				else if (swiper.isElement) bullet.setAttribute("part", "bullet");
				if (params.dynamicBullets && bulletIndex !== void 0) {
					if (bulletIndex >= firstIndex && bulletIndex <= lastIndex) bullet.classList.add(...`${params.bulletActiveClass}-main`.split(" "));
					if (bulletIndex === firstIndex) setSideBullets(bullet, "prev");
					if (bulletIndex === lastIndex) setSideBullets(bullet, "next");
				}
			});
			else {
				const bullet = bullets[current];
				if (bullet) bullet.classList.add(...params.bulletActiveClass.split(" "));
				if (swiper.isElement) bullets.forEach((bulletEl, bulletIndex) => {
					bulletEl.setAttribute("part", bulletIndex === current ? "bullet-active" : "bullet");
				});
				if (params.dynamicBullets) {
					const firstDisplayedBullet = bullets[firstIndex];
					const lastDisplayedBullet = bullets[lastIndex];
					for (let i = firstIndex; i <= lastIndex; i += 1) if (bullets[i]) bullets[i].classList.add(...`${params.bulletActiveClass}-main`.split(" "));
					setSideBullets(firstDisplayedBullet, "prev");
					setSideBullets(lastDisplayedBullet, "next");
				}
			}
			if (params.dynamicBullets) {
				const dynamicBulletsLength = Math.min(bullets.length, params.dynamicMainBullets + 4);
				const bulletsOffset = ((bulletSize ?? 0) * dynamicBulletsLength - (bulletSize ?? 0)) / 2 - midIndex * (bulletSize ?? 0);
				const offsetProp = rtl ? "right" : "left";
				const positionDim = swiper.isHorizontal() ? offsetProp : "top";
				bullets.forEach((bullet) => {
					bullet.style[positionDim] = `${bulletsOffset}px`;
				});
			}
		}
		els.forEach((subEl, subElIndex) => {
			if (params.type === "fraction") {
				subEl.querySelectorAll(classesToSelector(params.currentClass)).forEach((fractionEl) => {
					fractionEl.textContent = String(params.formatFractionCurrent(current + 1));
				});
				subEl.querySelectorAll(classesToSelector(params.totalClass)).forEach((totalEl) => {
					totalEl.textContent = String(params.formatFractionTotal(total));
				});
			}
			if (params.type === "progressbar") {
				let progressbarDirection;
				if (params.progressbarOpposite) progressbarDirection = swiper.isHorizontal() ? "vertical" : "horizontal";
				else progressbarDirection = swiper.isHorizontal() ? "horizontal" : "vertical";
				const scale = (current + 1) / total;
				let scaleX = 1;
				let scaleY = 1;
				if (progressbarDirection === "horizontal") scaleX = scale;
				else scaleY = scale;
				subEl.querySelectorAll(classesToSelector(params.progressbarFillClass)).forEach((progressEl) => {
					progressEl.style.transform = `translate3d(0,0,0) scaleX(${scaleX}) scaleY(${scaleY})`;
					progressEl.style.transitionDuration = `${swiper.params.speed}ms`;
				});
			}
			if (params.type === "custom" && params.renderCustom) {
				setInnerHTML(subEl, params.renderCustom(swiper, current + 1, total));
				if (subElIndex === 0) emit("paginationRender", subEl);
			} else {
				if (subElIndex === 0) emit("paginationRender", subEl);
				emit("paginationUpdate", subEl);
			}
			if (swiper.params.watchOverflow && swiper.enabled) subEl.classList[swiper.isLocked ? "add" : "remove"](params.lockClass);
		});
	}
	function render() {
		const params = getParams();
		if (isPaginationDisabled()) return;
		const gridParams = swiper.params.grid;
		const slidesLength = isVirtualEnabled$2(swiper) ? swiper.virtual.slides.length : swiper.grid && gridParams?.rows && gridParams.rows > 1 ? swiper.slides.length / Math.ceil(gridParams.rows) : swiper.slides.length;
		const els = makeElementsArray(swiper.pagination.el);
		let paginationHTML = "";
		if (params.type === "bullets") {
			let numberOfBullets = swiper.params.loop ? Math.ceil(slidesLength / (swiper.params.slidesPerGroup ?? 1)) : swiper.snapGrid.length;
			if (swiper.params.freeMode && isFreeModeEnabled(swiper) && numberOfBullets > slidesLength) numberOfBullets = slidesLength;
			for (let i = 0; i < numberOfBullets; i += 1) if (params.renderBullet) paginationHTML += params.renderBullet.call(swiper, i, params.bulletClass);
			else paginationHTML += `<${params.bulletElement} ${swiper.isElement ? "part=\"bullet\"" : ""} class="${params.bulletClass}"></${params.bulletElement}>`;
		}
		if (params.type === "fraction") if (params.renderFraction) paginationHTML = params.renderFraction.call(swiper, params.currentClass, params.totalClass);
		else paginationHTML = `<span class="${params.currentClass}"></span> / <span class="${params.totalClass}"></span>`;
		if (params.type === "progressbar") if (params.renderProgressbar) paginationHTML = params.renderProgressbar.call(swiper, params.progressbarFillClass);
		else paginationHTML = `<span class="${params.progressbarFillClass}"></span>`;
		swiper.pagination.bullets = [];
		els.forEach((subEl) => {
			if (params.type !== "custom") setInnerHTML(subEl, paginationHTML || "");
			if (params.type === "bullets") swiper.pagination.bullets.push(...Array.from(subEl.querySelectorAll(classesToSelector(params.bulletClass))));
		});
		if (params.type !== "custom") emit("paginationRender", els[0]);
	}
	function init() {
		swiper.params.pagination = createElementIfNotDefined(swiper, swiper.originalParams.pagination, swiper.params.pagination, { el: "swiper-pagination" });
		const params = getParams();
		if (!params.el) return;
		let el;
		if (typeof params.el === "string" && swiper.isElement) el = swiper.el.querySelector(params.el);
		if (!el && typeof params.el === "string") el = [...document.querySelectorAll(params.el)];
		if (!el) el = params.el;
		if (!el || Array.isArray(el) && el.length === 0) return;
		if (swiper.params.uniqueNavElements && typeof params.el === "string" && Array.isArray(el) && el.length > 1) {
			el = [...swiper.el.querySelectorAll(params.el)];
			if (el.length > 1) {
				const found = el.find((subEl) => {
					if (elementParents(subEl, ".swiper")[0] !== swiper.el) return false;
					return true;
				});
				if (found) el = found;
			}
		}
		if (Array.isArray(el) && el.length === 1) el = el[0];
		Object.assign(swiper.pagination, { el });
		makeElementsArray(el).forEach((subEl) => {
			if (params.type === "bullets" && params.clickable) subEl.classList.add(...(params.clickableClass || "").split(" "));
			subEl.classList.add(params.modifierClass + params.type);
			subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
			if (params.type === "bullets" && params.dynamicBullets) {
				subEl.classList.add(`${params.modifierClass}${params.type}-dynamic`);
				dynamicBulletIndex = 0;
				if (params.dynamicMainBullets < 1) params.dynamicMainBullets = 1;
			}
			if (params.type === "progressbar" && params.progressbarOpposite) subEl.classList.add(params.progressbarOppositeClass);
			if (params.clickable) subEl.addEventListener("click", onBulletClick);
			if (!swiper.enabled) subEl.classList.add(params.lockClass);
		});
	}
	function destroy() {
		const params = getParams();
		if (isPaginationDisabled()) return;
		const el = swiper.pagination.el;
		if (el) makeElementsArray(el).forEach((subEl) => {
			subEl.classList.remove(params.hiddenClass);
			subEl.classList.remove(params.modifierClass + params.type);
			subEl.classList.remove(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
			if (params.clickable) {
				subEl.classList.remove(...(params.clickableClass || "").split(" "));
				subEl.removeEventListener("click", onBulletClick);
			}
		});
		if (swiper.pagination.bullets) swiper.pagination.bullets.forEach((subEl) => subEl.classList.remove(...params.bulletActiveClass.split(" ")));
	}
	on("changeDirection", () => {
		if (!swiper.pagination || !swiper.pagination.el) return;
		const params = getParams();
		makeElementsArray(swiper.pagination.el).forEach((subEl) => {
			subEl.classList.remove(params.horizontalClass, params.verticalClass);
			subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
		});
	});
	on("init", () => {
		if (getParams().enabled === false) disable();
		else {
			init();
			render();
			update();
		}
	});
	on("activeIndexChange", () => {
		if (typeof swiper.snapIndex === "undefined") update();
	});
	on("snapIndexChange", () => {
		update();
	});
	on("snapGridLengthChange", () => {
		render();
		update();
	});
	on("destroy", () => {
		destroy();
	});
	on("enable disable", () => {
		const { el } = swiper.pagination;
		if (el) {
			const params = getParams();
			makeElementsArray(el).forEach((subEl) => subEl.classList[swiper.enabled ? "remove" : "add"](params.lockClass));
		}
	});
	on("lock unlock", () => {
		update();
	});
	on("click", (_s, e) => {
		const targetEl = e.target;
		const els = makeElementsArray(swiper.pagination.el);
		const params = getParams();
		if (params.el && params.hideOnClick && els && els.length > 0 && !targetEl.classList.contains(params.bulletClass)) {
			if (swiper.navigation && (swiper.navigation.nextEl && targetEl === swiper.navigation.nextEl || swiper.navigation.prevEl && targetEl === swiper.navigation.prevEl)) return;
			if (els[0].classList.contains(params.hiddenClass) === true) emit("paginationShow");
			else emit("paginationHide");
			els.forEach((subEl) => subEl.classList.toggle(params.hiddenClass));
		}
	});
	const enable = () => {
		const params = getParams();
		swiper.el.classList.remove(params.paginationDisabledClass);
		const { el } = swiper.pagination;
		if (el) makeElementsArray(el).forEach((subEl) => subEl.classList.remove(params.paginationDisabledClass));
		init();
		render();
		update();
	};
	const disable = () => {
		const params = getParams();
		swiper.el.classList.add(params.paginationDisabledClass);
		const { el } = swiper.pagination;
		if (el) makeElementsArray(el).forEach((subEl) => subEl.classList.add(params.paginationDisabledClass));
		destroy();
	};
	Object.assign(swiper.pagination, {
		enable,
		disable,
		render,
		update,
		init,
		destroy
	});
};
//#endregion
//#region node_modules/swiper/modules/scrollbar.mjs
var Scrollbar = ({ swiper, extendParams, on, emit }) => {
	let isTouched = false;
	let timeout = null;
	let dragTimeout = null;
	let dragStartPos = 0;
	let dragSize = 0;
	let trackSize = 0;
	let divider = 0;
	extendParams({ scrollbar: {
		el: null,
		dragSize: "auto",
		hide: false,
		draggable: false,
		snapOnRelease: true,
		lockClass: "swiper-scrollbar-lock",
		dragClass: "swiper-scrollbar-drag",
		scrollbarDisabledClass: "swiper-scrollbar-disabled",
		horizontalClass: `swiper-scrollbar-horizontal`,
		verticalClass: `swiper-scrollbar-vertical`
	} });
	swiper.scrollbar = {
		el: null,
		dragEl: null
	};
	function getParams() {
		return swiper.params.scrollbar;
	}
	function setTranslate() {
		const params = getParams();
		if (!params.el || !swiper.scrollbar.el) return;
		const { scrollbar, rtlTranslate: rtl } = swiper;
		const { dragEl, el } = scrollbar;
		const progress = swiper.params.loop ? swiper.progressLoop ?? 0 : swiper.progress;
		let newSize = dragSize;
		let newPos = (trackSize - dragSize) * progress;
		if (rtl) {
			newPos = -newPos;
			if (newPos > 0) {
				newSize = dragSize - newPos;
				newPos = 0;
			} else if (-newPos + dragSize > trackSize) newSize = trackSize + newPos;
		} else if (newPos < 0) {
			newSize = dragSize + newPos;
			newPos = 0;
		} else if (newPos + dragSize > trackSize) newSize = trackSize - newPos;
		if (swiper.isHorizontal()) {
			dragEl.style.transform = `translate3d(${newPos}px, 0, 0)`;
			dragEl.style.width = `${newSize}px`;
		} else {
			dragEl.style.transform = `translate3d(0px, ${newPos}px, 0)`;
			dragEl.style.height = `${newSize}px`;
		}
		if (params.hide) {
			if (timeout) clearTimeout(timeout);
			el.style.opacity = "1";
			timeout = setTimeout(() => {
				el.style.opacity = "0";
				el.style.transitionDuration = "400ms";
			}, 1e3);
		}
	}
	function setTransition(duration) {
		if (!getParams().el || !swiper.scrollbar.el) return;
		swiper.scrollbar.dragEl.style.transitionDuration = `${duration}ms`;
	}
	function updateSize() {
		const params = getParams();
		if (!params.el || !swiper.scrollbar.el) return;
		const { scrollbar } = swiper;
		const { dragEl, el } = scrollbar;
		dragEl.style.width = "";
		dragEl.style.height = "";
		trackSize = swiper.isHorizontal() ? el.offsetWidth : el.offsetHeight;
		divider = swiper.size / (swiper.virtualSize + (swiper.params.slidesOffsetBefore ?? 0) - (swiper.params.centeredSlides ? swiper.snapGrid[0] : 0));
		if (params.dragSize === "auto") dragSize = trackSize * divider;
		else dragSize = parseInt(String(params.dragSize), 10);
		if (swiper.isHorizontal()) dragEl.style.width = `${dragSize}px`;
		else dragEl.style.height = `${dragSize}px`;
		if (divider >= 1) el.style.display = "none";
		else el.style.display = "";
		if (params.hide) el.style.opacity = "0";
		if (swiper.params.watchOverflow && swiper.enabled) scrollbar.el.classList[swiper.isLocked ? "add" : "remove"](params.lockClass);
	}
	function getPointerPosition(e) {
		if (swiper.isHorizontal()) return e.clientX ?? e.touches?.[0]?.clientX ?? 0;
		return e.clientY ?? e.touches?.[0]?.clientY ?? 0;
	}
	function setDragPosition(e) {
		const { scrollbar, rtlTranslate: rtl } = swiper;
		const { el } = scrollbar;
		let positionRatio;
		positionRatio = (getPointerPosition(e) - elementOffset(el)[swiper.isHorizontal() ? "left" : "top"] - (dragStartPos !== null ? dragStartPos : dragSize / 2)) / (trackSize - dragSize);
		positionRatio = Math.max(Math.min(positionRatio, 1), 0);
		if (rtl) positionRatio = 1 - positionRatio;
		const position = swiper.minTranslate() + (swiper.maxTranslate() - swiper.minTranslate()) * positionRatio;
		swiper.updateProgress(position);
		swiper.setTranslate(position);
		swiper.updateActiveIndex();
		swiper.updateSlidesClasses();
	}
	function onDragStart(e) {
		const params = getParams();
		const { scrollbar, wrapperEl } = swiper;
		const { el, dragEl } = scrollbar;
		isTouched = true;
		dragStartPos = e.target === dragEl ? getPointerPosition(e) - e.target.getBoundingClientRect()[swiper.isHorizontal() ? "left" : "top"] : null;
		e.preventDefault();
		e.stopPropagation();
		wrapperEl.style.transitionDuration = "100ms";
		dragEl.style.transitionDuration = "100ms";
		setDragPosition(e);
		if (dragTimeout) clearTimeout(dragTimeout);
		el.style.transitionDuration = "0ms";
		if (params.hide) el.style.opacity = "1";
		if (swiper.params.cssMode) swiper.wrapperEl.style.scrollSnapType = "none";
		emit("scrollbarDragStart", e);
	}
	function onDragMove(e) {
		const { scrollbar, wrapperEl } = swiper;
		const { el, dragEl } = scrollbar;
		if (!isTouched) return;
		if (e.cancelable) e.preventDefault();
		setDragPosition(e);
		wrapperEl.style.transitionDuration = "0ms";
		el.style.transitionDuration = "0ms";
		dragEl.style.transitionDuration = "0ms";
		emit("scrollbarDragMove", e);
	}
	function onDragEnd(e) {
		const params = getParams();
		const { scrollbar, wrapperEl } = swiper;
		const { el } = scrollbar;
		if (!isTouched) return;
		isTouched = false;
		if (swiper.params.cssMode) {
			swiper.wrapperEl.style.scrollSnapType = "";
			wrapperEl.style.transitionDuration = "";
		}
		if (params.hide) {
			if (dragTimeout) clearTimeout(dragTimeout);
			dragTimeout = nextTick(() => {
				el.style.opacity = "0";
				el.style.transitionDuration = "400ms";
			}, 1e3);
		}
		emit("scrollbarDragEnd", e);
		if (params.snapOnRelease) swiper.slideToClosest();
	}
	function events(method) {
		const { scrollbar, params } = swiper;
		const el = scrollbar.el;
		if (!el) return;
		const activeListener = params.passiveListeners ? {
			passive: false,
			capture: false
		} : false;
		const passiveListener = params.passiveListeners ? {
			passive: true,
			capture: false
		} : false;
		const eventMethod = method === "on" ? "addEventListener" : "removeEventListener";
		el[eventMethod]("pointerdown", onDragStart, activeListener);
		document[eventMethod]("pointermove", onDragMove, activeListener);
		document[eventMethod]("pointerup", onDragEnd, passiveListener);
	}
	function enableDraggable() {
		if (!getParams().el || !swiper.scrollbar.el) return;
		events("on");
	}
	function disableDraggable() {
		if (!getParams().el || !swiper.scrollbar.el) return;
		events("off");
	}
	function init() {
		const { scrollbar, el: swiperEl } = swiper;
		swiper.params.scrollbar = createElementIfNotDefined(swiper, swiper.originalParams.scrollbar, swiper.params.scrollbar, { el: "swiper-scrollbar" });
		const params = getParams();
		if (!params.el) return;
		let el;
		if (typeof params.el === "string" && swiper.isElement) el = swiper.el.querySelector(params.el);
		else el = params.el;
		if (!el && typeof params.el === "string") {
			el = document.querySelectorAll(params.el);
			if (!el.length) return;
		} else if (!el) el = params.el;
		if (swiper.params.uniqueNavElements && typeof params.el === "string" && el.length > 1 && swiperEl.querySelectorAll(params.el).length === 1) el = swiperEl.querySelector(params.el);
		if (el.length > 0) el = el[0];
		const elTyped = el;
		elTyped.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
		let dragEl = null;
		if (elTyped) {
			dragEl = elTyped.querySelector(classesToSelector(params.dragClass));
			if (!dragEl) {
				dragEl = createElement("div", params.dragClass);
				elTyped.append(dragEl);
			}
		}
		Object.assign(scrollbar, {
			el: elTyped,
			dragEl
		});
		if (params.draggable) enableDraggable();
		if (elTyped) elTyped.classList[swiper.enabled ? "remove" : "add"](...classesToTokens(params.lockClass));
	}
	function destroy() {
		const params = getParams();
		const el = swiper.scrollbar.el;
		if (el) el.classList.remove(...classesToTokens(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass));
		disableDraggable();
	}
	on("changeDirection", () => {
		if (!swiper.scrollbar || !swiper.scrollbar.el) return;
		const params = getParams();
		makeElementsArray(swiper.scrollbar.el).forEach((subEl) => {
			subEl.classList.remove(params.horizontalClass, params.verticalClass);
			subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
		});
	});
	on("init", () => {
		if (getParams().enabled === false) disable();
		else {
			init();
			updateSize();
			setTranslate();
		}
	});
	on("update resize observerUpdate lock unlock changeDirection", () => {
		updateSize();
	});
	on("setTranslate", () => {
		setTranslate();
	});
	on("setTransition", (_s, duration) => {
		setTransition(duration);
	});
	on("enable disable", () => {
		const { el } = swiper.scrollbar;
		if (el) el.classList[swiper.enabled ? "remove" : "add"](...classesToTokens(getParams().lockClass));
	});
	on("destroy", () => {
		destroy();
	});
	const enable = () => {
		const params = getParams();
		swiper.el.classList.remove(...classesToTokens(params.scrollbarDisabledClass));
		if (swiper.scrollbar.el) swiper.scrollbar.el.classList.remove(...classesToTokens(params.scrollbarDisabledClass));
		init();
		updateSize();
		setTranslate();
	};
	const disable = () => {
		const params = getParams();
		swiper.el.classList.add(...classesToTokens(params.scrollbarDisabledClass));
		if (swiper.scrollbar.el) swiper.scrollbar.el.classList.add(...classesToTokens(params.scrollbarDisabledClass));
		destroy();
	};
	Object.assign(swiper.scrollbar, {
		enable,
		disable,
		updateSize,
		setTranslate,
		init,
		destroy
	});
};
//#endregion
//#region node_modules/swiper/modules/parallax.mjs
var Parallax = ({ swiper, extendParams, on }) => {
	extendParams({ parallax: { enabled: false } });
	function getParams() {
		return swiper.params.parallax;
	}
	const elementsSelector = "[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y], [data-swiper-parallax-opacity], [data-swiper-parallax-scale]";
	const setTransform = (el, progress) => {
		const { rtl } = swiper;
		const rtlFactor = rtl ? -1 : 1;
		const p = el.getAttribute("data-swiper-parallax") || "0";
		let x = el.getAttribute("data-swiper-parallax-x");
		let y = el.getAttribute("data-swiper-parallax-y");
		const scale = el.getAttribute("data-swiper-parallax-scale");
		const opacity = el.getAttribute("data-swiper-parallax-opacity");
		const rotate = el.getAttribute("data-swiper-parallax-rotate");
		if (x || y) {
			x = x || "0";
			y = y || "0";
		} else if (swiper.isHorizontal()) {
			x = p;
			y = "0";
		} else {
			y = p;
			x = "0";
		}
		if (x.indexOf("%") >= 0) x = `${parseInt(x, 10) * progress * rtlFactor}%`;
		else x = `${Number(x) * progress * rtlFactor}px`;
		if (y.indexOf("%") >= 0) y = `${parseInt(y, 10) * progress}%`;
		else y = `${Number(y) * progress}px`;
		if (typeof opacity !== "undefined" && opacity !== null) {
			const opacityNum = Number(opacity);
			const currentOpacity = opacityNum - (opacityNum - 1) * (1 - Math.abs(progress));
			el.style.opacity = String(currentOpacity);
		}
		let transform = `translate3d(${x}, ${y}, 0px)`;
		if (typeof scale !== "undefined" && scale !== null) {
			const scaleNum = Number(scale);
			const currentScale = scaleNum - (scaleNum - 1) * (1 - Math.abs(progress));
			transform += ` scale(${currentScale})`;
		}
		if (rotate && typeof rotate !== "undefined" && rotate !== null) {
			const currentRotate = Number(rotate) * progress * -1;
			transform += ` rotate(${currentRotate}deg)`;
		}
		el.style.transform = transform;
	};
	const setTranslate = () => {
		const { el, slides, progress, snapGrid } = swiper;
		const elements = elementChildren(el, elementsSelector);
		if (swiper.isElement) elements.push(...elementChildren(swiper.hostEl, elementsSelector));
		elements.forEach((subEl) => {
			setTransform(subEl, progress);
		});
		slides.forEach((slideEl, slideIndex) => {
			let slideProgress = slideEl.progress ?? 0;
			if ((swiper.params.slidesPerGroup ?? 1) > 1 && swiper.params.slidesPerView !== "auto") slideProgress += Math.ceil(slideIndex / 2) - progress * (snapGrid.length - 1);
			slideProgress = Math.min(Math.max(slideProgress, -1), 1);
			slideEl.querySelectorAll(`${elementsSelector}, [data-swiper-parallax-rotate]`).forEach((subEl) => {
				setTransform(subEl, slideProgress);
			});
		});
	};
	const setTransition = (duration = swiper.params.speed ?? 300) => {
		const { el, hostEl } = swiper;
		const elements = [...el.querySelectorAll(elementsSelector)];
		if (swiper.isElement) elements.push(...hostEl.querySelectorAll(elementsSelector));
		elements.forEach((parallaxEl) => {
			const attr = parallaxEl.getAttribute("data-swiper-parallax-duration");
			let parallaxDuration = (attr ? parseInt(attr, 10) : 0) || duration;
			if (duration === 0) parallaxDuration = 0;
			parallaxEl.style.transitionDuration = `${parallaxDuration}ms`;
		});
	};
	on("beforeInit", () => {
		if (!getParams().enabled) return;
		swiper.params.watchSlidesProgress = true;
		swiper.originalParams.watchSlidesProgress = true;
	});
	on("init", () => {
		if (!getParams().enabled) return;
		setTranslate();
	});
	on("setTranslate", () => {
		if (!getParams().enabled) return;
		setTranslate();
	});
	on("setTransition", (_swiper, duration) => {
		if (!getParams().enabled) return;
		setTransition(duration);
	});
};
//#endregion
//#region node_modules/swiper/modules/zoom.mjs
var Zoom = ({ swiper, extendParams, on, emit }) => {
	extendParams({ zoom: {
		enabled: false,
		limitToOriginalSize: false,
		maxRatio: 3,
		minRatio: 1,
		panOnMouseMove: false,
		toggle: true,
		containerClass: "swiper-zoom-container",
		zoomedSlideClass: "swiper-slide-zoomed"
	} });
	swiper.zoom = { enabled: false };
	function getParams() {
		return swiper.params.zoom;
	}
	let currentScale = 1;
	let isScaling = false;
	let isPanningWithMouse = false;
	let mousePanStart = {
		x: 0,
		y: 0
	};
	const mousePanSensitivity = -3;
	let fakeGestureTouched = false;
	let fakeGestureMoved = false;
	const evCache = [];
	const gesture = {
		originX: 0,
		originY: 0,
		slideEl: void 0,
		slideWidth: void 0,
		slideHeight: void 0,
		imageEl: void 0,
		imageWrapEl: void 0,
		maxRatio: 3
	};
	const image = {
		isTouched: void 0,
		isMoved: void 0,
		currentX: void 0,
		currentY: void 0,
		minX: void 0,
		minY: void 0,
		maxX: void 0,
		maxY: void 0,
		width: void 0,
		height: void 0,
		startX: void 0,
		startY: void 0,
		touchesStart: {},
		touchesCurrent: {}
	};
	const velocity = {
		x: void 0,
		y: void 0,
		prevPositionX: void 0,
		prevPositionY: void 0,
		prevTime: void 0
	};
	let scale = 1;
	Object.defineProperty(swiper.zoom, "scale", {
		get() {
			return scale;
		},
		set(value) {
			if (scale !== value) {
				const imageEl = gesture.imageEl;
				const slideEl = gesture.slideEl;
				emit("zoomChange", value, imageEl, slideEl);
			}
			scale = value;
		}
	});
	function getDistanceBetweenTouches() {
		if (evCache.length < 2) return 1;
		const x1 = evCache[0].pageX;
		const y1 = evCache[0].pageY;
		const x2 = evCache[1].pageX;
		const y2 = evCache[1].pageY;
		return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
	}
	function getMaxRatio() {
		const params = getParams();
		const attr = gesture.imageWrapEl?.getAttribute("data-swiper-zoom");
		const maxRatio = attr != null ? Number(attr) : params.maxRatio;
		const imageEl = gesture.imageEl;
		if (params.limitToOriginalSize && imageEl && imageEl.naturalWidth) {
			const imageMaxRatio = imageEl.naturalWidth / imageEl.offsetWidth;
			return Math.min(imageMaxRatio, maxRatio);
		}
		return maxRatio;
	}
	function getScaleOrigin() {
		if (evCache.length < 2 || !gesture.imageEl) return [null, null];
		const box = gesture.imageEl.getBoundingClientRect();
		return [(evCache[0].pageX + (evCache[1].pageX - evCache[0].pageX) / 2 - box.x - window.scrollX) / currentScale, (evCache[0].pageY + (evCache[1].pageY - evCache[0].pageY) / 2 - box.y - window.scrollY) / currentScale];
	}
	function getSlideSelector() {
		return swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
	}
	function eventWithinSlide(e) {
		const slideSelector = getSlideSelector();
		const target = e.target;
		if (!target) return false;
		if (target.matches(slideSelector)) return true;
		if (swiper.slides.filter((slideEl) => slideEl.contains(target)).length > 0) return true;
		return false;
	}
	function eventWithinZoomContainer(e) {
		const selector = `.${getParams().containerClass}`;
		const target = e.target;
		if (!target) return false;
		if (target.matches(selector)) return true;
		if ([...swiper.hostEl.querySelectorAll(selector)].filter((containerEl) => containerEl.contains(target)).length > 0) return true;
		return false;
	}
	function onGestureStart(e) {
		if (e.pointerType === "mouse") evCache.splice(0, evCache.length);
		if (!eventWithinSlide(e)) return;
		const params = getParams();
		fakeGestureTouched = false;
		fakeGestureMoved = false;
		evCache.push(e);
		if (evCache.length < 2) return;
		fakeGestureTouched = true;
		gesture.scaleStart = getDistanceBetweenTouches();
		if (!gesture.slideEl) {
			const target = e.target;
			gesture.slideEl = target?.closest(`.${swiper.params.slideClass}, swiper-slide`) ?? void 0;
			if (!gesture.slideEl) gesture.slideEl = swiper.slides[swiper.activeIndex];
			let imageEl = gesture.slideEl?.querySelector(`.${params.containerClass}`) ?? null;
			if (imageEl) imageEl = imageEl.querySelectorAll("picture, img, svg, canvas, .swiper-zoom-target")[0] ?? null;
			gesture.imageEl = imageEl ?? void 0;
			if (imageEl) gesture.imageWrapEl = elementParents(imageEl, `.${params.containerClass}`)[0] ?? void 0;
			else gesture.imageWrapEl = void 0;
			if (!gesture.imageWrapEl) {
				gesture.imageEl = void 0;
				return;
			}
			gesture.maxRatio = getMaxRatio();
		}
		if (gesture.imageEl) {
			const [originX, originY] = getScaleOrigin();
			gesture.originX = originX ?? 0;
			gesture.originY = originY ?? 0;
			gesture.imageEl.style.transitionDuration = "0ms";
		}
		isScaling = true;
	}
	function onGestureChange(e) {
		if (!eventWithinSlide(e)) return;
		const params = getParams();
		const zoom = swiper.zoom;
		const pointerIndex = evCache.findIndex((cachedEv) => cachedEv.pointerId === e.pointerId);
		if (pointerIndex >= 0) evCache[pointerIndex] = e;
		if (evCache.length < 2) return;
		fakeGestureMoved = true;
		gesture.scaleMove = getDistanceBetweenTouches();
		if (!gesture.imageEl) return;
		zoom.scale = gesture.scaleMove / (gesture.scaleStart ?? 1) * currentScale;
		if (zoom.scale > gesture.maxRatio) zoom.scale = gesture.maxRatio - 1 + (zoom.scale - gesture.maxRatio + 1) ** .5;
		if (zoom.scale < params.minRatio) zoom.scale = params.minRatio + 1 - (params.minRatio - zoom.scale + 1) ** .5;
		gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;
	}
	function onGestureEnd(e) {
		if (!eventWithinSlide(e)) return;
		if (e.pointerType === "mouse" && e.type === "pointerout") return;
		const params = getParams();
		const zoom = swiper.zoom;
		const pointerIndex = evCache.findIndex((cachedEv) => cachedEv.pointerId === e.pointerId);
		if (pointerIndex >= 0) evCache.splice(pointerIndex, 1);
		if (!fakeGestureTouched || !fakeGestureMoved) return;
		fakeGestureTouched = false;
		fakeGestureMoved = false;
		if (!gesture.imageEl) return;
		zoom.scale = Math.max(Math.min(zoom.scale, gesture.maxRatio), params.minRatio);
		gesture.imageEl.style.transitionDuration = `${swiper.params.speed}ms`;
		gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;
		currentScale = zoom.scale;
		isScaling = false;
		if (zoom.scale > 1 && gesture.slideEl) gesture.slideEl.classList.add(`${params.zoomedSlideClass}`);
		else if (zoom.scale <= 1 && gesture.slideEl) gesture.slideEl.classList.remove(`${params.zoomedSlideClass}`);
		if (zoom.scale === 1) {
			gesture.originX = 0;
			gesture.originY = 0;
			gesture.slideEl = void 0;
		}
	}
	let allowTouchMoveTimeout;
	function allowTouchMove() {
		swiper.touchEventsData.preventTouchMoveFromPointerMove = false;
	}
	function preventTouchMove() {
		if (allowTouchMoveTimeout !== void 0) clearTimeout(allowTouchMoveTimeout);
		swiper.touchEventsData.preventTouchMoveFromPointerMove = true;
		allowTouchMoveTimeout = setTimeout(() => {
			if (swiper.destroyed) return;
			allowTouchMove();
		});
	}
	function onTouchStart(e) {
		const device = swiper.device;
		if (!gesture.imageEl) return;
		if (image.isTouched) return;
		if (device.android && e.cancelable) e.preventDefault();
		image.isTouched = true;
		const event = evCache.length > 0 ? evCache[0] : e;
		image.touchesStart.x = event.pageX;
		image.touchesStart.y = event.pageY;
	}
	function onTouchMove(e) {
		const isMousePan = e.pointerType === "mouse" && getParams().panOnMouseMove;
		if (!eventWithinSlide(e) || !eventWithinZoomContainer(e)) return;
		const zoom = swiper.zoom;
		if (!gesture.imageEl) return;
		if (!image.isTouched || !gesture.slideEl) {
			if (isMousePan) onMouseMove(e);
			return;
		}
		if (isMousePan) {
			onMouseMove(e);
			return;
		}
		if (!image.isMoved) {
			image.width = gesture.imageEl.offsetWidth || gesture.imageEl.clientWidth;
			image.height = gesture.imageEl.offsetHeight || gesture.imageEl.clientHeight;
			image.startX = getTranslate(gesture.imageWrapEl, "x") || 0;
			image.startY = getTranslate(gesture.imageWrapEl, "y") || 0;
			gesture.slideWidth = gesture.slideEl.offsetWidth;
			gesture.slideHeight = gesture.slideEl.offsetHeight;
			gesture.imageWrapEl.style.transitionDuration = "0ms";
		}
		const scaledWidth = image.width * zoom.scale;
		const scaledHeight = image.height * zoom.scale;
		image.minX = Math.min(gesture.slideWidth / 2 - scaledWidth / 2, 0);
		image.maxX = -image.minX;
		image.minY = Math.min(gesture.slideHeight / 2 - scaledHeight / 2, 0);
		image.maxY = -image.minY;
		image.touchesCurrent.x = evCache.length > 0 ? evCache[0].pageX : e.pageX;
		image.touchesCurrent.y = evCache.length > 0 ? evCache[0].pageY : e.pageY;
		if (Math.max(Math.abs(image.touchesCurrent.x - (image.touchesStart.x ?? 0)), Math.abs(image.touchesCurrent.y - (image.touchesStart.y ?? 0))) > 5) swiper.allowClick = false;
		const startX = image.startX ?? 0;
		const startY = image.startY ?? 0;
		if (!image.isMoved && !isScaling) {
			if (swiper.isHorizontal() && (Math.floor(image.minX) === Math.floor(startX) && image.touchesCurrent.x < (image.touchesStart.x ?? 0) || Math.floor(image.maxX) === Math.floor(startX) && image.touchesCurrent.x > (image.touchesStart.x ?? 0))) {
				image.isTouched = false;
				allowTouchMove();
				return;
			}
			if (!swiper.isHorizontal() && (Math.floor(image.minY) === Math.floor(startY) && image.touchesCurrent.y < (image.touchesStart.y ?? 0) || Math.floor(image.maxY) === Math.floor(startY) && image.touchesCurrent.y > (image.touchesStart.y ?? 0))) {
				image.isTouched = false;
				allowTouchMove();
				return;
			}
		}
		if (e.cancelable) e.preventDefault();
		e.stopPropagation();
		preventTouchMove();
		image.isMoved = true;
		const scaleRatio = (zoom.scale - currentScale) / (gesture.maxRatio - getParams().minRatio);
		const { originX, originY } = gesture;
		image.currentX = image.touchesCurrent.x - (image.touchesStart.x ?? 0) + startX + scaleRatio * (image.width - originX * 2);
		image.currentY = image.touchesCurrent.y - (image.touchesStart.y ?? 0) + startY + scaleRatio * (image.height - originY * 2);
		if (image.currentX < image.minX) image.currentX = image.minX + 1 - (image.minX - image.currentX + 1) ** .8;
		if (image.currentX > image.maxX) image.currentX = image.maxX - 1 + (image.currentX - image.maxX + 1) ** .8;
		if (image.currentY < image.minY) image.currentY = image.minY + 1 - (image.minY - image.currentY + 1) ** .8;
		if (image.currentY > image.maxY) image.currentY = image.maxY - 1 + (image.currentY - image.maxY + 1) ** .8;
		if (!velocity.prevPositionX) velocity.prevPositionX = image.touchesCurrent.x;
		if (!velocity.prevPositionY) velocity.prevPositionY = image.touchesCurrent.y;
		if (!velocity.prevTime) velocity.prevTime = Date.now();
		velocity.x = (image.touchesCurrent.x - velocity.prevPositionX) / (Date.now() - velocity.prevTime) / 2;
		velocity.y = (image.touchesCurrent.y - velocity.prevPositionY) / (Date.now() - velocity.prevTime) / 2;
		if (Math.abs(image.touchesCurrent.x - velocity.prevPositionX) < 2) velocity.x = 0;
		if (Math.abs(image.touchesCurrent.y - velocity.prevPositionY) < 2) velocity.y = 0;
		velocity.prevPositionX = image.touchesCurrent.x;
		velocity.prevPositionY = image.touchesCurrent.y;
		velocity.prevTime = Date.now();
		gesture.imageWrapEl.style.transform = `translate3d(${image.currentX}px, ${image.currentY}px,0)`;
	}
	function onTouchEnd() {
		const zoom = swiper.zoom;
		evCache.length = 0;
		if (!gesture.imageEl) return;
		if (!image.isTouched || !image.isMoved) {
			image.isTouched = false;
			image.isMoved = false;
			return;
		}
		image.isTouched = false;
		image.isMoved = false;
		let momentumDurationX = 300;
		let momentumDurationY = 300;
		const velocityX = velocity.x ?? 0;
		const velocityY = velocity.y ?? 0;
		const momentumDistanceX = velocityX * momentumDurationX;
		const newPositionX = image.currentX + momentumDistanceX;
		const momentumDistanceY = velocityY * momentumDurationY;
		const newPositionY = image.currentY + momentumDistanceY;
		if (velocityX !== 0) momentumDurationX = Math.abs((newPositionX - image.currentX) / velocityX);
		if (velocityY !== 0) momentumDurationY = Math.abs((newPositionY - image.currentY) / velocityY);
		const momentumDuration = Math.max(momentumDurationX, momentumDurationY);
		image.currentX = newPositionX;
		image.currentY = newPositionY;
		const scaledWidth = image.width * zoom.scale;
		const scaledHeight = image.height * zoom.scale;
		image.minX = Math.min(gesture.slideWidth / 2 - scaledWidth / 2, 0);
		image.maxX = -image.minX;
		image.minY = Math.min(gesture.slideHeight / 2 - scaledHeight / 2, 0);
		image.maxY = -image.minY;
		image.currentX = Math.max(Math.min(image.currentX, image.maxX), image.minX);
		image.currentY = Math.max(Math.min(image.currentY, image.maxY), image.minY);
		gesture.imageWrapEl.style.transitionDuration = `${momentumDuration}ms`;
		gesture.imageWrapEl.style.transform = `translate3d(${image.currentX}px, ${image.currentY}px,0)`;
	}
	function onTransitionEnd() {
		const zoom = swiper.zoom;
		if (gesture.slideEl && swiper.activeIndex !== swiper.slides.indexOf(gesture.slideEl)) {
			if (gesture.imageEl) gesture.imageEl.style.transform = "translate3d(0,0,0) scale(1)";
			if (gesture.imageWrapEl) gesture.imageWrapEl.style.transform = "translate3d(0,0,0)";
			gesture.slideEl.classList.remove(`${getParams().zoomedSlideClass}`);
			zoom.scale = 1;
			currentScale = 1;
			gesture.slideEl = void 0;
			gesture.imageEl = void 0;
			gesture.imageWrapEl = void 0;
			gesture.originX = 0;
			gesture.originY = 0;
		}
	}
	function onMouseMove(e) {
		if (currentScale <= 1 || !gesture.imageWrapEl) return;
		if (!eventWithinSlide(e) || !eventWithinZoomContainer(e)) return;
		const currentTransform = window.getComputedStyle(gesture.imageWrapEl).transform;
		const matrix = new window.DOMMatrix(currentTransform);
		if (!isPanningWithMouse) {
			isPanningWithMouse = true;
			mousePanStart.x = e.clientX;
			mousePanStart.y = e.clientY;
			image.startX = matrix.e;
			image.startY = matrix.f;
			image.width = gesture.imageEl.offsetWidth || gesture.imageEl.clientWidth;
			image.height = gesture.imageEl.offsetHeight || gesture.imageEl.clientHeight;
			gesture.slideWidth = gesture.slideEl.offsetWidth;
			gesture.slideHeight = gesture.slideEl.offsetHeight;
			return;
		}
		const deltaX = (e.clientX - mousePanStart.x) * mousePanSensitivity;
		const deltaY = (e.clientY - mousePanStart.y) * mousePanSensitivity;
		const scaledWidth = image.width * currentScale;
		const scaledHeight = image.height * currentScale;
		const slideWidth = gesture.slideWidth;
		const slideHeight = gesture.slideHeight;
		const minX = Math.min(slideWidth / 2 - scaledWidth / 2, 0);
		const maxX = -minX;
		const minY = Math.min(slideHeight / 2 - scaledHeight / 2, 0);
		const maxY = -minY;
		const newX = Math.max(Math.min(image.startX + deltaX, maxX), minX);
		const newY = Math.max(Math.min(image.startY + deltaY, maxY), minY);
		gesture.imageWrapEl.style.transitionDuration = "0ms";
		gesture.imageWrapEl.style.transform = `translate3d(${newX}px, ${newY}px, 0)`;
		mousePanStart.x = e.clientX;
		mousePanStart.y = e.clientY;
		image.startX = newX;
		image.startY = newY;
		image.currentX = newX;
		image.currentY = newY;
	}
	function zoomIn(e) {
		const zoom = swiper.zoom;
		const params = getParams();
		if (!gesture.slideEl) {
			if (e && typeof e !== "number" && "target" in e && e.target) gesture.slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`) ?? void 0;
			if (!gesture.slideEl) {
				const virtual = swiper.params.virtual;
				if (virtual && virtual.enabled && swiper.virtual) gesture.slideEl = elementChildren(swiper.slidesEl, `.${swiper.params.slideActiveClass}`)[0] ?? void 0;
				else gesture.slideEl = swiper.slides[swiper.activeIndex];
			}
			let imageEl = gesture.slideEl?.querySelector(`.${params.containerClass}`) ?? null;
			if (imageEl) imageEl = imageEl.querySelectorAll("picture, img, svg, canvas, .swiper-zoom-target")[0] ?? null;
			gesture.imageEl = imageEl ?? void 0;
			if (imageEl) gesture.imageWrapEl = elementParents(imageEl, `.${params.containerClass}`)[0] ?? void 0;
			else gesture.imageWrapEl = void 0;
		}
		if (!gesture.imageEl || !gesture.imageWrapEl || !gesture.slideEl) return;
		gesture.maxRatio = getMaxRatio();
		if (swiper.params.cssMode) {
			swiper.wrapperEl.style.overflow = "hidden";
			swiper.wrapperEl.style.touchAction = "none";
		}
		gesture.slideEl.classList.add(`${params.zoomedSlideClass}`);
		let touchX;
		let touchY;
		let offsetX;
		let offsetY;
		let diffX;
		let diffY;
		let translateX;
		let translateY;
		let imageWidth;
		let imageHeight;
		let scaledWidth;
		let scaledHeight;
		let translateMinX;
		let translateMinY;
		let translateMaxX;
		let translateMaxY;
		let slideWidth;
		let slideHeight;
		const eventIsPointer = e && typeof e !== "number";
		if (typeof image.touchesStart.x === "undefined" && eventIsPointer) {
			touchX = e.pageX;
			touchY = e.pageY;
		} else {
			touchX = image.touchesStart.x;
			touchY = image.touchesStart.y;
		}
		const prevScale = currentScale;
		const forceZoomRatio = typeof e === "number" ? e : null;
		if (currentScale === 1 && forceZoomRatio) {
			touchX = void 0;
			touchY = void 0;
			image.touchesStart.x = void 0;
			image.touchesStart.y = void 0;
		}
		const maxRatio = getMaxRatio();
		zoom.scale = forceZoomRatio || maxRatio;
		currentScale = forceZoomRatio || maxRatio;
		if (e && !(currentScale === 1 && forceZoomRatio)) {
			slideWidth = gesture.slideEl.offsetWidth;
			slideHeight = gesture.slideEl.offsetHeight;
			offsetX = elementOffset(gesture.slideEl).left + window.scrollX;
			offsetY = elementOffset(gesture.slideEl).top + window.scrollY;
			diffX = offsetX + slideWidth / 2 - (touchX ?? 0);
			diffY = offsetY + slideHeight / 2 - (touchY ?? 0);
			imageWidth = gesture.imageEl.offsetWidth || gesture.imageEl.clientWidth;
			imageHeight = gesture.imageEl.offsetHeight || gesture.imageEl.clientHeight;
			scaledWidth = imageWidth * zoom.scale;
			scaledHeight = imageHeight * zoom.scale;
			translateMinX = Math.min(slideWidth / 2 - scaledWidth / 2, 0);
			translateMinY = Math.min(slideHeight / 2 - scaledHeight / 2, 0);
			translateMaxX = -translateMinX;
			translateMaxY = -translateMinY;
			if (prevScale > 0 && forceZoomRatio && typeof image.currentX === "number" && typeof image.currentY === "number") {
				translateX = image.currentX * zoom.scale / prevScale;
				translateY = image.currentY * zoom.scale / prevScale;
			} else {
				translateX = diffX * zoom.scale;
				translateY = diffY * zoom.scale;
			}
			if (translateX < translateMinX) translateX = translateMinX;
			if (translateX > translateMaxX) translateX = translateMaxX;
			if (translateY < translateMinY) translateY = translateMinY;
			if (translateY > translateMaxY) translateY = translateMaxY;
		} else {
			translateX = 0;
			translateY = 0;
		}
		if (forceZoomRatio && zoom.scale === 1) {
			gesture.originX = 0;
			gesture.originY = 0;
		}
		image.currentX = translateX;
		image.currentY = translateY;
		gesture.imageWrapEl.style.transitionDuration = "300ms";
		gesture.imageWrapEl.style.transform = `translate3d(${translateX}px, ${translateY}px,0)`;
		gesture.imageEl.style.transitionDuration = "300ms";
		gesture.imageEl.style.transform = `translate3d(0,0,0) scale(${zoom.scale})`;
	}
	function zoomOut() {
		const zoom = swiper.zoom;
		const params = getParams();
		if (!gesture.slideEl) {
			const virtual = swiper.params.virtual;
			if (virtual && virtual.enabled && swiper.virtual) gesture.slideEl = elementChildren(swiper.slidesEl, `.${swiper.params.slideActiveClass}`)[0] ?? void 0;
			else gesture.slideEl = swiper.slides[swiper.activeIndex];
			let imageEl = gesture.slideEl?.querySelector(`.${params.containerClass}`) ?? null;
			if (imageEl) imageEl = imageEl.querySelectorAll("picture, img, svg, canvas, .swiper-zoom-target")[0] ?? null;
			gesture.imageEl = imageEl ?? void 0;
			if (imageEl) gesture.imageWrapEl = elementParents(imageEl, `.${params.containerClass}`)[0] ?? void 0;
			else gesture.imageWrapEl = void 0;
		}
		if (!gesture.imageEl || !gesture.imageWrapEl || !gesture.slideEl) return;
		gesture.maxRatio = getMaxRatio();
		if (swiper.params.cssMode) {
			swiper.wrapperEl.style.overflow = "";
			swiper.wrapperEl.style.touchAction = "";
		}
		zoom.scale = 1;
		currentScale = 1;
		image.currentX = void 0;
		image.currentY = void 0;
		image.touchesStart.x = void 0;
		image.touchesStart.y = void 0;
		gesture.imageWrapEl.style.transitionDuration = "300ms";
		gesture.imageWrapEl.style.transform = "translate3d(0,0,0)";
		gesture.imageEl.style.transitionDuration = "300ms";
		gesture.imageEl.style.transform = "translate3d(0,0,0) scale(1)";
		gesture.slideEl.classList.remove(`${params.zoomedSlideClass}`);
		gesture.slideEl = void 0;
		gesture.originX = 0;
		gesture.originY = 0;
		if (params.panOnMouseMove) {
			mousePanStart = {
				x: 0,
				y: 0
			};
			if (isPanningWithMouse) {
				isPanningWithMouse = false;
				image.startX = 0;
				image.startY = 0;
			}
		}
	}
	function zoomToggle(e) {
		const zoom = swiper.zoom;
		if (zoom.scale && zoom.scale !== 1) zoomOut();
		else zoomIn(e);
	}
	function getListeners() {
		return {
			passiveListener: swiper.params.passiveListeners ? {
				passive: true,
				capture: false
			} : false,
			activeListenerWithCapture: swiper.params.passiveListeners ? {
				passive: false,
				capture: true
			} : true
		};
	}
	function enable() {
		const zoom = swiper.zoom;
		if (zoom.enabled) return;
		zoom.enabled = true;
		const { passiveListener, activeListenerWithCapture } = getListeners();
		swiper.wrapperEl.addEventListener("pointerdown", onGestureStart, passiveListener);
		swiper.wrapperEl.addEventListener("pointermove", onGestureChange, activeListenerWithCapture);
		[
			"pointerup",
			"pointercancel",
			"pointerout"
		].forEach((eventName) => {
			swiper.wrapperEl.addEventListener(eventName, onGestureEnd, passiveListener);
		});
		swiper.wrapperEl.addEventListener("pointermove", onTouchMove, activeListenerWithCapture);
	}
	function disable() {
		const zoom = swiper.zoom;
		if (!zoom.enabled) return;
		zoom.enabled = false;
		const { passiveListener, activeListenerWithCapture } = getListeners();
		swiper.wrapperEl.removeEventListener("pointerdown", onGestureStart, passiveListener);
		swiper.wrapperEl.removeEventListener("pointermove", onGestureChange, activeListenerWithCapture);
		[
			"pointerup",
			"pointercancel",
			"pointerout"
		].forEach((eventName) => {
			swiper.wrapperEl.removeEventListener(eventName, onGestureEnd, passiveListener);
		});
		swiper.wrapperEl.removeEventListener("pointermove", onTouchMove, activeListenerWithCapture);
	}
	on("init", () => {
		if (getParams().enabled) enable();
	});
	on("destroy", () => {
		disable();
	});
	on("touchStart", (_s, e) => {
		if (!swiper.zoom.enabled) return;
		onTouchStart(e);
	});
	on("touchEnd", () => {
		if (!swiper.zoom.enabled) return;
		onTouchEnd();
	});
	on("doubleTap", (_s, e) => {
		if (!swiper.animating && getParams().enabled && swiper.zoom.enabled && getParams().toggle) zoomToggle(e);
	});
	on("transitionEnd", () => {
		if (swiper.zoom.enabled && getParams().enabled) onTransitionEnd();
	});
	on("slideChange", () => {
		if (swiper.zoom.enabled && getParams().enabled && swiper.params.cssMode) onTransitionEnd();
	});
	Object.assign(swiper.zoom, {
		enable,
		disable,
		in: zoomIn,
		out: zoomOut,
		toggle: zoomToggle
	});
};
//#endregion
//#region node_modules/swiper/modules/controller.mjs
var LinearSpline = class {
	x;
	y;
	lastIndex;
	binarySearch;
	constructor(x, y) {
		let maxIndex;
		let minIndex;
		let guess;
		this.binarySearch = (array, val) => {
			minIndex = -1;
			maxIndex = array.length;
			while (maxIndex - minIndex > 1) {
				guess = maxIndex + minIndex >> 1;
				if (array[guess] <= val) minIndex = guess;
				else maxIndex = guess;
			}
			return maxIndex;
		};
		this.x = x;
		this.y = y;
		this.lastIndex = x.length - 1;
	}
	interpolate(x2) {
		if (!x2) return 0;
		const i3 = this.binarySearch(this.x, x2);
		const i1 = i3 - 1;
		return (x2 - this.x[i1]) * (this.y[i3] - this.y[i1]) / (this.x[i3] - this.x[i1]) + this.y[i1];
	}
};
var Controller = ({ swiper, extendParams, on }) => {
	extendParams({ controller: {
		control: void 0,
		inverse: false,
		by: "slide"
	} });
	swiper.controller = { control: void 0 };
	function getParams() {
		return swiper.params.controller;
	}
	function getInterpolateFunction(c) {
		swiper.controller.spline = swiper.params.loop ? new LinearSpline(swiper.slidesGrid, c.slidesGrid) : new LinearSpline(swiper.snapGrid, c.snapGrid);
	}
	function setTranslate(_t, byController) {
		const controlled = swiper.controller.control;
		let multiplier;
		let controlledTranslate;
		const SwiperCtor = swiper.constructor;
		function setControlledTranslate(c) {
			if (c.destroyed) return;
			const translate = swiper.rtlTranslate ? -swiper.translate : swiper.translate;
			const controllerParams = getParams();
			if (controllerParams.by === "slide") {
				getInterpolateFunction(c);
				controlledTranslate = -swiper.controller.spline.interpolate(-translate);
			} else controlledTranslate = 0;
			if (!controlledTranslate || controllerParams.by === "container") {
				multiplier = (c.maxTranslate() - c.minTranslate()) / (swiper.maxTranslate() - swiper.minTranslate());
				if (Number.isNaN(multiplier) || !Number.isFinite(multiplier)) multiplier = 1;
				controlledTranslate = (translate - swiper.minTranslate()) * multiplier + c.minTranslate();
			}
			if (controllerParams.inverse) controlledTranslate = c.maxTranslate() - controlledTranslate;
			c.updateProgress(controlledTranslate);
			c.setTranslate(controlledTranslate, swiper);
			c.updateActiveIndex();
			c.updateSlidesClasses();
		}
		if (Array.isArray(controlled)) for (let i = 0; i < controlled.length; i += 1) {
			const target = controlled[i];
			if (target && target !== byController && target instanceof SwiperCtor) setControlledTranslate(target);
		}
		else if (controlled instanceof SwiperCtor && byController !== controlled) setControlledTranslate(controlled);
	}
	function setTransition(duration, byController) {
		const SwiperCtor = swiper.constructor;
		const controlled = swiper.controller.control;
		function setControlledTransition(c) {
			if (c.destroyed) return;
			c.setTransition(duration, swiper);
			if (duration !== 0) {
				c.transitionStart();
				if (c.params.autoHeight) nextTick(() => {
					c.updateAutoHeight();
				});
				elementTransitionEnd(c.wrapperEl, () => {
					if (!controlled) return;
					c.transitionEnd();
				});
			}
		}
		if (Array.isArray(controlled)) for (let i = 0; i < controlled.length; i += 1) {
			const target = controlled[i];
			if (target && target !== byController && target instanceof SwiperCtor) setControlledTransition(target);
		}
		else if (controlled instanceof SwiperCtor && byController !== controlled) setControlledTransition(controlled);
	}
	function removeSpline() {
		if (!swiper.controller.control) return;
		if (swiper.controller.spline) {
			swiper.controller.spline = void 0;
			delete swiper.controller.spline;
		}
	}
	on("beforeInit", () => {
		const controllerParam = getParams().control;
		if (typeof window !== "undefined" && (typeof controllerParam === "string" || controllerParam instanceof HTMLElement)) {
			(typeof controllerParam === "string" ? [...document.querySelectorAll(controllerParam)] : [controllerParam]).forEach((controlElement) => {
				if (!swiper.controller.control) swiper.controller.control = [];
				const list = swiper.controller.control;
				if (controlElement && controlElement.swiper) list.push(controlElement.swiper);
				else if (controlElement) {
					const eventName = `${swiper.params.eventsPrefix}init`;
					const onControllerSwiper = (e) => {
						const detail = e.detail;
						if (detail && detail[0]) list.push(detail[0]);
						swiper.update();
						controlElement.removeEventListener(eventName, onControllerSwiper);
					};
					controlElement.addEventListener(eventName, onControllerSwiper);
				}
			});
			return;
		}
		swiper.controller.control = controllerParam;
	});
	on("update", () => {
		removeSpline();
	});
	on("resize", () => {
		removeSpline();
	});
	on("observerUpdate", () => {
		removeSpline();
	});
	on("setTranslate", (_s, translate, byController) => {
		if (!swiper.controller.control) return;
		if (!Array.isArray(swiper.controller.control) && swiper.controller.control.destroyed) return;
		swiper.controller.setTranslate(translate, byController);
	});
	on("setTransition", (_s, duration, byController) => {
		if (!swiper.controller.control) return;
		if (!Array.isArray(swiper.controller.control) && swiper.controller.control.destroyed) return;
		swiper.controller.setTransition(duration, byController);
	});
	Object.assign(swiper.controller, {
		setTranslate,
		setTransition
	});
};
//#endregion
//#region node_modules/swiper/modules/a11y.mjs
var isVirtualEnabled$1 = (swiper) => !!swiper.virtual && !!swiper.params.virtual?.enabled;
var A11y = ({ swiper, extendParams, on }) => {
	extendParams({ a11y: {
		enabled: true,
		notificationClass: "swiper-notification",
		prevSlideMessage: "Previous slide",
		nextSlideMessage: "Next slide",
		firstSlideMessage: "This is the first slide",
		lastSlideMessage: "This is the last slide",
		paginationBulletMessage: "Go to slide {{index}}",
		slideLabelMessage: "{{index}} / {{slidesLength}}",
		containerMessage: null,
		containerRoleDescriptionMessage: null,
		containerRole: null,
		itemRoleDescriptionMessage: null,
		slideRole: "group",
		id: null,
		scrollOnFocus: true,
		wrapperLiveRegion: true
	} });
	swiper.a11y = { clicked: false };
	let liveRegion = null;
	let preventFocusHandler = false;
	let focusTargetSlideEl;
	let visibilityChangedTimestamp = (/* @__PURE__ */ new Date()).getTime();
	function getParams() {
		return swiper.params.a11y;
	}
	function notify(message) {
		const notification = liveRegion;
		if (!notification || !message) return;
		setInnerHTML(notification, message);
	}
	function getRandomNumber(size = 16) {
		const randomChar = () => Math.round(16 * Math.random()).toString(16);
		return "x".repeat(size).replace(/x/g, randomChar);
	}
	function makeElFocusable(el) {
		makeElementsArray(el).forEach((subEl) => {
			subEl.setAttribute("tabIndex", "0");
		});
	}
	function makeElNotFocusable(el) {
		makeElementsArray(el).forEach((subEl) => {
			subEl.setAttribute("tabIndex", "-1");
		});
	}
	function addElRole(el, role) {
		makeElementsArray(el).forEach((subEl) => {
			subEl.setAttribute("role", role);
		});
	}
	function addElRoleDescription(el, description) {
		makeElementsArray(el).forEach((subEl) => {
			subEl.setAttribute("aria-roledescription", description);
		});
	}
	function addElLabel(el, label) {
		makeElementsArray(el).forEach((subEl) => {
			subEl.setAttribute("aria-label", label);
		});
	}
	function addElId(el, id) {
		makeElementsArray(el).forEach((subEl) => {
			subEl.setAttribute("id", id);
		});
	}
	function addElLive(el, live) {
		makeElementsArray(el).forEach((subEl) => {
			subEl.setAttribute("aria-live", live);
		});
	}
	function disableEl(el) {
		makeElementsArray(el).forEach((subEl) => {
			subEl.setAttribute("aria-disabled", "true");
		});
	}
	function enableEl(el) {
		makeElementsArray(el).forEach((subEl) => {
			subEl.removeAttribute("aria-disabled");
		});
	}
	function onEnterOrSpaceKey(e) {
		if (e.keyCode !== 13 && e.keyCode !== 32) return;
		const params = getParams();
		const paginationParams = swiper.params.pagination;
		const targetEl = e.target;
		if (swiper.pagination && swiper.pagination.el && (targetEl === swiper.pagination.el || swiper.pagination.el.contains(targetEl))) {
			if (!targetEl.matches(classesToSelector(paginationParams?.bulletClass))) return;
		}
		if (swiper.navigation && swiper.navigation.prevEl && swiper.navigation.nextEl) {
			const prevEls = makeElementsArray(swiper.navigation.prevEl);
			if (makeElementsArray(swiper.navigation.nextEl).includes(targetEl)) {
				if (!(swiper.isEnd && !swiper.params.loop)) swiper.slideNext();
				if (swiper.isEnd) notify(params.lastSlideMessage);
				else notify(params.nextSlideMessage);
			}
			if (prevEls.includes(targetEl)) {
				if (!(swiper.isBeginning && !swiper.params.loop)) swiper.slidePrev();
				if (swiper.isBeginning) notify(params.firstSlideMessage);
				else notify(params.prevSlideMessage);
			}
		}
		if (swiper.pagination && targetEl.matches(classesToSelector(paginationParams?.bulletClass))) targetEl.click();
	}
	function updateNavigation() {
		if (swiper.params.loop || swiper.params.rewind || !swiper.navigation) return;
		const { nextEl, prevEl } = swiper.navigation;
		if (prevEl) if (swiper.isBeginning) {
			disableEl(prevEl);
			makeElNotFocusable(prevEl);
		} else {
			enableEl(prevEl);
			makeElFocusable(prevEl);
		}
		if (nextEl) if (swiper.isEnd) {
			disableEl(nextEl);
			makeElNotFocusable(nextEl);
		} else {
			enableEl(nextEl);
			makeElFocusable(nextEl);
		}
	}
	function hasPagination() {
		return !!(swiper.pagination && swiper.pagination.bullets && swiper.pagination.bullets.length);
	}
	function hasClickablePagination() {
		const paginationParams = swiper.params.pagination;
		return hasPagination() && !!paginationParams?.clickable;
	}
	function updatePagination() {
		const params = getParams();
		if (!hasPagination()) return;
		const paginationParams = swiper.params.pagination;
		swiper.pagination.bullets.forEach((bulletEl) => {
			if (paginationParams.clickable) {
				makeElFocusable(bulletEl);
				if (!paginationParams.renderBullet) {
					addElRole(bulletEl, "button");
					addElLabel(bulletEl, params.paginationBulletMessage.replace(/\{\{index\}\}/, String((elementIndex(bulletEl) ?? 0) + 1)));
				}
			}
			if (bulletEl.matches(classesToSelector(paginationParams.bulletActiveClass))) bulletEl.setAttribute("aria-current", "true");
			else bulletEl.removeAttribute("aria-current");
		});
	}
	const initNavEl = (el, _wrapperId, message) => {
		makeElFocusable(el);
		if (el.tagName !== "BUTTON") {
			addElRole(el, "button");
			el.addEventListener("keydown", onEnterOrSpaceKey);
		}
		addElLabel(el, message);
	};
	const handlePointerDown = (e) => {
		if (focusTargetSlideEl && focusTargetSlideEl !== e.target && !focusTargetSlideEl.contains(e.target)) preventFocusHandler = true;
		swiper.a11y.clicked = true;
	};
	const handlePointerUp = () => {
		preventFocusHandler = false;
		requestAnimationFrame(() => {
			requestAnimationFrame(() => {
				if (!swiper.destroyed) swiper.a11y.clicked = false;
			});
		});
	};
	const onVisibilityChange = (_e) => {
		visibilityChangedTimestamp = (/* @__PURE__ */ new Date()).getTime();
	};
	const handleFocus = (e) => {
		const params = getParams();
		if (swiper.a11y.clicked || !params.scrollOnFocus) return;
		if ((/* @__PURE__ */ new Date()).getTime() - visibilityChangedTimestamp < 100) return;
		const slideEl = e.target.closest(`.${swiper.params.slideClass}, swiper-slide`);
		if (!slideEl || !swiper.slides.includes(slideEl)) return;
		focusTargetSlideEl = slideEl;
		const isVirtual = isVirtualEnabled$1(swiper);
		const isActive = (isVirtual ? parseInt(slideEl.getAttribute("data-swiper-slide-index") || "0", 10) : swiper.slides.indexOf(slideEl)) === swiper.activeIndex;
		const isVisible = swiper.params.watchSlidesProgress && swiper.visibleSlides && swiper.visibleSlides.includes(slideEl);
		if (isActive || isVisible) return;
		const sourceCapabilities = e.sourceCapabilities;
		if (sourceCapabilities && sourceCapabilities.firesTouchEvents) return;
		if (swiper.isHorizontal()) swiper.el.scrollLeft = 0;
		else swiper.el.scrollTop = 0;
		requestAnimationFrame(() => {
			if (preventFocusHandler) return;
			if (swiper.params.loop) swiper.slideToLoop(swiper.getSlideIndexWhenGrid(parseInt(slideEl.getAttribute("data-swiper-slide-index") || "0", 10)), 0);
			else if (isVirtual) swiper.slideTo(swiper.getSlideIndexWhenGrid(parseInt(slideEl.getAttribute("data-swiper-slide-index") || "0", 10)), 0);
			else swiper.slideTo(swiper.getSlideIndexWhenGrid(swiper.slides.indexOf(slideEl)), 0);
			preventFocusHandler = false;
		});
	};
	const initSlides = () => {
		const params = getParams();
		if (params.itemRoleDescriptionMessage) addElRoleDescription(swiper.slides, params.itemRoleDescriptionMessage);
		if (params.slideRole) addElRole(swiper.slides, params.slideRole);
		const slidesLength = swiper.slides.length;
		const slideLabelMessage = params.slideLabelMessage;
		if (slideLabelMessage) swiper.slides.forEach((slideEl, index) => {
			const slideIndex = swiper.params.loop ? parseInt(slideEl.getAttribute("data-swiper-slide-index") || "0", 10) : index;
			addElLabel(slideEl, slideLabelMessage.replace(/\{\{index\}\}/, String(slideIndex + 1)).replace(/\{\{slidesLength\}\}/, String(slidesLength)));
		});
	};
	const init = () => {
		const params = getParams();
		if (liveRegion) swiper.el.append(liveRegion);
		const containerEl = swiper.el;
		if (params.containerRoleDescriptionMessage) addElRoleDescription(containerEl, params.containerRoleDescriptionMessage);
		if (params.containerMessage) addElLabel(containerEl, params.containerMessage);
		if (params.containerRole) addElRole(containerEl, params.containerRole);
		const wrapperEl = swiper.wrapperEl;
		const wrapperId = String(params.id || wrapperEl.getAttribute("id") || `swiper-wrapper-${getRandomNumber(16)}`);
		addElId(wrapperEl, wrapperId);
		if (params.wrapperLiveRegion) {
			const autoplayParams = swiper.params.autoplay;
			addElLive(wrapperEl, swiper.params.autoplay && autoplayParams?.enabled ? "off" : "polite");
		}
		initSlides();
		const nav = swiper.navigation ? swiper.navigation : {
			nextEl: void 0,
			prevEl: void 0
		};
		const nextEls = makeElementsArray(nav.nextEl);
		const prevEls = makeElementsArray(nav.prevEl);
		if (nextEls) nextEls.forEach((el) => initNavEl(el, wrapperId, params.nextSlideMessage));
		if (prevEls) prevEls.forEach((el) => initNavEl(el, wrapperId, params.prevSlideMessage));
		if (hasClickablePagination()) makeElementsArray(swiper.pagination.el).forEach((el) => {
			el.addEventListener("keydown", onEnterOrSpaceKey);
		});
		document.addEventListener("visibilitychange", onVisibilityChange);
		swiper.el.addEventListener("focus", handleFocus, true);
		swiper.el.addEventListener("pointerdown", handlePointerDown, true);
		swiper.el.addEventListener("pointerup", handlePointerUp, true);
	};
	function destroy() {
		if (liveRegion) liveRegion.remove();
		const nav = swiper.navigation ? swiper.navigation : {
			nextEl: void 0,
			prevEl: void 0
		};
		const nextEls = makeElementsArray(nav.nextEl);
		const prevEls = makeElementsArray(nav.prevEl);
		if (nextEls) nextEls.forEach((el) => el.removeEventListener("keydown", onEnterOrSpaceKey));
		if (prevEls) prevEls.forEach((el) => el.removeEventListener("keydown", onEnterOrSpaceKey));
		if (hasClickablePagination()) makeElementsArray(swiper.pagination.el).forEach((el) => {
			el.removeEventListener("keydown", onEnterOrSpaceKey);
		});
		document.removeEventListener("visibilitychange", onVisibilityChange);
		if (swiper.el && typeof swiper.el !== "string") {
			swiper.el.removeEventListener("focus", handleFocus, true);
			swiper.el.removeEventListener("pointerdown", handlePointerDown, true);
			swiper.el.removeEventListener("pointerup", handlePointerUp, true);
		}
	}
	on("beforeInit", () => {
		liveRegion = createElement("span", getParams().notificationClass);
		liveRegion.setAttribute("aria-live", "assertive");
		liveRegion.setAttribute("aria-atomic", "true");
	});
	on("afterInit", () => {
		if (!getParams().enabled) return;
		init();
	});
	on("slidesLengthChange snapGridLengthChange slidesGridLengthChange", () => {
		if (!getParams().enabled) return;
		initSlides();
	});
	on("fromEdge toEdge afterInit lock unlock", () => {
		if (!getParams().enabled) return;
		updateNavigation();
	});
	on("paginationUpdate", () => {
		if (!getParams().enabled) return;
		updatePagination();
	});
	on("destroy", () => {
		if (!getParams().enabled) return;
		destroy();
	});
};
//#endregion
//#region node_modules/swiper/modules/history.mjs
var History = ({ swiper, extendParams, on }) => {
	extendParams({ history: {
		enabled: false,
		root: "",
		replaceState: false,
		key: "slides",
		keepQuery: false
	} });
	let initialized = false;
	let paths = {
		key: void 0,
		value: void 0
	};
	function getParams() {
		return swiper.params.history;
	}
	const slugify = (text) => {
		return text.toString().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
	};
	const getPathValues = (urlOverride) => {
		let location;
		if (urlOverride) location = new URL(urlOverride);
		else location = window.location;
		const pathArray = location.pathname.slice(1).split("/").filter((part) => part !== "");
		const total = pathArray.length;
		return {
			key: pathArray[total - 2],
			value: pathArray[total - 1]
		};
	};
	const setHistory = (key, index) => {
		const params = getParams();
		if (!initialized || !params.enabled) return;
		let location;
		if (swiper.params.url) location = new URL(swiper.params.url);
		else location = window.location;
		const isVirtualEnabled = !!swiper.params.virtual?.enabled;
		const slide = swiper.virtual && isVirtualEnabled ? swiper.slidesEl.querySelector(`[data-swiper-slide-index="${index}"]`) : swiper.slides[index];
		if (!slide) return;
		let value = slugify(slide.getAttribute("data-history") || "");
		const root = params.root;
		if (root.length > 0) value = `${root[root.length - 1] === "/" ? root.slice(0, root.length - 1) : root}/${key ? `${key}/` : ""}${value}`;
		else if (!location.pathname.includes(key || "")) value = `${key ? `${key}/` : ""}${value}`;
		if (params.keepQuery) value += location.search;
		const currentState = window.history.state;
		if (currentState && currentState.value === value) return;
		if (params.replaceState) window.history.replaceState({ value }, "", value);
		else window.history.pushState({ value }, "", value);
	};
	const scrollToSlide = (speed, value, runCallbacks) => {
		if (value) for (let i = 0, length = swiper.slides.length; i < length; i += 1) {
			const slide = swiper.slides[i];
			if (slugify(slide.getAttribute("data-history") || "") === value) {
				const index = swiper.getSlideIndex(slide);
				swiper.slideTo(index, speed, runCallbacks);
			}
		}
		else swiper.slideTo(0, speed, runCallbacks);
	};
	const setHistoryPopState = () => {
		paths = getPathValues(swiper.params.url);
		scrollToSlide(swiper.params.speed, paths.value, false);
	};
	const init = () => {
		const params = swiper.params.history;
		if (!params) return;
		if (!window.history || !window.history.pushState) {
			params.enabled = false;
			const hashParams = swiper.params.hashNavigation;
			if (hashParams) hashParams.enabled = true;
			return;
		}
		initialized = true;
		paths = getPathValues(swiper.params.url);
		if (!paths.key && !paths.value) {
			if (!params.replaceState) window.addEventListener("popstate", setHistoryPopState);
			return;
		}
		scrollToSlide(0, paths.value, swiper.params.runCallbacksOnInit);
		if (!params.replaceState) window.addEventListener("popstate", setHistoryPopState);
	};
	const destroy = () => {
		if (!getParams().replaceState) window.removeEventListener("popstate", setHistoryPopState);
	};
	on("init", () => {
		if (getParams().enabled) init();
	});
	on("destroy", () => {
		if (getParams().enabled) destroy();
	});
	on("transitionEnd _freeModeNoMomentumRelease", () => {
		if (initialized) setHistory(getParams().key, swiper.activeIndex);
	});
	on("slideChange", () => {
		if (initialized && swiper.params.cssMode) setHistory(getParams().key, swiper.activeIndex);
	});
};
//#endregion
//#region node_modules/swiper/modules/hash-navigation.mjs
var isVirtualEnabled = (swiper) => !!swiper.virtual && !!swiper.params.virtual?.enabled;
var HashNavigation = ({ swiper, extendParams, emit, on }) => {
	let initialized = false;
	extendParams({ hashNavigation: {
		enabled: false,
		replaceState: false,
		watchState: false,
		getSlideIndex(_s, hash) {
			if (isVirtualEnabled(swiper)) {
				const slideWithHash = swiper.slides.find((slideEl) => slideEl.getAttribute("data-hash") === hash);
				if (!slideWithHash) return 0;
				return parseInt(slideWithHash.getAttribute("data-swiper-slide-index") || "0", 10);
			}
			const matched = elementChildren(swiper.slidesEl, `.${swiper.params.slideClass}[data-hash="${hash}"], swiper-slide[data-hash="${hash}"]`)[0];
			return matched ? swiper.getSlideIndex(matched) : 0;
		}
	} });
	function getParams() {
		return swiper.params.hashNavigation;
	}
	const onHashChange = () => {
		emit("hashChange");
		const newHash = document.location.hash.replace("#", "");
		const activeSlideEl = isVirtualEnabled(swiper) ? swiper.slidesEl.querySelector(`[data-swiper-slide-index="${swiper.activeIndex}"]`) : swiper.slides[swiper.activeIndex];
		if (newHash !== (activeSlideEl ? activeSlideEl.getAttribute("data-hash") : "")) {
			const newIndex = getParams().getSlideIndex(swiper, newHash);
			if (typeof newIndex === "undefined" || Number.isNaN(newIndex)) return;
			swiper.slideTo(newIndex);
		}
	};
	const setHash = () => {
		const params = getParams();
		if (!initialized || !params.enabled) return;
		const activeSlideEl = isVirtualEnabled(swiper) ? swiper.slidesEl.querySelector(`[data-swiper-slide-index="${swiper.activeIndex}"]`) : swiper.slides[swiper.activeIndex];
		const activeSlideHash = activeSlideEl ? activeSlideEl.getAttribute("data-hash") || activeSlideEl.getAttribute("data-history") : "";
		if (params.replaceState && window.history && window.history.replaceState) {
			window.history.replaceState(null, "", `#${activeSlideHash}` || "");
			emit("hashSet");
		} else {
			document.location.hash = activeSlideHash || "";
			emit("hashSet");
		}
	};
	const init = () => {
		const params = getParams();
		const historyParams = swiper.params.history;
		if (!params.enabled || historyParams && historyParams.enabled) return;
		initialized = true;
		const hash = document.location.hash.replace("#", "");
		if (hash) {
			const speed = 0;
			const index = params.getSlideIndex(swiper, hash);
			swiper.slideTo(index || 0, speed, swiper.params.runCallbacksOnInit, true);
		}
		if (params.watchState) window.addEventListener("hashchange", onHashChange);
	};
	const destroy = () => {
		if (getParams().watchState) window.removeEventListener("hashchange", onHashChange);
	};
	on("init", () => {
		if (getParams().enabled) init();
	});
	on("destroy", () => {
		if (getParams().enabled) destroy();
	});
	on("transitionEnd _freeModeNoMomentumRelease", () => {
		if (initialized) setHash();
	});
	on("slideChange", () => {
		if (initialized && swiper.params.cssMode) setHash();
	});
};
//#endregion
//#region node_modules/swiper/modules/autoplay.mjs
var Autoplay = ({ swiper, extendParams, on, emit, params }) => {
	swiper.autoplay = {
		running: false,
		paused: false,
		timeLeft: 0
	};
	extendParams({ autoplay: {
		enabled: false,
		delay: 3e3,
		waitForTransition: true,
		disableOnInteraction: false,
		stopOnLastSlide: false,
		reverseDirection: false,
		pauseOnMouseEnter: false
	} });
	function getParams() {
		return swiper.params.autoplay;
	}
	const initialAutoplayDelay = typeof params.autoplay === "object" && params.autoplay && typeof params.autoplay.delay === "number" ? params.autoplay.delay : 3e3;
	let timeout;
	let raf;
	let autoplayDelayTotal = initialAutoplayDelay;
	let autoplayDelayCurrent = initialAutoplayDelay;
	let autoplayTimeLeft = 0;
	let autoplayStartTime = (/* @__PURE__ */ new Date()).getTime();
	let wasPaused = false;
	let isTouched = false;
	let pausedByTouch = false;
	let touchStartTimeout;
	let pausedByInteraction = false;
	let pausedByPointerEnter = false;
	function onTransitionEnd(e) {
		if (!swiper || swiper.destroyed || !swiper.wrapperEl) return;
		if (e.target !== swiper.wrapperEl) return;
		swiper.wrapperEl.removeEventListener("transitionend", onTransitionEnd);
		const detail = e.detail;
		if (pausedByPointerEnter || detail && detail.bySwiperTouchMove) return;
		resume();
	}
	const calcTimeLeft = () => {
		if (swiper.destroyed || !swiper.autoplay.running) return;
		if (swiper.autoplay.paused) wasPaused = true;
		else if (wasPaused) {
			autoplayDelayCurrent = autoplayTimeLeft;
			wasPaused = false;
		}
		const timeLeft = swiper.autoplay.paused ? autoplayTimeLeft : autoplayStartTime + autoplayDelayCurrent - (/* @__PURE__ */ new Date()).getTime();
		swiper.autoplay.timeLeft = timeLeft;
		emit("autoplayTimeLeft", timeLeft, timeLeft / autoplayDelayTotal);
		raf = requestAnimationFrame(() => {
			calcTimeLeft();
		});
	};
	const getSlideDelay = () => {
		let activeSlideEl;
		const virtualEnabled = !!swiper.params.virtual?.enabled;
		if (swiper.virtual && virtualEnabled) activeSlideEl = swiper.slides.find((slideEl) => slideEl.classList.contains("swiper-slide-active"));
		else activeSlideEl = swiper.slides[swiper.activeIndex];
		if (!activeSlideEl) return void 0;
		const attr = activeSlideEl.getAttribute("data-swiper-autoplay");
		if (attr == null) return void 0;
		return parseInt(attr, 10);
	};
	const getTotalDelay = () => {
		let totalDelay = getParams().delay;
		const currentSlideDelay = getSlideDelay();
		if (typeof currentSlideDelay === "number" && !Number.isNaN(currentSlideDelay) && currentSlideDelay > 0) totalDelay = currentSlideDelay;
		return totalDelay;
	};
	const run = (delayForce) => {
		if (swiper.destroyed || !swiper.autoplay.running) return 0;
		if (raf !== void 0) cancelAnimationFrame(raf);
		calcTimeLeft();
		let delay = delayForce;
		if (typeof delay === "undefined") {
			delay = getTotalDelay();
			autoplayDelayTotal = delay;
			autoplayDelayCurrent = delay;
		}
		autoplayTimeLeft = delay;
		const speed = swiper.params.speed;
		const proceed = () => {
			if (!swiper || swiper.destroyed) return;
			const autoplayParams = getParams();
			if (autoplayParams.reverseDirection) {
				if (!swiper.isBeginning || swiper.params.loop || swiper.params.rewind) {
					swiper.slidePrev(speed, true, true);
					emit("autoplay");
				} else if (!autoplayParams.stopOnLastSlide) {
					swiper.slideTo(swiper.slides.length - 1, speed, true, true);
					emit("autoplay");
				}
			} else if (!swiper.isEnd || swiper.params.loop || swiper.params.rewind) {
				swiper.slideNext(speed, true, true);
				emit("autoplay");
			} else if (!autoplayParams.stopOnLastSlide) {
				swiper.slideTo(0, speed, true, true);
				emit("autoplay");
			}
			if (swiper.params.cssMode) {
				autoplayStartTime = (/* @__PURE__ */ new Date()).getTime();
				requestAnimationFrame(() => {
					run();
				});
			}
		};
		if (delay > 0) {
			if (timeout !== void 0) clearTimeout(timeout);
			timeout = setTimeout(() => {
				proceed();
			}, delay);
		} else requestAnimationFrame(() => {
			proceed();
		});
		return delay;
	};
	const start = () => {
		autoplayStartTime = (/* @__PURE__ */ new Date()).getTime();
		swiper.autoplay.running = true;
		run();
		emit("autoplayStart");
		return true;
	};
	const stop = () => {
		swiper.autoplay.running = false;
		if (timeout !== void 0) clearTimeout(timeout);
		if (raf !== void 0) cancelAnimationFrame(raf);
		emit("autoplayStop");
		return true;
	};
	const pause = (internal, reset) => {
		if (swiper.destroyed || !swiper.autoplay.running) return;
		if (timeout !== void 0) clearTimeout(timeout);
		if (!internal) pausedByInteraction = true;
		const proceed = () => {
			emit("autoplayPause");
			if (getParams().waitForTransition) swiper.wrapperEl.addEventListener("transitionend", onTransitionEnd);
			else resume();
		};
		swiper.autoplay.paused = true;
		if (reset) {
			proceed();
			return;
		}
		autoplayTimeLeft = (autoplayTimeLeft || getParams().delay) - ((/* @__PURE__ */ new Date()).getTime() - autoplayStartTime);
		if (swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop) return;
		if (autoplayTimeLeft < 0) autoplayTimeLeft = 0;
		proceed();
	};
	const resume = () => {
		if (swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop || swiper.destroyed || !swiper.autoplay.running) return;
		autoplayStartTime = (/* @__PURE__ */ new Date()).getTime();
		if (pausedByInteraction) {
			pausedByInteraction = false;
			run(autoplayTimeLeft);
		} else run();
		swiper.autoplay.paused = false;
		emit("autoplayResume");
	};
	const onVisibilityChange = () => {
		if (swiper.destroyed || !swiper.autoplay.running) return;
		if (document.visibilityState === "hidden") {
			pausedByInteraction = true;
			pause(true);
		}
		if (document.visibilityState === "visible") resume();
	};
	const onPointerEnter = (e) => {
		if (e.pointerType !== "mouse") return;
		pausedByInteraction = true;
		pausedByPointerEnter = true;
		if (swiper.animating || swiper.autoplay.paused) return;
		pause(true);
	};
	const onPointerLeave = (e) => {
		if (e.pointerType !== "mouse") return;
		pausedByPointerEnter = false;
		if (swiper.autoplay.paused) resume();
	};
	const attachMouseEvents = () => {
		if (getParams().pauseOnMouseEnter) {
			swiper.el.addEventListener("pointerenter", onPointerEnter);
			swiper.el.addEventListener("pointerleave", onPointerLeave);
		}
	};
	const detachMouseEvents = () => {
		if (swiper.el && typeof swiper.el !== "string") {
			swiper.el.removeEventListener("pointerenter", onPointerEnter);
			swiper.el.removeEventListener("pointerleave", onPointerLeave);
		}
	};
	const attachDocumentEvents = () => {
		document.addEventListener("visibilitychange", onVisibilityChange);
	};
	const detachDocumentEvents = () => {
		document.removeEventListener("visibilitychange", onVisibilityChange);
	};
	on("init", () => {
		if (getParams().enabled) {
			attachMouseEvents();
			attachDocumentEvents();
			start();
		}
	});
	on("destroy", () => {
		detachMouseEvents();
		detachDocumentEvents();
		if (swiper.autoplay.running) stop();
	});
	on("_freeModeStaticRelease", () => {
		if (pausedByTouch || pausedByInteraction) resume();
	});
	on("_freeModeNoMomentumRelease", () => {
		if (!getParams().disableOnInteraction) pause(true, true);
		else stop();
	});
	on("beforeTransitionStart", (_s, _speed, internal) => {
		if (swiper.destroyed || !swiper.autoplay.running) return;
		if (internal || !getParams().disableOnInteraction) pause(true, true);
		else stop();
	});
	on("sliderFirstMove", () => {
		if (swiper.destroyed || !swiper.autoplay.running) return;
		if (getParams().disableOnInteraction) {
			stop();
			return;
		}
		isTouched = true;
		pausedByTouch = false;
		pausedByInteraction = false;
		touchStartTimeout = setTimeout(() => {
			pausedByInteraction = true;
			pausedByTouch = true;
			pause(true);
		}, 200);
	});
	on("touchEnd", () => {
		if (swiper.destroyed || !swiper.autoplay.running || !isTouched) return;
		if (touchStartTimeout !== void 0) clearTimeout(touchStartTimeout);
		if (timeout !== void 0) clearTimeout(timeout);
		if (getParams().disableOnInteraction) {
			pausedByTouch = false;
			isTouched = false;
			return;
		}
		if (pausedByTouch && swiper.params.cssMode) resume();
		pausedByTouch = false;
		isTouched = false;
	});
	on("slideChange", () => {
		if (swiper.destroyed || !swiper.autoplay.running) return;
		if (swiper.autoplay.paused) {
			autoplayTimeLeft = getTotalDelay();
			autoplayDelayTotal = getTotalDelay();
		}
	});
	Object.assign(swiper.autoplay, {
		start,
		stop,
		pause,
		resume
	});
};
//#endregion
//#region node_modules/swiper/modules/thumbs.mjs
var Thumb = ({ swiper, extendParams, on }) => {
	extendParams({ thumbs: {
		swiper: null,
		multipleActiveThumbs: true,
		autoScrollOffset: 0,
		slideThumbActiveClass: "swiper-slide-thumb-active",
		thumbsContainerClass: "swiper-thumbs"
	} });
	let initialized = false;
	let swiperCreated = false;
	swiper.thumbs = { swiper: null };
	function getParams() {
		return swiper.params.thumbs;
	}
	function isVirtualEnabled() {
		const thumbsSwiper = swiper.thumbs.swiper;
		if (!thumbsSwiper || thumbsSwiper.destroyed) return false;
		const virtual = thumbsSwiper.params.virtual;
		return !!virtual && !!virtual.enabled;
	}
	function onThumbClick() {
		const thumbsSwiper = swiper.thumbs.swiper;
		if (!thumbsSwiper || thumbsSwiper.destroyed) return;
		const clickedIndex = thumbsSwiper.clickedIndex;
		const clickedSlide = thumbsSwiper.clickedSlide;
		const thumbsParams = getParams();
		if (clickedSlide && clickedSlide.classList.contains(thumbsParams.slideThumbActiveClass)) return;
		if (typeof clickedIndex === "undefined" || clickedIndex === null) return;
		let slideToIndex;
		if (thumbsSwiper.params.loop) {
			const attr = thumbsSwiper.clickedSlide?.getAttribute("data-swiper-slide-index");
			slideToIndex = attr == null ? clickedIndex : parseInt(attr, 10);
		} else slideToIndex = clickedIndex;
		if (swiper.params.loop) swiper.slideToLoop(slideToIndex);
		else swiper.slideTo(slideToIndex);
	}
	function init() {
		const thumbsParams = getParams();
		if (initialized) return false;
		initialized = true;
		const SwiperClass = swiper.constructor;
		if (thumbsParams.swiper instanceof SwiperClass) {
			if (thumbsParams.swiper.destroyed) {
				initialized = false;
				return false;
			}
			const thumbsSwiper = thumbsParams.swiper;
			swiper.thumbs.swiper = thumbsSwiper;
			Object.assign(thumbsSwiper.originalParams, {
				watchSlidesProgress: true,
				slideToClickedSlide: false
			});
			Object.assign(thumbsSwiper.params, {
				watchSlidesProgress: true,
				slideToClickedSlide: false
			});
			thumbsSwiper.update();
		} else if (isObject(thumbsParams.swiper)) {
			const thumbsSwiperParams = Object.assign({}, thumbsParams.swiper);
			Object.assign(thumbsSwiperParams, {
				watchSlidesProgress: true,
				slideToClickedSlide: false
			});
			swiper.thumbs.swiper = new SwiperClass(thumbsSwiperParams);
			swiperCreated = true;
		}
		const thumbsSwiper = swiper.thumbs.swiper;
		if (!thumbsSwiper) return false;
		thumbsSwiper.el.classList.add(thumbsParams.thumbsContainerClass);
		thumbsSwiper.on("tap", onThumbClick);
		if (isVirtualEnabled()) thumbsSwiper.on("virtualUpdate", () => {
			update(false, { autoScroll: false });
		});
		return true;
	}
	function update(initial, p) {
		const thumbsSwiper = swiper.thumbs.swiper;
		if (!thumbsSwiper || thumbsSwiper.destroyed) return;
		let thumbsToActivate = 1;
		const thumbsParams = getParams();
		const thumbActiveClass = thumbsParams.slideThumbActiveClass;
		const slidesPerView = swiper.params.slidesPerView;
		if (typeof slidesPerView === "number" && slidesPerView > 1 && !swiper.params.centeredSlides) thumbsToActivate = slidesPerView;
		if (!thumbsParams.multipleActiveThumbs) thumbsToActivate = 1;
		thumbsToActivate = Math.floor(thumbsToActivate);
		thumbsSwiper.slides.forEach((slideEl) => slideEl.classList.remove(thumbActiveClass));
		if (thumbsSwiper.params.loop || isVirtualEnabled()) for (let i = 0; i < thumbsToActivate; i += 1) elementChildren(thumbsSwiper.slidesEl, `[data-swiper-slide-index="${swiper.realIndex + i}"]`).forEach((slideEl) => {
			slideEl.classList.add(thumbActiveClass);
		});
		else for (let i = 0; i < thumbsToActivate; i += 1) {
			const slide = thumbsSwiper.slides[swiper.realIndex + i];
			if (slide) slide.classList.add(thumbActiveClass);
		}
		if (p?.autoScroll ?? true) autoScroll(initial ? 0 : void 0);
	}
	function autoScroll(slideSpeed) {
		const thumbsSwiper = swiper.thumbs.swiper;
		if (!thumbsSwiper || thumbsSwiper.destroyed) return;
		const thumbsSlidesPerView = thumbsSwiper.params.slidesPerView;
		const slidesPerView = thumbsSlidesPerView === "auto" ? thumbsSwiper.slidesPerViewDynamic() : thumbsSlidesPerView ?? 1;
		const autoScrollOffset = getParams().autoScrollOffset;
		const useOffset = autoScrollOffset && !thumbsSwiper.params.loop;
		if (swiper.realIndex !== thumbsSwiper.realIndex || useOffset) {
			const currentThumbsIndex = thumbsSwiper.activeIndex;
			let newThumbsIndex;
			let direction;
			if (thumbsSwiper.params.loop) {
				const newThumbsSlide = thumbsSwiper.slides.find((slideEl) => slideEl.getAttribute("data-swiper-slide-index") === `${swiper.realIndex}`);
				newThumbsIndex = newThumbsSlide ? thumbsSwiper.slides.indexOf(newThumbsSlide) : -1;
				direction = swiper.activeIndex > swiper.previousIndex ? "next" : "prev";
			} else {
				newThumbsIndex = swiper.realIndex;
				direction = newThumbsIndex > swiper.previousIndex ? "next" : "prev";
			}
			if (useOffset) newThumbsIndex += direction === "next" ? autoScrollOffset : -1 * autoScrollOffset;
			if (thumbsSwiper.visibleSlidesIndexes && thumbsSwiper.visibleSlidesIndexes.indexOf(newThumbsIndex) < 0) {
				if (thumbsSwiper.params.centeredSlides) if (newThumbsIndex > currentThumbsIndex) newThumbsIndex = newThumbsIndex - Math.floor(slidesPerView / 2) + 1;
				else newThumbsIndex = newThumbsIndex + Math.floor(slidesPerView / 2) - 1;
				else if (newThumbsIndex > currentThumbsIndex && thumbsSwiper.params.slidesPerGroup === 1);
				thumbsSwiper.slideTo(newThumbsIndex, slideSpeed);
			}
		}
	}
	on("beforeInit", () => {
		const thumbs = swiper.params.thumbs;
		if (!thumbs || !thumbs.swiper) return;
		if (typeof thumbs.swiper === "string" || thumbs.swiper instanceof HTMLElement) {
			const getThumbsElementAndInit = () => {
				const thumbsElement = typeof thumbs.swiper === "string" ? document.querySelector(thumbs.swiper) : thumbs.swiper;
				if (thumbsElement && thumbsElement.swiper) {
					thumbs.swiper = thumbsElement.swiper;
					init();
					update(true);
				} else if (thumbsElement) {
					const eventName = `${swiper.params.eventsPrefix}init`;
					const onThumbsSwiper = (e) => {
						const detail = e.detail;
						thumbs.swiper = detail[0];
						thumbsElement.removeEventListener(eventName, onThumbsSwiper);
						init();
						update(true);
						thumbs.swiper.update();
						swiper.update();
					};
					thumbsElement.addEventListener(eventName, onThumbsSwiper);
				}
				return thumbsElement;
			};
			const watchForThumbsToAppear = () => {
				if (swiper.destroyed) return;
				if (!getThumbsElementAndInit()) requestAnimationFrame(watchForThumbsToAppear);
			};
			requestAnimationFrame(watchForThumbsToAppear);
		} else {
			init();
			update(true);
		}
	});
	on("slideChange update resize observerUpdate", () => {
		update();
	});
	on("setTransition", (_s, duration) => {
		const thumbsSwiper = swiper.thumbs.swiper;
		if (!thumbsSwiper || thumbsSwiper.destroyed) return;
		thumbsSwiper.setTransition(duration);
	});
	on("beforeDestroy", () => {
		const thumbsSwiper = swiper.thumbs.swiper;
		if (!thumbsSwiper || thumbsSwiper.destroyed) return;
		if (swiperCreated) thumbsSwiper.destroy();
	});
	Object.assign(swiper.thumbs, {
		init,
		update
	});
};
//#endregion
//#region node_modules/swiper/modules/free-mode.mjs
var FreeMode = ({ swiper, extendParams, emit, once }) => {
	extendParams({ freeMode: {
		enabled: false,
		momentum: true,
		momentumRatio: 1,
		momentumBounce: true,
		momentumBounceRatio: 1,
		momentumVelocityRatio: 1,
		sticky: false,
		minimumVelocity: .02
	} });
	function getParams() {
		return swiper.params.freeMode;
	}
	function onTouchStart() {
		if (swiper.params.cssMode) return;
		const translate = swiper.getTranslate();
		swiper.setTranslate(translate);
		swiper.setTransition(0);
		swiper.touchEventsData.velocities.length = 0;
		swiper.freeMode.onTouchEnd({ currentPos: swiper.rtl ? swiper.translate : -swiper.translate });
	}
	function onTouchMove() {
		if (swiper.params.cssMode) return;
		const { touchEventsData: data, touches } = swiper;
		if (data.velocities.length === 0) data.velocities.push({
			position: touches[swiper.isHorizontal() ? "startX" : "startY"],
			time: data.touchStartTime ?? now()
		});
		data.velocities.push({
			position: touches[swiper.isHorizontal() ? "currentX" : "currentY"],
			time: now()
		});
	}
	function onTouchEnd({ currentPos }) {
		if (swiper.params.cssMode) return;
		const { wrapperEl, rtlTranslate: rtl, snapGrid, touchEventsData: data } = swiper;
		const params = swiper.params;
		const freeModeParams = getParams();
		const touchEndTime = now();
		const timeDiff = touchEndTime - (data.touchStartTime ?? touchEndTime);
		if (currentPos < -swiper.minTranslate()) {
			swiper.slideTo(swiper.activeIndex);
			return;
		}
		if (currentPos > -swiper.maxTranslate()) {
			if (swiper.slides.length < snapGrid.length) swiper.slideTo(snapGrid.length - 1);
			else swiper.slideTo(swiper.slides.length - 1);
			return;
		}
		if (freeModeParams.momentum) {
			if (data.velocities.length > 1) {
				const lastMoveEvent = data.velocities.pop();
				const velocityEvent = data.velocities.pop();
				const distance = lastMoveEvent.position - velocityEvent.position;
				const time = lastMoveEvent.time - velocityEvent.time;
				swiper.velocity = distance / time;
				swiper.velocity /= 2;
				if (Math.abs(swiper.velocity) < freeModeParams.minimumVelocity) swiper.velocity = 0;
				if (time > 150 || now() - lastMoveEvent.time > 300) swiper.velocity = 0;
			} else swiper.velocity = 0;
			swiper.velocity *= freeModeParams.momentumVelocityRatio;
			data.velocities.length = 0;
			let momentumDuration = 1e3 * freeModeParams.momentumRatio;
			const momentumDistance = swiper.velocity * momentumDuration;
			let newPosition = swiper.translate + momentumDistance;
			if (rtl) newPosition = -newPosition;
			let doBounce = false;
			let afterBouncePosition;
			const bounceAmount = Math.abs(swiper.velocity) * 20 * freeModeParams.momentumBounceRatio;
			let needsLoopFix = false;
			if (newPosition < swiper.maxTranslate()) {
				if (freeModeParams.momentumBounce) {
					if (newPosition + swiper.maxTranslate() < -bounceAmount) newPosition = swiper.maxTranslate() - bounceAmount;
					afterBouncePosition = swiper.maxTranslate();
					doBounce = true;
					data.allowMomentumBounce = true;
				} else newPosition = swiper.maxTranslate();
				if (params.loop && params.centeredSlides) needsLoopFix = true;
			} else if (newPosition > swiper.minTranslate()) {
				if (freeModeParams.momentumBounce) {
					if (newPosition - swiper.minTranslate() > bounceAmount) newPosition = swiper.minTranslate() + bounceAmount;
					afterBouncePosition = swiper.minTranslate();
					doBounce = true;
					data.allowMomentumBounce = true;
				} else newPosition = swiper.minTranslate();
				if (params.loop && params.centeredSlides) needsLoopFix = true;
			} else if (freeModeParams.sticky) {
				let nextSlide = 0;
				for (let j = 0; j < snapGrid.length; j += 1) if (snapGrid[j] > -newPosition) {
					nextSlide = j;
					break;
				}
				if (Math.abs(snapGrid[nextSlide] - newPosition) < Math.abs((snapGrid[nextSlide - 1] ?? snapGrid[nextSlide]) - newPosition) || swiper.swipeDirection === "next") newPosition = snapGrid[nextSlide];
				else newPosition = snapGrid[nextSlide - 1];
				newPosition = -newPosition;
			}
			if (needsLoopFix) once("transitionEnd", () => {
				swiper.loopFix();
			});
			if (swiper.velocity !== 0) {
				if (rtl) momentumDuration = Math.abs((-newPosition - swiper.translate) / swiper.velocity);
				else momentumDuration = Math.abs((newPosition - swiper.translate) / swiper.velocity);
				if (freeModeParams.sticky) {
					const moveDistance = Math.abs((rtl ? -newPosition : newPosition) - swiper.translate);
					const currentSlideSize = swiper.slidesSizesGrid[swiper.activeIndex];
					const speed = params.speed;
					if (moveDistance < currentSlideSize) momentumDuration = speed;
					else if (moveDistance < 2 * currentSlideSize) momentumDuration = speed * 1.5;
					else momentumDuration = speed * 2.5;
				}
			} else if (freeModeParams.sticky) {
				swiper.slideToClosest();
				return;
			}
			if (freeModeParams.momentumBounce && doBounce && afterBouncePosition !== void 0) {
				swiper.updateProgress(afterBouncePosition);
				swiper.setTransition(momentumDuration);
				swiper.setTranslate(newPosition);
				swiper.transitionStart(true, swiper.swipeDirection);
				swiper.animating = true;
				elementTransitionEnd(wrapperEl, () => {
					if (!swiper || swiper.destroyed || !data.allowMomentumBounce) return;
					emit("momentumBounce");
					swiper.setTransition(params.speed);
					setTimeout(() => {
						swiper.setTranslate(afterBouncePosition);
						elementTransitionEnd(wrapperEl, () => {
							if (!swiper || swiper.destroyed) return;
							swiper.transitionEnd();
						});
					}, 0);
				});
			} else if (swiper.velocity) {
				emit("_freeModeNoMomentumRelease");
				swiper.updateProgress(newPosition);
				swiper.setTransition(momentumDuration);
				swiper.setTranslate(newPosition);
				swiper.transitionStart(true, swiper.swipeDirection);
				if (!swiper.animating) {
					swiper.animating = true;
					elementTransitionEnd(wrapperEl, () => {
						if (!swiper || swiper.destroyed) return;
						swiper.transitionEnd();
					});
				}
			} else swiper.updateProgress(newPosition);
			swiper.updateActiveIndex();
			swiper.updateSlidesClasses();
		} else if (freeModeParams.sticky) {
			swiper.slideToClosest();
			return;
		} else emit("_freeModeNoMomentumRelease");
		if (!freeModeParams.momentum || timeDiff >= params.longSwipesMs) {
			emit("_freeModeStaticRelease");
			swiper.updateProgress();
			swiper.updateActiveIndex();
			swiper.updateSlidesClasses();
		}
	}
	swiper.freeMode = {
		onTouchStart,
		onTouchMove,
		onTouchEnd
	};
};
//#endregion
//#region node_modules/swiper/modules/grid.mjs
var Grid = ({ swiper, extendParams, on }) => {
	extendParams({ grid: {
		rows: 1,
		fill: "column"
	} });
	function getParams() {
		return swiper.params.grid;
	}
	let slidesNumberEvenToRows;
	let slidesPerRow;
	let numFullColumns;
	let wasMultiRow;
	const getSpaceBetween = () => {
		let spaceBetween = swiper.params.spaceBetween ?? 0;
		if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiper.size;
		else if (typeof spaceBetween === "string") spaceBetween = parseFloat(spaceBetween);
		return spaceBetween;
	};
	const isVirtualEnabled = () => {
		const virtualParams = swiper.params.virtual;
		return !!swiper.virtual && typeof virtualParams === "object" && virtualParams !== null && !!virtualParams.enabled;
	};
	const initSlides = (slides) => {
		const { slidesPerView } = swiper.params;
		const { rows, fill } = getParams();
		const slidesLength = isVirtualEnabled() ? swiper.virtual.slides.length : slides.length;
		numFullColumns = Math.floor(slidesLength / rows);
		if (Math.floor(slidesLength / rows) === slidesLength / rows) slidesNumberEvenToRows = slidesLength;
		else slidesNumberEvenToRows = Math.ceil(slidesLength / rows) * rows;
		if (slidesPerView !== "auto" && fill === "row") slidesNumberEvenToRows = Math.max(slidesNumberEvenToRows, Math.floor(slidesPerView ?? 1) * rows);
		slidesPerRow = slidesNumberEvenToRows / rows;
	};
	const unsetSlides = () => {
		if (swiper.slides) swiper.slides.forEach((slide) => {
			if (slide.swiperSlideGridSet) {
				slide.style.height = "";
				slide.style.setProperty(swiper.getDirectionLabel("margin-top"), "");
			}
		});
	};
	const updateSlide = (i, slide, slides) => {
		const { slidesPerGroup } = swiper.params;
		const spaceBetween = getSpaceBetween();
		const { rows, fill } = getParams();
		const slidesLength = isVirtualEnabled() ? swiper.virtual.slides.length : slides.length;
		let newSlideOrderIndex;
		let column;
		let row;
		if (fill === "row" && (slidesPerGroup ?? 1) > 1) {
			const groupsPer = slidesPerGroup ?? 1;
			const groupIndex = Math.floor(i / (groupsPer * rows));
			const slideIndexInGroup = i - rows * groupsPer * groupIndex;
			const columnsInGroup = groupIndex === 0 ? groupsPer : Math.min(Math.ceil((slidesLength - groupIndex * rows * groupsPer) / rows), groupsPer);
			row = Math.floor(slideIndexInGroup / columnsInGroup);
			column = slideIndexInGroup - row * columnsInGroup + groupIndex * groupsPer;
			newSlideOrderIndex = column + row * slidesNumberEvenToRows / rows;
			slide.style.order = String(newSlideOrderIndex);
		} else if (fill === "column") {
			column = Math.floor(i / rows);
			row = i - column * rows;
			if (column > numFullColumns || column === numFullColumns && row === rows - 1) {
				row += 1;
				if (row >= rows) {
					row = 0;
					column += 1;
				}
			}
		} else {
			row = Math.floor(i / slidesPerRow);
			column = i - row * slidesPerRow;
		}
		const gridSlide = slide;
		gridSlide.row = row;
		gridSlide.column = column;
		slide.style.height = `calc((100% - ${(rows - 1) * spaceBetween}px) / ${rows})`;
		slide.style.setProperty(swiper.getDirectionLabel("margin-top"), row !== 0 && spaceBetween ? `${spaceBetween}px` : "");
		gridSlide.swiperSlideGridSet = true;
	};
	const updateWrapperSize = (slideSize, snapGrid) => {
		const { centeredSlides, roundLengths } = swiper.params;
		const spaceBetween = getSpaceBetween();
		const { rows } = getParams();
		swiper.virtualSize = (slideSize + spaceBetween) * slidesNumberEvenToRows;
		swiper.virtualSize = Math.ceil(swiper.virtualSize / rows) - spaceBetween;
		if (!swiper.params.cssMode) swiper.wrapperEl.style.setProperty(swiper.getDirectionLabel("width"), `${swiper.virtualSize + spaceBetween}px`);
		if (centeredSlides) {
			const newSlidesGrid = [];
			for (let i = 0; i < snapGrid.length; i += 1) {
				let slidesGridItem = snapGrid[i];
				if (roundLengths) slidesGridItem = Math.floor(slidesGridItem);
				if (snapGrid[i] < swiper.virtualSize + snapGrid[0]) newSlidesGrid.push(slidesGridItem);
			}
			snapGrid.splice(0, snapGrid.length);
			snapGrid.push(...newSlidesGrid);
		}
	};
	const onInit = () => {
		const gridParams = swiper.params.grid;
		wasMultiRow = !!(gridParams && (gridParams.rows ?? 1) > 1);
	};
	const onUpdate = () => {
		const { params, el } = swiper;
		const gridParams = params.grid;
		const isMultiRow = !!(gridParams && (gridParams.rows ?? 1) > 1);
		if (wasMultiRow && !isMultiRow) {
			el.classList.remove(`${params.containerModifierClass}grid`, `${params.containerModifierClass}grid-column`);
			numFullColumns = 1;
			swiper.emitContainerClasses();
		} else if (!wasMultiRow && isMultiRow) {
			el.classList.add(`${params.containerModifierClass}grid`);
			if (gridParams.fill === "column") el.classList.add(`${params.containerModifierClass}grid-column`);
			swiper.emitContainerClasses();
		}
		wasMultiRow = isMultiRow;
	};
	on("init", onInit);
	on("update", onUpdate);
	swiper.grid = {
		initSlides,
		unsetSlides,
		updateSlide,
		updateWrapperSize
	};
};
//#endregion
//#region node_modules/swiper/modules/manipulation.mjs
function addSlide(index, slides) {
	const swiper = this;
	const { params, activeIndex, slidesEl } = swiper;
	let activeIndexBuffer = activeIndex;
	if (params.loop) {
		activeIndexBuffer -= swiper.loopedSlides ?? 0;
		swiper.loopDestroy();
		swiper.recalcSlides();
	}
	const baseLength = swiper.slides.length;
	if (index <= 0) {
		swiper.prependSlide(slides);
		return;
	}
	if (index >= baseLength) {
		swiper.appendSlide(slides);
		return;
	}
	let newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + 1 : activeIndexBuffer;
	const slidesBuffer = [];
	for (let i = baseLength - 1; i >= index; i -= 1) {
		const currentSlide = swiper.slides[i];
		if (!currentSlide) continue;
		currentSlide.remove();
		slidesBuffer.unshift(currentSlide);
	}
	if (Array.isArray(slides)) {
		for (let i = 0; i < slides.length; i += 1) {
			const slide = slides[i];
			if (slide) slidesEl.append(slide);
		}
		newActiveIndex = activeIndexBuffer > index ? activeIndexBuffer + slides.length : activeIndexBuffer;
	} else slidesEl.append(slides);
	for (let i = 0; i < slidesBuffer.length; i += 1) slidesEl.append(slidesBuffer[i]);
	swiper.recalcSlides();
	if (params.loop) swiper.loopCreate();
	if (!params.observer || swiper.isElement) swiper.update();
	if (params.loop) swiper.slideTo(newActiveIndex + (swiper.loopedSlides ?? 0), 0, false);
	else swiper.slideTo(newActiveIndex, 0, false);
}
function appendSlide(slides) {
	const swiper = this;
	const { params, slidesEl } = swiper;
	if (params.loop) swiper.loopDestroy();
	const appendElement = (slideEl) => {
		if (typeof slideEl === "string") {
			const tempDOM = document.createElement("div");
			setInnerHTML(tempDOM, slideEl);
			const child = tempDOM.children[0];
			if (child) slidesEl.append(child);
			setInnerHTML(tempDOM, "");
		} else slidesEl.append(slideEl);
	};
	if (Array.isArray(slides)) for (let i = 0; i < slides.length; i += 1) {
		const slide = slides[i];
		if (slide) appendElement(slide);
	}
	else appendElement(slides);
	swiper.recalcSlides();
	if (params.loop) swiper.loopCreate();
	if (!params.observer || swiper.isElement) swiper.update();
}
function prependSlide(slides) {
	const swiper = this;
	const { params, activeIndex, slidesEl } = swiper;
	if (params.loop) swiper.loopDestroy();
	let newActiveIndex = activeIndex + 1;
	const prependElement = (slideEl) => {
		if (typeof slideEl === "string") {
			const tempDOM = document.createElement("div");
			setInnerHTML(tempDOM, slideEl);
			const child = tempDOM.children[0];
			if (child) slidesEl.prepend(child);
			setInnerHTML(tempDOM, "");
		} else slidesEl.prepend(slideEl);
	};
	if (Array.isArray(slides)) {
		for (let i = 0; i < slides.length; i += 1) {
			const slide = slides[i];
			if (slide) prependElement(slide);
		}
		newActiveIndex = activeIndex + slides.length;
	} else prependElement(slides);
	swiper.recalcSlides();
	if (params.loop) swiper.loopCreate();
	if (!params.observer || swiper.isElement) swiper.update();
	swiper.slideTo(newActiveIndex, 0, false);
}
function removeAllSlides() {
	const swiper = this;
	const slidesIndexes = [];
	for (let i = 0; i < swiper.slides.length; i += 1) slidesIndexes.push(i);
	swiper.removeSlide(slidesIndexes);
}
function removeSlide(slidesIndexes) {
	const swiper = this;
	const { params, activeIndex } = swiper;
	let activeIndexBuffer = activeIndex;
	if (params.loop) {
		activeIndexBuffer -= swiper.loopedSlides ?? 0;
		swiper.loopDestroy();
	}
	let newActiveIndex = activeIndexBuffer;
	if (Array.isArray(slidesIndexes)) {
		for (let i = 0; i < slidesIndexes.length; i += 1) {
			const indexToRemove = slidesIndexes[i];
			if (swiper.slides[indexToRemove]) swiper.slides[indexToRemove].remove();
			if (indexToRemove < newActiveIndex) newActiveIndex -= 1;
		}
		newActiveIndex = Math.max(newActiveIndex, 0);
	} else {
		const indexToRemove = slidesIndexes;
		if (swiper.slides[indexToRemove]) swiper.slides[indexToRemove].remove();
		if (indexToRemove < newActiveIndex) newActiveIndex -= 1;
		newActiveIndex = Math.max(newActiveIndex, 0);
	}
	swiper.recalcSlides();
	if (params.loop) swiper.loopCreate();
	if (!params.observer || swiper.isElement) swiper.update();
	if (params.loop) swiper.slideTo(newActiveIndex + (swiper.loopedSlides ?? 0), 0, false);
	else swiper.slideTo(newActiveIndex, 0, false);
}
var Manipulation = ({ swiper }) => {
	Object.assign(swiper, {
		appendSlide: appendSlide.bind(swiper),
		prependSlide: prependSlide.bind(swiper),
		addSlide: addSlide.bind(swiper),
		removeSlide: removeSlide.bind(swiper),
		removeAllSlides: removeAllSlides.bind(swiper)
	});
};
//#endregion
//#region node_modules/swiper/shared/effect-init.mjs
function effectInit(params) {
	const { effect, swiper, on, setTranslate, setTransition, overwriteParams, perspective, recreateShadows, getEffectParams } = params;
	on("beforeInit", () => {
		if (swiper.params.effect !== effect) return;
		swiper.classNames.push(`${swiper.params.containerModifierClass}${effect}`);
		if (perspective && perspective()) swiper.classNames.push(`${swiper.params.containerModifierClass}3d`);
		const overwriteParamsResult = overwriteParams ? overwriteParams() : {};
		Object.assign(swiper.params, overwriteParamsResult);
		Object.assign(swiper.originalParams, overwriteParamsResult);
	});
	on("setTranslate _virtualUpdated", () => {
		if (swiper.params.effect !== effect) return;
		setTranslate();
	});
	on("setTransition", (_s, duration) => {
		if (swiper.params.effect !== effect) return;
		setTransition(duration);
	});
	on("transitionEnd", () => {
		if (swiper.params.effect !== effect) return;
		if (recreateShadows) {
			const effectParams = getEffectParams ? getEffectParams() : void 0;
			if (!effectParams || !effectParams.slideShadows) return;
			swiper.slides.forEach((slideEl) => {
				slideEl.querySelectorAll(".swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left").forEach((shadowEl) => shadowEl.remove());
			});
			recreateShadows();
		}
	});
	let requireUpdateOnVirtual = false;
	on("virtualUpdate", () => {
		if (swiper.params.effect !== effect) return;
		if (!swiper.slides.length) requireUpdateOnVirtual = true;
		requestAnimationFrame(() => {
			if (requireUpdateOnVirtual && swiper.slides && swiper.slides.length) {
				setTranslate();
				requireUpdateOnVirtual = false;
			}
		});
	});
}
//#endregion
//#region node_modules/swiper/shared/effect-target.mjs
function effectTarget(_effectParams, slideEl) {
	const transformEl = getSlideTransformEl(slideEl);
	if (transformEl !== slideEl) {
		transformEl.style.backfaceVisibility = "hidden";
		transformEl.style.setProperty("-webkit-backface-visibility", "hidden");
	}
	return transformEl;
}
//#endregion
//#region node_modules/swiper/shared/effect-virtual-transition-end.mjs
function effectVirtualTransitionEnd({ swiper, duration, transformElements, allSlides }) {
	const { activeIndex } = swiper;
	const getSlide = (el) => {
		if (!el.parentElement) return swiper.slides.find((slideEl) => slideEl.shadowRoot && slideEl.shadowRoot === el.parentNode);
		if (el.parentElement instanceof HTMLElement) return el.parentElement;
	};
	if (swiper.params.virtualTranslate && duration !== 0) {
		let eventTriggered = false;
		let transitionEndTarget;
		if (allSlides) transitionEndTarget = transformElements;
		else transitionEndTarget = transformElements.filter((transformEl) => {
			const el = transformEl.classList.contains("swiper-slide-transform") ? getSlide(transformEl) : transformEl;
			return !!el && swiper.getSlideIndex(el) === activeIndex;
		});
		transitionEndTarget.forEach((el) => {
			elementTransitionEnd(el, () => {
				if (eventTriggered) return;
				if (!swiper || swiper.destroyed) return;
				eventTriggered = true;
				swiper.animating = false;
				const evt = new CustomEvent("transitionend", {
					bubbles: true,
					cancelable: true
				});
				swiper.wrapperEl.dispatchEvent(evt);
			});
		});
	}
}
//#endregion
//#region node_modules/swiper/modules/effect-fade.mjs
var EffectFade = ({ swiper, extendParams, on }) => {
	extendParams({ fadeEffect: { crossFade: false } });
	function getParams() {
		return swiper.params.fadeEffect;
	}
	const setTranslate = () => {
		const { slides } = swiper;
		const params = getParams();
		for (let i = 0; i < slides.length; i += 1) {
			const slideEl = slides[i];
			let tx = -(slideEl.swiperSlideOffset ?? 0);
			if (!swiper.params.virtualTranslate) tx -= swiper.translate;
			let ty = 0;
			if (!swiper.isHorizontal()) {
				ty = tx;
				tx = 0;
			}
			const slideProgress = slideEl.progress ?? 0;
			const slideOpacity = params.crossFade ? Math.max(1 - Math.abs(slideProgress), 0) : 1 + Math.min(Math.max(slideProgress, -1), 0);
			const targetEl = effectTarget(params, slideEl);
			targetEl.style.opacity = String(slideOpacity);
			targetEl.style.transform = `translate3d(${tx}px, ${ty}px, 0px)`;
		}
	};
	const setTransition = (duration) => {
		const transformElements = swiper.slides.map((slideEl) => getSlideTransformEl(slideEl));
		transformElements.forEach((el) => {
			el.style.transitionDuration = `${duration}ms`;
		});
		effectVirtualTransitionEnd({
			swiper,
			duration,
			transformElements,
			allSlides: true
		});
	};
	effectInit({
		effect: "fade",
		swiper,
		on,
		setTranslate,
		setTransition,
		overwriteParams: () => ({
			slidesPerView: 1,
			slidesPerGroup: 1,
			watchSlidesProgress: true,
			spaceBetween: 0,
			virtualTranslate: !swiper.params.cssMode
		})
	});
};
//#endregion
//#region node_modules/swiper/modules/effect-cube.mjs
var EffectCube = ({ swiper, extendParams, on }) => {
	extendParams({ cubeEffect: {
		slideShadows: true,
		shadow: true,
		shadowOffset: 20,
		shadowScale: .94
	} });
	function getParams() {
		return swiper.params.cubeEffect;
	}
	const createSlideShadows = (slideEl, progress, isHorizontal) => {
		let shadowBefore = isHorizontal ? slideEl.querySelector(".swiper-slide-shadow-left") : slideEl.querySelector(".swiper-slide-shadow-top");
		let shadowAfter = isHorizontal ? slideEl.querySelector(".swiper-slide-shadow-right") : slideEl.querySelector(".swiper-slide-shadow-bottom");
		if (!shadowBefore) {
			shadowBefore = createElement("div", `swiper-slide-shadow-cube swiper-slide-shadow-${isHorizontal ? "left" : "top"}`.split(" "));
			slideEl.append(shadowBefore);
		}
		if (!shadowAfter) {
			shadowAfter = createElement("div", `swiper-slide-shadow-cube swiper-slide-shadow-${isHorizontal ? "right" : "bottom"}`.split(" "));
			slideEl.append(shadowAfter);
		}
		if (shadowBefore) shadowBefore.style.opacity = String(Math.max(-progress, 0));
		if (shadowAfter) shadowAfter.style.opacity = String(Math.max(progress, 0));
	};
	const recreateShadows = () => {
		const isHorizontal = swiper.isHorizontal();
		swiper.slides.forEach((slideEl) => {
			const progress = Math.max(Math.min(slideEl.progress ?? 0, 1), -1);
			createSlideShadows(slideEl, progress, isHorizontal);
		});
	};
	const setTranslate = () => {
		const { el, wrapperEl, slides, width: swiperWidth, height: swiperHeight, rtlTranslate: rtl, size: swiperSize } = swiper;
		const r = getRotateFix(swiper);
		const params = getParams();
		const isHorizontal = swiper.isHorizontal();
		const isVirtual = !!(swiper.virtual && swiper.params.virtual?.enabled);
		let wrapperRotate = 0;
		let cubeShadowEl = null;
		if (params.shadow) if (isHorizontal) {
			cubeShadowEl = swiper.wrapperEl.querySelector(".swiper-cube-shadow");
			if (!cubeShadowEl) {
				cubeShadowEl = createElement("div", "swiper-cube-shadow");
				swiper.wrapperEl.append(cubeShadowEl);
			}
			cubeShadowEl.style.height = `${swiperWidth}px`;
		} else {
			cubeShadowEl = el.querySelector(".swiper-cube-shadow");
			if (!cubeShadowEl) {
				cubeShadowEl = createElement("div", "swiper-cube-shadow");
				el.append(cubeShadowEl);
			}
		}
		for (let i = 0; i < slides.length; i += 1) {
			const slideEl = slides[i];
			let slideIndex = i;
			if (isVirtual) slideIndex = parseInt(slideEl.getAttribute("data-swiper-slide-index") ?? "0", 10);
			let slideAngle = slideIndex * 90;
			let round = Math.floor(slideAngle / 360);
			if (rtl) {
				slideAngle = -slideAngle;
				round = Math.floor(-slideAngle / 360);
			}
			const progress = Math.max(Math.min(slideEl.progress ?? 0, 1), -1);
			let tx = 0;
			let ty = 0;
			let tz = 0;
			if (slideIndex % 4 === 0) {
				tx = -round * 4 * swiperSize;
				tz = 0;
			} else if ((slideIndex - 1) % 4 === 0) {
				tx = 0;
				tz = -round * 4 * swiperSize;
			} else if ((slideIndex - 2) % 4 === 0) {
				tx = swiperSize + round * 4 * swiperSize;
				tz = swiperSize;
			} else if ((slideIndex - 3) % 4 === 0) {
				tx = -swiperSize;
				tz = 3 * swiperSize + swiperSize * 4 * round;
			}
			if (rtl) tx = -tx;
			if (!isHorizontal) {
				ty = tx;
				tx = 0;
			}
			const transform = `rotateX(${r(isHorizontal ? 0 : -slideAngle)}deg) rotateY(${r(isHorizontal ? slideAngle : 0)}deg) translate3d(${tx}px, ${ty}px, ${tz}px)`;
			if (progress <= 1 && progress > -1) {
				wrapperRotate = slideIndex * 90 + progress * 90;
				if (rtl) wrapperRotate = -slideIndex * 90 - progress * 90;
			}
			slideEl.style.transform = transform;
			if (params.slideShadows) createSlideShadows(slideEl, progress, isHorizontal);
		}
		wrapperEl.style.transformOrigin = `50% 50% -${swiperSize / 2}px`;
		wrapperEl.style.setProperty("-webkit-transform-origin", `50% 50% -${swiperSize / 2}px`);
		if (params.shadow && cubeShadowEl) if (isHorizontal) cubeShadowEl.style.transform = `translate3d(0px, ${swiperWidth / 2 + params.shadowOffset}px, ${-swiperWidth / 2}px) rotateX(89.99deg) rotateZ(0deg) scale(${params.shadowScale})`;
		else {
			const shadowAngle = Math.abs(wrapperRotate) - Math.floor(Math.abs(wrapperRotate) / 90) * 90;
			const multiplier = 1.5 - (Math.sin(shadowAngle * 2 * Math.PI / 360) / 2 + Math.cos(shadowAngle * 2 * Math.PI / 360) / 2);
			const scale1 = params.shadowScale;
			const scale2 = params.shadowScale / multiplier;
			const offset = params.shadowOffset;
			cubeShadowEl.style.transform = `scale3d(${scale1}, 1, ${scale2}) translate3d(0px, ${swiperHeight / 2 + offset}px, ${-swiperHeight / 2 / scale2}px) rotateX(-89.99deg)`;
		}
		wrapperEl.style.transform = `translate3d(0px,0,0px) rotateX(${r(swiper.isHorizontal() ? 0 : wrapperRotate)}deg) rotateY(${r(swiper.isHorizontal() ? -wrapperRotate : 0)}deg)`;
		wrapperEl.style.setProperty("--swiper-cube-translate-z", "0px");
	};
	const setTransition = (duration) => {
		const { el, slides } = swiper;
		slides.forEach((slideEl) => {
			slideEl.style.transitionDuration = `${duration}ms`;
			slideEl.querySelectorAll(".swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left").forEach((subEl) => {
				subEl.style.transitionDuration = `${duration}ms`;
			});
		});
		if (swiper.params.cubeEffect?.shadow && !swiper.isHorizontal()) {
			const shadowEl = el.querySelector(".swiper-cube-shadow");
			if (shadowEl) shadowEl.style.transitionDuration = `${duration}ms`;
		}
	};
	effectInit({
		effect: "cube",
		swiper,
		on,
		setTranslate,
		setTransition,
		recreateShadows,
		getEffectParams: () => swiper.params.cubeEffect,
		perspective: () => true,
		overwriteParams: () => ({
			slidesPerView: 1,
			slidesPerGroup: 1,
			watchSlidesProgress: true,
			resistanceRatio: 0,
			spaceBetween: 0,
			centeredSlides: false,
			virtualTranslate: true
		})
	});
};
//#endregion
//#region node_modules/swiper/shared/create-shadow.mjs
function createShadow(suffix, slideEl, side) {
	const shadowClass = `swiper-slide-shadow${side ? `-${side}` : ""}${suffix ? ` swiper-slide-shadow-${suffix}` : ""}`;
	const shadowContainer = getSlideTransformEl(slideEl);
	const selector = `.${shadowClass.split(" ").join(".")}`;
	const existing = shadowContainer.querySelector(selector);
	if (existing) return existing;
	const created = createElement("div", shadowClass.split(" "));
	shadowContainer.append(created);
	return created;
}
//#endregion
//#region node_modules/swiper/modules/effect-flip.mjs
var EffectFlip = ({ swiper, extendParams, on }) => {
	extendParams({ flipEffect: {
		slideShadows: true,
		limitRotation: true
	} });
	function getParams() {
		return swiper.params.flipEffect;
	}
	const createSlideShadows = (slideEl, progress) => {
		let shadowBefore = swiper.isHorizontal() ? slideEl.querySelector(".swiper-slide-shadow-left") : slideEl.querySelector(".swiper-slide-shadow-top");
		let shadowAfter = swiper.isHorizontal() ? slideEl.querySelector(".swiper-slide-shadow-right") : slideEl.querySelector(".swiper-slide-shadow-bottom");
		if (!shadowBefore) shadowBefore = createShadow("flip", slideEl, swiper.isHorizontal() ? "left" : "top");
		if (!shadowAfter) shadowAfter = createShadow("flip", slideEl, swiper.isHorizontal() ? "right" : "bottom");
		if (shadowBefore) shadowBefore.style.opacity = String(Math.max(-progress, 0));
		if (shadowAfter) shadowAfter.style.opacity = String(Math.max(progress, 0));
	};
	const recreateShadows = () => {
		const params = getParams();
		swiper.slides.forEach((slideEl) => {
			let progress = slideEl.progress ?? 0;
			if (params.limitRotation) progress = Math.max(Math.min(progress, 1), -1);
			createSlideShadows(slideEl, progress);
		});
	};
	const setTranslate = () => {
		const { slides, rtlTranslate: rtl } = swiper;
		const params = getParams();
		const rotateFix = getRotateFix(swiper);
		for (let i = 0; i < slides.length; i += 1) {
			const slideEl = slides[i];
			let progress = slideEl.progress ?? 0;
			if (params.limitRotation) progress = Math.max(Math.min(progress, 1), -1);
			const offset = slideEl.swiperSlideOffset ?? 0;
			let rotateY = -180 * progress;
			let rotateX = 0;
			let tx = swiper.params.cssMode ? -offset - swiper.translate : -offset;
			let ty = 0;
			if (!swiper.isHorizontal()) {
				ty = tx;
				tx = 0;
				rotateX = -rotateY;
				rotateY = 0;
			} else if (rtl) rotateY = -rotateY;
			slideEl.style.zIndex = String(-Math.abs(Math.round(progress)) + slides.length);
			if (params.slideShadows) createSlideShadows(slideEl, progress);
			const transform = `translate3d(${tx}px, ${ty}px, 0px) rotateX(${rotateFix(rotateX)}deg) rotateY(${rotateFix(rotateY)}deg)`;
			const targetEl = effectTarget(params, slideEl);
			targetEl.style.transform = transform;
		}
	};
	const setTransition = (duration) => {
		const transformElements = swiper.slides.map((slideEl) => getSlideTransformEl(slideEl));
		transformElements.forEach((el) => {
			el.style.transitionDuration = `${duration}ms`;
			el.querySelectorAll(".swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left").forEach((shadowEl) => {
				shadowEl.style.transitionDuration = `${duration}ms`;
			});
		});
		effectVirtualTransitionEnd({
			swiper,
			duration,
			transformElements
		});
	};
	effectInit({
		effect: "flip",
		swiper,
		on,
		setTranslate,
		setTransition,
		recreateShadows,
		getEffectParams: () => swiper.params.flipEffect,
		perspective: () => true,
		overwriteParams: () => ({
			slidesPerView: 1,
			slidesPerGroup: 1,
			watchSlidesProgress: true,
			spaceBetween: 0,
			virtualTranslate: !swiper.params.cssMode
		})
	});
};
//#endregion
//#region node_modules/swiper/modules/effect-coverflow.mjs
var EffectCoverflow = ({ swiper, extendParams, on }) => {
	extendParams({ coverflowEffect: {
		rotate: 50,
		stretch: 0,
		depth: 100,
		scale: 1,
		modifier: 1,
		slideShadows: true
	} });
	function getParams() {
		return swiper.params.coverflowEffect;
	}
	const setTranslate = () => {
		const { width: swiperWidth, height: swiperHeight, slides, slidesSizesGrid } = swiper;
		const params = getParams();
		const isHorizontal = swiper.isHorizontal();
		const transform = swiper.translate;
		const center = isHorizontal ? -transform + swiperWidth / 2 : -transform + swiperHeight / 2;
		const rotate = isHorizontal ? params.rotate : -params.rotate;
		const translate = params.depth;
		const r = getRotateFix(swiper);
		for (let i = 0, length = slides.length; i < length; i += 1) {
			const slideEl = slides[i];
			const slideSize = slidesSizesGrid[i];
			const centerOffset = (center - (slideEl.swiperSlideOffset ?? 0) - slideSize / 2) / slideSize;
			const offsetMultiplier = typeof params.modifier === "function" ? params.modifier(centerOffset) : centerOffset * params.modifier;
			let rotateY = isHorizontal ? rotate * offsetMultiplier : 0;
			let rotateX = isHorizontal ? 0 : rotate * offsetMultiplier;
			let translateZ = -translate * Math.abs(offsetMultiplier);
			let stretch = typeof params.stretch === "string" && params.stretch.indexOf("%") !== -1 ? parseFloat(params.stretch) / 100 * slideSize : params.stretch;
			let translateY = isHorizontal ? 0 : stretch * offsetMultiplier;
			let translateX = isHorizontal ? stretch * offsetMultiplier : 0;
			let scale = 1 - (1 - params.scale) * Math.abs(offsetMultiplier);
			if (Math.abs(translateX) < .001) translateX = 0;
			if (Math.abs(translateY) < .001) translateY = 0;
			if (Math.abs(translateZ) < .001) translateZ = 0;
			if (Math.abs(rotateY) < .001) rotateY = 0;
			if (Math.abs(rotateX) < .001) rotateX = 0;
			if (Math.abs(scale) < .001) scale = 0;
			const slideTransform = `translate3d(${translateX}px,${translateY}px,${translateZ}px)  rotateX(${r(rotateX)}deg) rotateY(${r(rotateY)}deg) scale(${scale})`;
			const targetEl = effectTarget(params, slideEl);
			targetEl.style.transform = slideTransform;
			slideEl.style.zIndex = String(-Math.abs(Math.round(offsetMultiplier)) + 1);
			if (params.slideShadows) {
				let shadowBeforeEl = isHorizontal ? slideEl.querySelector(".swiper-slide-shadow-left") : slideEl.querySelector(".swiper-slide-shadow-top");
				let shadowAfterEl = isHorizontal ? slideEl.querySelector(".swiper-slide-shadow-right") : slideEl.querySelector(".swiper-slide-shadow-bottom");
				if (!shadowBeforeEl) shadowBeforeEl = createShadow("coverflow", slideEl, isHorizontal ? "left" : "top");
				if (!shadowAfterEl) shadowAfterEl = createShadow("coverflow", slideEl, isHorizontal ? "right" : "bottom");
				if (shadowBeforeEl) shadowBeforeEl.style.opacity = String(offsetMultiplier > 0 ? offsetMultiplier : 0);
				if (shadowAfterEl) shadowAfterEl.style.opacity = String(-offsetMultiplier > 0 ? -offsetMultiplier : 0);
			}
		}
	};
	const setTransition = (duration) => {
		swiper.slides.map((slideEl) => getSlideTransformEl(slideEl)).forEach((el) => {
			el.style.transitionDuration = `${duration}ms`;
			el.querySelectorAll(".swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left").forEach((shadowEl) => {
				shadowEl.style.transitionDuration = `${duration}ms`;
			});
		});
	};
	effectInit({
		effect: "coverflow",
		swiper,
		on,
		setTranslate,
		setTransition,
		perspective: () => true,
		overwriteParams: () => ({ watchSlidesProgress: true })
	});
};
//#endregion
//#region node_modules/swiper/modules/effect-creative.mjs
var EffectCreative = ({ swiper, extendParams, on }) => {
	extendParams({ creativeEffect: {
		limitProgress: 1,
		shadowPerProgress: false,
		progressMultiplier: 1,
		perspective: true,
		prev: {
			translate: [
				0,
				0,
				0
			],
			rotate: [
				0,
				0,
				0
			],
			opacity: 1,
			scale: 1
		},
		next: {
			translate: [
				0,
				0,
				0
			],
			rotate: [
				0,
				0,
				0
			],
			opacity: 1,
			scale: 1
		}
	} });
	function getParams() {
		return swiper.params.creativeEffect;
	}
	const getTranslateValue = (value) => {
		if (typeof value === "string") return value;
		return `${value}px`;
	};
	const setTranslate = () => {
		const { slides, wrapperEl, slidesSizesGrid } = swiper;
		const params = getParams();
		const { progressMultiplier: multiplier } = params;
		const isCenteredSlides = swiper.params.centeredSlides;
		const rotateFix = getRotateFix(swiper);
		if (isCenteredSlides) {
			const margin = slidesSizesGrid[0] / 2 - (swiper.params.slidesOffsetBefore ?? 0);
			wrapperEl.style.transform = `translateX(calc(50% - ${margin}px))`;
		}
		for (let i = 0; i < slides.length; i += 1) {
			const slideEl = slides[i];
			const slideProgress = slideEl.progress ?? 0;
			const progress = Math.min(Math.max(slideProgress, -params.limitProgress), params.limitProgress);
			let originalProgress = progress;
			if (!isCenteredSlides) originalProgress = Math.min(Math.max(slideEl.originalProgress ?? 0, -params.limitProgress), params.limitProgress);
			const offset = slideEl.swiperSlideOffset ?? 0;
			const t = [
				swiper.params.cssMode ? -offset - swiper.translate : -offset,
				0,
				0
			];
			const r = [
				0,
				0,
				0
			];
			let custom = false;
			if (!swiper.isHorizontal()) {
				t[1] = t[0];
				t[0] = 0;
			}
			let data = {
				translate: [
					0,
					0,
					0
				],
				rotate: [
					0,
					0,
					0
				],
				scale: 1,
				opacity: 1
			};
			if (progress < 0) {
				data = params.next;
				custom = true;
			} else if (progress > 0) {
				data = params.prev;
				custom = true;
			}
			t.forEach((value, index) => {
				t[index] = `calc(${value}px + (${getTranslateValue(data.translate[index])} * ${Math.abs(progress * multiplier)}))`;
			});
			r.forEach((_value, index) => {
				r[index] = data.rotate[index] * Math.abs(progress * multiplier);
			});
			slideEl.style.zIndex = String(-Math.abs(Math.round(slideProgress)) + slides.length);
			const translateString = t.join(", ");
			const rotateString = `rotateX(${rotateFix(r[0])}deg) rotateY(${rotateFix(r[1])}deg) rotateZ(${rotateFix(r[2])}deg)`;
			const scaleString = originalProgress < 0 ? `scale(${1 + (1 - data.scale) * originalProgress * multiplier})` : `scale(${1 - (1 - data.scale) * originalProgress * multiplier})`;
			const opacityString = originalProgress < 0 ? 1 + (1 - data.opacity) * originalProgress * multiplier : 1 - (1 - data.opacity) * originalProgress * multiplier;
			const transform = `translate3d(${translateString}) ${rotateString} ${scaleString}`;
			if (custom && data.shadow || !custom) {
				let shadowEl = slideEl.querySelector(".swiper-slide-shadow");
				if (!shadowEl && data.shadow) shadowEl = createShadow("creative", slideEl);
				if (shadowEl) {
					const shadowOpacity = params.shadowPerProgress ? progress * (1 / params.limitProgress) : progress;
					shadowEl.style.opacity = String(Math.min(Math.max(Math.abs(shadowOpacity), 0), 1));
				}
			}
			const targetEl = effectTarget(params, slideEl);
			targetEl.style.transform = transform;
			targetEl.style.opacity = String(opacityString);
			if (data.origin) targetEl.style.transformOrigin = data.origin;
		}
	};
	const setTransition = (duration) => {
		const transformElements = swiper.slides.map((slideEl) => getSlideTransformEl(slideEl));
		transformElements.forEach((el) => {
			el.style.transitionDuration = `${duration}ms`;
			el.querySelectorAll(".swiper-slide-shadow").forEach((shadowEl) => {
				shadowEl.style.transitionDuration = `${duration}ms`;
			});
		});
		effectVirtualTransitionEnd({
			swiper,
			duration,
			transformElements,
			allSlides: true
		});
	};
	effectInit({
		effect: "creative",
		swiper,
		on,
		setTranslate,
		setTransition,
		perspective: () => getParams().perspective,
		overwriteParams: () => ({
			watchSlidesProgress: true,
			virtualTranslate: !swiper.params.cssMode
		})
	});
};
//#endregion
//#region node_modules/swiper/modules/effect-cards.mjs
var EffectCards = ({ swiper, extendParams, on }) => {
	extendParams({ cardsEffect: {
		slideShadows: true,
		rotate: true,
		perSlideRotate: 2,
		perSlideOffset: 8
	} });
	function getParams() {
		return swiper.params.cardsEffect;
	}
	const setTranslate = () => {
		const { slides, activeIndex, rtlTranslate: rtl } = swiper;
		const params = getParams();
		const { startTranslate, isTouched } = swiper.touchEventsData;
		const currentTranslate = rtl ? -swiper.translate : swiper.translate;
		for (let i = 0; i < slides.length; i += 1) {
			const slideEl = slides[i];
			const slideProgress = slideEl.progress ?? 0;
			const progress = Math.min(Math.max(slideProgress, -4), 4);
			let offset = slideEl.swiperSlideOffset ?? 0;
			if (swiper.params.centeredSlides && !swiper.params.cssMode) swiper.wrapperEl.style.transform = `translateX(${swiper.minTranslate()}px)`;
			if (swiper.params.centeredSlides && swiper.params.cssMode) offset -= slides[0].swiperSlideOffset ?? 0;
			let tX = swiper.params.cssMode ? -offset - swiper.translate : -offset;
			let tY = 0;
			const tZ = -100 * Math.abs(progress);
			let scale = 1;
			let rotate = -params.perSlideRotate * progress;
			let tXAdd = params.perSlideOffset - Math.abs(progress) * .75;
			const slideIndex = swiper.virtual && swiper.params.virtual?.enabled ? swiper.virtual.from + i : i;
			const isSwipeToNext = (slideIndex === activeIndex || slideIndex === activeIndex - 1) && progress > 0 && progress < 1 && (isTouched || swiper.params.cssMode) && (currentTranslate ?? 0) < (startTranslate ?? 0);
			const isSwipeToPrev = (slideIndex === activeIndex || slideIndex === activeIndex + 1) && progress < 0 && progress > -1 && (isTouched || swiper.params.cssMode) && (currentTranslate ?? 0) > (startTranslate ?? 0);
			if (isSwipeToNext || isSwipeToPrev) {
				const subProgress = (1 - Math.abs((Math.abs(progress) - .5) / .5)) ** .5;
				rotate += -28 * progress * subProgress;
				scale += -.5 * subProgress;
				tXAdd += 96 * subProgress;
				tY = `${(params.rotate || swiper.isHorizontal() ? -25 : 0) * subProgress * Math.abs(progress)}%`;
			}
			if (progress < 0) tX = `calc(${tX}px ${rtl ? "-" : "+"} (${tXAdd * Math.abs(progress)}%))`;
			else if (progress > 0) tX = `calc(${tX}px ${rtl ? "-" : "+"} (-${tXAdd * Math.abs(progress)}%))`;
			else tX = `${tX}px`;
			if (!swiper.isHorizontal()) {
				const prevY = tY;
				tY = tX;
				tX = prevY;
			}
			const scaleString = progress < 0 ? `${1 + (1 - scale) * progress}` : `${1 - (1 - scale) * progress}`;
			const transform = `
        translate3d(${tX}, ${tY}, ${tZ}px)
        rotateZ(${params.rotate ? rtl ? -rotate : rotate : 0}deg)
        scale(${scaleString})
      `;
			if (params.slideShadows) {
				let shadowEl = slideEl.querySelector(".swiper-slide-shadow");
				if (!shadowEl) shadowEl = createShadow("cards", slideEl);
				if (shadowEl) shadowEl.style.opacity = String(Math.min(Math.max((Math.abs(progress) - .5) / .5, 0), 1));
			}
			slideEl.style.zIndex = String(-Math.abs(Math.round(slideProgress)) + slides.length);
			const targetEl = effectTarget(params, slideEl);
			targetEl.style.transform = transform;
		}
	};
	const setTransition = (duration) => {
		const transformElements = swiper.slides.map((slideEl) => getSlideTransformEl(slideEl));
		transformElements.forEach((el) => {
			el.style.transitionDuration = `${duration}ms`;
			el.querySelectorAll(".swiper-slide-shadow").forEach((shadowEl) => {
				shadowEl.style.transitionDuration = `${duration}ms`;
			});
		});
		effectVirtualTransitionEnd({
			swiper,
			duration,
			transformElements
		});
	};
	effectInit({
		effect: "cards",
		swiper,
		on,
		setTranslate,
		setTransition,
		perspective: () => true,
		overwriteParams: () => ({
			_loopSwapReset: false,
			watchSlidesProgress: true,
			loopAdditionalSlides: getParams().rotate ? 3 : 2,
			centeredSlides: true,
			virtualTranslate: !swiper.params.cssMode
		})
	});
};
//#endregion
export { A11y, Autoplay, Controller, EffectCards, EffectCoverflow, EffectCreative, EffectCube, EffectFade, EffectFlip, FreeMode, Grid, HashNavigation, History, Keyboard, Manipulation, Mousewheel, Navigation, Pagination, Parallax, Scrollbar, Thumb as Thumbs, Virtual, Zoom };
