infinity-forge 2.4.0 → 2.4.1

package/dist/ui/components/carousel/carousel-lib/core/loop/loopFix.js

@@ -0,0 +1,230 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-nocheck
+var utils_1 = require("../../shared/utils.js");
+function loopFix(_a) {
+    var _b = _a === void 0 ? {} : _a, slideRealIndex = _b.slideRealIndex, _c = _b.slideTo, slideTo = _c === void 0 ? true : _c, direction = _b.direction, setTranslate = _b.setTranslate, activeSlideIndex = _b.activeSlideIndex, byController = _b.byController, byMousewheel = _b.byMousewheel;
+    var swiper = this;
+    if (!swiper.params.loop)
+        return;
+    swiper.emit('beforeLoopFix');
+    var slides = swiper.slides, allowSlidePrev = swiper.allowSlidePrev, allowSlideNext = swiper.allowSlideNext, slidesEl = swiper.slidesEl, params = swiper.params;
+    var centeredSlides = params.centeredSlides;
+    swiper.allowSlidePrev = true;
+    swiper.allowSlideNext = true;
+    if (swiper.virtual && params.virtual.enabled) {
+        if (slideTo) {
+            if (!params.centeredSlides && swiper.snapIndex === 0) {
+                swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
+            }
+            else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {
+                swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);
+            }
+            else if (swiper.snapIndex === swiper.snapGrid.length - 1) {
+                swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
+            }
+        }
+        swiper.allowSlidePrev = allowSlidePrev;
+        swiper.allowSlideNext = allowSlideNext;
+        swiper.emit('loopFix');
+        return;
+    }
+    var slidesPerView = params.slidesPerView;
+    if (slidesPerView === 'auto') {
+        slidesPerView = swiper.slidesPerViewDynamic();
+    }
+    else {
+        slidesPerView = Math.ceil(parseFloat(params.slidesPerView, 10));
+        if (centeredSlides && slidesPerView % 2 === 0) {
+            slidesPerView = slidesPerView + 1;
+        }
+    }
+    var slidesPerGroup = params.slidesPerGroupAuto ? slidesPerView : params.slidesPerGroup;
+    var loopedSlides = slidesPerGroup;
+    if (loopedSlides % slidesPerGroup !== 0) {
+        loopedSlides += slidesPerGroup - (loopedSlides % slidesPerGroup);
+    }
+    loopedSlides += params.loopAdditionalSlides;
+    swiper.loopedSlides = loopedSlides;
+    var gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
+    if (slides.length < slidesPerView + loopedSlides) {
+        (0, utils_1.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');
+    }
+    else if (gridEnabled && params.grid.fill === 'row') {
+        (0, utils_1.showWarning)('Swiper Loop Warning: Loop mode is not compatible with grid.fill = `row`');
+    }
+    var prependSlidesIndexes = [];
+    var appendSlidesIndexes = [];
+    var activeIndex = swiper.activeIndex;
+    if (typeof activeSlideIndex === 'undefined') {
+        activeSlideIndex = swiper.getSlideIndex(slides.filter(function (el) { return el.classList.contains(params.slideActiveClass); })[0]);
+    }
+    else {
+        activeIndex = activeSlideIndex;
+    }
+    var isNext = direction === 'next' || !direction;
+    var isPrev = direction === 'prev' || !direction;
+    var slidesPrepended = 0;
+    var slidesAppended = 0;
+    var cols = gridEnabled ? Math.ceil(slides.length / params.grid.rows) : slides.length;
+    var activeColIndex = gridEnabled ? slides[activeSlideIndex].column : activeSlideIndex;
+    var activeColIndexWithShift = activeColIndex +
+        (centeredSlides && typeof setTranslate === 'undefined' ? -slidesPerView / 2 + 0.5 : 0);
+    // prepend last slides before start
+    if (activeColIndexWithShift < loopedSlides) {
+        slidesPrepended = Math.max(loopedSlides - activeColIndexWithShift, slidesPerGroup);
+        for (var i = 0; i < loopedSlides - activeColIndexWithShift; i += 1) {
+            var index = i - Math.floor(i / cols) * cols;
+            if (gridEnabled) {
+                var colIndexToPrepend = cols - index - 1;
+                for (var i_1 = slides.length - 1; i_1 >= 0; i_1 -= 1) {
+                    if (slides[i_1].column === colIndexToPrepend)
+                        prependSlidesIndexes.push(i_1);
+                }
+                // slides.forEach((slide, slideIndex) => {
+                //   if (slide.column === colIndexToPrepend) prependSlidesIndexes.push(slideIndex);
+                // });
+            }
+            else {
+                prependSlidesIndexes.push(cols - index - 1);
+            }
+        }
+    }
+    else if (activeColIndexWithShift + slidesPerView > cols - loopedSlides) {
+        slidesAppended = Math.max(activeColIndexWithShift - (cols - loopedSlides * 2), slidesPerGroup);
+        var _loop_1 = function (i) {
+            var index = i - Math.floor(i / cols) * cols;
+            if (gridEnabled) {
+                slides.forEach(function (slide, slideIndex) {
+                    if (slide.column === index)
+                        appendSlidesIndexes.push(slideIndex);
+                });
+            }
+            else {
+                appendSlidesIndexes.push(index);
+            }
+        };
+        for (var i = 0; i < slidesAppended; i += 1) {
+            _loop_1(i);
+        }
+    }
+    swiper.__preventObserver__ = true;
+    requestAnimationFrame(function () {
+        swiper.__preventObserver__ = false;
+    });
+    if (isPrev) {
+        prependSlidesIndexes.forEach(function (index) {
+            slides[index].swiperLoopMoveDOM = true;
+            slidesEl.prepend(slides[index]);
+            slides[index].swiperLoopMoveDOM = false;
+        });
+    }
+    if (isNext) {
+        appendSlidesIndexes.forEach(function (index) {
+            slides[index].swiperLoopMoveDOM = true;
+            slidesEl.append(slides[index]);
+            slides[index].swiperLoopMoveDOM = false;
+        });
+    }
+    swiper.recalcSlides();
+    if (params.slidesPerView === 'auto') {
+        swiper.updateSlides();
+    }
+    else if (gridEnabled &&
+        ((prependSlidesIndexes.length > 0 && isPrev) || (appendSlidesIndexes.length > 0 && isNext))) {
+        swiper.slides.forEach(function (slide, slideIndex) {
+            swiper.grid.updateSlide(slideIndex, slide, swiper.slides);
+        });
+    }
+    if (params.watchSlidesProgress) {
+        swiper.updateSlidesOffset();
+    }
+    if (slideTo) {
+        if (prependSlidesIndexes.length > 0 && isPrev) {
+            if (typeof slideRealIndex === 'undefined') {
+                var currentSlideTranslate = swiper.slidesGrid[activeIndex];
+                var newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
+                var diff = newSlideTranslate - currentSlideTranslate;
+                if (byMousewheel) {
+                    swiper.setTranslate(swiper.translate - diff);
+                }
+                else {
+                    swiper.slideTo(activeIndex + Math.ceil(slidesPrepended), 0, false, true);
+                    if (setTranslate) {
+                        swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
+                        swiper.touchEventsData.currentTranslate =
+                            swiper.touchEventsData.currentTranslate - diff;
+                    }
+                }
+            }
+            else {
+                if (setTranslate) {
+                    var shift = gridEnabled
+                        ? prependSlidesIndexes.length / params.grid.rows
+                        : prependSlidesIndexes.length;
+                    swiper.slideTo(swiper.activeIndex + shift, 0, false, true);
+                    swiper.touchEventsData.currentTranslate = swiper.translate;
+                }
+            }
+        }
+        else if (appendSlidesIndexes.length > 0 && isNext) {
+            if (typeof slideRealIndex === 'undefined') {
+                var currentSlideTranslate = swiper.slidesGrid[activeIndex];
+                var newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
+                var diff = newSlideTranslate - currentSlideTranslate;
+                if (byMousewheel) {
+                    swiper.setTranslate(swiper.translate - diff);
+                }
+                else {
+                    swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
+                    if (setTranslate) {
+                        swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
+                        swiper.touchEventsData.currentTranslate =
+                            swiper.touchEventsData.currentTranslate - diff;
+                    }
+                }
+            }
+            else {
+                var shift = gridEnabled
+                    ? appendSlidesIndexes.length / params.grid.rows
+                    : appendSlidesIndexes.length;
+                swiper.slideTo(swiper.activeIndex - shift, 0, false, true);
+            }
+        }
+    }
+    swiper.allowSlidePrev = allowSlidePrev;
+    swiper.allowSlideNext = allowSlideNext;
+    if (swiper.controller && swiper.controller.control && !byController) {
+        var loopParams_1 = {
+            slideRealIndex: slideRealIndex,
+            direction: direction,
+            setTranslate: setTranslate,
+            activeSlideIndex: activeSlideIndex,
+            byController: true,
+        };
+        if (Array.isArray(swiper.controller.control)) {
+            swiper.controller.control.forEach(function (c) {
+                if (!c.destroyed && c.params.loop)
+                    c.loopFix(__assign(__assign({}, loopParams_1), { slideTo: c.params.slidesPerView === params.slidesPerView ? slideTo : false }));
+            });
+        }
+        else if (swiper.controller.control instanceof swiper.constructor &&
+            swiper.controller.control.params.loop) {
+            swiper.controller.control.loopFix(__assign(__assign({}, loopParams_1), { slideTo: swiper.controller.control.params.slidesPerView === params.slidesPerView ? slideTo : false }));
+        }
+    }
+    swiper.emit('loopFix');
+}
+exports.default = loopFix;
+//# sourceMappingURL=loopFix.js.map

package/dist/ui/components/carousel/carousel-lib/core/modules/observer/observer.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 //@ts-nocheck
-var utils_1 = require("../../../shared/utils");
-var window_1 = require("../../../ssr-window/window");
+var utils_1 = require("../../../shared/utils.js");
+var window_1 = require("../../../ssr-window/window.js");
 function Observer(_a) {
     var swiper = _a.swiper, extendParams = _a.extendParams, on = _a.on, emit = _a.emit;
     var observers = [];

package/dist/ui/components/carousel/carousel-lib/core/modules/resize/resize.js

@@ -1,7 +1,7 @@
 "use strict";
 //@ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
-var window_1 = require("../../../ssr-window/window");
+var window_1 = require("../../../ssr-window/window.js");
 function Resize(_a) {
     var swiper = _a.swiper, on = _a.on, emit = _a.emit;
     var window = (0, window_1.getWindow)();

package/dist/ui/components/carousel/carousel-lib/core/slide/index.d.ts

@@ -0,0 +1,17 @@
+import slideTo from './slideTo.js';
+import slideToLoop from './slideToLoop.js';
+import slideNext from './slideNext.js';
+import slidePrev from './slidePrev.js';
+import slideReset from './slideReset.js';
+import slideToClosest from './slideToClosest.js';
+import slideToClickedSlide from './slideToClickedSlide.js';
+declare const _default: {
+    slideTo: typeof slideTo;
+    slideToLoop: typeof slideToLoop;
+    slideNext: typeof slideNext;
+    slidePrev: typeof slidePrev;
+    slideReset: typeof slideReset;
+    slideToClosest: typeof slideToClosest;
+    slideToClickedSlide: typeof slideToClickedSlide;
+};
+export default _default;

package/dist/ui/components/carousel/carousel-lib/core/slide/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var slideTo_1 = __importDefault(require("./slideTo.js"));
+var slideToLoop_1 = __importDefault(require("./slideToLoop.js"));
+var slideNext_1 = __importDefault(require("./slideNext.js"));
+var slidePrev_1 = __importDefault(require("./slidePrev.js"));
+var slideReset_1 = __importDefault(require("./slideReset.js"));
+var slideToClosest_1 = __importDefault(require("./slideToClosest.js"));
+var slideToClickedSlide_1 = __importDefault(require("./slideToClickedSlide.js"));
+exports.default = {
+    slideTo: slideTo_1.default,
+    slideToLoop: slideToLoop_1.default,
+    slideNext: slideNext_1.default,
+    slidePrev: slidePrev_1.default,
+    slideReset: slideReset_1.default,
+    slideToClosest: slideToClosest_1.default,
+    slideToClickedSlide: slideToClickedSlide_1.default,
+};
+//# sourceMappingURL=index.js.map

package/dist/ui/components/carousel/carousel-lib/core/slide/slideTo.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../shared/utils.js");
+function slideTo(index, speed, runCallbacks, internal, initial) {
+    var _a;
+    if (index === void 0) { index = 0; }
+    if (runCallbacks === void 0) { runCallbacks = true; }
+    if (typeof index === 'string') {
+        index = parseInt(index, 10);
+    }
+    var swiper = this;
+    var slideIndex = index;
+    if (slideIndex < 0)
+        slideIndex = 0;
+    var params = swiper.params, snapGrid = swiper.snapGrid, slidesGrid = swiper.slidesGrid, previousIndex = swiper.previousIndex, activeIndex = swiper.activeIndex, rtl = swiper.rtlTranslate, wrapperEl = swiper.wrapperEl, enabled = swiper.enabled;
+    if ((!enabled && !internal && !initial) ||
+        swiper.destroyed ||
+        (swiper.animating && params.preventInteractionOnTransition)) {
+        return false;
+    }
+    if (typeof speed === 'undefined') {
+        speed = swiper.params.speed;
+    }
+    var skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
+    var snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
+    if (snapIndex >= snapGrid.length)
+        snapIndex = snapGrid.length - 1;
+    var translate = -snapGrid[snapIndex];
+    // Normalize slideIndex
+    if (params.normalizeSlideIndex) {
+        for (var i = 0; i < slidesGrid.length; i += 1) {
+            var normalizedTranslate = -Math.floor(translate * 100);
+            var normalizedGrid = Math.floor(slidesGrid[i] * 100);
+            var normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
+            if (typeof slidesGrid[i + 1] !== 'undefined') {
+                if (normalizedTranslate >= normalizedGrid &&
+                    normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
+                    slideIndex = i;
+                }
+                else if (normalizedTranslate >= normalizedGrid &&
+                    normalizedTranslate < normalizedGridNext) {
+                    slideIndex = i + 1;
+                }
+            }
+            else if (normalizedTranslate >= normalizedGrid) {
+                slideIndex = i;
+            }
+        }
+    }
+    // Directions locks
+    if (swiper.initialized && slideIndex !== activeIndex) {
+        if (!swiper.allowSlideNext &&
+            (rtl
+                ? translate > swiper.translate && translate > swiper.minTranslate()
+                : translate < swiper.translate && translate < swiper.minTranslate())) {
+            return false;
+        }
+        if (!swiper.allowSlidePrev &&
+            translate > swiper.translate &&
+            translate > swiper.maxTranslate()) {
+            if ((activeIndex || 0) !== slideIndex) {
+                return false;
+            }
+        }
+    }
+    if (slideIndex !== (previousIndex || 0) && runCallbacks) {
+        swiper.emit('beforeSlideChangeStart');
+    }
+    // Update progress
+    swiper.updateProgress(translate);
+    var direction;
+    if (slideIndex > activeIndex)
+        direction = 'next';
+    else if (slideIndex < activeIndex)
+        direction = 'prev';
+    else
+        direction = 'reset';
+    // Update Index
+    if ((rtl && -translate === swiper.translate) || (!rtl && translate === swiper.translate)) {
+        swiper.updateActiveIndex(slideIndex);
+        // Update Height
+        if (params.autoHeight) {
+            swiper.updateAutoHeight();
+        }
+        swiper.updateSlidesClasses();
+        if (params.effect !== 'slide') {
+            swiper.setTranslate(translate);
+        }
+        if (direction !== 'reset') {
+            swiper.transitionStart(runCallbacks, direction);
+            swiper.transitionEnd(runCallbacks, direction);
+        }
+        return false;
+    }
+    if (params.cssMode) {
+        var isH_1 = swiper.isHorizontal();
+        var t_1 = rtl ? translate : -translate;
+        if (speed === 0) {
+            var isVirtual = swiper.virtual && swiper.params.virtual.enabled;
+            if (isVirtual) {
+                swiper.wrapperEl.style.scrollSnapType = 'none';
+                swiper._immediateVirtual = true;
+            }
+            if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
+                swiper._cssModeVirtualInitialSet = true;
+                requestAnimationFrame(function () {
+                    wrapperEl[isH_1 ? 'scrollLeft' : 'scrollTop'] = t_1;
+                });
+            }
+            else {
+                wrapperEl[isH_1 ? 'scrollLeft' : 'scrollTop'] = t_1;
+            }
+            if (isVirtual) {
+                requestAnimationFrame(function () {
+                    swiper.wrapperEl.style.scrollSnapType = '';
+                    swiper._immediateVirtual = false;
+                });
+            }
+        }
+        else {
+            if (!swiper.support.smoothScroll) {
+                (0, utils_1.animateCSSModeScroll)({ swiper: swiper, targetPosition: t_1, side: isH_1 ? 'left' : 'top' });
+                return true;
+            }
+            wrapperEl.scrollTo((_a = {},
+                _a[isH_1 ? 'left' : 'top'] = t_1,
+                _a.behavior = 'smooth',
+                _a));
+        }
+        return true;
+    }
+    swiper.setTransition(speed);
+    swiper.setTranslate(translate);
+    swiper.updateActiveIndex(slideIndex);
+    swiper.updateSlidesClasses();
+    swiper.emit('beforeTransitionStart', speed, internal);
+    swiper.transitionStart(runCallbacks, direction);
+    if (speed === 0) {
+        swiper.transitionEnd(runCallbacks, direction);
+    }
+    else if (!swiper.animating) {
+        swiper.animating = true;
+        if (!swiper.onSlideToWrapperTransitionEnd) {
+            swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
+                if (!swiper || swiper.destroyed)
+                    return;
+                if (e.target !== this)
+                    return;
+                swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
+                swiper.onSlideToWrapperTransitionEnd = null;
+                delete swiper.onSlideToWrapperTransitionEnd;
+                swiper.transitionEnd(runCallbacks, direction);
+            };
+        }
+        swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
+    }
+    return true;
+}
+exports.default = slideTo;
+//# sourceMappingURL=slideTo.js.map

package/dist/ui/components/carousel/carousel-lib/core/slide/slideToClickedSlide.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../shared/utils.js");
+function slideToClickedSlide() {
+    var swiper = this;
+    if (swiper.destroyed)
+        return;
+    var params = swiper.params, slidesEl = swiper.slidesEl;
+    var slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
+    var slideToIndex = swiper.clickedIndex;
+    var realIndex;
+    var slideSelector = swiper.isElement ? "swiper-slide" : ".".concat(params.slideClass);
+    if (params.loop) {
+        if (swiper.animating)
+            return;
+        realIndex = parseInt(swiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);
+        if (params.centeredSlides) {
+            if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 ||
+                slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
+                swiper.loopFix();
+                slideToIndex = swiper.getSlideIndex((0, utils_1.elementChildren)(slidesEl, "".concat(slideSelector, "[data-swiper-slide-index=\"").concat(realIndex, "\"]"))[0]);
+                (0, utils_1.nextTick)(function () {
+                    swiper.slideTo(slideToIndex);
+                });
+            }
+            else {
+                swiper.slideTo(slideToIndex);
+            }
+        }
+        else if (slideToIndex > swiper.slides.length - slidesPerView) {
+            swiper.loopFix();
+            slideToIndex = swiper.getSlideIndex((0, utils_1.elementChildren)(slidesEl, "".concat(slideSelector, "[data-swiper-slide-index=\"").concat(realIndex, "\"]"))[0]);
+            (0, utils_1.nextTick)(function () {
+                swiper.slideTo(slideToIndex);
+            });
+        }
+        else {
+            swiper.slideTo(slideToIndex);
+        }
+    }
+    else {
+        swiper.slideTo(slideToIndex);
+    }
+}
+exports.default = slideToClickedSlide;
+//# sourceMappingURL=slideToClickedSlide.js.map

package/dist/ui/components/carousel/carousel-lib/core/transition/index.d.ts

@@ -0,0 +1,9 @@
+import setTransition from './setTransition.js';
+import transitionStart from './transitionStart.js';
+import transitionEnd from './transitionEnd.js';
+declare const _default: {
+    setTransition: typeof setTransition;
+    transitionStart: typeof transitionStart;
+    transitionEnd: typeof transitionEnd;
+};
+export default _default;

package/dist/ui/components/carousel/carousel-lib/core/transition/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var setTransition_1 = __importDefault(require("./setTransition.js"));
+var transitionStart_1 = __importDefault(require("./transitionStart.js"));
+var transitionEnd_1 = __importDefault(require("./transitionEnd.js"));
+exports.default = {
+    setTransition: setTransition_1.default,
+    transitionStart: transitionStart_1.default,
+    transitionEnd: transitionEnd_1.default,
+};
+//# sourceMappingURL=index.js.map

package/dist/ui/components/carousel/carousel-lib/core/transition/transitionEnd.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var transitionEmit_1 = __importDefault(require("./transitionEmit.js"));
+function transitionEnd(runCallbacks, direction) {
+    if (runCallbacks === void 0) { runCallbacks = true; }
+    var swiper = this;
+    var params = swiper.params;
+    swiper.animating = false;
+    if (params.cssMode)
+        return;
+    swiper.setTransition(0);
+    (0, transitionEmit_1.default)({ swiper: swiper, runCallbacks: runCallbacks, direction: direction, step: 'End' });
+}
+exports.default = transitionEnd;
+//# sourceMappingURL=transitionEnd.js.map

package/dist/ui/components/carousel/carousel-lib/core/transition/transitionStart.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var transitionEmit_1 = __importDefault(require("./transitionEmit.js"));
+function transitionStart(runCallbacks, direction) {
+    if (runCallbacks === void 0) { runCallbacks = true; }
+    var swiper = this;
+    var params = swiper.params;
+    if (params.cssMode)
+        return;
+    if (params.autoHeight) {
+        swiper.updateAutoHeight();
+    }
+    (0, transitionEmit_1.default)({ swiper: swiper, runCallbacks: runCallbacks, direction: direction, step: 'Start' });
+}
+exports.default = transitionStart;
+//# sourceMappingURL=transitionStart.js.map

package/dist/ui/components/carousel/carousel-lib/core/translate/getTranslate.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../shared/utils.js");
+function getSwiperTranslate(axis) {
+    if (axis === void 0) { axis = this.isHorizontal() ? 'x' : 'y'; }
+    var swiper = this;
+    var params = swiper.params, rtl = swiper.rtlTranslate, translate = swiper.translate, wrapperEl = swiper.wrapperEl;
+    if (params.virtualTranslate) {
+        return rtl ? -translate : translate;
+    }
+    if (params.cssMode) {
+        return translate;
+    }
+    var currentTranslate = (0, utils_1.getTranslate)(wrapperEl, axis);
+    currentTranslate += swiper.cssOverflowAdjustment();
+    if (rtl)
+        currentTranslate = -currentTranslate;
+    return currentTranslate || 0;
+}
+exports.default = getSwiperTranslate;
+//# sourceMappingURL=getTranslate.js.map

package/dist/ui/components/carousel/carousel-lib/core/translate/index.d.ts

@@ -0,0 +1,13 @@
+import getTranslate from './getTranslate.js';
+import setTranslate from './setTranslate.js';
+import minTranslate from './minTranslate.js';
+import maxTranslate from './maxTranslate.js';
+import translateTo from './translateTo.js';
+declare const _default: {
+    getTranslate: typeof getTranslate;
+    setTranslate: typeof setTranslate;
+    minTranslate: typeof minTranslate;
+    maxTranslate: typeof maxTranslate;
+    translateTo: typeof translateTo;
+};
+export default _default;

package/dist/ui/components/carousel/carousel-lib/core/translate/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getTranslate_1 = __importDefault(require("./getTranslate.js"));
+var setTranslate_1 = __importDefault(require("./setTranslate.js"));
+var minTranslate_1 = __importDefault(require("./minTranslate.js"));
+var maxTranslate_1 = __importDefault(require("./maxTranslate.js"));
+var translateTo_1 = __importDefault(require("./translateTo.js"));
+exports.default = {
+    getTranslate: getTranslate_1.default,
+    setTranslate: setTranslate_1.default,
+    minTranslate: minTranslate_1.default,
+    maxTranslate: maxTranslate_1.default,
+    translateTo: translateTo_1.default,
+};
+//# sourceMappingURL=index.js.map