deleted file mode 100644

@@ -1,424 +0,0 @@

-import { window, document } from 'ssr-window';

-import $ from '../../utils/dom';

-import Utils from '../../utils/utils';

-

-function isEventSupported() {

-  const eventName = 'onwheel';

-  let isSupported = eventName in document;

-

-  if (!isSupported) {

-    const element = document.createElement('div');

-    element.setAttribute(eventName, 'return;');

-    isSupported = typeof element[eventName] === 'function';

-  }

-

-  if (!isSupported

-    && document.implementation

-    && document.implementation.hasFeature

-    // always returns true in newer browsers as per the standard.

-    // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature

-    && document.implementation.hasFeature('', '') !== true

-  ) {

-    // This is the only way to test support for the `wheel` event in IE9+.

-    isSupported = document.implementation.hasFeature('Events.wheel', '3.0');

-  }

-

-  return isSupported;

-}

-const Mousewheel = {

-  lastScrollTime: Utils.now(),

-  lastEventBeforeSnap: undefined,

-  recentWheelEvents: [],

-  event() {

-    if (window.navigator.userAgent.indexOf('firefox') > -1) return 'DOMMouseScroll';

-    return isEventSupported() ? 'wheel' : 'mousewheel';

-  },

-  normalize(e) {

-    // Reasonable defaults

-    const PIXEL_STEP = 10;

-    const LINE_HEIGHT = 40;

-    const PAGE_HEIGHT = 800;

-

-    let sX = 0;

-    let sY = 0; // spinX, spinY

-    let pX = 0;

-    let pY = 0; // pixelX, pixelY

-

-    // Legacy

-    if ('detail' in e) {

-      sY = e.detail;

-    }

-    if ('wheelDelta' in e) {

-      sY = -e.wheelDelta / 120;

-    }

-    if ('wheelDeltaY' in e) {

-      sY = -e.wheelDeltaY / 120;

-    }

-    if ('wheelDeltaX' in e) {

-      sX = -e.wheelDeltaX / 120;

-    }

-

-    // side scrolling on FF with DOMMouseScroll

-    if ('axis' in e && e.axis === e.HORIZONTAL_AXIS) {

-      sX = sY;

-      sY = 0;

-    }

-

-    pX = sX * PIXEL_STEP;

-    pY = sY * PIXEL_STEP;

-

-    if ('deltaY' in e) {

-      pY = e.deltaY;

-    }

-    if ('deltaX' in e) {

-      pX = e.deltaX;

-    }

-

-    if (e.shiftKey && !pX) { // if user scrolls with shift he wants horizontal scroll

-      pX = pY;

-      pY = 0;

-    }

-

-    if ((pX || pY) && e.deltaMode) {

-      if (e.deltaMode === 1) { // delta in LINE units

-        pX *= LINE_HEIGHT;

-        pY *= LINE_HEIGHT;

-      } else { // delta in PAGE units

-        pX *= PAGE_HEIGHT;

-        pY *= PAGE_HEIGHT;

-      }

-    }

-

-    // Fall-back if spin cannot be determined

-    if (pX && !sX) {

-      sX = (pX < 1) ? -1 : 1;

-    }

-    if (pY && !sY) {

-      sY = (pY < 1) ? -1 : 1;

-    }

-

-    return {

-      spinX: sX,

-      spinY: sY,

-      pixelX: pX,

-      pixelY: pY,

-    };

-  },

-  handleMouseEnter() {

-    const swiper = this;

-    swiper.mouseEntered = true;

-  },

-  handleMouseLeave() {

-    const swiper = this;

-    swiper.mouseEntered = false;

-  },

-  handle(event) {

-    let e = event;

-    const swiper = this;

-    const params = swiper.params.mousewheel;

-

-    if (swiper.params.cssMode) {

-      e.preventDefault();

-    }

-

-    let target = swiper.$el;

-    if (swiper.params.mousewheel.eventsTarged !== 'container') {

-      target = $(swiper.params.mousewheel.eventsTarged);

-    }

-    if (!swiper.mouseEntered && !target[0].contains(e.target) && !params.releaseOnEdges) return true;

-

-    if (e.originalEvent) e = e.originalEvent; // jquery fix

-    let delta = 0;

-    const rtlFactor = swiper.rtlTranslate ? -1 : 1;

-

-    const data = Mousewheel.normalize(e);

-

-    if (params.forceToAxis) {

-      if (swiper.isHorizontal()) {

-        if (Math.abs(data.pixelX) > Math.abs(data.pixelY)) delta = data.pixelX * rtlFactor;

-        else return true;

-      } else if (Math.abs(data.pixelY) > Math.abs(data.pixelX)) delta = data.pixelY;

-      else return true;

-    } else {

-      delta = Math.abs(data.pixelX) > Math.abs(data.pixelY) ? -data.pixelX * rtlFactor : -data.pixelY;

-    }

-

-    if (delta === 0) return true;

-

-    if (params.invert) delta = -delta;

-

-    if (!swiper.params.freeMode) {

-      // Register the new event in a variable which stores the relevant data

-      const newEvent = {

-        time: Utils.now(),

-        delta: Math.abs(delta),

-        direction: Math.sign(delta),

-        raw: event,

-      };

-

-      // Keep the most recent events

-      const recentWheelEvents = swiper.mousewheel.recentWheelEvents;

-      if (recentWheelEvents.length >= 2) {

-        recentWheelEvents.shift(); // only store the last N events

-      }

-      const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;

-      recentWheelEvents.push(newEvent);

-

-      // If there is at least one previous recorded event:

-      //   If direction has changed or

-      //   if the scroll is quicker than the previous one:

-      //     Animate the slider.

-      // Else (this is the first time the wheel is moved):

-      //     Animate the slider.

-      if (prevEvent) {

-        if (newEvent.direction !== prevEvent.direction || newEvent.delta > prevEvent.delta || newEvent.time > prevEvent.time + 150) {

-          swiper.mousewheel.animateSlider(newEvent);

-        }

-      } else {

-        swiper.mousewheel.animateSlider(newEvent);

-      }

-

-      // If it's time to release the scroll:

-      //   Return now so you don't hit the preventDefault.

-      if (swiper.mousewheel.releaseScroll(newEvent)) {

-        return true;

-      }

-    } else {

-      // Freemode or scrollContainer:

-

-      // If we recently snapped after a momentum scroll, then ignore wheel events

-      // to give time for the deceleration to finish. Stop ignoring after 500 msecs

-      // or if it's a new scroll (larger delta or inverse sign as last event before

-      // an end-of-momentum snap).

-      const newEvent = { time: Utils.now(), delta: Math.abs(delta), direction: Math.sign(delta) };

-      const { lastEventBeforeSnap } = swiper.mousewheel;

-      const ignoreWheelEvents = lastEventBeforeSnap

-        && newEvent.time < lastEventBeforeSnap.time + 500

-        && newEvent.delta <= lastEventBeforeSnap.delta

-        && newEvent.direction === lastEventBeforeSnap.direction;

-      if (!ignoreWheelEvents) {

-        swiper.mousewheel.lastEventBeforeSnap = undefined;

-

-        if (swiper.params.loop) {

-          swiper.loopFix();

-        }

-        let position = swiper.getTranslate() + (delta * params.sensitivity);

-        const wasBeginning = swiper.isBeginning;

-        const wasEnd = swiper.isEnd;

-

-        if (position >= swiper.minTranslate()) position = swiper.minTranslate();

-        if (position <= swiper.maxTranslate()) position = swiper.maxTranslate();

-

-        swiper.setTransition(0);

-        swiper.setTranslate(position);

-        swiper.updateProgress();

-        swiper.updateActiveIndex();

-        swiper.updateSlidesClasses();

-

-        if ((!wasBeginning && swiper.isBeginning) || (!wasEnd && swiper.isEnd)) {

-          swiper.updateSlidesClasses();

-        }

-

-        if (swiper.params.freeModeSticky) {

-          // When wheel scrolling starts with sticky (aka snap) enabled, then detect

-          // the end of a momentum scroll by storing recent (N=15?) wheel events.

-          // 1. do all N events have decreasing or same (absolute value) delta?

-          // 2. did all N events arrive in the last M (M=500?) msecs?

-          // 3. does the earliest event have an (absolute value) delta that's

-          //    at least P (P=1?) larger than the most recent event's delta?

-          // 4. does the latest event have a delta that's smaller than Q (Q=6?) pixels?

-          // If 1-4 are "yes" then we're near the end of a momuntum scroll deceleration.

-          // Snap immediately and ignore remaining wheel events in this scroll.

-          // See comment above for "remaining wheel events in this scroll" determination.

-          // If 1-4 aren't satisfied, then wait to snap until 500ms after the last event.

-          clearTimeout(swiper.mousewheel.timeout);

-          swiper.mousewheel.timeout = undefined;

-          const recentWheelEvents = swiper.mousewheel.recentWheelEvents;

-          if (recentWheelEvents.length >= 15) {

-            recentWheelEvents.shift(); // only store the last N events

-          }

-          const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;

-          const firstEvent = recentWheelEvents[0];

-          recentWheelEvents.push(newEvent);

-          if (prevEvent && (newEvent.delta > prevEvent.delta || newEvent.direction !== prevEvent.direction)) {

-            // Increasing or reverse-sign delta means the user started scrolling again. Clear the wheel event log.

-            recentWheelEvents.splice(0);

-          } else if (recentWheelEvents.length >= 15

-              && newEvent.time - firstEvent.time < 500

-              && firstEvent.delta - newEvent.delta >= 1

-              && newEvent.delta <= 6

-          ) {

-            // We're at the end of the deceleration of a momentum scroll, so there's no need

-            // to wait for more events. Snap ASAP on the next tick.

-            // Also, because there's some remaining momentum we'll bias the snap in the

-            // direction of the ongoing scroll because it's better UX for the scroll to snap

-            // in the same direction as the scroll instead of reversing to snap.  Therefore,

-            // if it's already scrolled more than 20% in the current direction, keep going.

-            const snapToThreshold = delta > 0 ? 0.8 : 0.2;

-            swiper.mousewheel.lastEventBeforeSnap = newEvent;

-            recentWheelEvents.splice(0);

-            swiper.mousewheel.timeout = Utils.nextTick(() => {

-              swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);

-            }, 0); // no delay; move on next tick

-          }

-          if (!swiper.mousewheel.timeout) {

-            // if we get here, then we haven't detected the end of a momentum scroll, so

-            // we'll consider a scroll "complete" when there haven't been any wheel events

-            // for 500ms.

-            swiper.mousewheel.timeout = Utils.nextTick(() => {

-              const snapToThreshold = 0.5;

-              swiper.mousewheel.lastEventBeforeSnap = newEvent;

-              recentWheelEvents.splice(0);

-              swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);

-            }, 500);

-          }

-        }

-

-        // Emit event

-        if (!ignoreWheelEvents) swiper.emit('scroll', e);

-

-        // Stop autoplay

-        if (swiper.params.autoplay && swiper.params.autoplayDisableOnInteraction) swiper.autoplay.stop();

-        // Return page scroll on edge positions

-        if (position === swiper.minTranslate() || position === swiper.maxTranslate()) return true;

-      }

-    }

-

-    if (e.preventDefault) e.preventDefault();

-    else e.returnValue = false;

-    return false;

-  },

-  animateSlider(newEvent) {

-    const swiper = this;

-    // If the movement is NOT big enough and

-    // if the last time the user scrolled was too close to the current one (avoid continuously triggering the slider):

-    //   Don't go any further (avoid insignificant scroll movement).

-    if (newEvent.delta >= 6 && Utils.now() - swiper.mousewheel.lastScrollTime < 60) {

-      // Return false as a default

-      return true;

-    }

-    // If user is scrolling towards the end:

-    //   If the slider hasn't hit the latest slide or

-    //   if the slider is a loop and

-    //   if the slider isn't moving right now:

-    //     Go to next slide and

-    //     emit a scroll event.

-    // Else (the user is scrolling towards the beginning) and

-    // if the slider hasn't hit the first slide or

-    // if the slider is a loop and

-    // if the slider isn't moving right now:

-    //   Go to prev slide and

-    //   emit a scroll event.

-    if (newEvent.direction < 0) {

-      if ((!swiper.isEnd || swiper.params.loop) && !swiper.animating) {

-        swiper.slideNext();

-        swiper.emit('scroll', newEvent.raw);

-      }

-    } else if ((!swiper.isBeginning || swiper.params.loop) && !swiper.animating) {

-      swiper.slidePrev();

-      swiper.emit('scroll', newEvent.raw);

-    }

-    // If you got here is because an animation has been triggered so store the current time

-    swiper.mousewheel.lastScrollTime = (new window.Date()).getTime();

-    // Return false as a default

-    return false;

-  },

-  releaseScroll(newEvent) {

-    const swiper = this;

-    const params = swiper.params.mousewheel;

-    if (newEvent.direction < 0) {

-      if (swiper.isEnd && !swiper.params.loop && params.releaseOnEdges) {

-        // Return true to animate scroll on edges

-        return true;

-      }

-    } else if (swiper.isBeginning && !swiper.params.loop && params.releaseOnEdges) {

-      // Return true to animate scroll on edges

-      return true;

-    }

-    return false;

-  },

-  enable() {

-    const swiper = this;

-    const event = Mousewheel.event();

-    if (swiper.params.cssMode) {

-      swiper.wrapperEl.removeEventListener(event, swiper.mousewheel.handle);

-      return true;

-    }

-    if (!event) return false;

-    if (swiper.mousewheel.enabled) return false;

-    let target = swiper.$el;

-    if (swiper.params.mousewheel.eventsTarged !== 'container') {

-      target = $(swiper.params.mousewheel.eventsTarged);

-    }

-    target.on('mouseenter', swiper.mousewheel.handleMouseEnter);

-    target.on('mouseleave', swiper.mousewheel.handleMouseLeave);

-    target.on(event, swiper.mousewheel.handle);

-    swiper.mousewheel.enabled = true;

-    return true;

-  },

-  disable() {

-    const swiper = this;

-    const event = Mousewheel.event();

-    if (swiper.params.cssMode) {

-      swiper.wrapperEl.addEventListener(event, swiper.mousewheel.handle);

-      return true;

-    }

-    if (!event) return false;

-    if (!swiper.mousewheel.enabled) return false;

-    let target = swiper.$el;

-    if (swiper.params.mousewheel.eventsTarged !== 'container') {

-      target = $(swiper.params.mousewheel.eventsTarged);

-    }

-    target.off(event, swiper.mousewheel.handle);

-    swiper.mousewheel.enabled = false;

-    return true;

-  },

-};

-

-export default {

-  name: 'mousewheel',

-  params: {

-    mousewheel: {

-      enabled: false,

-      releaseOnEdges: false,

-      invert: false,

-      forceToAxis: false,

-      sensitivity: 1,

-      eventsTarged: 'container',

-    },

-  },

-  create() {

-    const swiper = this;

-    Utils.extend(swiper, {

-      mousewheel: {

-        enabled: false,

-        enable: Mousewheel.enable.bind(swiper),

-        disable: Mousewheel.disable.bind(swiper),

-        handle: Mousewheel.handle.bind(swiper),

-        handleMouseEnter: Mousewheel.handleMouseEnter.bind(swiper),

-        handleMouseLeave: Mousewheel.handleMouseLeave.bind(swiper),

-        animateSlider: Mousewheel.animateSlider.bind(swiper),

-        releaseScroll: Mousewheel.releaseScroll.bind(swiper),

-        lastScrollTime: Utils.now(),

-        lastEventBeforeSnap: undefined,

-        recentWheelEvents: [],

-      },

-    });

-  },

-  on: {

-    init() {

-      const swiper = this;

-      if (!swiper.params.mousewheel.enabled && swiper.params.cssMode) {

-        swiper.mousewheel.disable();

-      }

-      if (swiper.params.mousewheel.enabled) swiper.mousewheel.enable();

-    },

-    destroy() {

-      const swiper = this;

-      if (swiper.params.cssMode) {

-        swiper.mousewheel.enable();

-      }

-      if (swiper.mousewheel.enabled) swiper.mousewheel.disable();

-    },

-  },

-};

new file mode 100644

@@ -0,0 +1,424 @@

+import { window, document } from 'ssr-window';

+import $ from '../../utils/dom';

+import Utils from '../../utils/utils';

+

+function isEventSupported() {

+  const eventName = 'onwheel';

+  let isSupported = eventName in document;

+

+  if (!isSupported) {

+    const element = document.createElement('div');

+    element.setAttribute(eventName, 'return;');

+    isSupported = typeof element[eventName] === 'function';

+  }

+

+  if (!isSupported

+    && document.implementation

+    && document.implementation.hasFeature

+    // always returns true in newer browsers as per the standard.

+    // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature

+    && document.implementation.hasFeature('', '') !== true

+  ) {

+    // This is the only way to test support for the `wheel` event in IE9+.

+    isSupported = document.implementation.hasFeature('Events.wheel', '3.0');

+  }

+

+  return isSupported;

+}

+const Mousewheel = {

+  lastScrollTime: Utils.now(),

+  lastEventBeforeSnap: undefined,

+  recentWheelEvents: [],

+  event() {

+    if (window.navigator.userAgent.indexOf('firefox') > -1) return 'DOMMouseScroll';

+    return isEventSupported() ? 'wheel' : 'mousewheel';

+  },

+  normalize(e) {

+    // Reasonable defaults

+    const PIXEL_STEP = 10;

+    const LINE_HEIGHT = 40;

+    const PAGE_HEIGHT = 800;

+

+    let sX = 0;

+    let sY = 0; // spinX, spinY

+    let pX = 0;

+    let pY = 0; // pixelX, pixelY

+

+    // Legacy

+    if ('detail' in e) {

+      sY = e.detail;

+    }

+    if ('wheelDelta' in e) {

+      sY = -e.wheelDelta / 120;

+    }

+    if ('wheelDeltaY' in e) {

+      sY = -e.wheelDeltaY / 120;

+    }

+    if ('wheelDeltaX' in e) {

+      sX = -e.wheelDeltaX / 120;

+    }

+

+    // side scrolling on FF with DOMMouseScroll

+    if ('axis' in e && e.axis === e.HORIZONTAL_AXIS) {

+      sX = sY;

+      sY = 0;

+    }

+

+    pX = sX * PIXEL_STEP;

+    pY = sY * PIXEL_STEP;

+

+    if ('deltaY' in e) {

+      pY = e.deltaY;

+    }

+    if ('deltaX' in e) {

+      pX = e.deltaX;

+    }

+

+    if (e.shiftKey && !pX) { // if user scrolls with shift he wants horizontal scroll

+      pX = pY;

+      pY = 0;

+    }

+

+    if ((pX || pY) && e.deltaMode) {

+      if (e.deltaMode === 1) { // delta in LINE units

+        pX *= LINE_HEIGHT;

+        pY *= LINE_HEIGHT;

+      } else { // delta in PAGE units

+        pX *= PAGE_HEIGHT;

+        pY *= PAGE_HEIGHT;

+      }

+    }

+

+    // Fall-back if spin cannot be determined

+    if (pX && !sX) {

+      sX = (pX < 1) ? -1 : 1;

+    }

+    if (pY && !sY) {

+      sY = (pY < 1) ? -1 : 1;

+    }

+

+    return {

+      spinX: sX,

+      spinY: sY,

+      pixelX: pX,

+      pixelY: pY,

+    };

+  },

+  handleMouseEnter() {

+    const swiper = this;

+    swiper.mouseEntered = true;

+  },

+  handleMouseLeave() {

+    const swiper = this;

+    swiper.mouseEntered = false;

+  },

+  handle(event) {

+    let e = event;

+    const swiper = this;

+    const params = swiper.params.mousewheel;

+

+    if (swiper.params.cssMode) {

+      e.preventDefault();

+    }

+

+    let target = swiper.$el;

+    if (swiper.params.mousewheel.eventsTarged !== 'container') {

+      target = $(swiper.params.mousewheel.eventsTarged);

+    }

+    if (!swiper.mouseEntered && !target[0].contains(e.target) && !params.releaseOnEdges) return true;

+

+    if (e.originalEvent) e = e.originalEvent; // jquery fix

+    let delta = 0;

+    const rtlFactor = swiper.rtlTranslate ? -1 : 1;

+

+    const data = Mousewheel.normalize(e);

+

+    if (params.forceToAxis) {

+      if (swiper.isHorizontal()) {

+        if (Math.abs(data.pixelX) > Math.abs(data.pixelY)) delta = data.pixelX * rtlFactor;

+        else return true;

+      } else if (Math.abs(data.pixelY) > Math.abs(data.pixelX)) delta = data.pixelY;

+      else return true;

+    } else {

+      delta = Math.abs(data.pixelX) > Math.abs(data.pixelY) ? -data.pixelX * rtlFactor : -data.pixelY;

+    }

+

+    if (delta === 0) return true;

+

+    if (params.invert) delta = -delta;

+

+    if (!swiper.params.freeMode) {

+      // Register the new event in a variable which stores the relevant data

+      const newEvent = {

+        time: Utils.now(),

+        delta: Math.abs(delta),

+        direction: Math.sign(delta),

+        raw: event,

+      };

+

+      // Keep the most recent events

+      const recentWheelEvents = swiper.mousewheel.recentWheelEvents;

+      if (recentWheelEvents.length >= 2) {

+        recentWheelEvents.shift(); // only store the last N events

+      }

+      const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;

+      recentWheelEvents.push(newEvent);

+

+      // If there is at least one previous recorded event:

+      //   If direction has changed or

+      //   if the scroll is quicker than the previous one:

+      //     Animate the slider.

+      // Else (this is the first time the wheel is moved):

+      //     Animate the slider.

+      if (prevEvent) {

+        if (newEvent.direction !== prevEvent.direction || newEvent.delta > prevEvent.delta || newEvent.time > prevEvent.time + 150) {

+          swiper.mousewheel.animateSlider(newEvent);

+        }

+      } else {

+        swiper.mousewheel.animateSlider(newEvent);

+      }

+

+      // If it's time to release the scroll:

+      //   Return now so you don't hit the preventDefault.

+      if (swiper.mousewheel.releaseScroll(newEvent)) {

+        return true;

+      }

+    } else {

+      // Freemode or scrollContainer:

+

+      // If we recently snapped after a momentum scroll, then ignore wheel events

+      // to give time for the deceleration to finish. Stop ignoring after 500 msecs

+      // or if it's a new scroll (larger delta or inverse sign as last event before

+      // an end-of-momentum snap).

+      const newEvent = { time: Utils.now(), delta: Math.abs(delta), direction: Math.sign(delta) };

+      const { lastEventBeforeSnap } = swiper.mousewheel;

+      const ignoreWheelEvents = lastEventBeforeSnap

+        && newEvent.time < lastEventBeforeSnap.time + 500

+        && newEvent.delta <= lastEventBeforeSnap.delta

+        && newEvent.direction === lastEventBeforeSnap.direction;

+      if (!ignoreWheelEvents) {

+        swiper.mousewheel.lastEventBeforeSnap = undefined;

+

+        if (swiper.params.loop) {

+          swiper.loopFix();

+        }

+        let position = swiper.getTranslate() + (delta * params.sensitivity);

+        const wasBeginning = swiper.isBeginning;

+        const wasEnd = swiper.isEnd;

+

+        if (position >= swiper.minTranslate()) position = swiper.minTranslate();

+        if (position <= swiper.maxTranslate()) position = swiper.maxTranslate();

+

+        swiper.setTransition(0);

+        swiper.setTranslate(position);

+        swiper.updateProgress();

+        swiper.updateActiveIndex();

+        swiper.updateSlidesClasses();

+

+        if ((!wasBeginning && swiper.isBeginning) || (!wasEnd && swiper.isEnd)) {

+          swiper.updateSlidesClasses();

+        }

+

+        if (swiper.params.freeModeSticky) {

+          // When wheel scrolling starts with sticky (aka snap) enabled, then detect

+          // the end of a momentum scroll by storing recent (N=15?) wheel events.

+          // 1. do all N events have decreasing or same (absolute value) delta?

+          // 2. did all N events arrive in the last M (M=500?) msecs?

+          // 3. does the earliest event have an (absolute value) delta that's

+          //    at least P (P=1?) larger than the most recent event's delta?

+          // 4. does the latest event have a delta that's smaller than Q (Q=6?) pixels?

+          // If 1-4 are "yes" then we're near the end of a momuntum scroll deceleration.

+          // Snap immediately and ignore remaining wheel events in this scroll.

+          // See comment above for "remaining wheel events in this scroll" determination.

+          // If 1-4 aren't satisfied, then wait to snap until 500ms after the last event.

+          clearTimeout(swiper.mousewheel.timeout);

+          swiper.mousewheel.timeout = undefined;

+          const recentWheelEvents = swiper.mousewheel.recentWheelEvents;

+          if (recentWheelEvents.length >= 15) {

+            recentWheelEvents.shift(); // only store the last N events

+          }

+          const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;

+          const firstEvent = recentWheelEvents[0];

+          recentWheelEvents.push(newEvent);

+          if (prevEvent && (newEvent.delta > prevEvent.delta || newEvent.direction !== prevEvent.direction)) {

+            // Increasing or reverse-sign delta means the user started scrolling again. Clear the wheel event log.

+            recentWheelEvents.splice(0);

+          } else if (recentWheelEvents.length >= 15

+              && newEvent.time - firstEvent.time < 500

+              && firstEvent.delta - newEvent.delta >= 1

+              && newEvent.delta <= 6

+          ) {

+            // We're at the end of the deceleration of a momentum scroll, so there's no need

+            // to wait for more events. Snap ASAP on the next tick.

+            // Also, because there's some remaining momentum we'll bias the snap in the

+            // direction of the ongoing scroll because it's better UX for the scroll to snap

+            // in the same direction as the scroll instead of reversing to snap.  Therefore,

+            // if it's already scrolled more than 20% in the current direction, keep going.

+            const snapToThreshold = delta > 0 ? 0.8 : 0.2;

+            swiper.mousewheel.lastEventBeforeSnap = newEvent;

+            recentWheelEvents.splice(0);

+            swiper.mousewheel.timeout = Utils.nextTick(() => {

+              swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);

+            }, 0); // no delay; move on next tick

+          }

+          if (!swiper.mousewheel.timeout) {

+            // if we get here, then we haven't detected the end of a momentum scroll, so

+            // we'll consider a scroll "complete" when there haven't been any wheel events

+            // for 500ms.

+            swiper.mousewheel.timeout = Utils.nextTick(() => {

+              const snapToThreshold = 0.5;

+              swiper.mousewheel.lastEventBeforeSnap = newEvent;

+              recentWheelEvents.splice(0);

+              swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);

+            }, 500);

+          }

+        }

+

+        // Emit event

+        if (!ignoreWheelEvents) swiper.emit('scroll', e);

+

+        // Stop autoplay

+        if (swiper.params.autoplay && swiper.params.autoplayDisableOnInteraction) swiper.autoplay.stop();

+        // Return page scroll on edge positions

+        if (position === swiper.minTranslate() || position === swiper.maxTranslate()) return true;

+      }

+    }

+

+    if (e.preventDefault) e.preventDefault();

+    else e.returnValue = false;

+    return false;

+  },

+  animateSlider(newEvent) {

+    const swiper = this;

+    // If the movement is NOT big enough and

+    // if the last time the user scrolled was too close to the current one (avoid continuously triggering the slider):

+    //   Don't go any further (avoid insignificant scroll movement).

+    if (newEvent.delta >= 6 && Utils.now() - swiper.mousewheel.lastScrollTime < 60) {

+      // Return false as a default

+      return true;

+    }

+    // If user is scrolling towards the end:

+    //   If the slider hasn't hit the latest slide or

+    //   if the slider is a loop and

+    //   if the slider isn't moving right now:

+    //     Go to next slide and

+    //     emit a scroll event.

+    // Else (the user is scrolling towards the beginning) and

+    // if the slider hasn't hit the first slide or

+    // if the slider is a loop and

+    // if the slider isn't moving right now:

+    //   Go to prev slide and

+    //   emit a scroll event.

+    if (newEvent.direction < 0) {

+      if ((!swiper.isEnd || swiper.params.loop) && !swiper.animating) {

+        swiper.slideNext();

+        swiper.emit('scroll', newEvent.raw);

+      }

+    } else if ((!swiper.isBeginning || swiper.params.loop) && !swiper.animating) {

+      swiper.slidePrev();

+      swiper.emit('scroll', newEvent.raw);

+    }

+    // If you got here is because an animation has been triggered so store the current time

+    swiper.mousewheel.lastScrollTime = (new window.Date()).getTime();

+    // Return false as a default

+    return false;

+  },

+  releaseScroll(newEvent) {

+    const swiper = this;

+    const params = swiper.params.mousewheel;

+    if (newEvent.direction < 0) {

+      if (swiper.isEnd && !swiper.params.loop && params.releaseOnEdges) {

+        // Return true to animate scroll on edges

+        return true;

+      }

+    } else if (swiper.isBeginning && !swiper.params.loop && params.releaseOnEdges) {

+      // Return true to animate scroll on edges

+      return true;

+    }

+    return false;

+  },

+  enable() {

+    const swiper = this;

+    const event = Mousewheel.event();

+    if (swiper.params.cssMode) {

+      swiper.wrapperEl.removeEventListener(event, swiper.mousewheel.handle);

+      return true;

+    }

+    if (!event) return false;

+    if (swiper.mousewheel.enabled) return false;

+    let target = swiper.$el;

+    if (swiper.params.mousewheel.eventsTarged !== 'container') {

+      target = $(swiper.params.mousewheel.eventsTarged);

+    }

+    target.on('mouseenter', swiper.mousewheel.handleMouseEnter);

+    target.on('mouseleave', swiper.mousewheel.handleMouseLeave);

+    target.on(event, swiper.mousewheel.handle);

+    swiper.mousewheel.enabled = true;

+    return true;

+  },

+  disable() {

+    const swiper = this;

+    const event = Mousewheel.event();

+    if (swiper.params.cssMode) {

+      swiper.wrapperEl.addEventListener(event, swiper.mousewheel.handle);

+      return true;

+    }

+    if (!event) return false;

+    if (!swiper.mousewheel.enabled) return false;

+    let target = swiper.$el;

+    if (swiper.params.mousewheel.eventsTarged !== 'container') {

+      target = $(swiper.params.mousewheel.eventsTarged);

+    }

+    target.off(event, swiper.mousewheel.handle);

+    swiper.mousewheel.enabled = false;

+    return true;

+  },

+};

+

+export default {

+  name: 'mousewheel',

+  params: {

+    mousewheel: {

+      enabled: false,

+      releaseOnEdges: false,

+      invert: false,

+      forceToAxis: false,

+      sensitivity: 1,

+      eventsTarged: 'container',

+    },

+  },

+  create() {

+    const swiper = this;

+    Utils.extend(swiper, {

+      mousewheel: {

+        enabled: false,

+        enable: Mousewheel.enable.bind(swiper),

+        disable: Mousewheel.disable.bind(swiper),

+        handle: Mousewheel.handle.bind(swiper),

+        handleMouseEnter: Mousewheel.handleMouseEnter.bind(swiper),

+        handleMouseLeave: Mousewheel.handleMouseLeave.bind(swiper),

+        animateSlider: Mousewheel.animateSlider.bind(swiper),

+        releaseScroll: Mousewheel.releaseScroll.bind(swiper),

+        lastScrollTime: Utils.now(),

+        lastEventBeforeSnap: undefined,

+        recentWheelEvents: [],

+      },

+    });

+  },

+  on: {

+    init() {

+      const swiper = this;

+      if (!swiper.params.mousewheel.enabled && swiper.params.cssMode) {

+        swiper.mousewheel.disable();

+      }

+      if (swiper.params.mousewheel.enabled) swiper.mousewheel.enable();

+    },

+    destroy() {

+      const swiper = this;

+      if (swiper.params.cssMode) {

+        swiper.mousewheel.enable();

+      }

+      if (swiper.mousewheel.enabled) swiper.mousewheel.disable();

+    },

+  },

+};