https://radiobrest.by/local/templates/brestfm/script.js

206    delay = 0;
207  }
208  return setTimeout(callback, delay);
209}
210function now() {
211  return Date.now();
212}
213function getComputedStyle$1(el) {
214  const window2 = getWindow();
215  let style;
216  if (window2.getComputedStyle) {
217    style = window2.getComputedStyle(el, null);
218  }
219  if (!style && el.currentStyle) {
220    style = el.currentStyle;
221  }
222  if (!style) {
223    style = el.style;
224  }
225  return style;
226}
227function getTranslate(el, axis) {
228  if (axis === void 0) {
229    axis = "x";
230  }
231  const window2 = getWindow();
232  let matrix;
233  let curTransform;
234  let transformMatrix;
235  const curStyle = getComputedStyle$1(el);
236  if (window2.WebKitCSSMatrix) {
237    curTransform = curStyle.transform || curStyle.webkitTransform;
238    if (curTransform.split(",").length > 6) {
239      curTransform = curTransform.split(", ").map((a) => a.replace(",", ".")).join(", ");
240    }
241    transformMatrix = new window2.WebKitCSSMatrix(curTransform === "none" ? "" : curTransform);
242  } else {
243    transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue("transform").replace("translate(", "matrix(1, 0, 0, 1,");
244    matrix = transformMatrix.toString().split(",");
245  }
246  if (axis === "x") {
247    if (window2.WebKitCSSMatrix) curTransform = transformMatrix.m41;
248    else if (matrix.length === 16) curTransform = parseFloat(matrix[12]);
249    else curTransform = parseFloat(matrix[4]);
250  }
251  if (axis === "y") {
252    if (window2.WebKitCSSMatrix) curTransform = transformMatrix.m42;
253    else if (matrix.length === 16) curTransform = parseFloat(matrix[13]);
254    else curTransform = parseFloat(matrix[5]);
255  }
256  return curTransform || 0;
257}
258function isObject(o) {
259  return typeof o === "object" && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === "Object";
260}
261function isNode(node) {
262  if (typeof window !== "undefined" && typeof window.HTMLElement !== "undefined") {
263    return node instanceof HTMLElement;
264  }
265  return node && (node.nodeType === 1 || node.nodeType === 11);
266}
267function extend() {
268  const to = Object(arguments.length <= 0 ? void 0 : arguments[0]);
269  const noExtend = ["__proto__", "constructor", "prototype"];
270  for (let i = 1; i < arguments.length; i += 1) {
271    const nextSource = i < 0 || arguments.length <= i ? void 0 : arguments[i];
272    if (nextSource !== void 0 && nextSource !== null && !isNode(nextSource)) {
273      const keysArray = Object.keys(Object(nextSource)).filter((key) => noExtend.indexOf(key) < 0);
274      for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
275        const nextKey = keysArray[nextIndex];
276        const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
277        if (desc !== void 0 && desc.enumerable) {
278          if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
279            if (nextSource[nextKey].__swiper__) {
280              to[nextKey] = nextSource[nextKey];
281            } else {
282              extend(to[nextKey], nextSource[nextKey]);
283            }
284          } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
285            to[nextKey] = {};
286            if (nextSource[nextKey].__swiper__) {
287              to[nextKey] = nextSource[nextKey];
288            } else {
289              extend(to[nextKey], nextSource[nextKey]);
290            }
291          } else {
292            to[nextKey] = nextSource[nextKey];
293          }
294        }
295      }
296    }
297  }
298  return to;
299}
300function setCSSProperty(el, varName, varValue) {
301  el.style.setProperty(varName, varValue);
302}
303function animateCSSModeScroll(_ref) {
304  let {
305    swiper,
306    targetPosition,
307    side
308  } = _ref;
309  const window2 = getWindow();
310  const startPosition = -swiper.translate;
311  let startTime = null;
312  let time;
313  const duration = swiper.params.speed;
314  swiper.wrapperEl.style.scrollSnapType = "none";
315  window2.cancelAnimationFrame(swiper.cssModeFrameID);
316  const dir = targetPosition > startPosition ? "next" : "prev";
317  const isOutOfBound = (current, target) => {
318    return dir === "next" && current >= target || dir === "prev" && current <= target;
319  };
320  const animate = () => {
321    time = (/* @__PURE__ */ new Date()).getTime();
322    if (startTime === null) {
323      startTime = time;
324    }
325    const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
326    const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;

490function getSupport() {
491  if (!support) {
492    support = calcSupport();
493  }
494  return support;
495}
496let deviceCached;
497function calcDevice(_temp) {
498  let {
499    userAgent
500  } = _temp === void 0 ? {} : _temp;
501  const support2 = getSupport();
502  const window2 = getWindow();
503  const platform = window2.navigator.platform;
504  const ua = userAgent || window2.navigator.userAgent;
505  const device = {
506    ios: false,
507    android: false
508  };
509  const screenWidth = window2.screen.width;
510  const screenHeight = window2.screen.height;
511  const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/);
512  let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
513  const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
514  const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
515  const windows = platform === "Win32";
516  let macos = platform === "MacIntel";
517  const iPadScreens = ["1024x1366", "1366x1024", "834x1194", "1194x834", "834x1112", "1112x834", "768x1024", "1024x768", "820x1180", "1180x820", "810x1080", "1080x810"];
518  if (!ipad && macos && support2.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
519    ipad = ua.match(/(Version)\/([\d.]+)/);
520    if (!ipad) ipad = [0, 1, "13_0_0"];
521    macos = false;
522  }
523  if (android && !windows) {
524    device.os = "android";
525    device.android = true;
526  }
527  if (ipad || iphone || ipod) {
528    device.os = "ios";
529    device.ios = true;
530  }
531  return device;
532}
533function getDevice(overrides) {
534  if (overrides === void 0) {
535    overrides = {};
536  }
537  if (!deviceCached) {
538    deviceCached = calcDevice(overrides);
539  }
540  return deviceCached;
541}
542let browser;
543function calcBrowser() {
544  const window2 = getWindow();
545  const device = getDevice();
546  let needPerspectiveFix = false;
547  function isSafari() {
548    const ua = window2.navigator.userAgent.toLowerCase();
549    return ua.indexOf("safari") >= 0 && ua.indexOf("chrome") < 0 && ua.indexOf("android") < 0;
550  }
551  if (isSafari()) {
552    const ua = String(window2.navigator.userAgent);
553    if (ua.includes("Version/")) {
554      const [major, minor] = ua.split("Version/")[1].split(" ")[0].split(".").map((num) => Number(num));
555      needPerspectiveFix = major < 16 || major === 16 && minor < 2;
556    }
557  }
558  const isWebView = /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window2.navigator.userAgent);
559  const isSafariBrowser = isSafari();
560  const need3dFix = isSafariBrowser || isWebView && device.ios;
561  return {
562    isSafari: needPerspectiveFix || isSafariBrowser,
563    needPerspectiveFix,
564    need3dFix,
565    isWebView
566  };
567}
568function getBrowser() {
569  if (!browser) {
570    browser = calcBrowser();
571  }
572  return browser;
573}
574function Resize(_ref) {
575  let {
576    swiper,
577    on,
578    emit
579  } = _ref;
580  const window2 = getWindow();
581  let observer = null;
582  let animationFrame = null;
583  const resizeHandler = () => {
584    if (!swiper || swiper.destroyed || !swiper.initialized) return;
585    emit("beforeResize");
586    emit("resize");
587  };
588  const createObserver = () => {
589    if (!swiper || swiper.destroyed || !swiper.initialized) return;
590    observer = new ResizeObserver((entries) => {
591      animationFrame = window2.requestAnimationFrame(() => {
592        const {
593          width,
594          height
595        } = swiper;
596        let newWidth = width;
597        let newHeight = height;
598        entries.forEach((_ref2) => {
599          let {
600            contentBoxSize,
601            contentRect,
602            target
603          } = _ref2;
604          if (target && target !== swiper.el) return;
605          newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
606          newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
607        });
608        if (newWidth !== width || newHeight !== height) {
609          resizeHandler();
610        }
611      });
612    });
613    observer.observe(swiper.el);
614  };
615  const removeObserver = () => {
616    if (animationFrame) {
617      window2.cancelAnimationFrame(animationFrame);
618    }
619    if (observer && observer.unobserve && swiper.el) {
620      observer.unobserve(swiper.el);
621      observer = null;
622    }
623  };
624  const orientationChangeHandler = () => {
625    if (!swiper || swiper.destroyed || !swiper.initialized) return;
626    emit("orientationchange");
627  };
628  on("init", () => {
629    if (swiper.params.resizeObserver && typeof window2.ResizeObserver !== "undefined") {
630      createObserver();
631      return;
632    }
633    window2.addEventListener("resize", resizeHandler);
634    window2.addEventListener("orientationchange", orientationChangeHandler);
635  });
636  on("destroy", () => {
637    removeObserver();
638    window2.removeEventListener("resize", resizeHandler);
639    window2.removeEventListener("orientationchange", orientationChangeHandler);
640  });
641}
642function Observer(_ref) {
643  let {
644    swiper,
645    extendParams,
646    on,
647    emit
648  } = _ref;
649  const observers = [];
650  const window2 = getWindow();
651  const attach = function(target, options) {
652    if (options === void 0) {
653      options = {};
654    }
655    const ObserverFunc = window2.MutationObserver || window2.WebkitMutationObserver;
656    const observer = new ObserverFunc((mutations) => {
657      if (swiper.__preventObserver__) return;
658      if (mutations.length === 1) {
659        emit("observerUpdate", mutations[0]);
660        return;
661      }
662      const observerUpdate = function observerUpdate2() {
663        emit("observerUpdate", mutations[0]);
664      };
665      if (window2.requestAnimationFrame) {
666        window2.requestAnimationFrame(observerUpdate);
667      } else {
668        window2.setTimeout(observerUpdate, 0);
669      }
670    });
671    observer.observe(target, {
672      attributes: typeof options.attributes === "undefined" ? true : options.attributes,
673      childList: swiper.isElement || (typeof options.childList === "undefined" ? true : options).childList,
674      characterData: typeof options.characterData === "undefined" ? true : options.characterData
675    });
676    observers.push(observer);
677  };
678  const init = () => {
679    if (!swiper.params.observer) return;
680    if (swiper.params.observeParents) {
681      const containerParents = elementParents(swiper.hostEl);
682      for (let i = 0; i < containerParents.length; i += 1) {
683        attach(containerParents[i]);
684      }
685    }
686    attach(swiper.hostEl, {
687      childList: swiper.params.observeSlideChildren
688    });
689    attach(swiper.wrapperEl, {
690      attributes: false
691    });
692  };
693  const destroy = () => {
694    observers.forEach((observer) => {
695      observer.disconnect();
696    });
697    observers.splice(0, observers.length);
698  };
699  extendParams({
700    observer: false,
701    observeParents: false,
702    observeSlideChildren: false
703  });
704  on("init", init);
705  on("destroy", destroy);
706}
707var eventsEmitter = {
708  on(events2, handler, priority) {
709    const self2 = this;
710    if (!self2.eventsListeners || self2.destroyed) return self2;
711    if (typeof handler !== "function") return self2;
712    const method = priority ? "unshift" : "push";
713    events2.split(" ").forEach((event2) => {
714      if (!self2.eventsListeners[event2]) self2.eventsListeners[event2] = [];
715      self2.eventsListeners[event2][method](handler);
716    });
717    return self2;
718  },
719  once(events2, handler, priority) {
720    const self2 = this;
721    if (!self2.eventsListeners || self2.destroyed) return self2;
722    if (typeof handler !== "function") return self2;
723    function onceHandler() {
724      self2.off(events2, onceHandler);
725      if (onceHandler.__emitterProxy) {
726        delete onceHandler.__emitterProxy;
727      }
728      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
729        args[_key] = arguments[_key];
730      }
731      handler.apply(self2, args);
732    }
733    onceHandler.__emitterProxy = handler;
734    return self2.on(events2, onceHandler, priority);
735  },
736  onAny(handler, priority) {
737    const self2 = this;
738    if (!self2.eventsListeners || self2.destroyed) return self2;
739    if (typeof handler !== "function") return self2;
740    const method = priority ? "unshift" : "push";
741    if (self2.eventsAnyListeners.indexOf(handler) < 0) {
742      self2.eventsAnyListeners[method](handler);
743    }
744    return self2;
745  },
746  offAny(handler) {
747    const self2 = this;
748    if (!self2.eventsListeners || self2.destroyed) return self2;
749    if (!self2.eventsAnyListeners) return self2;
750    const index = self2.eventsAnyListeners.indexOf(handler);
751    if (index >= 0) {
752      self2.eventsAnyListeners.splice(index, 1);
753    }
754    return self2;
755  },
756  off(events2, handler) {
757    const self2 = this;
758    if (!self2.eventsListeners || self2.destroyed) return self2;
759    if (!self2.eventsListeners) return self2;
760    events2.split(" ").forEach((event2) => {
761      if (typeof handler === "undefined") {
762        self2.eventsListeners[event2] = [];
763      } else if (self2.eventsListeners[event2]) {
764        self2.eventsListeners[event2].forEach((eventHandler, index) => {
765          if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
766            self2.eventsListeners[event2].splice(index, 1);
767          }
768        });
769      }
770    });
771    return self2;
772  },
773  emit() {
774    const self2 = this;
775    if (!self2.eventsListeners || self2.destroyed) return self2;
776    if (!self2.eventsListeners) return self2;
777    let events2;
778    let data;
779    let context;
780    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
781      args[_key2] = arguments[_key2];
782    }
783    if (typeof args[0] === "string" || Array.isArray(args[0])) {
784      events2 = args[0];
785      data = args.slice(1, args.length);
786      context = self2;
787    } else {
788      events2 = args[0].events;
789      data = args[0].data;
790      context = args[0].context || self2;
791    }
792    data.unshift(context);
793    const eventsArray = Array.isArray(events2) ? events2 : events2.split(" ");
794    eventsArray.forEach((event2) => {
795      if (self2.eventsAnyListeners && self2.eventsAnyListeners.length) {
796        self2.eventsAnyListeners.forEach((eventHandler) => {
797          eventHandler.apply(context, [event2, ...data]);
798        });
799      }
800      if (self2.eventsListeners && self2.eventsListeners[event2]) {
801        self2.eventsListeners[event2].forEach((eventHandler) => {
802          eventHandler.apply(context, data);
803        });
804      }
805    });
806    return self2;
807  }
808};
809function updateSize() {
810  const swiper = this;
811  let width;
812  let height;
813  const el = swiper.el;
814  if (typeof swiper.params.width !== "undefined" && swiper.params.width !== null) {
815    width = swiper.params.width;
816  } else {
817    width = el.clientWidth;
818  }
819  if (typeof swiper.params.height !== "undefined" && swiper.params.height !== null) {
820    height = swiper.params.height;
821  } else {
822    height = el.clientHeight;
823  }
824  if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
825    return;
826  }
827  width = width - parseInt(elementStyle(el, "padding-left") || 0, 10) - parseInt(elementStyle(el, "padding-right") || 0, 10);
828  height = height - parseInt(elementStyle(el, "padding-top") || 0, 10) - parseInt(elementStyle(el, "padding-bottom") || 0, 10);
829  if (Number.isNaN(width)) width = 0;
830  if (Number.isNaN(height)) height = 0;
831  Object.assign(swiper, {
832    width,
833    height,
834    size: swiper.isHorizontal() ? width : height
835  });
836}
837function updateSlides() {
838  const swiper = this;
839  function getDirectionPropertyValue(node, label) {
840    return parseFloat(node.getPropertyValue(swiper.getDirectionLabel(label)) || 0);
841  }
842  const params = swiper.params;
843  const {
844    wrapperEl,
845    slidesEl,
846    size: swiperSize,
847    rtlTranslate: rtl,
848    wrongRTL
849  } = swiper;
850  const isVirtual = swiper.virtual && params.virtual.enabled;
851  const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
852  const slides = elementChildren(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);
853  const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
854  let snapGrid = [];
855  const slidesGrid = [];
856  const slidesSizesGrid = [];
857  let offsetBefore = params.slidesOffsetBefore;
858  if (typeof offsetBefore === "function") {
859    offsetBefore = params.slidesOffsetBefore.call(swiper);
860  }
861  let offsetAfter = params.slidesOffsetAfter;
862  if (typeof offsetAfter === "function") {
863    offsetAfter = params.slidesOffsetAfter.call(swiper);
864  }
865  const previousSnapGridLength = swiper.snapGrid.length;
866  const previousSlidesGridLength = swiper.slidesGrid.length;
867  let spaceBetween = params.spaceBetween;
868  let slidePosition = -offsetBefore;
869  let prevSlideSize = 0;
870  let index = 0;
871  if (typeof swiperSize === "undefined") {
872    return;
873  }
874  if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) {
875    spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiperSize;
876  } else if (typeof spaceBetween === "string") {
877    spaceBetween = parseFloat(spaceBetween);
878  }
879  swiper.virtualSize = -spaceBetween;
880  slides.forEach((slideEl) => {
881    if (rtl) {
882      slideEl.style.marginLeft = "";
883    } else {
884      slideEl.style.marginRight = "";
885    }
886    slideEl.style.marginBottom = "";
887    slideEl.style.marginTop = "";
888  });
889  if (params.centeredSlides && params.cssMode) {
890    setCSSProperty(wrapperEl, "--swiper-centered-offset-before", "");
891    setCSSProperty(wrapperEl, "--swiper-centered-offset-after", "");
892  }
893  const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
894  if (gridEnabled) {
895    swiper.grid.initSlides(slides);
896  } else if (swiper.grid) {
897    swiper.grid.unsetSlides();
898  }
899  let slideSize;
900  const shouldResetSlideSize = params.slidesPerView === "auto" && params.breakpoints && Object.keys(params.breakpoints).filter((key) => {
901    return typeof params.breakpoints[key].slidesPerView !== "undefined";
902  }).length > 0;
903  for (let i = 0; i < slidesLength; i += 1) {
904    slideSize = 0;
905    let slide2;
906    if (slides[i]) slide2 = slides[i];
907    if (gridEnabled) {
908      swiper.grid.updateSlide(i, slide2, slides);
909    }
910    if (slides[i] && elementStyle(slide2, "display") === "none") continue;
911    if (params.slidesPerView === "auto") {
912      if (shouldResetSlideSize) {
913        slides[i].style[swiper.getDirectionLabel("width")] = ``;
914      }
915      const slideStyles = getComputedStyle(slide2);
916      const currentTransform = slide2.style.transform;
917      const currentWebKitTransform = slide2.style.webkitTransform;
918      if (currentTransform) {
919        slide2.style.transform = "none";
920      }
921      if (currentWebKitTransform) {
922        slide2.style.webkitTransform = "none";
923      }
924      if (params.roundLengths) {
925        slideSize = swiper.isHorizontal() ? elementOuterSize(slide2, "width") : elementOuterSize(slide2, "height");
926      } else {
927        const width = getDirectionPropertyValue(slideStyles, "width");
928        const paddingLeft = getDirectionPropertyValue(slideStyles, "padding-left");
929        const paddingRight = getDirectionPropertyValue(slideStyles, "padding-right");
930        const marginLeft = getDirectionPropertyValue(slideStyles, "margin-left");
931        const marginRight = getDirectionPropertyValue(slideStyles, "margin-right");
932        const boxSizing = slideStyles.getPropertyValue("box-sizing");
933        if (boxSizing && boxSizing === "border-box") {
934          slideSize = width + marginLeft + marginRight;
935        } else {
936          const {
937            clientWidth,
938            offsetWidth
939          } = slide2;
940          slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
941        }
942      }
943      if (currentTransform) {
944        slide2.style.transform = currentTransform;
945      }
946      if (currentWebKitTransform) {
947        slide2.style.webkitTransform = currentWebKitTransform;
948      }
949      if (params.roundLengths) slideSize = Math.floor(slideSize);
950    } else {
951      slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
952      if (params.roundLengths) slideSize = Math.floor(slideSize);
953      if (slides[i]) {
954        slides[i].style[swiper.getDirectionLabel("width")] = `${slideSize}px`;
955      }
956    }
957    if (slides[i]) {
958      slides[i].swiperSlideSize = slideSize;
959    }
960    slidesSizesGrid.push(slideSize);
961    if (params.centeredSlides) {
962      slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
963      if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
964      if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
965      if (Math.abs(slidePosition) < 1 / 1e3) slidePosition = 0;
966      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
967      if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
968      slidesGrid.push(slidePosition);
969    } else {
970      if (params.roundLengths) slidePosition = Math.floor(slidePosition);
971      if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
972      slidesGrid.push(slidePosition);
973      slidePosition = slidePosition + slideSize + spaceBetween;
974    }
975    swiper.virtualSize += slideSize + spaceBetween;
976    prevSlideSize = slideSize;
977    index += 1;
978  }
979  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
980  if (rtl && wrongRTL && (params.effect === "slide" || params.effect === "coverflow")) {
981    wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;
982  }
983  if (params.setWrapperSize) {
984    wrapperEl.style[swiper.getDirectionLabel("width")] = `${swiper.virtualSize + spaceBetween}px`;
985  }
986  if (gridEnabled) {
987    swiper.grid.updateWrapperSize(slideSize, snapGrid);
988  }
989  if (!params.centeredSlides) {
990    const newSlidesGrid = [];
991    for (let i = 0; i < snapGrid.length; i += 1) {
992      let slidesGridItem = snapGrid[i];
993      if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
994      if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
995        newSlidesGrid.push(slidesGridItem);
996      }
997    }
998    snapGrid = newSlidesGrid;
999    if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
1000      snapGrid.push(swiper.virtualSize - swiperSize);
1001    }
1002  }
1003  if (isVirtual && params.loop) {
1004    const size = slidesSizesGrid[0] + spaceBetween;
1005    if (params.slidesPerGroup > 1) {
1006      const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
1007      const groupSize = size * params.slidesPerGroup;
1008      for (let i = 0; i < groups; i += 1) {
1009        snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
1010      }
1011    }
1012    for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
1013      if (params.slidesPerGroup === 1) {
1014        snapGrid.push(snapGrid[snapGrid.length - 1] + size);
1015      }
1016      slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
1017      swiper.virtualSize += size;
1018    }
1019  }
1020  if (snapGrid.length === 0) snapGrid = [0];
1021  if (spaceBetween !== 0) {
1022    const key = swiper.isHorizontal() && rtl ? "marginLeft" : swiper.getDirectionLabel("marginRight");
1023    slides.filter((_, slideIndex) => {
1024      if (!params.cssMode || params.loop) return true;
1025      if (slideIndex === slides.length - 1) {
1026        return false;
1027      }
1028      return true;
1029    }).forEach((slideEl) => {
1030      slideEl.style[key] = `${spaceBetween}px`;
1031    });
1032  }
1033  if (params.centeredSlides && params.centeredSlidesBounds) {
1034    let allSlidesSize = 0;
1035    slidesSizesGrid.forEach((slideSizeValue) => {
1036      allSlidesSize += slideSizeValue + (spaceBetween || 0);
1037    });
1038    allSlidesSize -= spaceBetween;
1039    const maxSnap = allSlidesSize > swiperSize ? allSlidesSize - swiperSize : 0;
1040    snapGrid = snapGrid.map((snap) => {
1041      if (snap <= 0) return -offsetBefore;
1042      if (snap > maxSnap) return maxSnap + offsetAfter;
1043      return snap;
1044    });
1045  }
1046  if (params.centerInsufficientSlides) {
1047    let allSlidesSize = 0;
1048    slidesSizesGrid.forEach((slideSizeValue) => {
1049      allSlidesSize += slideSizeValue + (spaceBetween || 0);
1050    });
1051    allSlidesSize -= spaceBetween;
1052    const offsetSize = (params.slidesOffsetBefore || 0) + (params.slidesOffsetAfter || 0);
1053    if (allSlidesSize + offsetSize < swiperSize) {
1054      const allSlidesOffset = (swiperSize - allSlidesSize - offsetSize) / 2;
1055      snapGrid.forEach((snap, snapIndex) => {
1056        snapGrid[snapIndex] = snap - allSlidesOffset;
1057      });
1058      slidesGrid.forEach((snap, snapIndex) => {
1059        slidesGrid[snapIndex] = snap + allSlidesOffset;
1060      });
1061    }
1062  }
1063  Object.assign(swiper, {
1064    slides,
1065    snapGrid,
1066    slidesGrid,
1067    slidesSizesGrid
1068  });
1069  if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1070    setCSSProperty(wrapperEl, "--swiper-centered-offset-before", `${-snapGrid[0]}px`);
1071    setCSSProperty(wrapperEl, "--swiper-centered-offset-after", `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1072    const addToSnapGrid = -swiper.snapGrid[0];
1073    const addToSlidesGrid = -swiper.slidesGrid[0];
1074    swiper.snapGrid = swiper.snapGrid.map((v) => v + addToSnapGrid);
1075    swiper.slidesGrid = swiper.slidesGrid.map((v) => v + addToSlidesGrid);
1076  }
1077  if (slidesLength !== previousSlidesLength) {
1078    swiper.emit("slidesLengthChange");
1079  }
1080  if (snapGrid.length !== previousSnapGridLength) {
1081    if (swiper.params.watchOverflow) swiper.checkOverflow();
1082    swiper.emit("snapGridLengthChange");
1083  }
1084  if (slidesGrid.length !== previousSlidesGridLength) {
1085    swiper.emit("slidesGridLengthChange");
1086  }
1087  if (params.watchSlidesProgress) {
1088    swiper.updateSlidesOffset();
1089  }
1090  swiper.emit("slidesUpdated");
1091  if (!isVirtual && !params.cssMode && (params.effect === "slide" || params.effect === "fade")) {
1092    const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1093    const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1094    if (slidesLength <= params.maxBackfaceHiddenSlides) {
1095      if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1096    } else if (hasClassBackfaceClassAdded) {
1097      swiper.el.classList.remove(backFaceHiddenClass);
1098    }
1099  }
1100}
1101function updateAutoHeight(speed) {
1102  const swiper = this;
1103  const activeSlides = [];
1104  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1105  let newHeight = 0;
1106  let i;
1107  if (typeof speed === "number") {
1108    swiper.setTransition(speed);
1109  } else if (speed === true) {
1110    swiper.setTransition(swiper.params.speed);
1111  }
1112  const getSlideByIndex = (index) => {
1113    if (isVirtual) {
1114      return swiper.slides[swiper.getSlideIndexByData(index)];
1115    }
1116    return swiper.slides[index];
1117  };
1118  if (swiper.params.slidesPerView !== "auto" && swiper.params.slidesPerView > 1) {
1119    if (swiper.params.centeredSlides) {
1120      (swiper.visibleSlides || []).forEach((slide2) => {
1121        activeSlides.push(slide2);
1122      });
1123    } else {
1124      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1125        const index = swiper.activeIndex + i;
1126        if (index > swiper.slides.length && !isVirtual) break;
1127        activeSlides.push(getSlideByIndex(index));
1128      }
1129    }
1130  } else {
1131    activeSlides.push(getSlideByIndex(swiper.activeIndex));
1132  }
1133  for (i = 0; i < activeSlides.length; i += 1) {
1134    if (typeof activeSlides[i] !== "undefined") {
1135      const height = activeSlides[i].offsetHeight;
1136      newHeight = height > newHeight ? height : newHeight;
1137    }
1138  }
1139  if (newHeight || newHeight === 0) swiper.wrapperEl.style.height = `${newHeight}px`;
1140}
1141function updateSlidesOffset() {
1142  const swiper = this;
1143  const slides = swiper.slides;
1144  const minusOffset = swiper.isElement ? swiper.isHorizontal() ? swiper.wrapperEl.offsetLeft : swiper.wrapperEl.offsetTop : 0;
1145  for (let i = 0; i < slides.length; i += 1) {
1146    slides[i].swiperSlideOffset = (swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop) - minu

1146sOffset - swiper.cssOverflowAdjustment();
1147  }
1148}
1149const toggleSlideClasses$1 = (slideEl, condition, className) => {
1150  if (condition && !slideEl.classList.contains(className)) {
1151    slideEl.classList.add(className);
1152  } else if (!condition && slideEl.classList.contains(className)) {
1153    slideEl.classList.remove(className);
1154  }
1155};
1156function updateSlidesProgress(translate2) {
1157  if (translate2 === void 0) {
1158    translate2 = this && this.translate || 0;
1159  }
1160  const swiper = this;
1161  const params = swiper.params;
1162  const {
1163    slides,
1164    rtlTranslate: rtl,
1165    snapGrid
1166  } = swiper;
1167  if (slides.length === 0) return;
1168  if (typeof slides[0].swiperSlideOffset === "undefined") swiper.updateSlidesOffset();
1169  let offsetCenter = -translate2;
1170  if (rtl) offsetCenter = translate2;
1171  swiper.visibleSlidesIndexes = [];
1172  swiper.visibleSlides = [];
1173  let spaceBetween = params.spaceBetween;
1174  if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) {
1175    spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiper.size;
1176  } else if (typeof spaceBetween === "string") {
1177    spaceBetween = parseFloat(spaceBetween);
1178  }
1179  for (let i = 0; i < slides.length; i += 1) {
1180    const slide2 = slides[i];
1181    let slideOffset = slide2.swiperSlideOffset;
1182    if (params.cssMode && params.centeredSlides) {
1183      slideOffset -= slides[0].swiperSlideOffset;
1184    }
1185    const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide2.swiperSlideSize + spaceBetween);
1186    const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide2.swiperSlideSize + spaceBetween);
1187    const slideBefore = -(offsetCenter - slideOffset);
1188    const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1189    const isFullyVisible = slideBefore >= 0 && slideBefore <= swiper.size - swiper.slidesSizesGrid[i];
1190    const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
1191    if (isVisible) {
1192      swiper.visibleSlides.push(slide2);
1193      swiper.visibleSlidesIndexes.push(i);
1194    }

1195    toggleSlideClasses$1(slide2, isVisible, params.slideVisibleClass);
1196    toggleSlideClasses$1(slide2, isFullyVisible, params.slideFullyVisibleClass);
1197    slide2.progress = rtl ? -slideProgress : slideProgress;
1198    slide2.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1199  }
1200}
1201function updateProgress(translate2) {
1202  const swiper = this;
1203  if (typeof translate2 === "undefined") {
1204    const multiplier = swiper.rtlTranslate ? -1 : 1;
1205    translate2 = swiper && swiper.translate && swiper.translate * multiplier || 0;
1206  }
1207  const params = swiper.params;
1208  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1209  let {
1210    progress,
1211    isBeginning,
1212    isEnd,
1213    progressLoop
1214  } = swiper;
1215  const wasBeginning = isBeginning;
1216  const wasEnd = isEnd;
1217  if (translatesDiff === 0) {
1218    progress = 0;
1219    isBeginning = true;
1220    isEnd = true;
1221  } else {
1222    progress = (translate2 - swiper.minTranslate()) / translatesDiff;
1223    const isBeginningRounded = Math.abs(translate2 - swiper.minTranslate()) < 1;
1224    const isEndRounded = Math.abs(translate2 - swiper.maxTranslate()) < 1;
1225    isBeginning = isBeginningRounded || progress <= 0;
1226    isEnd = isEndRounded || progress >= 1;
1227    if (isBeginningRounded) progress = 0;
1228    if (isEndRounded) progress = 1;
1229  }
1230  if (params.loop) {
1231    const firstSlideIndex = swiper.getSlideIndexByData(0);
1232    const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
1233    const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
1234    const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
1235    const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
1236    const translateAbs = Math.abs(translate2);
1237    if (translateAbs >= firstSlideTranslate) {
1238      progressLoop = (translateAbs - firstSlideTranslate) / translateMax;
1239    } else {
1240      progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
1241    }
1242    if (progressLoop > 1) progressLoop -= 1;
1243  }
1244  Object.assign(swiper, {
1245    progress,
1246    progressLoop,
1247    isBeginning,
1248    isEnd
1249  });
1250  if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate2);
1251  if (isBeginning && !wasBeginning) {
1252    swiper.emit("reachBeginning toEdge");
1253  }
1254  if (isEnd && !wasEnd) {
1255    swiper.emit("reachEnd toEdge");
1256  }
1257  if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
1258    swiper.emit("fromEdge");
1259  }
1260  swiper.emit("progress", progress);
1261}
1262const toggleSlideClasses = (slideEl, condition, className) => {
1263  if (condition && !slideEl.classList.contains(className)) {
1264    slideEl.classList.add(className);
1265  } else if (!condition && slideEl.classList.contains(className)) {
1266    slideEl.classList.remove(className);
1267  }
1268};
1269function updateSlidesClasses() {
1270  const swiper = this;
1271  const {
1272    slides,
1273    params,
1274    slidesEl,
1275    activeIndex
1276  } = swiper;
1277  const isVirtual = swiper.virtual && params.virtual.enabled;
1278  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1279  const getFilteredSlide = (selector) => {
1280    return elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
1281  };
1282  let activeSlide;
1283  let prevSlide;
1284  let nextSlide;
1285  if (isVirtual) {
1286    if (params.loop) {
1287      let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1288      if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1289      if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1290      activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1291    } else {
1292      activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
1293    }
1294  } else {
1295    if (gridEnabled) {
1296      activeSlide = slides.filter((slideEl) => slideEl.column === activeIndex)[0];
1297      nextSlide = slides.filter((slideEl) => slideEl.column === activeIndex + 1)[0];
1298      prevSlide = slides.filter((slideEl) => slideEl.column === activeIndex - 1)[0];
1299    } else {
1300      activeSlide = slides[activeIndex];
1301    }
1302  }
1303  if (activeSlide) {
1304    if (!gridEnabled) {
1305      nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1306      if (params.loop && !nextSlide) {
1307        nextSlide = slides[0];
1308      }
1309      prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1310      if (params.loop && !prevSlide === 0) {
1311        prevSlide = slides[slides.length - 1];
1312      }
1313    }
1314  }

1315  slides.forEach((slideEl) => {
1316    toggleSlideClasses(slideEl, slideEl === activeSlide, params.slideActiveClass);
1317    toggleSlideClasses(slideEl, slideEl === nextSlide, params.slideNextClass);
1318    toggleSlideClasses(slideEl, slideEl === prevSlide, params.slidePrevClass);
1319  });
1320  swiper.emitSlidesClasses();
1321}
1322const processLazyPreloader = (swiper, imageEl) => {
1323  if (!swiper || swiper.destroyed || !swiper.params) return;
1324  const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
1325  const slideEl = imageEl.closest(slideSelector());
1326  if (slideEl) {
1327    let lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1328    if (!lazyEl && swiper.isElement) {
1329      if (slideEl.shadowRoot) {
1330        lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1331      } else {
1332        requestAnimationFrame(() => {
1333          if (slideEl.shadowRoot) {
1334            lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1335            if (lazyEl) lazyEl.remove();
1336          }
1337        });
1338      }
1339    }
1340    if (lazyEl) lazyEl.remove();
1341  }
1342};
1343const unlazy = (swiper, index) => {
1344  if (!swiper.slides[index]) return;
1345  const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1346  if (imageEl) imageEl.removeAttribute("loading");
1347};
1348const preload = (swiper) => {
1349  if (!swiper || swiper.destroyed || !swiper.params) return;
1350  let amount = swiper.params.lazyPreloadPrevNext;
1351  const len = swiper.slides.length;
1352  if (!len || !amount || amount < 0) return;
1353  amount = Math.min(amount, len);
1354  const slidesPerView = swiper.params.slidesPerView === "auto" ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1355  const activeIndex = swiper.activeIndex;
1356  if (swiper.params.grid && swiper.params.grid.rows > 1) {
1357    const activeColumn = activeIndex;
1358    const preloadColumns = [activeColumn - amount];
1359    preloadColumns.push(...Array.from({
1360      length: amount
1361    }).map((_, i) => {
1362      return activeColumn + slidesPerView + i;
1363    }));
1364    swiper.slides.forEach((slideEl, i) => {
1365      if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1366    });
1367    return;
1368  }
1369  const slideIndexLastInView = activeIndex + slidesPerView - 1;
1370  if (swiper.params.rewind || swiper.params.loop) {
1371    for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1372      const realIndex = (i % len + len) % len;
1373      if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1374    }
1375  } else {
1376    for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {
1377      if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {
1378        unlazy(swiper, i);
1379      }
1380    }
1381  }
1382};
1383function getActiveIndexByTranslate(swiper) {
1384  const {
1385    slidesGrid,
1386    params
1387  } = swiper;
1388  const translate2 = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1389  let activeIndex;
1390  for (let i = 0; i < slidesGrid.length; i += 1) {
1391    if (typeof slidesGrid[i + 1] !== "undefined") {
1392      if (translate2 >= slidesGrid[i] && translate2 < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1393        activeIndex = i;
1394      } else if (translate2 >= slidesGrid[i] && translate2 < slidesGrid[i + 1]) {
1395        activeIndex = i + 1;
1396      }
1397    } else if (translate2 >= slidesGrid[i]) {
1398      activeIndex = i;
1399    }
1400  }
1401  if (params.normalizeSlideIndex) {
1402    if (activeIndex < 0 || typeof activeIndex === "undefined") activeIndex = 0;
1403  }
1404  return activeIndex;
1405}
1406function updateActiveIndex(newActiveIndex) {
1407  const swiper = this;
1408  const translate2 = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1409  const {
1410    snapGrid,
1411    params,
1412    activeIndex: previousIndex,
1413    realIndex: previousRealIndex,
1414    snapIndex: previousSnapIndex
1415  } = swiper;
1416  let activeIndex = newActiveIndex;
1417  let snapIndex;
1418  const getVirtualRealIndex = (aIndex) => {
1419    let realIndex2 = aIndex - swiper.virtual.slidesBefore;
1420    if (realIndex2 < 0) {
1421      realIndex2 = swiper.virtual.slides.length + realIndex2;
1422    }
1423    if (realIndex2 >= swiper.virtual.slides.length) {
1424      realIndex2 -= swiper.virtual.slides.length;
1425    }
1426    return realIndex2;
1427  };
1428  if (typeof activeIndex === "undefined") {
1429    activeIndex = getActiveIndexByTranslate(swiper);
1430  }

1431  if (snapGrid.indexOf(translate2) >= 0) {
1432    snapIndex = snapGrid.indexOf(translate2);
1433  } else {
1434    const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1435    snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1436  }
1437  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1438  if (activeIndex === previousIndex && !swiper.params.loop) {
1439    if (snapIndex !== previousSnapIndex) {
1440      swiper.snapIndex = snapIndex;
1441      swiper.emit("snapIndexChange");
1442    }
1443    return;
1444  }
1445  if (activeIndex === previousIndex && swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1446    swiper.realIndex = getVirtualRealIndex(activeIndex);
1447    return;
1448  }
1449  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1450  let realIndex;
1451  if (swiper.virtual && params.virtual.enabled && params.loop) {
1452    realIndex = getVirtualRealIndex(activeIndex);
1453  } else if (gridEnabled) {
1454    const firstSlideInColumn = swiper.slides.filter((slideEl) => slideEl.column === activeIndex)[0];
1455    let activeSlideIndex = parseInt(firstSlideInColumn.getAttribute("data-swiper-slide-index"), 10);
1456    if (Number.isNaN(activeSlideIndex)) {
1457      activeSlideIndex = Math.max(swiper.slides.indexOf(firstSlideInColumn), 0);
1458    }
1459    realIndex = Math.floor(activeSlideIndex / params.grid.rows);
1460  } else if (swiper.slides[activeIndex]) {
1461    const slideIndex = swiper.slides[activeIndex].getAttribute("data-swiper-slide-index");
1462    if (slideIndex) {
1463      realIndex = parseInt(slideIndex, 10);
1464    } else {
1465      realIndex = activeIndex;
1466    }
1467  } else {
1468    realIndex = activeIndex;
1469  }
1470  Object.assign(swiper, {
1471    previousSnapIndex,
1472    snapIndex,
1473    previousRealIndex,
1474    realIndex,
1475    previousIndex,
1476    activeIndex
1477  });
1478  if (swiper.initialized) {
1479    preload(swiper);
1480  }
1481  swiper.emit("activeIndexChange");
1482  swiper.emit("snapIndexChange");
1483  if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1484    if (previousRealIndex !== realIndex) {
1485      swiper.emit("realIndexChange");
1486    }
1487    swiper.emit("slideChange");
1488  }
1489}
1490function updateClickedSlide(el, path) {
1491  const swiper = this;
1492  const params = swiper.params;
1493  let slide2 = el.closest(`.${params.slideClass}, swiper-slide`);
1494  if (!slide2 && swiper.isElement && path && path.length > 1 && path.includes(el)) {
1495    [...path.slice(path.indexOf(el) + 1, path.length)].forEach((pathEl) => {
1496      if (!slide2 && pathEl.matches && pathEl.matches(`.${params.slideClass}, swiper-slide`)) {
1497        slide2 = pathEl;
1498      }
1499    });
1500  }
1501  let slideFound = false;
1502  let slideIndex;
1503  if (slide2) {
1504    for (let i = 0; i < swiper.slides.length; i += 1) {
1505      if (swiper.slides[i] === slide2) {
1506        slideFound = true;
1507        slideIndex = i;
1508        break;
1509      }
1510    }
1511  }
1512  if (slide2 && slideFound) {
1513    swiper.clickedSlide = slide2;
1514    if (swiper.virtual && swiper.params.virtual.enabled) {
1515      swiper.clickedIndex = parseInt(slide2.getAttribute("data-swiper-slide-index"), 10);
1516    } else {
1517      swiper.clickedIndex = slideIndex;
1518    }
1519  } else {
1520    swiper.clickedSlide = void 0;
1521    swiper.clickedIndex = void 0;
1522    return;
1523  }
1524  if (params.slideToClickedSlide && swiper.clickedIndex !== void 0 && swiper.clickedIndex !== swiper.activeIndex) {
1525    swiper.slideToClickedSlide();
1526  }
1527}
1528var update = {
1529  updateSize,
1530  updateSlides,
1531  updateAutoHeight,
1532  updateSlidesOffset,
1533  updateSlidesProgress,
1534  updateProgress,
1535  updateSlidesClasses,
1536  updateActiveIndex,
1537  updateClickedSlide
1538};
1539function getSwiperTranslate(axis) {
1540  if (axis === void 0) {
1541    axis = this.isHorizontal() ? "x" : "y";
1542  }
1543  const swiper = this;
1544  const {
1545    params,
1546    rtlTranslate: rtl,
1547    translate: translate2,
1548    wrapperEl
1549  } = swiper;
1550  if (params.virtualTranslate) {
1551    return rtl ? -translate2 : translate2;
1552  }
1553  if (params.cssMode) {
1554    return translate2;
1555  }
1556  let currentTranslate = getTranslate(wrapperEl, axis);
1557  currentTranslate += swiper.cssOverflowAdjustment();
1558  if (rtl) currentTranslate = -currentTranslate;
1559  return currentTranslate || 0;
1560}
1561function setTranslate(translate2, byController) {
1562  const swiper = this;
1563  const {
1564    rtlTranslate: rtl,
1565    params,
1566    wrapperEl,
1567    progress
1568  } = swiper;
1569  let x = 0;
1570  let y = 0;
1571  const z = 0;
1572  if (swiper.isHorizontal()) {
1573    x = rtl ? -translate2 : translate2;
1574  } else {
1575    y = translate2;
1576  }
1577  if (params.roundLengths) {
1578    x = Math.floor(x);
1579    y = Math.floor(y);
1580  }
1581  swiper.previousTranslate = swiper.translate;
1582  swiper.translate = swiper.isHorizontal() ? x : y;
1583  if (params.cssMode) {
1584    wrapperEl[swiper.isHorizontal() ? "scrollLeft" : "scrollTop"] = swiper.isHorizontal() ? -x : -y;
1585  } else if (!params.virtualTranslate) {
1586    if (swiper.isHorizontal()) {
1587      x -= swiper.cssOverflowAdjustment();
1588    } else {
1589      y -= swiper.cssOverflowAdjustment();
1590    }
1591    wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;
1592  }
1593  let newProgress;
1594  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1595  if (translatesDiff === 0) {
1596    newProgress = 0;
1597  } else {
1598    newProgress = (translate2 - swiper.minTranslate()) / translatesDiff;
1599  }
1600  if (newProgress !== progress) {
1601    swiper.updateProgress(translate2);
1602  }
1603  swiper.emit("setTranslate", swiper.translate, byController);
1604}
1605function minTranslate() {
1606  return -this.snapGrid[0];
1607}
1608function maxTranslate() {
1609  return -this.snapGrid[this.snapGrid.length - 1];
1610}
1611function translateTo(translate2, speed, runCallbacks, translateBounds, internal) {
1612  if (translate2 === void 0) {
1613    translate2 = 0;
1614  }
1615  if (speed === void 0) {
1616    speed = this.params.speed;
1617  }
1618  if (runCallbacks === void 0) {
1619    runCallbacks = true;
1620  }
1621  if (translateBounds === void 0) {
1622    translateBounds = true;
1623  }
1624  const swiper = this;
1625  const {
1626    params,
1627    wrapperEl
1628  } = swiper;
1629  if (swiper.animating && params.preventInteractionOnTransition) {
1630    return false;
1631  }
1632  const minTranslate2 = swiper.minTranslate();
1633  const maxTranslate2 = swiper.maxTranslate();
1634  let newTranslate;
1635  if (translateBounds && translate2 > minTranslate2) newTranslate = minTranslate2;
1636  else if (translateBounds && translate2 < maxTranslate2) newTranslate = maxTranslate2;
1637  else newTranslate = translate2;
1638  swiper.updateProgress(newTranslate);
1639  if (params.cssMode) {
1640    const isH = swiper.isHorizontal();
1641    if (speed === 0) {
1642      wrapperEl[isH ? "scrollLeft" : "scrollTop"] = -newTranslate;
1643    } else {
1644      if (!swiper.support.smoothScroll) {
1645        animateCSSModeScroll({
1646          swiper,
1647          targetPosition: -newTranslate,
1648          side: isH ? "left" : "top"
1649        });
1650        return true;
1651      }
1652      wrapperEl.scrollTo({
1653        [isH ? "left" : "top"]: -newTranslate,
1654        behavior: "smooth"
1655      });
1656    }
1657    return true;
1658  }
1659  if (speed === 0) {
1660    swiper.setTransition(0);
1661    swiper.setTranslate(newTranslate);
1662    if (runCallbacks) {
1663      swiper.emit("beforeTransitionStart", speed, internal);
1664      swiper.emit("transitionEnd");
1665    }
1666  } else {
1667    swiper.setTransition(speed);
1668    swiper.setTranslate(newTranslate);
1669    if (runCallbacks) {
1670      swiper.emit("beforeTransitionStart", speed, internal);
1671      swiper.emit("transitionStart");
1672    }
1673    if (!swiper.animating) {
1674      swiper.animating = true;
1675      if (!swiper.onTranslateToWrapperTransitionEnd) {
1676        swiper.onTranslateToWrapperTransitionEnd = function transitionEnd2(e) {
1677          if (!swiper || swiper.destroyed) return;
1678          if (e.target !== this) return;
1679          swiper.wrapperEl.removeEventListener("transitionend", swiper.onTranslateToWrapperTransitionEnd);
1680          swiper.onTranslateToWrapperTransitionEnd = null;
1681          delete swiper.onTranslateToWrapperTransitionEnd;
1682          swiper.animating = false;
1683          if (runCallbacks) {
1684            swiper.emit("transitionEnd");
1685          }
1686        };
1687      }
1688      swiper.wrapperEl.addEventListener("transitionend", swiper.onTranslateToWrapperTransitionEnd);
1689    }
1690  }
1691  return true;
1692}
1693var translate = {
1694  getTranslate: getSwiperTranslate,
1695  setTranslate,
1696  minTranslate,
1697  maxTranslate,
1698  translateTo
1699};
1700function setTransition(duration, byController) {
1701  const swiper = this;
1702  if (!swiper.params.cssMode) {
1703    swiper.wrapperEl.style.transitionDuration = `${duration}ms`;
1704    swiper.wrapperEl.style.transitionDelay = duration === 0 ? `0ms` : "";
1705  }
1706  swiper.emit("setTransition", duration, byController);
1707}
1708function transitionEmit(_ref) {
1709  let {
1710    swiper,
1711    runCallbacks,
1712    direction,
1713    step
1714  } = _ref;
1715  const {
1716    activeIndex,
1717    previousIndex
1718  } = swiper;
1719  let dir = direction;
1720  if (!dir) {
1721    if (activeIndex > previousIndex) dir = "next";
1722    else if (activeIndex < previousIndex) dir = "prev";
1723    else dir = "reset";
1724  }
1725  swiper.emit(`transition${step}`);
1726  if (runCallbacks && activeIndex !== previousIndex) {
1727    if (dir === "reset") {
1728      swiper.emit(`slideResetTransition${step}`);
1729      return;
1730    }
1731    swiper.emit(`slideChangeTransition${step}`);
1732    if (dir === "next") {
1733      swiper.emit(`slideNextTransition${step}`);
1734    } else {
1735      swiper.emit(`slidePrevTransition${step}`);
1736    }
1737  }
1738}
1739function transitionStart(runCallbacks, direction) {
1740  if (runCallbacks === void 0) {
1741    runCallbacks = true;
1742  }
1743  const swiper = this;
1744  const {
1745    params
1746  } = swiper;
1747  if (params.cssMode) return;
1748  if (params.autoHeight) {
1749    swiper.updateAutoHeight();
1750  }
1751  transitionEmit({
1752    swiper,
1753    runCallbacks,
1754    direction,
1755    step: "Start"
1756  });
1757}
1758function transitionEnd(runCallbacks, direction) {
1759  if (runCallbacks === void 0) {
1760    runCallbacks = true;
1761  }
1762  const swiper = this;
1763  const {
1764    params
1765  } = swiper;
1766  swiper.animating = false;
1767  if (params.cssMode) return;
1768  swiper.setTransition(0);
1769  transitionEmit({
1770    swiper,
1771    runCallbacks,
1772    direction,
1773    step: "End"
1774  });
1775}
1776var transition = {
1777  setTransition,
1778  transitionStart,
1779  transitionEnd
1780};
1781function slideTo(index, speed, runCallbacks, internal, initial) {
1782  if (index === void 0) {
1783    index = 0;
1784  }
1785  if (runCallbacks === void 0) {
1786    runCallbacks = true;
1787  }
1788  if (typeof index === "string") {
1789    index = parseInt(index, 10);
1790  }
1791  const swiper = this;
1792  let slideIndex = index;
1793  if (slideIndex < 0) slideIndex = 0;
1794  const {
1795    params,
1796    snapGrid,
1797    slidesGrid,
1798    previousIndex,
1799    activeIndex,
1800    rtlTranslate: rtl,
1801    wrapperEl,
1802    enabled
1803  } = swiper;
1804  if (!enabled && !internal && !initial || swiper.destroyed || swiper.animating && params.preventInteractionOnTransition) {
1805    return false;
1806  }
1807  if (typeof speed === "undefined") {
1808    speed = swiper.params.speed;
1809  }
1810  const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
1811  let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
1812  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1813  const translate2 = -snapGrid[snapIndex];
1814  if (params.normalizeSlideIndex) {
1815    for (let i = 0; i < slidesGrid.length; i += 1) {
1816      const normalizedTranslate = -Math.floor(translate2 * 100);
1817      const normalizedGrid = Math.floor(slidesGrid[i] * 100);
1818      const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
1819      if (typeof slidesGrid[i + 1] !== "undefined") {
1820        if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
1821          slideIndex = i;
1822        } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
1823          slideIndex = i + 1;
1824        }
1825      } else if (normalizedTranslate >= normalizedGrid) {
1826        slideIndex = i;
1827      }
1828    }
1829  }
1830  if (swiper.initialized && slideIndex !== activeIndex) {
1831    if (!swiper.allowSlideNext && (rtl ? translate2 > swiper.translate && translate2 > swiper.minTranslate() : translate2 < swiper.translate && translate2 < swiper.minTranslate())) {
1832      return false;
1833    }
1834    if (!swiper.allowSlidePrev && translate2 > swiper.translate && translate2 > swiper.maxTranslate()) {
1835      if ((activeIndex || 0) !== slideIndex) {
1836        return false;
1837      }
1838    }
1839  }
1840  if (slideIndex !== (previousIndex || 0) && runCallbacks) {
1841    swiper.emit("beforeSlideChangeStart");
1842  }
1843  swiper.updateProgress(translate2);
1844  let direction;
1845  if (slideIndex > activeIndex) direction = "next";
1846  else if (slideIndex < activeIndex) direction = "prev";
1847  else direction = "reset";
1848  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1849  const isInitialVirtual = isVirtual && initial;
1850  if (!isInitialVirtual && (rtl && -translate2 === swiper.translate || !rtl && translate2 === swiper.translate)) {
1851    swiper.updateActiveIndex(slideIndex);
1852    if (params.autoHeight) {
1853      swiper.updateAutoHeight();
1854    }
1855    swiper.updateSlidesClasses();
1856    if (params.effect !== "slide") {
1857      swiper.setTranslate(translate2);
1858    }
1859    if (direction !== "reset") {
1860      swiper.transitionStart(runCallbacks, direction);
1861      swiper.transitionEnd(runCallbacks, direction);
1862    }
1863    return false;
1864  }
1865  if (params.cssMode) {
1866    const isH = swiper.isHorizontal();
1867    const t = rtl ? translate2 : -translate2;
1868    if (speed === 0) {
1869      if (isVirtual) {
1870        swiper.wrapperEl.style.scrollSnapType = "none";
1871        swiper._immediateVirtual = true;
1872      }
1873      if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
1874        swiper._cssModeVirtualInitialSet = true;
1875        requestAnimationFrame(() => {
1876          wrapperEl[isH ? "scrollLeft" : "scrollTop"] = t;
1877        });
1878      } else {
1879        wrapperEl[isH ? "scrollLeft" : "scrollTop"] = t;
1880      }
1881      if (isVirtual) {
1882        requestAnimationFrame(() => {
1883          swiper.wrapperEl.style.scrollSnapType = "";
1884          swiper._immediateVirtual = false;
1885        });
1886      }
1887    } else {
1888      if (!swiper.support.smoothScroll) {
1889        animateCSSModeScroll({
1890          swiper,
1891          targetPosition: t,
1892          side: isH ? "left" : "top"
1893        });
1894        return true;
1895      }
1896      wrapperEl.scrollTo({
1897        [isH ? "left" : "top"]: t,
1898        behavior: "smooth"
1899      });
1900    }
1901    return true;
1902  }
1903  swiper.setTransition(speed);
1904  swiper.setTranslate(translate2);
1905  swiper.updateActiveIndex(slideIndex);
1906  swiper.updateSlidesClasses();
1907  swiper.emit("beforeTransitionStart", speed, internal);
1908  swiper.transitionStart(runCallbacks, direction);
1909  if (speed === 0) {
1910    swiper.transitionEnd(runCallbacks, direction);
1911  } else if (!swiper.animating) {
1912    swiper.animating = true;
1913    if (!swiper.onSlideToWrapperTransitionEnd) {
1914      swiper.onSlideToWrapperTransitionEnd = function transitionEnd2(e) {
1915        if (!swiper || swiper.destroyed) return;
1916        if (e.target !== this) return;
1917        swiper.wrapperEl.removeEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
1918        swiper.onSlideToWrapperTransitionEnd = null;
1919        delete swiper.onSlideToWrapperTransitionEnd;
1920        swiper.transitionEnd(runCallbacks, direction);
1921      };
1922    }
1923    swiper.wrapperEl.addEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
1924  }
1925  return true;
1926}
1927function slideToLoop(index, speed, runCallbacks, internal) {
1928  if (index === void 0) {
1929    index = 0;
1930  }
1931  if (runCallbacks === void 0) {
1932    runCallbacks = true;
1933  }
1934  if (typeof index === "string") {
1935    const indexAsNumber = parseInt(index, 10);
1936    index = indexAsNumber;
1937  }
1938  const swiper = this;
1939  if (swiper.destroyed) return;
1940  if (typeof speed === "undefined") {
1941    speed = swiper.params.speed;
1942  }
1943  const gridEnabled = swiper.grid && swiper.params.grid && swiper.params.grid.rows > 1;
1944  let newIndex = index;
1945  if (swiper.params.loop) {
1946    if (swiper.virtual && swiper.params.virtual.enabled) {
1947      newIndex = newIndex + swiper.virtual.slidesBefore;
1948    } else {
1949      let targetSlideIndex;
1950      if (gridEnabled) {
1951        const slideIndex = newIndex * swiper.params.grid.rows;
1952        targetSlideIndex = swiper.slides.filter((slideEl) => slideEl.getAttribute("data-swiper-slide-index") * 1 === slideIndex)[0].column;
1953      } else {
1954        targetSlideIndex = swiper.getSlideIndexByData(newIndex);
1955      }
1956      const cols = gridEnabled ? Math.ceil(swiper.slides.length / swiper.params.grid.rows) : swiper.slides.length;
1957      const {
1958        centeredSlides
1959      } = swiper.params;
1960      let slidesPerView = swiper.params.slidesPerView;
1961      if (slidesPerView === "auto") {
1962        slidesPerView = swiper.slidesPerViewDynamic();
1963      } else {
1964        slidesPerView = Math.ceil(parseFloat(swiper.params.slidesPerView, 10));
1965        if (centeredSlides && slidesPerView % 2 === 0) {
1966          slidesPerView = slidesPerView + 1;
1967        }
1968      }
1969      let needLoopFix = cols - targetSlideIndex < slidesPerView;
1970      if (centeredSlides) {
1971        needLoopFix = needLoopFix || targetSlideIndex < Math.ceil(slidesPerView / 2);
1972      }
1973      if (internal && centeredSlides && swiper.params.slidesPerView !== "auto" && !gridEnabled) {
1974        needLoopFix = false;
1975      }
1976      if (needLoopFix) {
1977        const direction = centeredSlides ? targetSlideIndex < swiper.activeIndex ? "prev" : "next" : targetSlideIndex - swiper.activeIndex - 1 < swiper.params.slidesPerView ? "next" : "prev";
1978        swiper.loopFix({
1979          direction,
1980          slideTo: true,
1981          activeSlideIndex: direction === "next" ? targetSlideIndex + 1 : targetSlideIndex - cols + 1,
1982          slideRealIndex: direction === "next" ? swiper.realIndex : void 0
1983        });
1984      }
1985      if (gridEnabled) {
1986        const slideIndex = newIndex * swiper.params.grid.rows;
1987        newIndex = swiper.slides.filter((slideEl) => slideEl.getAttribute("data-swiper-slide-index") * 1 === slideIndex)[0].column;
1988      } else {
1989        newIndex = swiper.getSlideIndexByData(newIndex);
1990      }
1991    }
1992  }
1993  requestAnimationFrame(() => {
1994    swiper.slideTo(newIndex, speed, runCallbacks, internal);
1995  });
1996  return swiper;
1997}
1998function slideNext(speed, runCallbacks, internal) {
1999  if (runCallbacks === void 0) {
2000    runCallbacks = true;
2001  }
2002  const swiper = this;
2003  const {
2004    enabled,
2005    params,
2006    animating
2007  } = swiper;
2008  if (!enabled || swiper.destroyed) return swiper;
2009  if (typeof speed === "undefined") {
2010    speed = swiper.params.speed;
2011  }
2012  let perGroup = params.slidesPerGroup;
2013  if (params.slidesPerView === "auto" && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2014    perGroup = Math.max(swiper.slidesPerViewDynamic("current", true), 1);
2015  }
2016  const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2017  const isVirtual = swiper.virtual && params.virtual.enabled;
2018  if (params.loop) {
2019    if (animating && !isVirtual && params.loopPreventsSliding) return false;
2020    swiper.loopFix({
2021      direction: "next"
2022    });
2023    swiper._clientLeft = swiper.wrapperEl.clientLeft;
2024    if (swiper.activeIndex === swiper.slides.length - 1 && params.cssMode) {
2025      requestAnimationFrame(() => {
2026        swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2027      });
2028      return true;
2029    }
2030  }
2031  if (params.rewind && swiper.isEnd) {
2032    return swiper.slideTo(0, speed, runCallbacks, internal);
2033  }
2034  return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2035}
2036function slidePrev(speed, runCallbacks, internal) {
2037  if (runCallbacks === void 0) {
2038    runCallbacks = true;
2039  }
2040  const swiper = this;
2041  const {
2042    params,
2043    snapGrid,
2044    slidesGrid,
2045    rtlTranslate,
2046    enabled,
2047    animating
2048  } = swiper;
2049  if (!enabled || swiper.destroyed) return swiper;
2050  if (typeof speed === "undefined") {
2051    speed = swiper.params.speed;
2052  }
2053  const isVirtual = swiper.virtual && params.virtual.enabled;
2054  if (params.loop) {
2055    if (animating && !isVirtual && params.loopPreventsSliding) return false;
2056    swiper.loopFix({
2057      direction: "prev"
2058    });
2059    swiper._clientLeft = swiper.wrapperEl.clientLeft;
2060  }
2061  const translate2 = rtlTranslate ? swiper.translate : -swiper.translate;
2062  function normalize(val) {
2063    if (val < 0) return -Math.floor(Math.abs(val));
2064    return Math.floor(val);
2065  }
2066  const normalizedTranslate = normalize(translate2);
2067  const normalizedSnapGrid = snapGrid.map((val) => normalize(val));
2068  let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2069  if (typeof prevSnap === "undefined" && params.cssMode) {
2070    let prevSnapIndex;
2071    snapGrid.forEach((snap, snapIndex) => {
2072      if (normalizedTranslate >= snap) {
2073        prevSnapIndex = snapIndex;
2074      }
2075    });
2076    if (typeof prevSnapIndex !== "undefined") {
2077      prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2078    }
2079  }
2080  let prevIndex = 0;
2081  if (typeof prevSnap !== "undefined") {
2082    prevIndex = slidesGrid.indexOf(prevSnap);
2083    if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2084    if (params.slidesPerView === "auto" && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2085      prevIndex = prevIndex - swiper.slidesPerViewDynamic("previous", true) + 1;
2086      prevIndex = Math.max(prevIndex, 0);
2087    }
2088  }
2089  if (params.rewind && swiper.isBeginning) {
2090    const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2091    return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2092  } else if (params.loop && swiper.activeIndex === 0 && params.cssMode) {
2093    requestAnimationFrame(() => {
2094      swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2095    });
2096    return true;
2097  }
2098  return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2099}
2100function slideReset(speed, runCallbacks, internal) {
2101  if (runCallbacks === void 0) {
2102    runCallbacks = true;
2103  }
2104  const swiper = this;
2105  if (swiper.destroyed) return;
2106  if (typeof speed === "undefined") {
2107    speed = swiper.params.speed;
2108  }
2109  return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2110}
2111function slideToClosest(speed, runCallbacks, internal, threshold) {
2112  if (runCallbacks === void 0) {
2113    runCallbacks = true;
2114  }
2115  if (threshold === void 0) {
2116    threshold = 0.5;
2117  }
2118  const swiper = this;
2119  if (swiper.destroyed) return;
2120  if (typeof speed === "undefined") {
2121    speed = swiper.params.speed;
2122  }
2123  let index = swiper.activeIndex;
2124  const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2125  const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2126  const translate2 = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2127  if (translate2 >= swiper.snapGrid[snapIndex]) {
2128    const currentSnap = swiper.snapGrid[snapIndex];
2129    const nextSnap = swiper.snapGrid[snapIndex + 1];
2130    if (translate2 - currentSnap > (nextSnap - currentSnap) * threshold) {
2131      index += swiper.params.slidesPerGroup;
2132    }
2133  } else {
2134    const prevSnap = swiper.snapGrid[snapIndex - 1];
2135    const currentSnap = swiper.snapGrid[snapIndex];
2136    if (translate2 - prevSnap <= (currentSnap - prevSnap) * threshold) {
2137      index -= swiper.params.slidesPerGroup;
2138    }
2139  }
2140  index = Math.max(index, 0);
2141  index = Math.min(index, swiper.slidesGrid.length - 1);
2142  return swiper.slideTo(index, speed, runCallbacks, internal);
2143}
2144function slideToClickedSlide() {
2145  const swiper = this;
2146  if (swiper.destroyed) return;
2147  const {
2148    params,
2149    slidesEl
2150  } = swiper;
2151  const slidesPerView = params.slidesPerView === "auto" ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2152  let slideToIndex = swiper.clickedIndex;
2153  let realIndex;
2154  const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;
2155  if (params.loop) {
2156    if (swiper.animating) return;
2157    realIndex = parseInt(swiper.clickedSlide.getAttribute("data-swiper-slide-index"), 10);
2158    if (params.centeredSlides) {
2159      if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2160        swiper.loopFix();
2161        slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2162        nextTick(() => {
2163          swiper.slideTo(slideToIndex);
2164        });
2165      } else {
2166        swiper.slideTo(slideToIndex);
2167      }
2168    } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2169      swiper.loopFix();
2170      slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2171      nextTick(() => {
2172        swiper.slideTo(slideToIndex);
2173      });
2174    } else {
2175      swiper.slideTo(slideToIndex);
2176    }
2177  } else {
2178    swiper.slideTo(slideToIndex);
2179  }
2180}
2181var slide = {
2182  slideTo,
2183  slideToLoop,
2184  slideNext,
2185  slidePrev,
2186  slideReset,
2187  slideToClosest,
2188  slideToClickedSlide
2189};
2190function loopCreate(slideRealIndex) {
2191  const swiper = this;
2192  const {
2193    params,
2194    slidesEl
2195  } = swiper;
2196  if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2197  const initSlides = () => {
2198    const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
2199    slides.forEach((el, index) => {
2200      el.setAttribute("data-swiper-slide-index", index);
2201    });
2202  };
2203  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2204  const slidesPerGroup = params.slidesPerGroup * (gridEnabled ? params.grid.rows : 1);
2205  const shouldFillGroup = swiper.slides.length % slidesPerGroup !== 0;
2206  const shouldFillGrid = gridEnabled && swiper.slides.length % params.grid.rows !== 0;
2207  const addBlankSlides = (amountOfSlides) => {
2208    for (let i = 0; i < amountOfSlides; i += 1) {
2209      const slideEl = swiper.isElement ? createElement("swiper-slide", [params.slideBlankClass]) : createElement("div", [params.slideClass, params.slideBlankClass]);
2210      swiper.slidesEl.append(slideEl);
2211    }
2212  };
2213  if (shouldFillGroup) {
2214    if (params.loopAddBlankSlides) {
2215      const slidesToAdd = slidesPerGroup - swiper.slides.length % slidesPerGroup;
2216      addBlankSlides(slidesToAdd);
2217      swiper.recalcSlides();
2218      swiper.updateSlides();
2219    } else {
2220      showWarning("Swiper Loop Warning: The number of slides is not even to slidesPerGroup, loop mode may not function properly. You need to add more slides (or make duplicates, or empty slides)");
2221    }
2222    initSlides();
2223  } else if (shouldFillGrid) {
2224    if (params.loopAddBlankSlides) {
2225      const slidesToAdd = params.grid.rows - swiper.slides.length % params.grid.rows;
2226      addBlankSlides(slidesToAdd);
2227      swiper.recalcSlides();
2228      swiper.updateSlides();
2229    } else {
2230      showWarning("Swiper Loop Warning: The number of slides is not even to grid.rows, loop mode may not function properly. You need to add more slides (or make duplicates, or empty slides)");
2231    }
2232    initSlides();
2233  } else {
2234    initSlides();
2235  }
2236  swiper.loopFix({
2237    slideRealIndex,
2238    direction: params.centeredSlides ? void 0 : "next"
2239  });
2240}
2241function loopFix(_temp) {
2242  let {
2243    slideRealIndex,
2244    slideTo: slideTo2 = true,
2245    direction,
2246    setTranslate: setTranslate2,
2247    activeSlideIndex,
2248    byController,
2249    byMousewheel
2250  } = _temp === void 0 ? {} : _temp;
2251  const swiper = this;
2252  if (!swiper.params.loop) return;
2253  swiper.emit("beforeLoopFix");
2254  const {
2255    slides,
2256    allowSlidePrev,
2257    allowSlideNext,
2258    slidesEl,
2259    params
2260  } = swiper;
2261  const {
2262    centeredSlides
2263  } = params;
2264  swiper.allowSlidePrev = true;
2265  swiper.allowSlideNext = true;
2266  if (swiper.virtual && params.virtual.enabled) {
2267    if (slideTo2) {
2268      if (!params.centeredSlides && swiper.snapIndex === 0) {
2269        swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
2270      } else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {
2271        swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);
2272      } else if (swiper.snapIndex === swiper.snapGrid.length - 1) {
2273        swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
2274      }
2275    }
2276    swiper.allowSlidePrev = allowSlidePrev;
2277    swiper.allowSlideNext = allowSlideNext;
2278    swiper.emit("loopFix");
2279    return;
2280  }
2281  let slidesPerView = params.slidesPerView;
2282  if (slidesPerView === "auto") {
2283    slidesPerView = swiper.slidesPerViewDynamic();
2284  } else {
2285    slidesPerView = Math.ceil(parseFloat(params.slidesPerView, 10));
2286    if (centeredSlides && slidesPerView % 2 === 0) {
2287      slidesPerView = slidesPerView + 1;
2288    }
2289  }
2290  const slidesPerGroup = params.slidesPerGroupAuto ? slidesPerView : params.slidesPerGroup;
2291  let loopedSlides = slidesPerGroup;
2292  if (loopedSlides % slidesPerGroup !== 0) {
2293    loopedSlides += slidesPerGroup - loopedSlides % slidesPerGroup;
2294  }
2295  loopedSlides += params.loopAdditionalSlides;
2296  swiper.loopedSlides = loopedSlides;
2297  const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2298  if (slides.length < slidesPerView + loopedSlides) {
2299    showWarning("Swiper Loop Warning: The number of slides is not enough for loop mode, it will be disabled and not function properly. You need to add more slides (or make duplicates) or lower the values of slidesPerView and slidesPerGroup parameters");
2300  } else if (gridEnabled && params.grid.fill === "row") {
2301    showWarning("Swiper Loop Warning: Loop mode is not compatible with grid.fill = `row`");
2302  }
2303  const prependSlidesIndexes = [];
2304  const appendSlidesIndexes = [];
2305  let activeIndex = swiper.activeIndex;
2306  if (typeof activeSlideIndex === "undefined") {
2307    activeSlideIndex = swiper.getSlideIndex(slides.filter((el) => el.classList.contains(params.slideActiveClass))[0]);
2308  } else {
2309    activeIndex = activeSlideIndex;
2310  }
2311  const isNext = direction === "next" || !direction;
2312  const isPrev = direction === "prev" || !direction;
2313  let slidesPrepended = 0;
2314  let slidesAppended = 0;
2315  const cols = gridEnabled ? Math.ceil(slides.length / params.grid.rows) : slides.length;
2316  const activeColIndex = gridEnabled ? slides[activeSlideIndex].column : activeSlideIndex;
2317  const activeColIndexWithShift = activeColIndex + (centeredSlides && typeof setTranslate2 === "undefined" ? -slidesPerView / 2 + 0.5 : 0);
2318  if (activeColIndexWithShift < loopedSlides) {
2319    slidesPrepended = Math.max(loopedSlides - activeColIndexWithShift, slidesPerGroup);
2320    for (let i = 0; i < loopedSlides - activeColIndexWithShift; i += 1) {

2349idesIndexes.forEach((index) => {
2350      slides[index].swiperLoopMoveDOM = true;
2351      slidesEl.prepend(slides[index]);
2352      slides[index].swiperLoopMoveDOM = false;
2353    });
2354  }
2355  if (isNext) {
2356    appendSlidesIndexes.forEach((index) => {
2357      slides[index].swiperLoopMoveDOM = true;
2358      slidesEl.append(slides[index]);
2359      slides[index].swiperLoopMoveDOM = false;
2360    });
2361  }
2362  swiper.recalcSlides();
2363  if (params.slidesPerView === "auto") {
2364    swiper.updateSlides();
2365  } else if (gridEnabled && (prependSlidesIndexes.length > 0 && isPrev || appendSlidesIndexes.length > 0 && isNext)) {
2366    swiper.slides.forEach((slide2, slideIndex) => {
2367      swiper.grid.updateSlide(slideIndex, slide2, swiper.slides);
2368    });
2369  }
2370  if (params.watchSlidesProgress) {
2371    swiper.updateSlidesOffset();
2372  }
2373  if (slideTo2) {
2374    if (prependSlidesIndexes.length > 0 && isPrev) {
2375      if (typeof slideRealIndex === "undefined") {
2376        const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2377        const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
2378        const diff = newSlideTranslate - currentSlideTranslate;
2379        if (byMousewheel) {
2380          swiper.setTranslate(swiper.translate - diff);
2381        } else {
2382          swiper.slideTo(activeIndex + Math.ceil(slidesPrepended), 0, false, true);
2383          if (setTranslate2) {
2384            swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2385            swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2386          }
2387        }
2388      } else {
2389        if (setTranslate2) {
2390          const shift = gridEnabled ? prependSlidesIndexes.length / params.grid.rows : prependSlidesIndexes.length;
2391          swiper.slideTo(swiper.activeIndex + shift, 0, false, true);
2392          swiper.touchEventsData.currentTranslate = swiper.translate;
2393        }
2394      }
2395    } else if (appendSlidesIndexes.length > 0 && isNext) {
2396      if (typeof slideRealIndex === "undefined") {
2397        const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2398        const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
2399        const diff = newSlideTranslate - currentSlideTranslate;
2400        if (byMousewheel) {
2401          swiper.setTranslate(swiper.translate - diff);
2402        } else {
2403          swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
2404          if (setTranslate2) {
2405            swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2406            swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2407          }
2408        }
2409      } else {
2410        const shift = gridEnabled ? appendSlidesIndexes.length / params.grid.rows : appendSlidesIndexes.length;
2411        swiper.slideTo(swiper.activeIndex - shift, 0, false, true);
2412      }
2413    }
2414  }
2415  swiper.allowSlidePrev = allowSlidePrev;
2416  swiper.allowSlideNext = allowSlideNext;
2417  if (swiper.controller && swiper.controller.control && !byController) {
2418    const loopParams = {
2419      slideRealIndex,
2420      direction,
2421      setTranslate: setTranslate2,
2422      activeSlideIndex,
2423      byController: true
2424    };
2425    if (Array.isArray(swiper.controller.control)) {
2426      swiper.controller.control.forEach((c) => {
2427        if (!c.destroyed && c.params.loop) c.loopFix({
2428          ...loopParams,
2429          slideTo: c.params.slidesPerView === params.slidesPerView ? slideTo2 : false
2430        });
2431      });
2432    } else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {
2433      swiper.controller.control.loopFix({
2434        ...loopParams,
2435        slideTo: swiper.controller.control.params.slidesPerView === params.slidesPerView ? slideTo2 : false
2436      });
2437    }
2438  }
2439  swiper.emit("loopFix");
2440}
2441function loopDestroy() {
2442  const swiper = this;
2443  const {
2444    params,
2445    slidesEl
2446  } = swiper;
2447  if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2448  swiper.recalcSlides();
2449  const newSlidesOrder = [];
2450  swiper.slides.forEach((slideEl) => {
2451    const index = typeof slideEl.swiperSlideIndex === "undefined" ? slideEl.getAttribute("data-swiper-slide-index") * 1 : slideEl.swiperSlideIndex;
2452    newSlidesOrder[index] = slideEl;
2453  });
2454  swiper.slides.forEach((slideEl) => {
2455    slideEl.removeAttribute("data-swiper-slide-index");
2456  });
2457  newSlidesOrder.forEach((slideEl) => {
2458    slidesEl.append(slideEl);
2459  });
2460  swiper.recalcSlides();
2461  swiper.slideTo(swiper.realIndex, 0);
2462}
2463var loop = {
2464  loopCreate,
2465  loopFix,
2466  loopDestroy
2467};
2468function setGrabCursor(moving) {
2469  const swiper = this;
2470  if (!swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
2471  const el = swiper.params.touchEventsTarget === "container" ? swiper.el : swiper.wrapperEl;
2472  if (swiper.isElement) {
2473    swiper.__preventObserver__ = true;
2474  }
2475  el.style.cursor = "move";
2476  el.style.cursor = moving ? "grabbing" : "grab";
2477  if (swiper.isElement) {
2478    requestAnimationFrame(() => {
2479      swiper.__preventObserver__ = false;
2480    });
2481  }
2482}
2483function unsetGrabCursor() {
2484  const swiper = this;
2485  if (swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
2486    return;
2487  }
2488  if (swiper.isElement) {
2489    swiper.__preventObserver__ = true;
2490  }
2491  swiper[swiper.params.touchEventsTarget === "container" ? "el" : "wrapperEl"].style.cursor = "";
2492  if (swiper.isElement) {
2493    requestAnimationFrame(() => {
2494      swiper.__preventObserver__ = false;
2495    });
2496  }
2497}
2498var grabCursor = {
2499  setGrabCursor,
2500  unsetGrabCursor
2501};
2502function closestElement(selector, base) {
2503  if (base === void 0) {
2504    base = this;
2505  }
2506  function __closestFrom(el) {
2507    if (!el || el === getDocument() || el === getWindow()) return null;
2508    if (el.assignedSlot) el = el.assignedSlot;
2509    const found = el.closest(selector);
2510    if (!found && !el.getRootNode) {
2511      return null;
2512    }
2513    return found || __closestFrom(el.getRootNode().host);
2514  }
2515  return __closestFrom(base);
2516}
2517function preventEdgeSwipe(swiper, event2, startX) {
2518  const window2 = getWindow();
2519  const {
2520    params
2521  } = swiper;
2522  const edgeSwipeDetection = params.edgeSwipeDetection;
2523  const edgeSwipeThreshold = params.edgeSwipeThreshold;
2524  if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window2.innerWidth - edgeSwipeThreshold)) {
2525    if (edgeSwipeDetection === "prevent") {
2526      event2.preventDefault();
2527      return true;
2528    }
2529    return false;
2530  }
2531  return true;
2532}
2533function onTouchStart(event2) {
2534  const swiper = this;
2535  const document2 = getDocument();
2536  let e = event2;
2537  if (e.originalEvent) e = e.originalEvent;
2538  const data = swiper.touchEventsData;
2539  if (e.type === "pointerdown") {
2540    if (data.pointerId !== null && data.pointerId !== e.pointerId) {
2541      return;
2542    }
2543    data.pointerId = e.pointerId;
2544  } else if (e.type === "touchstart" && e.targetTouches.length === 1) {
2545    data.touchId = e.targetTouches[0].identifier;
2546  }
2547  if (e.type === "touchstart") {
2548    preventEdgeSwipe(swiper, e, e.targetTouches[0].pageX);
2549    return;
2550  }
2551  const {
2552    params,
2553    touches,
2554    enabled
2555  } = swiper;
2556  if (!enabled) return;
2557  if (!params.simulateTouch && e.pointerType === "mouse") return;
2558  if (swiper.animating && params.preventInteractionOnTransition) {
2559    return;
2560  }
2561  if (!swiper.animating && params.cssMode && params.loop) {
2562    swiper.loopFix();
2563  }
2564  let targetEl = e.target;
2565  if (params.touchEventsTarget === "wrapper") {
2566    if (!elementIsChildOf(targetEl, swiper.wrapperEl)) return;
2567  }
2568  if ("which" in e && e.which === 3) return;
2569  if ("button" in e && e.button > 0) return;
2570  if (data.isTouched && data.isMoved) return;
2571  const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== "";
2572  const eventPath = e.composedPath ? e.composedPath() : e.path;
2573  if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
2574    targetEl = eventPath[0];
2575  }
2576  const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
2577  const isTargetShadow = !!(e.target && e.target.shadowRoot);
2578  if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))) {
2579    swiper.allowClick = true;
2580    return;
2581  }
2582  if (params.swipeHandler) {
2583    if (!targetEl.closest(params.swipeHandler)) return;
2584  }
2585  touches.currentX = e.pageX;
2586  touches.currentY = e.pageY;
2587  const startX = touches.currentX;
2588  const startY = touches.currentY;
2589  if (!preventEdgeSwipe(swiper, e, startX)) {
2590    return;
2591  }
2592  Object.assign(data, {
2593    isTouched: true,
2594    isMoved: false,
2595    allowTouchCallbacks: true,
2596    isScrolling: void 0,
2597    startMoving: void 0
2598  });
2599  touches.startX = startX;
2600  touches.startY = startY;
2601  data.touchStartTime = now();
2602  swiper.allowClick = true;
2603  swiper.updateSize();
2604  swiper.swipeDirection = void 0;
2605  if (params.threshold > 0) data.allowThresholdMove = false;
2606  let preventDefault = true;
2607  if (targetEl.matches(data.focusableElements)) {
2608    preventDefault = false;
2609    if (targetEl.nodeName === "SELECT") {
2610      data.isTouched = false;
2611    }
2612  }
2613  if (document2.activeElement && document2.activeElement.matches(data.focusableElements) && document2.activeElement !== targetEl && (e.pointerType === "mouse" || e.pointerType !== "mouse" && !targetEl.matches(data.focusableElements))) {
2614    document2.activeElement.blur();
2615  }
2616  const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
2617  if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !targetEl.isContentEditable) {
2618    e.preventDefault();
2619  }
2620  if (params.freeMode && params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {
2621    swiper.freeMode.onTouchStart();
2622  }
2623  swiper.emit("touchStart", e);
2624}
2625function onTouchMove(event2) {
2626  const document2 = getDocument();
2627  const swiper = this;
2628  const data = swiper.touchEventsData;
2629  const {
2630    params,
2631    touches,
2632    rtlTranslate: rtl,
2633    enabled
2634  } = swiper;
2635  if (!enabled) return;
2636  if (!params.simulateTouch && event2.pointerType === "mouse") return;
2637  let e = event2;
2638  if (e.originalEvent) e = e.originalEvent;
2639  if (e.type === "pointermove") {
2640    if (data.touchId !== null) return;
2641    const id = e.pointerId;
2642    if (id !== data.pointerId) return;
2643  }
2644  let targetTouch;
2645  if (e.type === "touchmove") {
2646    targetTouch = [...e.changedTouches].filter((t) => t.identifier === data.touchId)[0];
2647    if (!targetTouch || targetTouch.identifier !== data.touchId) return;
2648  } else {
2649    targetTouch = e;
2650  }
2651  if (!data.isTouched) {
2652    if (data.startMoving && data.isScrolling) {
2653      swiper.emit("touchMoveOpposite", e);
2654    }
2655    return;
2656  }
2657  const pageX = targetTouch.pageX;
2658  const pageY = targetTouch.pageY;
2659  if (e.preventedByNestedSwiper) {
2660    touches.startX = pageX;
2661    touches.startY = pageY;
2662    return;
2663  }
2664  if (!swiper.allowTouchMove) {
2665    if (!e.target.matches(data.focusableElements)) {
2666      swiper.allowClick = false;
2667    }
2668    if (data.isTouched) {
2669      Object.assign(touches, {
2670        startX: pageX,
2671        startY: pageY,
2672        currentX: pageX,
2673        currentY: pageY
2674      });
2675      data.touchStartTime = now();
2676    }
2677    return;
2678  }
2679  if (params.touchReleaseOnEdges && !params.loop) {
2680    if (swiper.isVertical()) {
2681      if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {
2682        data.isTouched = false;
2683        data.isMoved = false;
2684        return;
2685      }
2686    } else if (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate()) {
2687      return;
2688    }
2689  }
2690  if (document2.activeElement && document2.activeElement.matches(data.focusableElements) && document2.activeElement !== e.target && e.pointerType !== "mouse") {
2691    document2.activeElement.blur();
2692  }
2693  if (document2.activeElement) {
2694    if (e.target === document2.activeElement && e.target.matches(data.focusableElements)) {
2695      data.isMoved = true;
2696      swiper.allowClick = false;
2697      return;
2698    }
2699  }
2700  if (data.allowTouchCallbacks) {
2701    swiper.emit("touchMove", e);
2702  }
2703  touches.previousX = touches.currentX;
2704  touches.previousY = touches.currentY;
2705  touches.currentX = pageX;
2706  touches.currentY = pageY;
2707  const diffX = touches.currentX - touches.startX;
2708  const diffY = touches.currentY - touches.startY;
2709  if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;
2710  if (typeof data.isScrolling === "undefined") {
2711    let touchAngle;
2712    if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) {
2713      data.isScrolling = false;
2714    } else {
2715      if (diffX * diffX + diffY * diffY >= 25) {
2716        touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;
2717        data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
2718      }
2719    }
2720  }
2721  if (data.isScrolling) {
2722    swiper.emit("touchMoveOpposite", e);
2723  }
2724  if (typeof data.startMoving === "undefined") {
2725    if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
2726      data.startMoving = true;
2727    }
2728  }
2729  if (data.isScrolling || e.type === "touchmove" && data.preventTouchMoveFromPointerMove) {
2730    data.isTouched = false;
2731    return;
2732  }
2733  if (!data.startMoving) {
2734    return;
2735  }
2736  swiper.allowClick = false;
2737  if (!params.cssMode && e.cancelable) {
2738    e.preventDefault();
2739  }
2740  if (params.touchMoveStopPropagation && !params.nested) {
2741    e.stopPropagation();
2742  }
2743  let diff = swiper.isHorizontal() ? diffX : diffY;
2744  let touchesDiff = swiper.isHorizontal() ? touches.currentX - touches.previousX : touches.currentY - touches.previousY;
2745  if (params.oneWayMovement) {
2746    diff = Math.abs(diff) * (rtl ? 1 : -1);
2747    touchesDiff = Math.abs(touchesDiff) * (rtl ? 1 : -1);
2748  }
2749  touches.diff = diff;
2750  diff *= params.touchRatio;
2751  if (rtl) {
2752    diff = -diff;
2753    touchesDiff = -touchesDiff;
2754  }
2755  const prevTouchesDirection = swiper.touchesDirection;
2756  swiper.swipeDirection = diff > 0 ? "prev" : "next";
2757  swiper.touchesDirection = touchesDiff > 0 ? "prev" : "next";
2758  const isLoop = swiper.params.loop && !params.cssMode;
2759  const allowLoopFix = swiper.touchesDirection === "next" && swiper.allowSlideNext || swiper.touchesDirection === "prev" && swiper.allowSlidePrev;
2760  if (!data.isMoved) {
2761    if (isLoop && allowLoopFix) {
2762      swiper.loopFix({
2763        direction: swiper.swipeDirection
2764      });
2765    }
2766    data.startTranslate = swiper.getTranslate();
2767    swiper.setTransition(0);
2768    if (swiper.animating) {
2769      const evt = new window.CustomEvent("transitionend", {
2770        bubbles: true,
2771        cancelable: true,
2772        detail: {
2773          bySwiperTouchMove: true
2774        }
2775      });
2776      swiper.wrapperEl.dispatchEvent(evt);
2777    }
2778    data.allowMomentumBounce = false;
2779    if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
2780      swiper.setGrabCursor(true);
2781    }
2782    swiper.emit("sliderFirstMove", e);
2783  }
2784  let loopFixed;
2785  (/* @__PURE__ */ new Date()).getTime();
2786  if (data.isMoved && data.allowThresholdMove && prevTouchesDirection !== swiper.touchesDirection && isLoop && allowLoopFix && Math.abs(diff) >= 1) {
2787    Object.assign(touches, {
2788      startX: pageX,
2789      startY: pageY,
2790      currentX: pageX,
2791      currentY: pageY,
2792      startTranslate: data.currentTranslate
2793    });
2794    data.loopSwapReset = true;
2795    data.startTranslate = data.currentTranslate;
2796    return;
2797  }
2798  swiper.emit("sliderMove", e);
2799  data.isMoved = true;
2800  data.currentTranslate = diff + data.startTranslate;
2801  let disableParentSwiper = true;
2802  let resistanceRatio = params.resistanceRatio;
2803  if (params.touchReleaseOnEdges) {
2804    resistanceRatio = 0;
2805  }
2806  if (diff > 0) {
2807    if (isLoop && allowLoopFix && !loopFixed && data.allowThresholdMove && data.currentTranslate > (params.centeredSlides ? swiper.minTranslate() - swiper.slidesSizesGrid[swiper.activeIndex + 1] - (params.slidesPerView !== "auto" && swiper.slides.length - params.slidesPerView >= 2 ? swiper.slidesSizesGrid[swiper.activeIndex + 1] + swiper.params.spaceBetween : 0) - swiper.params.spaceBetween : swiper.minTranslate())) {
2808      swiper.loopFix({
2809        direction: "prev",
2810        setTranslate: true,
2811        activeSlideIndex: 0
2812      });
2813    }
2814    if (data.currentTranslate > swiper.minTranslate()) {
2815      disableParentSwiper = false;
2816      if (params.resistance) {
2817        data.currentTranslate = swiper.minTranslate() - 1 + (-swiper.minTranslate() + data.startTranslate + diff) ** resistanceRatio;
2818      }
2819    }
2820  } else if (diff < 0) {
2821    if (isLoop && allowLoopFix && !loopFixed && data.allowThresholdMove && data.currentTranslate < (params.centeredSlides ? swiper.maxTranslate() + swiper.slidesSizesGrid[swiper.slidesSizesGrid.length - 1] + swiper.params.spaceBetween + (params.slidesPerView !== "auto" && swiper.slides.length - params.slidesPerView >= 2 ? swiper.slidesSizesGrid[swiper.slidesSizesGrid.length - 1] + swiper.params.spaceBetween : 0) : swiper.maxTranslate())) {
2822      swiper.loopFix({
2823        direction: "next",
2824        setTranslate: true,
2825        activeSlideIndex: swiper.slides.length - (params.slidesPerView === "auto" ? swiper.slidesPerViewDynamic() : Math.ceil(parseFloat(params.slidesPerView, 10)))
2826      });
2827    }
2828    if (data.currentTranslate < swiper.maxTranslate()) {
2829      disableParentSwiper = false;
2830      if (params.resistance) {
2831        data.currentTranslate = swiper.maxTranslate() + 1 - (swiper.maxTranslate() - data.startTranslate - diff) ** resistanceRatio;
2832      }
2833    }
2834  }
2835  if (disableParentSwiper) {
2836    e.preventedByNestedSwiper = true;
2837  }
2838  if (!swiper.allowSlideNext && swiper.swipeDirection === "next" && data.currentTranslate < data.startTranslate) {
2839    data.currentTranslate = data.startTranslate;
2840  }
2841  if (!swiper.allowSlidePrev && swiper.swipeDirection === "prev" && data.currentTranslate > data.startTranslate) {
2842    data.currentTranslate = data.startTranslate;
2843  }
2844  if (!swiper.allowSlidePrev && !swiper.allowSlideNext) {
2845    data.currentTranslate = data.startTranslate;
2846  }
2847  if (params.threshold > 0) {
2848    if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {
2849      if (!data.allowThresholdMove) {
2850        data.allowThresholdMove = true;
2851        touches.startX = touches.currentX;
2852        touches.startY = touches.currentY;
2853        data.currentTranslate = data.startTranslate;
2854        touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;
2855        return;
2856      }
2857    } else {
2858      data.currentTranslate = data.startTranslate;
2859      return;
2860    }
2861  }
2862  if (!params.followFinger || params.cssMode) return;
2863  if (params.freeMode && params.freeMode.enabled && swiper.freeMode || params.watchSlidesProgress) {
2864    swiper.updateActiveIndex();
2865    swiper.updateSlidesClasses();
2866  }
2867  if (params.freeMode && params.freeMode.enabled && swiper.freeMode) {
2868    swiper.freeMode.onTouchMove();
2869  }
2870  swiper.updateProgress(data.currentTranslate);
2871  swiper.setTranslate(data.currentTranslate);
2872}
2873function onTouchEnd(event2) {
2874  const swiper = this;
2875  const data = swiper.touchEventsData;
2876  let e = event2;
2877  if (e.originalEvent) e = e.originalEvent;
2878  let targetTouch;
2879  const isTouchEvent = e.type === "touchend" || e.type === "touchcancel";
2880  if (!isTouchEvent) {
2881    if (data.touchId !== null) return;
2882    if (e.pointerId !== data.pointerId) return;
2883    targetTouch = e;
2884  } else {
2885    targetTouch = [...e.changedTouches].filter((t) => t.identifier === data.touchId)[0];
2886    if (!targetTouch || targetTouch.identifier !== data.touchId) return;
2887  }
2888  if (["pointercancel", "pointerout", "pointerleave", "contextmenu"].includes(e.type)) {
2889    const proceed = ["pointercancel", "contextmenu"].includes(e.type) && (swiper.browser.isSafari || swiper.browser.isWebView);
2890    if (!proceed) {
2891      return;
2892    }
2893  }
2894  data.pointerId = null;
2895  data.touchId = null;
2896  const {
2897    params,
2898    touches,
2899    rtlTranslate: rtl,
2900    slidesGrid,
2901    enabled
2902  } = swiper;
2903  if (!enabled) return;
2904  if (!params.simulateTouch && e.pointerType === "mouse") return;
2905  if (data.allowTouchCallbacks) {
2906    swiper.emit("touchEnd", e);
2907  }
2908  data.allowTouchCallbacks = false;
2909  if (!data.isTouched) {
2910    if (data.isMoved && params.grabCursor) {
2911      swiper.setGrabCursor(false);
2912    }
2913    data.isMoved = false;
2914    data.startMoving = false;
2915    return;
2916  }
2917  if (params.grabCursor && data.isMoved && data.isTouched && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
2918    swiper.setGrabCursor(false);
2919  }
2920  const touchEndTime = now();
2921  const timeDiff = touchEndTime - data.touchStartTime;
2922  if (swiper.allowClick) {
2923    const pathTree = e.path || e.composedPath && e.composedPath();
2924    swiper.updateClickedSlide(pathTree && pathTree[0] || e.target, pathTree);
2925    swiper.emit("tap click", e);
2926    if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) {
2927      swiper.emit("doubleTap doubleClick", e);
2928    }
2929  }
2930  data.lastClickTime = now();
2931  nextTick(() => {
2932    if (!swiper.destroyed) swiper.allowClick = true;
2933  });
2934  if (!data.isTouched || !data.isMoved || !swiper.swipeDirection || touches.diff === 0 && !data.loopSwapReset || data.currentTranslate === data.startTranslate && !data.loopSwapReset) {
2935    data.isTouched = false;