infinity-forge 0.55.8 → 0.56.0

package/dist/ui/components/carousel/swiper/core/core.js

@@ -0,0 +1,654 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-nocheck
+/* eslint no-param-reassign: "off" */
+var utils_1 = require("../shared/utils.js");
+var get_support_1 = require("../shared/get-support.js");
+var get_device_1 = require("../shared/get-device.js");
+var get_browser_1 = require("../shared/get-browser.js");
+var resize_1 = __importDefault(require("./modules/resize/resize.js"));
+var observer_1 = __importDefault(require("./modules/observer/observer.js"));
+var events_emitter_1 = __importDefault(require("./events-emitter.js"));
+var index_1 = __importDefault(require("./update/index.js"));
+var index_2 = __importDefault(require("./translate/index.js"));
+var index_3 = __importDefault(require("./transition/index.js"));
+var index_4 = __importDefault(require("./slide/index.js"));
+var index_5 = __importDefault(require("./loop/index.js"));
+var index_6 = __importDefault(require("./grab-cursor/index.js"));
+var index_7 = __importDefault(require("./events/index.js"));
+var index_8 = __importDefault(require("./breakpoints/index.js"));
+var index_9 = __importDefault(require("./classes/index.js"));
+var index_10 = __importDefault(require("./check-overflow/index.js"));
+var defaults_1 = __importDefault(require("./defaults.js"));
+var moduleExtendParams_1 = __importDefault(require("./moduleExtendParams.js"));
+var process_lazy_preloader_1 = require("../shared/process-lazy-preloader.js");
+var document_1 = require("../ssr-window/document.js");
+var prototypes = {
+    eventsEmitter: events_emitter_1.default,
+    update: index_1.default,
+    translate: index_2.default,
+    transition: index_3.default,
+    slide: index_4.default,
+    loop: index_5.default,
+    grabCursor: index_6.default,
+    events: index_7.default,
+    breakpoints: index_8.default,
+    checkOverflow: index_10.default,
+    classes: index_9.default,
+};
+var extendedDefaults = {};
+var Swiper = /** @class */ (function () {
+    function Swiper() {
+        var _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var el;
+        var params;
+        if (args.length === 1 &&
+            args[0].constructor &&
+            Object.prototype.toString.call(args[0]).slice(8, -1) === 'Object') {
+            params = args[0];
+        }
+        else {
+            el = args[0], params = args[1];
+        }
+        if (!params)
+            params = {};
+        params = (0, utils_1.extend)({}, params);
+        if (el && !params.el)
+            params.el = el;
+        var document = (0, document_1.getDocument)();
+        if (params.el &&
+            typeof params.el === 'string' &&
+            document.querySelectorAll(params.el).length > 1) {
+            var swipers_1 = [];
+            document.querySelectorAll(params.el).forEach(function (containerEl) {
+                var newParams = (0, utils_1.extend)({}, params, { el: containerEl });
+                swipers_1.push(new Swiper(newParams));
+            });
+            // eslint-disable-next-line no-constructor-return
+            return swipers_1;
+        }
+        // Swiper Instance
+        var swiper = this;
+        swiper.__swiper__ = true;
+        swiper.support = (0, get_support_1.getSupport)();
+        swiper.device = (0, get_device_1.getDevice)({ userAgent: params.userAgent });
+        swiper.browser = (0, get_browser_1.getBrowser)();
+        swiper.eventsListeners = {};
+        swiper.eventsAnyListeners = [];
+        swiper.modules = __spreadArray([], swiper.__modules__, true);
+        if (params.modules && Array.isArray(params.modules)) {
+            (_a = swiper.modules).push.apply(_a, params.modules);
+        }
+        var allModulesParams = {};
+        swiper.modules.forEach(function (mod) {
+            mod({
+                params: params,
+                swiper: swiper,
+                extendParams: (0, moduleExtendParams_1.default)(params, allModulesParams),
+                on: swiper.on.bind(swiper),
+                once: swiper.once.bind(swiper),
+                off: swiper.off.bind(swiper),
+                emit: swiper.emit.bind(swiper),
+            });
+        });
+        // Extend defaults with modules params
+        var swiperParams = (0, utils_1.extend)({}, defaults_1.default, allModulesParams);
+        // Extend defaults with passed params
+        swiper.params = (0, utils_1.extend)({}, swiperParams, extendedDefaults, params);
+        swiper.originalParams = (0, utils_1.extend)({}, swiper.params);
+        swiper.passedParams = (0, utils_1.extend)({}, params);
+        // add event listeners
+        if (swiper.params && swiper.params.on) {
+            Object.keys(swiper.params.on).forEach(function (eventName) {
+                swiper.on(eventName, swiper.params.on[eventName]);
+            });
+        }
+        if (swiper.params && swiper.params.onAny) {
+            swiper.onAny(swiper.params.onAny);
+        }
+        // Extend Swiper
+        Object.assign(swiper, {
+            enabled: swiper.params.enabled,
+            el: el,
+            // Classes
+            classNames: [],
+            // Slides
+            slides: [],
+            slidesGrid: [],
+            snapGrid: [],
+            slidesSizesGrid: [],
+            // isDirection
+            isHorizontal: function () {
+                return swiper.params.direction === 'horizontal';
+            },
+            isVertical: function () {
+                return swiper.params.direction === 'vertical';
+            },
+            // Indexes
+            activeIndex: 0,
+            realIndex: 0,
+            //
+            isBeginning: true,
+            isEnd: false,
+            // Props
+            translate: 0,
+            previousTranslate: 0,
+            progress: 0,
+            velocity: 0,
+            animating: false,
+            cssOverflowAdjustment: function () {
+                // Returns 0 unless `translate` is > 2**23
+                // Should be subtracted from css values to prevent overflow
+                return Math.trunc(this.translate / Math.pow(2, 23)) * Math.pow(2, 23);
+            },
+            // Locks
+            allowSlideNext: swiper.params.allowSlideNext,
+            allowSlidePrev: swiper.params.allowSlidePrev,
+            // Touch Events
+            touchEventsData: {
+                isTouched: undefined,
+                isMoved: undefined,
+                allowTouchCallbacks: undefined,
+                touchStartTime: undefined,
+                isScrolling: undefined,
+                currentTranslate: undefined,
+                startTranslate: undefined,
+                allowThresholdMove: undefined,
+                // Form elements to match
+                focusableElements: swiper.params.focusableElements,
+                // Last click time
+                lastClickTime: 0,
+                clickTimeout: undefined,
+                // Velocities
+                velocities: [],
+                allowMomentumBounce: undefined,
+                startMoving: undefined,
+                pointerId: null,
+                touchId: null,
+            },
+            // Clicks
+            allowClick: true,
+            // Touches
+            allowTouchMove: swiper.params.allowTouchMove,
+            touches: {
+                startX: 0,
+                startY: 0,
+                currentX: 0,
+                currentY: 0,
+                diff: 0,
+            },
+            // Images
+            imagesToLoad: [],
+            imagesLoaded: 0,
+        });
+        swiper.emit('_swiper');
+        // Init
+        if (swiper.params.init) {
+            swiper.init();
+        }
+        // Return app instance
+        // eslint-disable-next-line no-constructor-return
+        return swiper;
+    }
+    Swiper.prototype.getDirectionLabel = function (property) {
+        if (this.isHorizontal()) {
+            return property;
+        }
+        // prettier-ignore
+        return {
+            'width': 'height',
+            'margin-top': 'margin-left',
+            'margin-bottom ': 'margin-right',
+            'margin-left': 'margin-top',
+            'margin-right': 'margin-bottom',
+            'padding-left': 'padding-top',
+            'padding-right': 'padding-bottom',
+            'marginRight': 'marginBottom',
+        }[property];
+    };
+    Swiper.prototype.getSlideIndex = function (slideEl) {
+        var _a = this, slidesEl = _a.slidesEl, params = _a.params;
+        var slides = (0, utils_1.elementChildren)(slidesEl, ".".concat(params.slideClass, ", swiper-slide"));
+        var firstSlideIndex = (0, utils_1.elementIndex)(slides[0]);
+        return (0, utils_1.elementIndex)(slideEl) - firstSlideIndex;
+    };
+    Swiper.prototype.getSlideIndexByData = function (index) {
+        return this.getSlideIndex(this.slides.filter(function (slideEl) { return slideEl.getAttribute('data-swiper-slide-index') * 1 === index; })[0]);
+    };
+    Swiper.prototype.recalcSlides = function () {
+        var swiper = this;
+        var slidesEl = swiper.slidesEl, params = swiper.params;
+        swiper.slides = (0, utils_1.elementChildren)(slidesEl, ".".concat(params.slideClass, ", swiper-slide"));
+    };
+    Swiper.prototype.enable = function () {
+        var swiper = this;
+        if (swiper.enabled)
+            return;
+        swiper.enabled = true;
+        if (swiper.params.grabCursor) {
+            swiper.setGrabCursor();
+        }
+        swiper.emit('enable');
+    };
+    Swiper.prototype.disable = function () {
+        var swiper = this;
+        if (!swiper.enabled)
+            return;
+        swiper.enabled = false;
+        if (swiper.params.grabCursor) {
+            swiper.unsetGrabCursor();
+        }
+        swiper.emit('disable');
+    };
+    Swiper.prototype.setProgress = function (progress, speed) {
+        var swiper = this;
+        progress = Math.min(Math.max(progress, 0), 1);
+        var min = swiper.minTranslate();
+        var max = swiper.maxTranslate();
+        var current = (max - min) * progress + min;
+        swiper.translateTo(current, typeof speed === 'undefined' ? 0 : speed);
+        swiper.updateActiveIndex();
+        swiper.updateSlidesClasses();
+    };
+    Swiper.prototype.emitContainerClasses = function () {
+        var swiper = this;
+        if (!swiper.params._emitClasses || !swiper.el)
+            return;
+        var cls = swiper.el.className.split(' ').filter(function (className) {
+            return (className.indexOf('swiper') === 0 ||
+                className.indexOf(swiper.params.containerModifierClass) === 0);
+        });
+        swiper.emit('_containerClasses', cls.join(' '));
+    };
+    Swiper.prototype.getSlideClasses = function (slideEl) {
+        var swiper = this;
+        if (swiper.destroyed)
+            return '';
+        return slideEl.className
+            .split(' ')
+            .filter(function (className) {
+            return (className.indexOf('swiper-slide') === 0 ||
+                className.indexOf(swiper.params.slideClass) === 0);
+        })
+            .join(' ');
+    };
+    Swiper.prototype.emitSlidesClasses = function () {
+        var swiper = this;
+        if (!swiper.params._emitClasses || !swiper.el)
+            return;
+        var updates = [];
+        swiper.slides.forEach(function (slideEl) {
+            var classNames = swiper.getSlideClasses(slideEl);
+            updates.push({ slideEl: slideEl, classNames: classNames });
+            swiper.emit('_slideClass', slideEl, classNames);
+        });
+        swiper.emit('_slideClasses', updates);
+    };
+    Swiper.prototype.slidesPerViewDynamic = function (view, exact) {
+        if (view === void 0) { view = 'current'; }
+        if (exact === void 0) { exact = false; }
+        var swiper = this;
+        var params = swiper.params, slides = swiper.slides, slidesGrid = swiper.slidesGrid, slidesSizesGrid = swiper.slidesSizesGrid, swiperSize = swiper.size, activeIndex = swiper.activeIndex;
+        var spv = 1;
+        if (typeof params.slidesPerView === 'number')
+            return params.slidesPerView;
+        if (params.centeredSlides) {
+            var slideSize = slides[activeIndex] ? Math.ceil(slides[activeIndex].swiperSlideSize) : 0;
+            var breakLoop = void 0;
+            for (var i = activeIndex + 1; i < slides.length; i += 1) {
+                if (slides[i] && !breakLoop) {
+                    slideSize += Math.ceil(slides[i].swiperSlideSize);
+                    spv += 1;
+                    if (slideSize > swiperSize)
+                        breakLoop = true;
+                }
+            }
+            for (var i = activeIndex - 1; i >= 0; i -= 1) {
+                if (slides[i] && !breakLoop) {
+                    slideSize += slides[i].swiperSlideSize;
+                    spv += 1;
+                    if (slideSize > swiperSize)
+                        breakLoop = true;
+                }
+            }
+        }
+        else {
+            // eslint-disable-next-line
+            if (view === 'current') {
+                for (var i = activeIndex + 1; i < slides.length; i += 1) {
+                    var slideInView = exact
+                        ? slidesGrid[i] + slidesSizesGrid[i] - slidesGrid[activeIndex] < swiperSize
+                        : slidesGrid[i] - slidesGrid[activeIndex] < swiperSize;
+                    if (slideInView) {
+                        spv += 1;
+                    }
+                }
+            }
+            else {
+                // previous
+                for (var i = activeIndex - 1; i >= 0; i -= 1) {
+                    var slideInView = slidesGrid[activeIndex] - slidesGrid[i] < swiperSize;
+                    if (slideInView) {
+                        spv += 1;
+                    }
+                }
+            }
+        }
+        return spv;
+    };
+    Swiper.prototype.update = function () {
+        var swiper = this;
+        if (!swiper || swiper.destroyed)
+            return;
+        var snapGrid = swiper.snapGrid, params = swiper.params;
+        // Breakpoints
+        if (params.breakpoints) {
+            swiper.setBreakpoint();
+        }
+        __spreadArray([], swiper.el.querySelectorAll('[loading="lazy"]'), true).forEach(function (imageEl) {
+            if (imageEl.complete) {
+                (0, process_lazy_preloader_1.processLazyPreloader)(swiper, imageEl);
+            }
+        });
+        swiper.updateSize();
+        swiper.updateSlides();
+        swiper.updateProgress();
+        swiper.updateSlidesClasses();
+        function setTranslate() {
+            var translateValue = swiper.rtlTranslate ? swiper.translate * -1 : swiper.translate;
+            var newTranslate = Math.min(Math.max(translateValue, swiper.maxTranslate()), swiper.minTranslate());
+            swiper.setTranslate(newTranslate);
+            swiper.updateActiveIndex();
+            swiper.updateSlidesClasses();
+        }
+        var translated;
+        if (params.freeMode && params.freeMode.enabled && !params.cssMode) {
+            setTranslate();
+            if (params.autoHeight) {
+                swiper.updateAutoHeight();
+            }
+        }
+        else {
+            if ((params.slidesPerView === 'auto' || params.slidesPerView > 1) &&
+                swiper.isEnd &&
+                !params.centeredSlides) {
+                var slides = swiper.virtual && params.virtual.enabled ? swiper.virtual.slides : swiper.slides;
+                translated = swiper.slideTo(slides.length - 1, 0, false, true);
+            }
+            else {
+                translated = swiper.slideTo(swiper.activeIndex, 0, false, true);
+            }
+            if (!translated) {
+                setTranslate();
+            }
+        }
+        if (params.watchOverflow && snapGrid !== swiper.snapGrid) {
+            swiper.checkOverflow();
+        }
+        swiper.emit('update');
+    };
+    Swiper.prototype.changeDirection = function (newDirection, needUpdate) {
+        if (needUpdate === void 0) { needUpdate = true; }
+        var swiper = this;
+        var currentDirection = swiper.params.direction;
+        if (!newDirection) {
+            // eslint-disable-next-line
+            newDirection = currentDirection === 'horizontal' ? 'vertical' : 'horizontal';
+        }
+        if (newDirection === currentDirection ||
+            (newDirection !== 'horizontal' && newDirection !== 'vertical')) {
+            return swiper;
+        }
+        swiper.el.classList.remove("".concat(swiper.params.containerModifierClass).concat(currentDirection));
+        swiper.el.classList.add("".concat(swiper.params.containerModifierClass).concat(newDirection));
+        swiper.emitContainerClasses();
+        swiper.params.direction = newDirection;
+        swiper.slides.forEach(function (slideEl) {
+            if (newDirection === 'vertical') {
+                slideEl.style.width = '';
+            }
+            else {
+                slideEl.style.height = '';
+            }
+        });
+        swiper.emit('changeDirection');
+        if (needUpdate)
+            swiper.update();
+        return swiper;
+    };
+    Swiper.prototype.changeLanguageDirection = function (direction) {
+        var swiper = this;
+        if ((swiper.rtl && direction === 'rtl') || (!swiper.rtl && direction === 'ltr'))
+            return;
+        swiper.rtl = direction === 'rtl';
+        swiper.rtlTranslate = swiper.params.direction === 'horizontal' && swiper.rtl;
+        if (swiper.rtl) {
+            swiper.el.classList.add("".concat(swiper.params.containerModifierClass, "rtl"));
+            swiper.el.dir = 'rtl';
+        }
+        else {
+            swiper.el.classList.remove("".concat(swiper.params.containerModifierClass, "rtl"));
+            swiper.el.dir = 'ltr';
+        }
+        swiper.update();
+    };
+    Swiper.prototype.mount = function (element) {
+        var swiper = this;
+        if (swiper.mounted)
+            return true;
+        // Find el
+        var el = element || swiper.params.el;
+        if (typeof el === 'string') {
+            el = document.querySelector(el);
+        }
+        if (!el) {
+            return false;
+        }
+        el.swiper = swiper;
+        if (el.parentNode &&
+            el.parentNode.host &&
+            el.parentNode.host.nodeName === swiper.params.swiperElementNodeName.toUpperCase()) {
+            swiper.isElement = true;
+        }
+        var getWrapperSelector = function () {
+            return ".".concat((swiper.params.wrapperClass || '').trim().split(' ').join('.'));
+        };
+        var getWrapper = function () {
+            if (el && el.shadowRoot && el.shadowRoot.querySelector) {
+                var res = el.shadowRoot.querySelector(getWrapperSelector());
+                // Children needs to return slot items
+                return res;
+            }
+            return (0, utils_1.elementChildren)(el, getWrapperSelector())[0];
+        };
+        // Find Wrapper
+        var wrapperEl = getWrapper();
+        if (!wrapperEl && swiper.params.createElements) {
+            wrapperEl = (0, utils_1.createElement)('div', swiper.params.wrapperClass);
+            el.append(wrapperEl);
+            (0, utils_1.elementChildren)(el, ".".concat(swiper.params.slideClass)).forEach(function (slideEl) {
+                wrapperEl.append(slideEl);
+            });
+        }
+        Object.assign(swiper, {
+            el: el,
+            wrapperEl: wrapperEl,
+            slidesEl: swiper.isElement && !el.parentNode.host.slideSlots ? el.parentNode.host : wrapperEl,
+            hostEl: swiper.isElement ? el.parentNode.host : el,
+            mounted: true,
+            // RTL
+            rtl: el.dir.toLowerCase() === 'rtl' || (0, utils_1.elementStyle)(el, 'direction') === 'rtl',
+            rtlTranslate: swiper.params.direction === 'horizontal' &&
+                (el.dir.toLowerCase() === 'rtl' || (0, utils_1.elementStyle)(el, 'direction') === 'rtl'),
+            wrongRTL: (0, utils_1.elementStyle)(wrapperEl, 'display') === '-webkit-box',
+        });
+        return true;
+    };
+    Swiper.prototype.init = function (el) {
+        var swiper = this;
+        if (swiper.initialized)
+            return swiper;
+        var mounted = swiper.mount(el);
+        if (mounted === false)
+            return swiper;
+        swiper.emit('beforeInit');
+        // Set breakpoint
+        if (swiper.params.breakpoints) {
+            swiper.setBreakpoint();
+        }
+        // Add Classes
+        swiper.addClasses();
+        // Update size
+        swiper.updateSize();
+        // Update slides
+        swiper.updateSlides();
+        if (swiper.params.watchOverflow) {
+            swiper.checkOverflow();
+        }
+        // Set Grab Cursor
+        if (swiper.params.grabCursor && swiper.enabled) {
+            swiper.setGrabCursor();
+        }
+        // Slide To Initial Slide
+        if (swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
+            swiper.slideTo(swiper.params.initialSlide + swiper.virtual.slidesBefore, 0, swiper.params.runCallbacksOnInit, false, true);
+        }
+        else {
+            swiper.slideTo(swiper.params.initialSlide, 0, swiper.params.runCallbacksOnInit, false, true);
+        }
+        // Create loop
+        if (swiper.params.loop) {
+            swiper.loopCreate();
+        }
+        // Attach events
+        swiper.attachEvents();
+        var lazyElements = __spreadArray([], swiper.el.querySelectorAll('[loading="lazy"]'), true);
+        if (swiper.isElement) {
+            lazyElements.push.apply(lazyElements, swiper.hostEl.querySelectorAll('[loading="lazy"]'));
+        }
+        lazyElements.forEach(function (imageEl) {
+            if (imageEl.complete) {
+                (0, process_lazy_preloader_1.processLazyPreloader)(swiper, imageEl);
+            }
+            else {
+                imageEl.addEventListener('load', function (e) {
+                    (0, process_lazy_preloader_1.processLazyPreloader)(swiper, e.target);
+                });
+            }
+        });
+        (0, process_lazy_preloader_1.preload)(swiper);
+        // Init Flag
+        swiper.initialized = true;
+        (0, process_lazy_preloader_1.preload)(swiper);
+        // Emit
+        swiper.emit('init');
+        swiper.emit('afterInit');
+        return swiper;
+    };
+    Swiper.prototype.destroy = function (deleteInstance, cleanStyles) {
+        if (deleteInstance === void 0) { deleteInstance = true; }
+        if (cleanStyles === void 0) { cleanStyles = true; }
+        var swiper = this;
+        var params = swiper.params, el = swiper.el, wrapperEl = swiper.wrapperEl, slides = swiper.slides;
+        if (typeof swiper.params === 'undefined' || swiper.destroyed) {
+            return null;
+        }
+        swiper.emit('beforeDestroy');
+        // Init Flag
+        swiper.initialized = false;
+        // Detach events
+        swiper.detachEvents();
+        // Destroy loop
+        if (params.loop) {
+            swiper.loopDestroy();
+        }
+        // Cleanup styles
+        if (cleanStyles) {
+            swiper.removeClasses();
+            if (el && typeof el !== 'string') {
+                el.removeAttribute('style');
+            }
+            if (wrapperEl) {
+                wrapperEl.removeAttribute('style');
+            }
+            if (slides && slides.length) {
+                slides.forEach(function (slideEl) {
+                    slideEl.classList.remove(params.slideVisibleClass, params.slideFullyVisibleClass, params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
+                    slideEl.removeAttribute('style');
+                    slideEl.removeAttribute('data-swiper-slide-index');
+                });
+            }
+        }
+        swiper.emit('destroy');
+        // Detach emitter events
+        Object.keys(swiper.eventsListeners).forEach(function (eventName) {
+            swiper.off(eventName);
+        });
+        if (deleteInstance !== false) {
+            if (swiper.el && typeof swiper.el !== 'string') {
+                swiper.el.swiper = null;
+            }
+            (0, utils_1.deleteProps)(swiper);
+        }
+        swiper.destroyed = true;
+        return null;
+    };
+    Swiper.extendDefaults = function (newDefaults) {
+        (0, utils_1.extend)(extendedDefaults, newDefaults);
+    };
+    Object.defineProperty(Swiper, "extendedDefaults", {
+        get: function () {
+            return extendedDefaults;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Swiper, "defaults", {
+        get: function () {
+            return defaults_1.default;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Swiper.installModule = function (mod) {
+        if (!Swiper.prototype.__modules__)
+            Swiper.prototype.__modules__ = [];
+        var modules = Swiper.prototype.__modules__;
+        if (typeof mod === 'function' && modules.indexOf(mod) < 0) {
+            modules.push(mod);
+        }
+    };
+    Swiper.use = function (module) {
+        if (Array.isArray(module)) {
+            module.forEach(function (m) { return Swiper.installModule(m); });
+            return Swiper;
+        }
+        Swiper.installModule(module);
+        return Swiper;
+    };
+    return Swiper;
+}());
+Object.keys(prototypes).forEach(function (prototypeGroup) {
+    Object.keys(prototypes[prototypeGroup]).forEach(function (protoMethod) {
+        Swiper.prototype[protoMethod] = prototypes[prototypeGroup][protoMethod];
+    });
+});
+Swiper.use([resize_1.default, observer_1.default]);
+exports.default = Swiper;
+//# sourceMappingURL=core.js.map