infinity-forge 2.4.0 → 2.4.2

package/dist/ui/components/carousel/carousel-lib/core/events/onTouchStart.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-nocheck
+var utils_1 = require("../../shared/utils");
+var document_1 = require("../../ssr-window/document");
+var window_1 = require("../../ssr-window/window");
+// Modified from https://stackoverflow.com/questions/54520554/custom-element-getrootnode-closest-function-crossing-multiple-parent-shadowd
+function closestElement(selector, base) {
+    if (base === void 0) { base = this; }
+    function __closestFrom(el) {
+        if (!el || el === (0, document_1.getDocument)() || el === (0, window_1.getWindow)())
+            return null;
+        if (el.assignedSlot)
+            el = el.assignedSlot;
+        var found = el.closest(selector);
+        if (!found && !el.getRootNode) {
+            return null;
+        }
+        return found || __closestFrom(el.getRootNode().host);
+    }
+    return __closestFrom(base);
+}
+function preventEdgeSwipe(swiper, event, startX) {
+    var window = (0, window_1.getWindow)();
+    var params = swiper.params;
+    var edgeSwipeDetection = params.edgeSwipeDetection;
+    var edgeSwipeThreshold = params.edgeSwipeThreshold;
+    if (edgeSwipeDetection &&
+        (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
+        if (edgeSwipeDetection === 'prevent') {
+            event.preventDefault();
+            return true;
+        }
+        return false;
+    }
+    return true;
+}
+function onTouchStart(event) {
+    var swiper = this;
+    var document = (0, document_1.getDocument)();
+    var e = event;
+    if (e.originalEvent)
+        e = e.originalEvent;
+    var data = swiper.touchEventsData;
+    if (e.type === 'pointerdown') {
+        if (data.pointerId !== null && data.pointerId !== e.pointerId) {
+            return;
+        }
+        data.pointerId = e.pointerId;
+    }
+    else if (e.type === 'touchstart' && e.targetTouches.length === 1) {
+        data.touchId = e.targetTouches[0].identifier;
+    }
+    if (e.type === 'touchstart') {
+        // don't proceed touch event
+        preventEdgeSwipe(swiper, e, e.targetTouches[0].pageX);
+        return;
+    }
+    var params = swiper.params, touches = swiper.touches, enabled = swiper.enabled;
+    if (!enabled)
+        return;
+    if (!params.simulateTouch && e.pointerType === 'mouse')
+        return;
+    if (swiper.animating && params.preventInteractionOnTransition) {
+        return;
+    }
+    if (!swiper.animating && params.cssMode && params.loop) {
+        swiper.loopFix();
+    }
+    var targetEl = e.target;
+    if (params.touchEventsTarget === 'wrapper') {
+        if (!swiper.wrapperEl.contains(targetEl))
+            return;
+    }
+    if ('which' in e && e.which === 3)
+        return;
+    if ('button' in e && e.button > 0)
+        return;
+    if (data.isTouched && data.isMoved)
+        return;
+    // change target el for shadow root component
+    var swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== '';
+    // eslint-disable-next-line
+    var eventPath = e.composedPath ? e.composedPath() : e.path;
+    if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
+        targetEl = eventPath[0];
+    }
+    var noSwipingSelector = params.noSwipingSelector
+        ? params.noSwipingSelector
+        : ".".concat(params.noSwipingClass);
+    var isTargetShadow = !!(e.target && e.target.shadowRoot);
+    // use closestElement for shadow root element to get the actual closest for nested shadow root element
+    if (params.noSwiping &&
+        (isTargetShadow
+            ? closestElement(noSwipingSelector, targetEl)
+            : targetEl.closest(noSwipingSelector))) {
+        swiper.allowClick = true;
+        return;
+    }
+    if (params.swipeHandler) {
+        if (!targetEl.closest(params.swipeHandler))
+            return;
+    }
+    touches.currentX = e.pageX;
+    touches.currentY = e.pageY;
+    var startX = touches.currentX;
+    var startY = touches.currentY;
+    // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
+    if (!preventEdgeSwipe(swiper, e, startX)) {
+        return;
+    }
+    Object.assign(data, {
+        isTouched: true,
+        isMoved: false,
+        allowTouchCallbacks: true,
+        isScrolling: undefined,
+        startMoving: undefined,
+    });
+    touches.startX = startX;
+    touches.startY = startY;
+    data.touchStartTime = (0, utils_1.now)();
+    swiper.allowClick = true;
+    swiper.updateSize();
+    swiper.swipeDirection = undefined;
+    if (params.threshold > 0)
+        data.allowThresholdMove = false;
+    var preventDefault = true;
+    if (targetEl.matches(data.focusableElements)) {
+        preventDefault = false;
+        if (targetEl.nodeName === 'SELECT') {
+            data.isTouched = false;
+        }
+    }
+    if (document.activeElement &&
+        document.activeElement.matches(data.focusableElements) &&
+        document.activeElement !== targetEl) {
+        document.activeElement.blur();
+    }
+    var shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
+    if ((params.touchStartForcePreventDefault || shouldPreventDefault) &&
+        !targetEl.isContentEditable) {
+        e.preventDefault();
+    }
+    if (params.freeMode &&
+        params.freeMode.enabled &&
+        swiper.freeMode &&
+        swiper.animating &&
+        !params.cssMode) {
+        swiper.freeMode.onTouchStart();
+    }
+    swiper.emit('touchStart', e);
+}
+exports.default = onTouchStart;
+//# sourceMappingURL=onTouchStart.js.map

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

@@ -0,0 +1,7 @@
+import setGrabCursor from './setGrabCursor';
+import unsetGrabCursor from './unsetGrabCursor';
+declare const _default: {
+    setGrabCursor: typeof setGrabCursor;
+    unsetGrabCursor: typeof unsetGrabCursor;
+};
+export default _default;

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

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var setGrabCursor_1 = __importDefault(require("./setGrabCursor"));
+var unsetGrabCursor_1 = __importDefault(require("./unsetGrabCursor"));
+exports.default = {
+    setGrabCursor: setGrabCursor_1.default,
+    unsetGrabCursor: unsetGrabCursor_1.default,
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,9 @@
+import loopCreate from './loopCreate';
+import loopFix from './loopFix';
+import loopDestroy from './loopDestroy';
+declare const _default: {
+    loopCreate: typeof loopCreate;
+    loopFix: typeof loopFix;
+    loopDestroy: typeof loopDestroy;
+};
+export default _default;

package/dist/ui/components/carousel/carousel-lib/core/loop/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 loopCreate_1 = __importDefault(require("./loopCreate"));
+var loopFix_1 = __importDefault(require("./loopFix"));
+var loopDestroy_1 = __importDefault(require("./loopDestroy"));
+exports.default = {
+    loopCreate: loopCreate_1.default,
+    loopFix: loopFix_1.default,
+    loopDestroy: loopDestroy_1.default,
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../shared/utils");
+function loopCreate(slideRealIndex) {
+    var swiper = this;
+    var params = swiper.params, slidesEl = swiper.slidesEl;
+    if (!params.loop || (swiper.virtual && swiper.params.virtual.enabled))
+        return;
+    var initSlides = function () {
+        var slides = (0, utils_1.elementChildren)(slidesEl, ".".concat(params.slideClass, ", swiper-slide"));
+        slides.forEach(function (el, index) {
+            el.setAttribute('data-swiper-slide-index', index);
+        });
+    };
+    var gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
+    var slidesPerGroup = params.slidesPerGroup * (gridEnabled ? params.grid.rows : 1);
+    var shouldFillGroup = swiper.slides.length % slidesPerGroup !== 0;
+    var shouldFillGrid = gridEnabled && swiper.slides.length % params.grid.rows !== 0;
+    var addBlankSlides = function (amountOfSlides) {
+        for (var i = 0; i < amountOfSlides; i += 1) {
+            var slideEl = swiper.isElement
+                ? (0, utils_1.createElement)('swiper-slide', [params.slideBlankClass])
+                : (0, utils_1.createElement)('div', [params.slideClass, params.slideBlankClass]);
+            swiper.slidesEl.append(slideEl);
+        }
+    };
+    if (shouldFillGroup) {
+        if (params.loopAddBlankSlides) {
+            var slidesToAdd = slidesPerGroup - (swiper.slides.length % slidesPerGroup);
+            addBlankSlides(slidesToAdd);
+            swiper.recalcSlides();
+            swiper.updateSlides();
+        }
+        else {
+            (0, utils_1.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)');
+        }
+        initSlides();
+    }
+    else if (shouldFillGrid) {
+        if (params.loopAddBlankSlides) {
+            var slidesToAdd = params.grid.rows - (swiper.slides.length % params.grid.rows);
+            addBlankSlides(slidesToAdd);
+            swiper.recalcSlides();
+            swiper.updateSlides();
+        }
+        else {
+            (0, utils_1.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)');
+        }
+        initSlides();
+    }
+    else {
+        initSlides();
+    }
+    swiper.loopFix({ slideRealIndex: slideRealIndex, direction: params.centeredSlides ? undefined : 'next' });
+}
+exports.default = loopCreate;
+//# sourceMappingURL=loopCreate.js.map

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");
+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/moduleExtendParams.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var utils_1 = require("../shared/utils.js");
-function moduleExtendParams(params, allModulesParams) {
-    return function extendParams(obj) {
-        if (obj === void 0) { obj = {}; }
-        var moduleParamName = Object.keys(obj)[0];
-        var moduleParams = obj[moduleParamName];
-        if (typeof moduleParams !== 'object' || moduleParams === null) {
-            (0, utils_1.extend)(allModulesParams, obj);
-            return;
-        }
-        if (params[moduleParamName] === true) {
-            params[moduleParamName] = { enabled: true };
-        }
-        if (moduleParamName === 'navigation' &&
-            params[moduleParamName] &&
-            params[moduleParamName].enabled &&
-            !params[moduleParamName].prevEl &&
-            !params[moduleParamName].nextEl) {
-            params[moduleParamName].auto = true;
-        }
-        if (['pagination', 'scrollbar'].indexOf(moduleParamName) >= 0 &&
-            params[moduleParamName] &&
-            params[moduleParamName].enabled &&
-            !params[moduleParamName].el) {
-            params[moduleParamName].auto = true;
-        }
-        if (!(moduleParamName in params && 'enabled' in moduleParams)) {
-            (0, utils_1.extend)(allModulesParams, obj);
-            return;
-        }
-        if (typeof params[moduleParamName] === 'object' && !('enabled' in params[moduleParamName])) {
-            params[moduleParamName].enabled = true;
-        }
-        if (!params[moduleParamName])
-            params[moduleParamName] = { enabled: false };
-        (0, utils_1.extend)(allModulesParams, obj);
-    };
-}
-exports.default = moduleExtendParams;
-//# sourceMappingURL=moduleExtendParams.js.map

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

@@ -0,0 +1,17 @@
+import slideTo from './slideTo';
+import slideToLoop from './slideToLoop';
+import slideNext from './slideNext';
+import slidePrev from './slidePrev';
+import slideReset from './slideReset';
+import slideToClosest from './slideToClosest';
+import slideToClickedSlide from './slideToClickedSlide';
+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"));
+var slideToLoop_1 = __importDefault(require("./slideToLoop"));
+var slideNext_1 = __importDefault(require("./slideNext"));
+var slidePrev_1 = __importDefault(require("./slidePrev"));
+var slideReset_1 = __importDefault(require("./slideReset"));
+var slideToClosest_1 = __importDefault(require("./slideToClosest"));
+var slideToClickedSlide_1 = __importDefault(require("./slideToClickedSlide"));
+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