infinity-forge 2.4.2 → 2.4.4

package/dist/ui/components/carousel/carousel-lib/modules/autoplay.js

@@ -0,0 +1,336 @@
+"use strict";
+/* eslint no-underscore-dangle: "off" */
+/* eslint no-use-before-define: "off" */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Autoplay = void 0;
+var document_1 = require("../ssr-window/document.js");
+function Autoplay(_a) {
+    var swiper = _a.swiper, extendParams = _a.extendParams, on = _a.on, emit = _a.emit, params = _a.params;
+    swiper.autoplay = {
+        running: false,
+        paused: false,
+        timeLeft: 0,
+    };
+    extendParams({
+        autoplay: {
+            enabled: false,
+            delay: 3000,
+            waitForTransition: true,
+            disableOnInteraction: false,
+            stopOnLastSlide: false,
+            reverseDirection: false,
+            pauseOnMouseEnter: false,
+        },
+    });
+    var timeout;
+    var raf;
+    var autoplayDelayTotal = params && params.autoplay ? params.autoplay.delay : 3000;
+    var autoplayDelayCurrent = params && params.autoplay ? params.autoplay.delay : 3000;
+    var autoplayTimeLeft;
+    var autoplayStartTime = new Date().getTime();
+    var wasPaused;
+    var isTouched;
+    var pausedByTouch;
+    var touchStartTimeout;
+    var slideChanged;
+    var pausedByInteraction;
+    var pausedByPointerEnter;
+    function onTransitionEnd(e) {
+        if (!swiper || swiper.destroyed || !swiper.wrapperEl)
+            return;
+        if (e.target !== swiper.wrapperEl)
+            return;
+        swiper.wrapperEl.removeEventListener('transitionend', onTransitionEnd);
+        if (pausedByPointerEnter || (e.detail && e.detail.bySwiperTouchMove)) {
+            return;
+        }
+        resume();
+    }
+    var calcTimeLeft = function () {
+        if (swiper.destroyed || !swiper.autoplay.running)
+            return;
+        if (swiper.autoplay.paused) {
+            wasPaused = true;
+        }
+        else if (wasPaused) {
+            autoplayDelayCurrent = autoplayTimeLeft;
+            wasPaused = false;
+        }
+        var timeLeft = swiper.autoplay.paused
+            ? autoplayTimeLeft
+            : autoplayStartTime + autoplayDelayCurrent - new Date().getTime();
+        swiper.autoplay.timeLeft = timeLeft;
+        emit('autoplayTimeLeft', timeLeft, timeLeft / autoplayDelayTotal);
+        raf = requestAnimationFrame(function () {
+            calcTimeLeft();
+        });
+    };
+    var getSlideDelay = function () {
+        var activeSlideEl;
+        if (swiper.virtual && swiper.params.virtual.enabled) {
+            activeSlideEl = swiper.slides.filter(function (slideEl) {
+                return slideEl.classList.contains('swiper-slide-active');
+            })[0];
+        }
+        else {
+            activeSlideEl = swiper.slides[swiper.activeIndex];
+        }
+        if (!activeSlideEl)
+            return undefined;
+        var currentSlideDelay = parseInt(activeSlideEl.getAttribute('data-swiper-autoplay'), 10);
+        return currentSlideDelay;
+    };
+    var run = function (delayForce) {
+        if (swiper.destroyed || !swiper.autoplay.running)
+            return;
+        cancelAnimationFrame(raf);
+        calcTimeLeft();
+        var delay = typeof delayForce === 'undefined' ? swiper.params.autoplay.delay : delayForce;
+        autoplayDelayTotal = swiper.params.autoplay.delay;
+        autoplayDelayCurrent = swiper.params.autoplay.delay;
+        var currentSlideDelay = getSlideDelay();
+        if (!Number.isNaN(currentSlideDelay) &&
+            currentSlideDelay > 0 &&
+            typeof delayForce === 'undefined') {
+            delay = currentSlideDelay;
+            autoplayDelayTotal = currentSlideDelay;
+            autoplayDelayCurrent = currentSlideDelay;
+        }
+        autoplayTimeLeft = delay;
+        var speed = swiper.params.speed;
+        var proceed = function () {
+            if (!swiper || swiper.destroyed)
+                return;
+            if (swiper.params.autoplay.reverseDirection) {
+                if (!swiper.isBeginning || swiper.params.loop || swiper.params.rewind) {
+                    swiper.slidePrev(speed, true, true);
+                    emit('autoplay');
+                }
+                else if (!swiper.params.autoplay.stopOnLastSlide) {
+                    swiper.slideTo(swiper.slides.length - 1, speed, true, true);
+                    emit('autoplay');
+                }
+            }
+            else {
+                if (!swiper.isEnd || swiper.params.loop || swiper.params.rewind) {
+                    swiper.slideNext(speed, true, true);
+                    emit('autoplay');
+                }
+                else if (!swiper.params.autoplay.stopOnLastSlide) {
+                    swiper.slideTo(0, speed, true, true);
+                    emit('autoplay');
+                }
+            }
+            if (swiper.params.cssMode) {
+                autoplayStartTime = new Date().getTime();
+                requestAnimationFrame(function () {
+                    run(undefined);
+                });
+            }
+        };
+        if (delay > 0) {
+            clearTimeout(timeout);
+            timeout = setTimeout(function () {
+                proceed();
+            }, delay);
+        }
+        else {
+            requestAnimationFrame(function () {
+                proceed();
+            });
+        }
+        // eslint-disable-next-line
+        return delay;
+    };
+    var start = function () {
+        autoplayStartTime = new Date().getTime();
+        swiper.autoplay.running = true;
+        run(undefined);
+        emit('autoplayStart');
+    };
+    var stop = function () {
+        swiper.autoplay.running = false;
+        clearTimeout(timeout);
+        cancelAnimationFrame(raf);
+        emit('autoplayStop');
+    };
+    var pause = function (internal, reset) {
+        if (swiper.destroyed || !swiper.autoplay.running)
+            return;
+        clearTimeout(timeout);
+        if (!internal) {
+            pausedByInteraction = true;
+        }
+        var proceed = function () {
+            emit('autoplayPause');
+            if (swiper.params.autoplay.waitForTransition) {
+                swiper.wrapperEl.addEventListener('transitionend', onTransitionEnd);
+            }
+            else {
+                resume();
+            }
+        };
+        swiper.autoplay.paused = true;
+        if (reset) {
+            if (slideChanged) {
+                autoplayTimeLeft = swiper.params.autoplay.delay;
+            }
+            slideChanged = false;
+            proceed();
+            return;
+        }
+        var delay = autoplayTimeLeft || swiper.params.autoplay.delay;
+        autoplayTimeLeft = delay - (new Date().getTime() - autoplayStartTime);
+        if (swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop)
+            return;
+        if (autoplayTimeLeft < 0)
+            autoplayTimeLeft = 0;
+        proceed();
+    };
+    var resume = function () {
+        if ((swiper.isEnd && autoplayTimeLeft < 0 && !swiper.params.loop) ||
+            swiper.destroyed ||
+            !swiper.autoplay.running)
+            return;
+        autoplayStartTime = new Date().getTime();
+        if (pausedByInteraction) {
+            pausedByInteraction = false;
+            run(autoplayTimeLeft);
+        }
+        else {
+            run(undefined);
+        }
+        swiper.autoplay.paused = false;
+        emit('autoplayResume');
+    };
+    var onVisibilityChange = function () {
+        if (swiper.destroyed || !swiper.autoplay.running)
+            return;
+        var document = (0, document_1.getDocument)();
+        if (document.visibilityState === 'hidden') {
+            pausedByInteraction = true;
+            pause(true, undefined);
+        }
+        if (document.visibilityState === 'visible') {
+            resume();
+        }
+    };
+    var onPointerEnter = function (e) {
+        if (e.pointerType !== 'mouse')
+            return;
+        pausedByInteraction = true;
+        pausedByPointerEnter = true;
+        if (swiper.animating || swiper.autoplay.paused)
+            return;
+        pause(true, undefined);
+    };
+    var onPointerLeave = function (e) {
+        if (e.pointerType !== 'mouse')
+            return;
+        pausedByPointerEnter = false;
+        if (swiper.autoplay.paused) {
+            resume();
+        }
+    };
+    var attachMouseEvents = function () {
+        if (swiper.params.autoplay.pauseOnMouseEnter) {
+            swiper.el.addEventListener('pointerenter', onPointerEnter);
+            swiper.el.addEventListener('pointerleave', onPointerLeave);
+        }
+    };
+    var detachMouseEvents = function () {
+        if (swiper.el && typeof swiper.el !== 'string') {
+            swiper.el.removeEventListener('pointerenter', onPointerEnter);
+            swiper.el.removeEventListener('pointerleave', onPointerLeave);
+        }
+    };
+    var attachDocumentEvents = function () {
+        var document = (0, document_1.getDocument)();
+        document.addEventListener('visibilitychange', onVisibilityChange);
+    };
+    var detachDocumentEvents = function () {
+        var document = (0, document_1.getDocument)();
+        document.removeEventListener('visibilitychange', onVisibilityChange);
+    };
+    on('init', function () {
+        if (swiper.params.autoplay.enabled) {
+            attachMouseEvents();
+            attachDocumentEvents();
+            start();
+        }
+    });
+    on('destroy', function () {
+        detachMouseEvents();
+        detachDocumentEvents();
+        if (swiper.autoplay.running) {
+            stop();
+        }
+    });
+    on('_freeModeStaticRelease', function () {
+        if (pausedByTouch || pausedByInteraction) {
+            resume();
+        }
+    });
+    on('_freeModeNoMomentumRelease', function () {
+        if (!swiper.params.autoplay.disableOnInteraction) {
+            pause(true, true);
+        }
+        else {
+            stop();
+        }
+    });
+    on('beforeTransitionStart', function (_s, speed, internal) {
+        if (swiper.destroyed || !swiper.autoplay.running)
+            return;
+        if (internal || !swiper.params.autoplay.disableOnInteraction) {
+            pause(true, true);
+        }
+        else {
+            stop();
+        }
+    });
+    on('sliderFirstMove', function () {
+        if (swiper.destroyed || !swiper.autoplay.running)
+            return;
+        if (swiper.params.autoplay.disableOnInteraction) {
+            stop();
+            return;
+        }
+        isTouched = true;
+        pausedByTouch = false;
+        pausedByInteraction = false;
+        touchStartTimeout = setTimeout(function () {
+            pausedByInteraction = true;
+            pausedByTouch = true;
+            pause(true, undefined);
+        }, 200);
+    });
+    on('touchEnd', function () {
+        if (swiper.destroyed || !swiper.autoplay.running || !isTouched)
+            return;
+        clearTimeout(touchStartTimeout);
+        clearTimeout(timeout);
+        if (swiper.params.autoplay.disableOnInteraction) {
+            pausedByTouch = false;
+            isTouched = false;
+            return;
+        }
+        if (pausedByTouch && swiper.params.cssMode)
+            resume();
+        pausedByTouch = false;
+        isTouched = false;
+    });
+    on('slideChange', function () {
+        if (swiper.destroyed || !swiper.autoplay.running)
+            return;
+        slideChanged = true;
+    });
+    Object.assign(swiper.autoplay, {
+        start: start,
+        stop: stop,
+        pause: pause,
+        resume: resume,
+    });
+}
+exports.Autoplay = Autoplay;
+//# sourceMappingURL=autoplay.js.map

package/dist/ui/components/carousel/carousel-lib/modules/effect-fade.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectFade = void 0;
+var effect_init_1 = __importDefault(require("../shared/effect-init.js"));
+var effect_target_1 = __importDefault(require("../shared/effect-target.js"));
+var effect_virtual_transition_end_1 = __importDefault(require("../shared/effect-virtual-transition-end.js"));
+var utils_1 = require("../shared/utils.js");
+function EffectFade(_a) {
+    var swiper = _a.swiper, extendParams = _a.extendParams, on = _a.on;
+    extendParams({
+        fadeEffect: {
+            crossFade: false,
+        },
+    });
+    var setTranslate = function () {
+        var slides = swiper.slides;
+        var params = swiper.params.fadeEffect;
+        for (var i = 0; i < slides.length; i += 1) {
+            var slideEl = swiper.slides[i];
+            var offset = slideEl.swiperSlideOffset;
+            var tx = -offset;
+            if (!swiper.params.virtualTranslate)
+                tx -= swiper.translate;
+            var ty = 0;
+            if (!swiper.isHorizontal()) {
+                ty = tx;
+                tx = 0;
+            }
+            var slideOpacity = swiper.params.fadeEffect.crossFade
+                ? Math.max(1 - Math.abs(slideEl.progress), 0)
+                : 1 + Math.min(Math.max(slideEl.progress, -1), 0);
+            var targetEl = (0, effect_target_1.default)(params, slideEl);
+            targetEl.style.opacity = slideOpacity;
+            targetEl.style.transform = "translate3d(".concat(tx, "px, ").concat(ty, "px, 0px)");
+        }
+    };
+    var setTransition = function (duration) {
+        var transformElements = swiper.slides.map(function (slideEl) { return (0, utils_1.getSlideTransformEl)(slideEl); });
+        transformElements.forEach(function (el) {
+            el.style.transitionDuration = "".concat(duration, "ms");
+        });
+        (0, effect_virtual_transition_end_1.default)({ swiper: swiper, duration: duration, transformElements: transformElements, allSlides: true });
+    };
+    (0, effect_init_1.default)({
+        effect: 'fade',
+        swiper: swiper,
+        on: on,
+        setTranslate: setTranslate,
+        setTransition: setTransition,
+        overwriteParams: function () { return ({
+            slidesPerView: 1,
+            slidesPerGroup: 1,
+            watchSlidesProgress: true,
+            spaceBetween: 0,
+            virtualTranslate: !swiper.params.cssMode,
+        }); },
+    });
+}
+exports.EffectFade = EffectFade;
+//# sourceMappingURL=effect-fade.js.map

package/dist/ui/components/carousel/carousel-lib/modules/free-mode.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freeMode = void 0;
+var utils_1 = require("../shared/utils.js");
+function freeMode(_a) {
+    var swiper = _a.swiper, extendParams = _a.extendParams, emit = _a.emit, once = _a.once;
+    extendParams({
+        freeMode: {
+            enabled: false,
+            momentum: true,
+            momentumRatio: 1,
+            momentumBounce: true,
+            momentumBounceRatio: 1,
+            momentumVelocityRatio: 1,
+            sticky: false,
+            minimumVelocity: 0.02,
+        },
+    });
+    function onTouchStart() {
+        if (swiper.params.cssMode)
+            return;
+        var translate = swiper.getTranslate();
+        swiper.setTranslate(translate);
+        swiper.setTransition(0);
+        swiper.touchEventsData.velocities.length = 0;
+        swiper.freeMode.onTouchEnd({ currentPos: swiper.rtl ? swiper.translate : -swiper.translate });
+    }
+    function onTouchMove() {
+        if (swiper.params.cssMode)
+            return;
+        var data = swiper.touchEventsData, touches = swiper.touches;
+        // Velocity
+        if (data.velocities.length === 0) {
+            data.velocities.push({
+                position: touches[swiper.isHorizontal() ? 'startX' : 'startY'],
+                time: data.touchStartTime,
+            });
+        }
+        data.velocities.push({
+            position: touches[swiper.isHorizontal() ? 'currentX' : 'currentY'],
+            time: (0, utils_1.now)(),
+        });
+    }
+    function onTouchEnd(_a) {
+        var currentPos = _a.currentPos;
+        if (swiper.params.cssMode)
+            return;
+        var params = swiper.params, wrapperEl = swiper.wrapperEl, rtl = swiper.rtlTranslate, snapGrid = swiper.snapGrid, data = swiper.touchEventsData;
+        // Time diff
+        var touchEndTime = (0, utils_1.now)();
+        var timeDiff = touchEndTime - data.touchStartTime;
+        if (currentPos < -swiper.minTranslate()) {
+            swiper.slideTo(swiper.activeIndex);
+            return;
+        }
+        if (currentPos > -swiper.maxTranslate()) {
+            if (swiper.slides.length < snapGrid.length) {
+                swiper.slideTo(snapGrid.length - 1);
+            }
+            else {
+                swiper.slideTo(swiper.slides.length - 1);
+            }
+            return;
+        }
+        if (params.freeMode.momentum) {
+            if (data.velocities.length > 1) {
+                var lastMoveEvent = data.velocities.pop();
+                var velocityEvent = data.velocities.pop();
+                var distance = lastMoveEvent.position - velocityEvent.position;
+                var time = lastMoveEvent.time - velocityEvent.time;
+                swiper.velocity = distance / time;
+                swiper.velocity /= 2;
+                if (Math.abs(swiper.velocity) < params.freeMode.minimumVelocity) {
+                    swiper.velocity = 0;
+                }
+                // this implies that the user stopped moving a finger then released.
+                // There would be no events with distance zero, so the last event is stale.
+                if (time > 150 || (0, utils_1.now)() - lastMoveEvent.time > 300) {
+                    swiper.velocity = 0;
+                }
+            }
+            else {
+                swiper.velocity = 0;
+            }
+            swiper.velocity *= params.freeMode.momentumVelocityRatio;
+            data.velocities.length = 0;
+            var momentumDuration = 1000 * params.freeMode.momentumRatio;
+            var momentumDistance = swiper.velocity * momentumDuration;
+            var newPosition = swiper.translate + momentumDistance;
+            if (rtl)
+                newPosition = -newPosition;
+            var doBounce = false;
+            var afterBouncePosition_1;
+            var bounceAmount = Math.abs(swiper.velocity) * 20 * params.freeMode.momentumBounceRatio;
+            var needsLoopFix = void 0;
+            if (newPosition < swiper.maxTranslate()) {
+                if (params.freeMode.momentumBounce) {
+                    if (newPosition + swiper.maxTranslate() < -bounceAmount) {
+                        newPosition = swiper.maxTranslate() - bounceAmount;
+                    }
+                    afterBouncePosition_1 = swiper.maxTranslate();
+                    doBounce = true;
+                    data.allowMomentumBounce = true;
+                }
+                else {
+                    newPosition = swiper.maxTranslate();
+                }
+                if (params.loop && params.centeredSlides)
+                    needsLoopFix = true;
+            }
+            else if (newPosition > swiper.minTranslate()) {
+                if (params.freeMode.momentumBounce) {
+                    if (newPosition - swiper.minTranslate() > bounceAmount) {
+                        newPosition = swiper.minTranslate() + bounceAmount;
+                    }
+                    afterBouncePosition_1 = swiper.minTranslate();
+                    doBounce = true;
+                    data.allowMomentumBounce = true;
+                }
+                else {
+                    newPosition = swiper.minTranslate();
+                }
+                if (params.loop && params.centeredSlides)
+                    needsLoopFix = true;
+            }
+            else if (params.freeMode.sticky) {
+                var nextSlide = void 0;
+                for (var j = 0; j < snapGrid.length; j += 1) {
+                    if (snapGrid[j] > -newPosition) {
+                        nextSlide = j;
+                        break;
+                    }
+                }
+                if (Math.abs(snapGrid[nextSlide] - newPosition) <
+                    Math.abs(snapGrid[nextSlide - 1] - newPosition) ||
+                    swiper.swipeDirection === 'next') {
+                    newPosition = snapGrid[nextSlide];
+                }
+                else {
+                    newPosition = snapGrid[nextSlide - 1];
+                }
+                newPosition = -newPosition;
+            }
+            if (needsLoopFix) {
+                once('transitionEnd', function () {
+                    swiper.loopFix();
+                });
+            }
+            // Fix duration
+            if (swiper.velocity !== 0) {
+                if (rtl) {
+                    momentumDuration = Math.abs((-newPosition - swiper.translate) / swiper.velocity);
+                }
+                else {
+                    momentumDuration = Math.abs((newPosition - swiper.translate) / swiper.velocity);
+                }
+                if (params.freeMode.sticky) {
+                    // If freeMode.sticky is active and the user ends a swipe with a slow-velocity
+                    // event, then durations can be 20+ seconds to slide one (or zero!) slides.
+                    // It's easy to see this when simulating touch with mouse events. To fix this,
+                    // limit single-slide swipes to the default slide duration. This also has the
+                    // nice side effect of matching slide speed if the user stopped moving before
+                    // lifting finger or mouse vs. moving slowly before lifting the finger/mouse.
+                    // For faster swipes, also apply limits (albeit higher ones).
+                    var moveDistance = Math.abs((rtl ? -newPosition : newPosition) - swiper.translate);
+                    var currentSlideSize = swiper.slidesSizesGrid[swiper.activeIndex];
+                    if (moveDistance < currentSlideSize) {
+                        momentumDuration = params.speed;
+                    }
+                    else if (moveDistance < 2 * currentSlideSize) {
+                        momentumDuration = params.speed * 1.5;
+                    }
+                    else {
+                        momentumDuration = params.speed * 2.5;
+                    }
+                }
+            }
+            else if (params.freeMode.sticky) {
+                swiper.slideToClosest();
+                return;
+            }
+            if (params.freeMode.momentumBounce && doBounce) {
+                swiper.updateProgress(afterBouncePosition_1);
+                swiper.setTransition(momentumDuration);
+                swiper.setTranslate(newPosition);
+                swiper.transitionStart(true, swiper.swipeDirection);
+                swiper.animating = true;
+                (0, utils_1.elementTransitionEnd)(wrapperEl, function () {
+                    if (!swiper || swiper.destroyed || !data.allowMomentumBounce)
+                        return;
+                    emit('momentumBounce');
+                    swiper.setTransition(params.speed);
+                    setTimeout(function () {
+                        swiper.setTranslate(afterBouncePosition_1);
+                        (0, utils_1.elementTransitionEnd)(wrapperEl, function () {
+                            if (!swiper || swiper.destroyed)
+                                return;
+                            swiper.transitionEnd();
+                        });
+                    }, 0);
+                });
+            }
+            else if (swiper.velocity) {
+                emit('_freeModeNoMomentumRelease');
+                swiper.updateProgress(newPosition);
+                swiper.setTransition(momentumDuration);
+                swiper.setTranslate(newPosition);
+                swiper.transitionStart(true, swiper.swipeDirection);
+                if (!swiper.animating) {
+                    swiper.animating = true;
+                    (0, utils_1.elementTransitionEnd)(wrapperEl, function () {
+                        if (!swiper || swiper.destroyed)
+                            return;
+                        swiper.transitionEnd();
+                    });
+                }
+            }
+            else {
+                swiper.updateProgress(newPosition);
+            }
+            swiper.updateActiveIndex();
+            swiper.updateSlidesClasses();
+        }
+        else if (params.freeMode.sticky) {
+            swiper.slideToClosest();
+            return;
+        }
+        else if (params.freeMode) {
+            emit('_freeModeNoMomentumRelease');
+        }
+        if (!params.freeMode.momentum || timeDiff >= params.longSwipesMs) {
+            emit('_freeModeStaticRelease');
+            swiper.updateProgress();
+            swiper.updateActiveIndex();
+            swiper.updateSlidesClasses();
+        }
+    }
+    Object.assign(swiper, {
+        freeMode: {
+            onTouchStart: onTouchStart,
+            onTouchMove: onTouchMove,
+            onTouchEnd: onTouchEnd,
+        },
+    });
+}
+exports.freeMode = freeMode;
+//# sourceMappingURL=free-mode.js.map

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

@@ -0,0 +1,6 @@
+export * from "./autoplay.js";
+export * from "./effect-fade.js";
+export * from "./free-mode.js";
+export * from "./navigation.js";
+export * from "./pagination.js";
+export * from "./virtual.js";

package/dist/ui/components/carousel/carousel-lib/modules/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./autoplay.js"), exports);
+__exportStar(require("./effect-fade.js"), exports);
+__exportStar(require("./free-mode.js"), exports);
+__exportStar(require("./navigation.js"), exports);
+__exportStar(require("./pagination.js"), exports);
+__exportStar(require("./virtual.js"), exports);
+//# sourceMappingURL=index.js.map