https://www.koinno.de/fileadmin/files/assets/js/main.js?1709204166

1/******/ (function(modules) { // webpackBootstrap
2/******/ 	// The module cache
3/******/ 	var installedModules = {};
4/******/
5/******/ 	// The require function
6/******/ 	function __webpack_require__(moduleId) {
7/******/
8/******/ 		// Check if module is in cache
9/******/ 		if(installedModules[moduleId]) {
10/******/ 			return installedModules[moduleId].exports;
11/******/ 		}
12/******/ 		// Create a new module (and put it into the cache)
13/******/ 		var module = installedModules[moduleId] = {
14/******/ 			i: moduleId,
15/******/ 			l: false,
16/******/ 			exports: {}
17/******/ 		};
18/******/
19/******/ 		// Execute the module function
20/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21/******/
22/******/ 		// Flag the module as loaded
23/******/ 		module.l = true;
24/******/
25/******/ 		// Return the exports of the module
26/******/ 		return module.exports;
27/******/ 	}
28/******/
29/******/
30/******/ 	// expose the modules object (__webpack_modules__)
31/******/ 	__webpack_require__.m = modules;
32/******/
33/******/ 	// expose the module cache
34/******/ 	__webpack_require__.c = installedModules;
35/******/
36/******/ 	// identity function for calling harmony imports with the correct context
37/******/ 	__webpack_require__.i = function(value) { return value; };
38/******/
39/******/ 	// define getter function for harmony exports
40/******/ 	__webpack_require__.d = function(exports, name, getter) {
41/******/ 		if(!__webpack_require__.o(exports, name)) {
42/******/ 			Object.defineProperty(exports, name, {
43/******/ 				configurable: false,
44/******/ 				enumerable: true,
45/******/ 				get: getter
46/******/ 			});
47/******/ 		}
48/******/ 	};
49/******/
50/******/ 	// getDefaultExport function for compatibility with non-harmony modules
51/******/ 	__webpack_require__.n = function(module) {
52/******/ 		var getter = module && module.__esModule ?
53/******/ 			function getDefault() { return module['default']; } :
54/******/ 			function getModuleExports() { return module; };
55/******/ 		__webpack_require__.d(getter, 'a', getter);
56/******/ 		return getter;
57/******/ 	};
58/******/
59/******/ 	// Object.prototype.hasOwnProperty.call
60/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
61/******/
62/******/ 	// __webpack_public_path__
63/******/ 	__webpack_require__.p = "";
64/******/
65/******/ 	// Load entry module and return exports
66/******/ 	return __webpack_require__(__webpack_require__.s = 8);
67/******/ })
68/************************************************************************/
69/******/ ([
70/* 0 */
71/***/ (function(module, exports, __webpack_require__) {
72
73"use strict";
74
75
76// to check if main.js is loaded in the browser at all
77// console.info('Let the games begin - Hello main.js! :)');
78
79// import some (vendor) libs
80// import $ from 'jquery';
81// import Foundation from 'foundation-sites';
82
83var _vanillaLazyload = __webpack_require__(5);
84
85var _vanillaLazyload2 = _interopRequireDefault(_vanillaLazyload);
86
87var _viewportUnitsBuggyfill = __webpack_require__(6);
88
89var _viewportUnitsBuggyfill2 = _interopRequireDefault(_viewportUnitsBuggyfill);
90
91var _smoothScroll = __webpack_require__(4);
92
93var _smoothScroll2 = _interopRequireDefault(_smoothScroll);
94
95var _GlideSlider = __webpack_require__(3);
96
97var _GlideSlider2 = _interopRequireDefault(_GlideSlider);
98
99var _EventsMap = __webpack_require__(2);
100
101var _EventsMap2 = _interopRequireDefault(_EventsMap);
102
103function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
104
105// let's create our own instance and say something
106// let start = new myGreeter();
107
108
109// TODO: crop BMWi JS into modules and include smaller files here instead of one 22k lines monster - remove it from TS again, then
110// import bmwiLib from './vendor/bmwi.production';
111
112
113// import / include the class definition
114// import myGreeter from './modules/Greet.js';
115var myGlideSlider = new _GlideSlider2.default();
116var myEventsMap = new _EventsMap2.default();
117
118/**
119 *
120 * Let the games begin! This is the very entry point of our app / website js.
121 *
122 *
123 */
124
125// see http://gregfranko.com/jquery-best-practices/#/4 - TODO: maybe tr

861  return Object.keys(obj).sort().reduce(function (r, k) {
862    r[k] = obj[k];
863
864    return r[k], r;
865  }, {});
866}
867
868/**
869 * Merges passed settings object with default options.
870 *
871 * @param  {Object} defaults
872 * @param  {Object} settings
873 * @return {Object}
874 */
875function mergeOptions(defaults, settings) {
876  var options = _extends({}, defaults, settings);
877
878  // `Object.assign` do not deeply merge objects, so we
879  // have to do it manually for every nested object
880  // in options. Although it does not look smart,
881  // it's smaller and faster than some fancy
882  // merging deep-merge algorithm script.
883  if (settings.hasOwnProperty('classes')) {
884    options.classes = _extends({}, defaults.classes, settings.classes);
885
886    if (settings.classes.hasOwnProperty('direction')) {
887      options.classes.direction = _extends({}, defaults.classes.direction, settings.classes.direction);
888    }
889  }
890
891  if (settings.hasOwnProperty('breakpoints')) {
892    options.breakpoints = _extends({}, defaults.breakpoints, settings.breakpoints);
893  }
894
895  return options;
896}
897
898var EventsBus = function () {
899  /**
900   * Construct a EventBus instance.
901   *
902   * @param {Object} events
903   */
904  function EventsBus() {
905    var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
906    classCallCheck(this, EventsBus);
907
908    this.events = events;
909    this.hop = events.hasOwnProperty;
910  }
911
912  /**
913   * Adds listener to the specifed event.
914   *
915   * @param {String|Array} event
916   * @param {Function} handler
917   */
918
919
920  createClass(EventsBus, [{
921    key: 'on',
922    value: function on(event, handler) {
923      if (isArray(event)) {
924        for (var i = 0; i < event.length; i++) {
925          this.on(event[i], handler);
926        }
927      }
928
929      // Create the event's object if not yet created
930      if (!this.hop.call(this.events, event)) {
931        this.events[event] = [];
932      }
933
934      // Add the handler to queue
935      var index = this.events[event].push(handler) - 1;
936
937      // Provide handle back for removal of event
938      return {
939        remove: function remove() {
940          delete this.events[event][index];
941        }
942      };
943    }
944
945    /**
946     * Runs registered handlers for specified event.
947     *
948     * @param {String|Array} event
949     * @param {Object=} context
950     */
951
952  }, {
953    key: 'emit',
954    value: function emit(event, context) {
955      if (isArray(event)) {
956        for (var i = 0; i < event.length; i++) {
957          this.emit(event[i], context);
958        }
959      }
960
961      // If the event doesn't exist, or there's no handlers in queue, just leave
962      if (!this.hop.call(this.events, event)) {
963        return;
964      }
965
966      // Cycle through events queue, fire!
967      this.events[event].forEach(function (item) {
968        item(context || {});
969      });
970    }
971  }]);
972  return EventsBus;
973}();
974
975var Glide = function () {
976  /**
977   * Construct glide.
978   *
979   * @param  {String} selector
980   * @param  {Object} options
981   */
982  function Glide(selector) {
983    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
984    classCallCheck(this, Glide);
985
986    this._c = {};
987    this._t = [];
988    this._e = new EventsBus();
989
990    this.disabled = false;
991    this.selector = selector;
992    this.settings = mergeOptions(defaults, options);
993    this.index = this.settings.startAt;
994  }
995
996  /**
997   * Initializes glide.
998   *
999   * @param {Object} extensions Collection of extensions to initialize.
1000   * @return {Glide}
1001   */
1002
1003
1004  createClass(Glide, [{
1005    key: 'mount',
1006    value: function mount$$1() {
1007      var extensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1008
1009      this._e.emit('mount.before');
1010
1011      if (isObject(extensions)) {
1012        this._c = mount(this, extensions, this._e);
1013      } else {
1014        warn('You need to provide a object on `mount()`');
1015      }
1016
1017      this._e.emit('mount.after');
1018
1019      return this;
1020    }
1021
1022    /**
1023     * Collects an instance `translate` transformers.
1024     *
1025     * @param  {Array} transformers Collection of transformers.
1026     * @return {Void}
1027     */
1028
1029  }, {
1030    key: 'mutate',
1031    value: function mutate() {
1032      var transformers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
1033
1034      if (isArray(transformers)) {
1035        this._t = transformers;
1036      } else {
1037        warn('You need to provide a array on `mutate()`');
1038      }
1039
1040      return this;
1041    }
1042
1043    /**
1044     * Updates glide with specified settings.
1045     *
1046     * @param {Object} settings
1047     * @return {Glide}
1048     */
1049
1050  }, {
1051    key: 'update',
1052    value: function update() {
1053      var settings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1054
1055      this.settings = mergeOptions(this.settings, settings);
1056
1057      if (settings.hasOwnProperty('startAt')) {
1058        this.index = settings.startAt;
1059      }
1060
1061      this._e.emit('update');
1062
1063      return this;
1064    }
1065
1066    /**
1067     * Change slide with specified pattern. A pattern must be in the special format:
1068     * `>` - Move one forward
1069     * `<` - Move one backward
1070     * `={i}` - Go to {i} zero-based slide (eq. '=1', will go to second slide)
1071     * `>>` - Rewinds to end (last slide)
1072     * `<<` - Rewinds to start (first slide)
1073     *
1074     * @param {String} pattern
1075     * @return {Glide}
1076     */
1077
1078  }, {
1079    key: 'go',
1080    value: function go(pattern) {
1081      this._c.Run.make(pattern);
1082
1083      return this;
1084    }
1085
1086    /**
1087     * Move track by specified distance.
1088     *
1089     * @param {String} distance
1090     * @return {Glide}
1091     */
1092
1093  }, {
1094    key: 'move',
1095    value: function move(distance) {
1096      this._c.Transition.disable();
1097      this._c.Move.make(distance);
1098
1099      return this;
1100    }
1101
1102    /**
1103     * Destroy instance and revert all changes done by this._c.
1104     *
1105     * @return {Glide}
1106     */
1107
1108  }, {
1109    key: 'destroy',
1110    value: function destroy() {
1111      this._e.emit('destroy');
1112
1113      return this;
1114    }
1115
1116    /**
1117     * Start instance autoplaying.
1118     *
1119     * @param {Boolean|Number} interval Run autoplaying with passed interval regardless of `autoplay` settings
1120     * @return {Glide}
1121     */
1122
1123  }, {
1124    key: 'play',
1125    value: function play() {
1126      var interval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
1127
1128      if (interval) {
1129        this.settings.autoplay = interval;
1130      }
1131
1132      this._e.emit('play');
1133
1134      return this;
1135    }
1136
1137    /**
1138     * Stop instance autoplaying.
1139     *
1140     * @return {Glide}
1141     */
1142
1143  }, {
1144    key: 'pause',
1145    value: function pause() {
1146      this._e.emit('pause');
1147
1148      return this;
1149    }
1150
1151    /**
1152     * Sets glide into a idle status.
1153     *
1154     * @return {Glide}
1155     */
1156
1157  }, {
1158    key: 'disable',
1159    value: function disable() {
1160      this.disabled = true;
1161
1162      return this;
1163    }
1164
1165    /**
1166     * Sets glide into a active status.
1167     *
1168     * @return {Glide}
1169     */
1170
1171  }, {
1172    key: 'enable',
1173    value: function enable() {
1174      this.disabled = false;
1175
1176      return this;
1177    }
1178
1179    /**
1180     * Adds cuutom event listener with handler.
1181     *
1182     * @param  {String|Array} event
1183     * @param  {Function} handler
1184     * @return {Glide}
1185     */
1186
1187  }, {
1188    key: 'on',
1189    value: function on(event, handler) {
1190      this._e.on(event, handler);
1191
1192      return this;
1193    }
1194
1195    /**
1196     * Checks if glide is a precised type.
1197     *
1198     * @param  {String} name
1199     * @return {Boolean}
1200     */
1201
1202  }, {
1203    key: 'isType',
1204    value: function isType(name) {
1205      return this.settings.type === name;
1206    }
1207
1208    /**
1209     * Gets value of the core options.
1210     *
1211     * @return {Object}
1212     */
1213
1214  }, {
1215    key: 'settings',
1216    get: function get$$1() {
1217      return this._o;
1218    }
1219
1220    /**
1221     * Sets value of the core options.
1222     *
1223     * @param  {Object} o
1224     * @return {Void}
1225     */
1226    ,
1227    set: function set$$1(o) {
1228      if (isObject(o)) {
1229        this._o = o;
1230      } else {
1231        warn('Options must be an `object` instance.');
1232      }
1233    }
1234
1235    /**
1236     * Gets current index of the slider.
1237     *
1238     * @return {Object}
1239     */
1240
1241  }, {
1242    key: 'index',
1243    get: function get$$1() {
1244      return this._i;
1245    }
1246
1247    /**
1248     * Sets current index a slider.
1249     *
1250     * @return {Object}
1251     */
1252    ,
1253    set: function set$$1(i) {
1254      this._i = toInt(i);
1255    }
1256
1257    /**
1258     * Gets type name of the slider.
1259     *
1260     * @return {String}
1261     */
1262
1263  }, {
1264    key: 'type',
1265    get: function get$$1() {
1266      return this.settings.type;
1267    }
1268
1269    /**
1270     * Gets value of the idle status.
1271     *
1272     * @return {Boolean}
1273     */
1274
1275  }, {
1276    key: 'disabled',
1277    get: function get$$1() {
1278      return this._d;
1279    }
1280
1281    /**
1282     * Sets value of the idle status.
1283     *
1284     * @return {Boolean}
1285     */
1286    ,
1287    set: function set$$1(status) {
1288      this._d = !!status;
1289    }
1290  }]);
1291  return Glide;
1292}();

1479        return length - 1 - (toInt(settings.perView) - 1) + toInt(settings.focusAt);
1480      }
1481
1482      return length - 1;
1483    }
1484  });
1485
1486  define(Run, 'offset', {
1487    /**
1488     * Gets status of the offsetting flag.
1489     *
1490     * @return {Boolean}
1491     */
1492    get: function get() {
1493      return this._o;
1494    }
1495  });
1496
1497  return Run;
1498}
1499
1500/**
1501 * Returns a current time.
1502 *
1503 * @return {Number}
1504 */
1505function now() {
1506  return new Date().getTime();
1507}
1508
1509/**
1510 * Returns a function, that, when invoked, will only be triggered
1511 * at most once during a given window of time.
1512 *
1513 * @param {Function} func
1514 * @param {Number} wait
1515 * @param {Object=} options
1516 * @return {Function}
1517 *
1518 * @see https://github.com/jashkenas/underscore
1519 */
1520function throttle(func, wait, options) {
1521  var timeout = void 0,
1522      context = void 0,
1523      args = void 0,
1524      result = void 0;
1525  var previous = 0;
1526  if (!options) options = {};
1527
1528  var later = function later() {
1529    previous = options.leading === false ? 0 : now();
1530    timeout = null;
1531    result = func.apply(context, args);
1532    if (!timeout) context = args = null;
1533  };
1534
1535  var throttled = function throttled() {
1536    var at = now();
1537    if (!previous && options.leading === false) previous = at;
1538    var remaining = wait - (at - previous);
1539    context = this;
1540    args = arguments;
1541    if (remaining <= 0 || remaining > wait) {
1542      if (timeout) {
1543        clearTimeout(timeout);
1544        timeout = null;
1545      }
1546      previous = at;
1547      result = func.apply(context, args);
1548      if (!timeout) context = args = null;
1549    } else if (!timeout && options.trailing !== false) {
1550      timeout = setTimeout(later, remaining);
1551    }
1552    return result;
1553  };
1554
1555  throttled.cancel = function () {
1556    clearTimeout(timeout);
1557    previous = 0;
1558    timeout = context = args = null;
1559  };
1560
1561  return throttled;
1562}
1563
1564var MARGIN_TYPE = {
1565  ltr: ['marginLeft', 'marginRight'],
1566  rtl: ['marginRight', 'marginLeft']
1567};
1568
1569function Gaps (Glide, Components, Events) {
1570  var Gaps = {
1571    /**
1572     * Applies gaps between slides. First and last
1573     * slides do not receive it's edge margins.
1574     *
1575     * @param {HTMLCollection} slides
1576     * @return {Void}
1577     */
1578    apply: function apply(slides) {
1579      for (var i = 0, len = slides.length; i < len; i++) {
1580        var style = slides[i].style;
1581        var direction = Components.Direction.value;
1582
1583        if (i !== 0) {
1584          style[MARGIN_TYPE[direction][0]] = this.value / 2 + 'px';
1585        } else {
1586          style[MARGIN_TYPE[direction][0]] = '';
1587        }
1588
1589        if (i !== slides.length - 1) {
1590          style[MARGIN_TYPE[direction][1]] = this.value / 2 + 'px';
1591        } else {
1592          style[MARGIN_TYPE[direction][1]] = '';
1593        }
1594      }
1595    },
1596
1597
1598    /**
1599     * Removes gaps from the slides.
1600     *
1601     * @param {HTMLCollection} slides
1602     * @returns {Void}
1603    */
1604    remove: function remove(slides) {
1605      for (var i = 0, len = slides.length; i < len; i++) {
1606        var style = slides[i].style;
1607
1608        style.marginLeft = '';
1609        style.marginRight = '';
1610      }
1611    }
1612  };
1613
1614  define(Gaps, 'value', {
1615    /**
1616     * Gets value of the gap.
1617     *
1618     * @returns {Number}
1619     */
1620    get: function get() {
1621      return toInt(Glide.settings.gap);
1622    }
1623  });
1624
1625  define(Gaps, 'grow', {
1626    /**
1627     * Gets additional dimentions value caused by gaps.
1628     * Used to increase width of the slides wrapper.
1629     *
1630     * @returns {Number}
1631     */
1632    get: function get() {
1633      return Gaps.value * (Components.Sizes.length - 1);
1634    }
1635  });
1636
1637  define(Gaps, 'reductor', {
1638    /**
1639     * Gets reduction value caused by gaps.
1640     * Used to subtract width of the slides.
1641     *
1642     * @returns {Number}
1643     */
1644    get: function get() {
1645      var perView = Glide.settings.perView;
1646
1647      return Gaps.value * (perView - 1) / perView;
1648    }
1649  });
1650
1651  /**
1652   * Apply calculated gaps:
1653   * - after building, so slides (including clones) will receive proper margins
1654   * - on updating via API, to recalculate gaps with new options
1655   */
1656  Events.on(['build.after', 'update'], throttle(function () {
1657    Gaps.apply(Components.Html.wrapper.children);
1658  }, 30));
1659
1660  /**
1661   * Remove gaps:
1662   * - on destroying to bring markup to its inital state
1663   */
1664  Events.on('destroy', function () {
1665    Gaps.remove(Components.Html.wrapper.children);
1666  });
1667
1668  return Gaps;
1669}
1670
1671/**
1672 * Finds siblings nodes of the passed node.
1673 *
1674 * @param  {Element} node
1675 * @return {Array}
1676 */
1677function siblings(node) {
1678  if (node && node.parentNode) {
1679    var n = node.parentNode.firstChild;
1680    var matched = [];
1681
1682    for (; n; n = n.nextSibling) {
1683      if (n.nodeType === 1 && n !== node) {
1684        matched.push(n);
1685      }
1686    }
1687
1688    return matched;
1689  }
1690
1691  return [];
1692}
1693
1694/**
1695 * Checks if passed node exist and is a valid element.
1696 *
1697 * @param  {Element} node
1698 * @return {Boolean}
1699 */
1700function exist(node) {
1701  if (node && node instanceof window.HTMLElement) {
1702    return true;
1703  }
1704
1705  return false;
1706}
1707
1708var TRACK_SELECTOR = '[data-glide-el="track"]';
1709
1710function Html (Glide, Components) {
1711  var Html = {
1712    /**
1713     * Setup slider HTML nodes.
1714     *
1715     * @param {Glide} glide
1716     */
1717    mount: function mount() {
1718      this.root = Glide.selector;
1719      this.track = this.root.querySelector(TRACK_SELECTOR);
1720      this.slides = Array.prototype.slice.call(this.wrapper.children).filter(function (slide) {
1721        return !slide.classList.contains(Glide.settings.classes.cloneSlide);
1722      });
1723    }
1724  };
1725
1726  define(Html, 'root', {
1727    /**
1728     * Gets node of the glide main element.
1729     *
1730     * @return {Object}
1731     */
1732    get: function get() {
1733      return Html._r;
1734    },
1735
1736
1737    /**
1738     * Sets node of the glide main element.
1739     *
1740     * @return {Object}
1741     */
1742    set: function set(r) {
1743      if (isString(r)) {
1744        r = document.querySelector(r);
1745      }
1746
1747      if (exist(r)) {
1748        Html._r = r;
1749      } else {
1750        warn('Root element must be a existing Html node');
1751      }
1752    }
1753  });
1754
1755  define(Html, 'track', {
1756    /**
1757     * Gets node of the glide track with slides.
1758     *
1759     * @return {Object}
1760     */
1761    get: function get() {
1762      return Html._t;
1763    },
1764
1765
1766    /**
1767     * Sets node of the glide track with slides.
1768     *
1769     * @return {Object}
1770     */
1771    set: function set(t) {
1772      if (exist(t)) {
1773        Html._t = t;
1774      } else {
1775        warn('Could not find track element. Please use ' + TRACK_SELECTOR + ' attribute.');
1776      }
1777    }
1778  });
1779
1780  define(Html, 'wrapper', {
1781    /**
1782     * Gets node of the slides wrapper.
1783     *
1784     * @return {Object}
1785     */
1786    get: function get() {
1787      return Html.track.children[0];
1788    }
1789  });
1790
1791  return Html;
1792}
1793
1794function Peek (Glide, Components, Events) {
1795  var Peek = {
1796    /**
1797     * Setups how much to peek based on settings.
1798     *
1799     * @return {Void}
1800     */
1801    mount: function mount() {
1802      this.value = Glide.settings.peek;
1803    }
1804  };
1805
1806  define(Peek, 'value', {
1807    /**
1808     * Gets value of the peek.
1809     *
1810     * @returns {Number|Object}
1811     */
1812    get: function get() {
1813      return Peek._v;
1814    },
1815
1816
1817    /**
1818     * Sets value of the peek.
1819     *
1820     * @param {Number|Object} value
1821     * @return {Void}
1822     */
1823    set: function set(value) {
1824      if (isObject(value)) {
1825        value.before = toInt(value.before);
1826        value.after = toInt(value.after);
1827      } else {
1828        value = toInt(value);
1829      }
1830
1831      Peek._v = value;
1832    }
1833  });
1834
1835  define(Peek, 'reductor', {
1836    /**
1837     * Gets reduction value caused by peek.
1838     *
1839     * @returns {Number}
1840     */
1841    get: function get() {
1842      var value = Peek.value;
1843      var perView = Glide.settings.perView;
1844
1845      if (isObject(value)) {
1846        return value.before / perView + value.after / perView;
1847      }
1848
1849      return value * 2 / perView;
1850    }
1851  });
1852
1853  /**
1854   * Recalculate peeking sizes on:
1855   * - when resizing window to update to proper percents
1856   */
1857  Events.on(['resize', 'update'], function () {
1858    Peek.mount();
1859  });
1860
1861  return Peek;
1862}
1863
1864function Move (Glide, Components, Events) {
1865  var Move = {
1866    /**
1867     * Constructs move component.
1868     *
1869     * @returns {Void}
1870     */
1871    mount: function mount() {
1872      this._o = 0;
1873    },
1874
1875
1876    /**
1877     * Calculates a movement value based on passed offset and currently active index.
1878     *
1879     * @param  {Number} offset
1880     * @return {Void}
1881     */
1882    make: function make() {
1883      var _this = this;
1884
1885      var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
1886
1887      this.offset = offset;
1888
1889      Events.emit('move', {
1890        movement: this.value
1891      });
1892
1893      Components.Transition.after(function () {
1894        Events.emit('move.after', {
1895          movement: _this.value
1896        });
1897      });
1898    }
1899  };
1900
1901  define(Move, 'offset', {
1902    /**
1903     * Gets an offset value used to modify current translate.
1904     *
1905     * @return {Object}
1906     */
1907    get: function get() {
1908      return Move._o;
1909    },
1910
1911
1912    /**
1913     * Sets an offset value used to modify current translate.
1914     *
1915     * @return {Object}
1916     */
1917    set: function set(value) {
1918      Move._o = !isUndefined(value) ? toInt(value) : 0;
1919    }
1920  });
1921
1922  define(Move, 'translate', {
1923    /**
1924     * Gets a raw movement value.
1925     *
1926     * @return {Number}
1927     */
1928    get: function get() {
1929      return Components.Sizes.slideWidth * Glide.index;
1930    }
1931  });
1932
1933  define(Move, 'value', {
1934    /**
1935     * Gets an actual movement value corrected by offset.
1936     *
1937     * @return {Number}
1938     */
1939    get: function get() {
1940      var offset = this.offset;
1941      var translate = this.translate;
1942
1943      if (Components.Direction.is('rtl')) {
1944        return translate + offset;
1945      }
1946
1947      return translate - offset;
1948    }
1949  });
1950
1951  /**
1952   * Make movement to proper slide on:
1953   * - before build, so glide will start at `startAt` index
1954   * - on each standard run to move to newly calculated index
1955   */
1956  Events.on(['build.before', 'run'], function () {
1957    Move.make();
1958  });
1959
1960  return Move;
1961}
1962
1963function Sizes (Glide, Components, Events) {
1964  var Sizes = {
1965    /**
1966     * Setups dimentions of slides.
1967     *
1968     * @return {Void}
1969     */
1970    setupSlides: function setupSlides() {
1971      var width = this.slideWidth + 'px';
1972      var slides = Components.Html.slides;
1973
1974      for (var i = 0; i < slides.length; i++) {
1975        slides[i].style.width = width;
1976      }
1977    },
1978
1979
1980    /**
1981     * Setups dimentions of slides wrapper.
1982     *
1983     * @return {Void}
1984     */
1985    setupWrapper: function setupWrapper(dimention) {
1986      Components.Html.wrapper.style.width = this.wrapperSize + 'px';
1987    },
1988
1989
1990    /**
1991     * Removes applied styles from HTML elements.
1992     *
1993     * @returns {Void}
1994     */
1995    remove: function remove() {
1996      var slides = Components.Html.slides;
1997
1998      for (var i = 0; i < slides.length; i++) {
1999        slides[i].style.width = '';
2000      }
2001
2002      Components.Html.wrapper.style.width = '';
2003    }
2004  };
2005
2006  define(Sizes, 'length', {
2007    /**
2008     * Gets count number of the slides.
2009     *
2010     * @return {Number}
2011     */
2012    get: function get() {
2013      return Components.Html.slides.length;
2014    }
2015  });
2016
2017  define(Sizes, 'width', {
2018    /**
2019     * Gets width value of the glide.
2020     *
2021     * @return {Number}
2022     */
2023    get: function get() {
2024      return Components.Html.root.offsetWidth;
2025    }
2026  });
2027
2028  define(Sizes, 'wrapperSize', {
2029    /**
2030     * Gets size of the slides wrapper.
2031     *
2032     * @return {Number}
2033     */
2034    get: function get() {
2035      return Sizes.slideWidth * Sizes.length + Components.Gaps.grow + Components.Clones.grow;
2036    }
2037  });
2038
2039  define(Sizes, 'slideWidth', {
2040    /**
2041     * Gets width value of the single slide.
2042     *
2043     * @return {Number}
2044     */
2045    get: function get() {
2046      return Sizes.width / Glide.settings.perView - Components.Peek.reductor - Components.Gaps.reductor;
2047    }
2048  });
2049
2050  /**
2051   * Apply calculated glide's dimensions:
2052   * - before building, so other dimentions (e.g. translate) will be calculated propertly
2053   * - when resizing window to recalculate sildes dimensions
2054   * - on updating via API, to calculate dimensions based on new options
2055   */
2056  Events.on(['build.before', 'resize', 'update'], function () {
2057    Sizes.setupSlides();
2058    Sizes.setupWrapper();
2059  });
2060
2061  /**
2062   * Remove calculated glide's dimensions:
2063   * - on destoting to bring markup to its inital state
2064   */
2065  Events.on('destroy', function () {
2066    Sizes.remove();
2067  });
2068
2069  return Sizes;
2070}
2071
2072function Build (Glide, Components, Events) {
2073  var Build = {
2074    /**
2075     * Init glide building. Adds classes, sets
2076     * dimensions and setups initial state.
2077     *
2078     * @return {Void}
2079     */
2080    mount: function mount() {
2081      Events.emit('build.before');
2082
2083      this.typeClass();
2084      this.activeClass();
2085
2086      Events.emit('build.after');
2087    },
2088
2089
2090    /**
2091     * Adds `type` class to the glide element.
2092     *
2093     * @return {Void}
2094     */
2095    typeClass: function typeClass() {
2096      Components.Html.root.classList.add(Glide.settings.classes[Glide.settings.type]);
2097    },
2098
2099
2100    /**
2101     * Sets active class to current slide.
2102     *
2103     * @return {Void}
2104     */
2105    activeClass: function activeClass() {
2106      var classes = Glide.settings.classes;
2107      var slide = Components.Html.slides[Glide.index];
2108
2109      if (slide) {
2110        slide.classList.add(classes.activeSlide);
2111
2112        siblings(slide).forEach(function (sibling) {
2113          sibling.classList.remove(classes.activeSlide);
2114        });
2115      }
2116    },
2117
2118
2119    /**
2120     * Removes HTML classes applied at building.
2121     *
2122     * @return {Void}
2123     */
2124    removeClasses: function removeClasses() {
2125      var classes = Glide.settings.classes;
2126
2127      Components.Html.root.classList.remove(classes[Glide.settings.type]);
2128
2129      Components.Html.slides.forEach(function (sibling) {
2130        sibling.classList.remove(classes.activeSlide);
2131      });
2132    }
2133  };
2134
2135  /**
2136   * Clear building classes:
2137   * - on destroying to bring HTML to its initial state
2138   * - on updating to remove classes before remounting component
2139   */
2140  Events.on(['destroy', 'update'], function () {
2141    Build.removeClasses();
2142  });
2143
2144  /**
2145   * Remount component:
2146   * - on resizing of the window to calculate new dimentions
2147   * - on updating settings via API
2148   */
2149  Events.on(['resize', 'update'], function () {
2150    Build.mount();
2151  });
2152
2153  /**
2154   * Swap active class of current slide:
2155   * - after each move to the new index
2156   */
2157  Events.on('move.after', function () {
2158    Build.activeClass();
2159  });
2160
2161  return Build;
2162}
2163
2164function Clones (Glide, Components, Events) {
2165  var Clones = {
2166    /**
2167     * Create pattern map and collect slides to be cloned.
2168     */
2169    mount: function mount() {
2170      this.items = [];
2171
2172      if (Glide.isType('carousel')) {
2173        this.items = this.collect();
2174      }
2175    },
2176
2177
2178    /**
2179     * Collect clones with pattern.
2180     *
2181     * @return {Void}
2182     */
2183    collect: function collect() {
2184      var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
2185      var slides = Components.Html.slides;
2186      var _Glide$settings = Glide.settings,
2187          perView = _Glide$settings.perView,
2188          classes = _Glide$settings.classes;
2189
2190
2191      var peekIncrementer = +!!Glide.settings.peek;
2192      var part = perView + peekIncrementer;
2193      var start = slides.slice(0, part);
2194      var end = slides.slice(-part);
2195
2196      for (var r = 0; r < Math.max(1, Math.floor(perView / slides.length)); r++) {
2197        for (var i = 0; i < start.length; i++) {
2198          var clone = start[i].cloneNode(true);
2199
2200          clone.classList.add(classes.cloneSlide);
2201
2202          items.push(clone);
2203        }
2204
2205        for (var _i = 0; _i < end.length; _i++) {
2206          var _clone = end[_i].cloneNode(true);
2207
2208          _clone.classList.add(classes.cloneSlide);
2209
2210          items.unshift(_clone);
2211        }
2212      }
2213
2214      return items;
2215    },
2216
2217
2218    /**
2219     * Append cloned slides with generated pattern.
2220     *
2221     * @return {Void}
2222     */
2223    append: function append() {
2224      var items = this.items;
2225      var _Components$Html = Components.Html,
2226          wrapper = _Components$Html.wrapper,
2227          slides = _Components$Html.slides;
2228
2229
2230      var half = Math.floor(items.length / 2);
2231      var prepend = items.slice(0, half).reverse();
2232      var append = items.slice(half, items.length);
2233      var width = Components.Sizes.slideWidth + 'px';
2234
2235      for (var i = 0; i < append.length; i++) {
2236        wrapper.appendChild(append[i]);
2237      }
2238
2239      for (var _i2 = 0; _i2 < prepend.length; _i2++) {
2240        wrapper.insertBefore(prepend[_i2], slides[0]);
2241      }
2242
2243      for (var _i3 = 0; _i3 < items.length; _i3++) {
2244        items[_i3].style.width = width;
2245      }
2246    },
2247
2248
2249    /**
2250     * Remove all cloned slides.
2251     *
2252     * @return {Void}
2253     */
2254    remove: function remove() {
2255      var items = this.items;
2256
2257
2258      for (var i = 0; i < items.length; i++) {
2259        Components.Html.wrapper.removeChild(items[i]);
2260      }
2261    }
2262  };
2263
2264  define(Clones, 'grow', {
2265    /**
2266     * Gets additional dimentions value caused by clones.
2267     *
2268     * @return {Number}
2269     */
2270    get: function get() {
2271      return (Components.Sizes.slideWidth + Components.Gaps.value) * Clones.items.length;
2272    }
2273  });
2274
2275  /**
2276   * Append additional slide's clones:
2277   * - while glide's type is `carousel`
2278   */
2279  Events.on('update', function () {
2280    Clones.remove();
2281    Clones.mount();
2282    Clones.append();
2283  });
2284
2285  /**
2286   * Append additional slide's clones:
2287   * - while glide's type is `carousel`
2288   */
2289  Events.on('build.before', function () {
2290    if (Glide.isType('carousel')) {
2291      Clones.append();
2292    }
2293  });
2294
2295  /**
2296   * Remove clones HTMLElements:
2297   * - on destroying, to bring HTML to its initial state
2298   */
2299  Events.on('destroy', function () {
2300    Clones.remove();
2301  });
2302
2303  return Clones;
2304}
2305
2306var EventsBinder = function () {
2307  /**
2308   * Construct a EventsBinder instance.
2309   */
2310  function EventsBinder() {
2311    var listeners = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2312    classCallCheck(this, EventsBinder);
2313
2314    this.listeners = listeners;
2315  }
2316
2317  /**
2318   * Adds events listeners to arrows HTML elements.
2319   *
2320   * @param  {String|Array} events
2321   * @param  {Element|Window|Document} el
2322   * @param  {Function} closure
2323   * @param  {Boolean|Object} capture
2324   * @return {Void}
2325   */
2326
2327
2328  createClass(EventsBinder, [{
2329    key: 'on',
2330    value: function on(events, el, closure) {
2331      var capture = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
2332
2333      if (isString(events)) {
2334        events = [events];
2335      }
2336
2337      for (var i = 0; i < events.length; i++) {
2338        this.listeners[events[i]] = closure;
2339
2340        el.addEventListener(events[i], this.listeners[events[i]], capture);
2341      }
2342    }
2343
2344    /**
2345     * Removes event listeners from arrows HTML elements.
2346     *
2347     * @param  {String|Array} events
2348     * @param  {Element|Window|Document} el
2349     * @param  {Boolean|Object} capture
2350     * @return {Void}
2351     */
2352
2353  }, {
2354    key: 'off',
2355    value: function off(events, el) {
2356      var capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
2357
2358      if (isString(events)) {
2359        events = [events];
2360      }
2361
2362      for (var i = 0; i < events.length; i++) {
2363        el.removeEventListener(events[i], this.listeners[events[i]], capture);
2364      }
2365    }
2366
2367    /**
2368     * Destroy collected listeners.
2369     *
2370     * @returns {Void}
2371     */
2372
2373  }, {
2374    key: 'destroy',
2375    value: function destroy() {
2376      delete this.listeners;
2377    }
2378  }]);
2379  return EventsBinder;
2380}();
2381
2382function Resize (Glide, Components, Events) {
2383  /**
2384   * Instance of the binder for DOM Events.
2385   *
2386   * @type {EventsBinder}
2387   */
2388  var Binder = new EventsBinder();
2389
2390  var Resize = {
2391    /**
2392     * Initializes window bindings.
2393     */
2394    mount: function mount() {
2395      this.bind();
2396    },
2397
2398
2399    /**
2400     * Binds `rezsize` listener to the window.
2401     * It's a costly event, so we are debouncing it.
2402     *
2403     * @return {Void}
2404     */
2405    bind: function bind() {
2406      Binder.on('resize', window, throttle(function () {
2407        Events.emit('resize');
2408      }, Glide.settings.throttle));
2409    },
2410
2411
2412    /**
2413     * Unbinds listeners from the window.
2414     *
2415     * @return {Void}
2416     */
2417    unbind: function unbind() {
2418      Binder.off('resize', window);
2419    }
2420  };
2421
2422  /**
2423   * Remove bindings from window:
2424   * - on destroying, to remove added EventListener
2425   */
2426  Events.on('destroy', function () {
2427    Resize.unbind();
2428    Binder.destroy();
2429  });
2430
2431  return Resize;
2432}
2433
2434var VALID_DIRECTIONS = ['ltr', 'rtl'];
2435var FLIPED_MOVEMENTS = {
2436  '>': '<',
2437  '<': '>',
2438  '=': '='
2439};
2440
2441function Direction (Glide, Components, Events) {
2442  var Direction = {
2443    /**
2444     * Setups gap value based on settings.
2445     *
2446     * @return {Void}
2447     */
2448    mount: function mount() {
2449      this.value = Glide.settings.direction;
2450    },
2451
2452
2453    /**
2454     * Resolves pattern based on direction value
2455     *
2456     * @param {String} pattern
2457     * @returns {String}
2458     */
2459    resolve: function resolve(pattern) {
2460      var token = pattern.slice(0, 1);
2461
2462      if (this.is('rtl')) {
2463        return pattern.split(token).join(FLIPED_MOVEMENTS[token]);
2464      }
2465
2466      return pattern;
2467    },
2468
2469
2470    /**
2471     * Checks value of direction mode.
2472     *
2473     * @param {String} direction
2474     * @returns {Boolean}
2475     */
2476    is: function is(direction) {
2477      return this.value === direction;
2478    },
2479
2480
2481    /**
2482     * Applies direction class to the root HTML element.
2483     *
2484     * @return {Void}
2485     */
2486    addClass: function addClass() {
2487      Components.Html.root.classList.add(Glide.settings.classes.direction[this.value]);
2488    },
2489
2490
2491    /**
2492     * Removes direction class from the root HTML element.
2493     *
2494     * @return {Void}
2495     */
2496    removeClass: function removeClass() {
2497      Components.Html.root.classList.remove(Glide.settings.classes.direction[this.value]);
2498    }
2499  };
2500
2501  define(Direction, 'value', {
2502    /**
2503     * Gets value of the direction.
2504     *
2505     * @returns {Number}
2506     */
2507    get: function get() {
2508      return Direction._v;
2509    },
2510
2511
2512    /**
2513     * Sets value of the direction.
2514     *
2515     * @param {String} value
2516     * @return {Void}
2517     */
2518    set: function set(value) {
2519      if (VALID_DIRECTIONS.indexOf(value) > -1) {
2520        Direction._v = value;
2521      } else {
2522        warn('Direction value must be `ltr` or `rtl`');
2523      }
2524    }
2525  });
2526
2527  /**
2528   * Clear direction class:
2529   * - on destroy to bring HTML to its initial state
2530   * - on update to remove class before reappling bellow
2531   */
2532  Events.on(['destroy', 'update'], function () {
2533    Direction.removeClass();
2534  });
2535
2536  /**
2537   * Remount component:
2538   * - on update to reflect changes in direction value
2539   */
2540  Events.on('update', function () {
2541    Direction.mount();
2542  });
2543
2544  /**
2545   * Apply direction class:
2546   * - before building to apply class for the first time
2547   * - on updating to reapply direction class that may changed
2548   */
2549  Events.on(['build.before', 'update'], function () {
2550    Direction.addClass();
2551  });
2552
2553  return Direction;
2554}
2555
2556/**
2557 * Reflects value of glide movement.
2558 *
2559 * @param  {Object} Glide
2560 * @param  {Object} Components
2561 * @return {Object}
2562 */
2563function Rtl (Glide, Components) {
2564  return {
2565    /**
2566     * Negates the passed translate if glide is in RTL option.
2567     *
2568     * @param  {Number} translate
2569     * @return {Number}
2570     */
2571    modify: function modify(translate) {
2572      if (Components.Direction.is('rtl')) {
2573        return -translate;
2574      }
2575
2576      return translate;
2577    }
2578  };
2579}
2580
2581/**
2582 * Updates glide movement with a `gap` settings.
2583 *
2584 * @param  {Object} Glide
2585 * @param  {Object} Components
2586 * @return {Object}
2587 */
2588function Gap (Glide, Components) {
2589  return {
2590    /**
2591     * Modifies passed translate value with number in the `gap` settings.
2592     *
2593     * @param  {Number} translate
2594     * @return {Number}
2595     */
2596    modify: function modify(translate) {
2597      return translate + Components.Gaps.value * Glide.index;
2598    }
2599  };
2600}
2601
2602/**
2603 * Updates glide movement with width of additional clones width.
2604 *
2605 * @param  {Object} Glide
2606 * @param  {Object} Components
2607 * @return {Object}
2608 */
2609function Grow (Glide, Components) {
2610  return {
2611    /**
2612     * Adds to the passed translate width of the half of clones.
2613     *
2614     * @param  {Number} translate
2615     * @return {Number}
2616     */
2617    modify: function modify(translate) {
2618      return translate + Components.Clones.grow / 2;
2619    }
2620  };
2621}
2622
2623/**
2624 * Updates glide movement with a `peek` settings.
2625 *
2626 * @param  {Object} Glide
2627 * @param  {Object} Components
2628 * @return {Object}
2629 */
2630function Peeking (Glide, Components) {
2631  return {
2632    /**
2633     * Modifies passed translate value with a `peek` setting.
2634     *
2635     * @param  {Number} translate
2636     * @return {Number}
2637     */
2638    modify: function modify(translate) {
2639      if (Glide.settings.focusAt >= 0) {
2640        var peek = Components.Peek.value;
2641
2642        if (isObject(peek)) {
2643          return translate - peek.before;
2644        }
2645
2646        return translate - peek;
2647      }
2648
2649      return translate;
2650    }
2651  };
2652}
2653
2654/**
2655 * Updates glide movement with a `focusAt` settings.
2656 *
2657 * @param  {Object} Glide
2658 * @param  {Object} Components
2659 * @return {Object}
2660 */
2661function Focusing (Glide, Components) {
2662  return {
2663    /**
2664     * Modifies passed translate value with index in the `focusAt` setting.
2665     *
2666     * @param  {Number} translate
2667     * @return {Number}
2668     */
2669    modify: function modify(translate) {
2670      var gap = Components.Gaps.value;
2671      var width = Components.Sizes.width;
2672      var focusAt = Glide.settings.focusAt;
2673      var slideWidth = Components.Sizes.slideWidth;
2674
2675      if (focusAt === 'center') {
2676        return translate - (width / 2 - slideWidth / 2);
2677      }
2678
2679      return translate - slideWidth * focusAt - gap * focusAt;
2680    }
2681  };
2682}
2683
2684/**
2685 * Applies diffrent transformers on translate value.
2686 *
2687 * @param  {Object} Glide
2688 * @param  {Object} Components
2689 * @return {Object}
2690 */
2691function mutator (Glide, Components, Events) {
2692  /**
2693   * Merge instance transformers with collection of default transformers.
2694   * It's important that the Rtl component be last on the list,
2695   * so it reflects all previous transformations.
2696   *
2697   * @type {Array}
2698   */
2699  var TRANSFORMERS = [Gap, Grow, Peeking, Focusing].concat(Glide._t, [Rtl]);
2700
2701  return {
2702    /**
2703     * Piplines translate value with registered transformers.
2704     *
2705     * @param  {Number} translate
2706     * @return {Number}
2707     */
2708    mutate: function mutate(translate) {
2709      for (var i = 0; i < TRANSFORMERS.length; i++) {
2710        var transformer = TRANSFORMERS[i];
2711
2712        if (isFunction(transformer) && isFunction(transformer().modify)) {
2713          translate = transformer(Glide, Components, Events).modify(translate);
2714        } else {
2715          warn('Transformer should be a function that returns an object with `modify()` method');
2716        }
2717      }
2718
2719      return translate;
2720    }
2721  };
2722}
2723
2724function Translate (Glide, Components, Events) {
2725  var Translate = {
2726    /**
2727     * Sets value of translate on HTML element.
2728     *
2729     * @param {Number} value
2730     * @return {Void}
2731     */
2732    set: function set(value) {
2733      var transform = mutator(Glide, Components).mutate(value);
2734
2735      Components.Html.wrapper.style.transform = 'translate3d(' + -1 * transform + 'px, 0px, 0px)';
2736    },
2737
2738
2739    /**
2740     * Removes value of translate from HTML element.
2741     *
2742     * @return {Void}
2743     */
2744    remove: function remove() {
2745      Components.Html.wrapper.style.transform = '';
2746    }
2747  };
2748
2749  /**
2750   * Set new translate value:
2751   * - on move to reflect index change
2752   * - on updating via API to reflect possible changes in options
2753   */
2754  Events.on('move', function (context) {
2755    var gap = Components.Gaps.value;
2756    var length = Components.Sizes.length;
2757    var width = Components.Sizes.slideWidth;
2758
2759    if (Glide.isType('carousel') && Components.Run.isOffset('<')) {
2760      Components.Transition.after(function () {
2761        Events.emit('translate.jump');
2762
2763        Translate.set(width * (length - 1));
2764      });
2765
2766      return Translate.set(-width - gap * length);
2767    }
2768
2769    if (Glide.isType('carousel') && Components.Run.isOffset('>')) {
2770      Components.Transition.after(function () {
2771        Events.emit('translate.jump');
2772
2773        Translate.set(0);
2774      });
2775
2776      return Translate.set(width * length + gap * length);
2777    }
2778
2779    return Translate.set(context.movement);
2780  });
2781
2782  /**
2783   * Remove translate:
2784   * - on destroying to bring markup to its inital state
2785   */
2786  Events.on('destroy', function () {
2787    Translate.remove();
2788  });
2789
2790  return Translate;
2791}
2792
2793function Transition (Glide, Components, Events) {
2794  /**
2795   * Holds inactivity status of transition.
2796   * When true transition is not applied.
2797   *
2798   * @type {Boolean}
2799   */
2800  var disabled = false;
2801
2802  var Transition = {
2803    /**
2804     * Composes string of the CSS transition.
2805     *
2806     * @param {String} property
2807     * @return {String}
2808     */
2809    compose: function compose(property) {
2810      var settings = Glide.settings;
2811
2812      if (!disabled) {
2813        return property + ' ' + this.duration + 'ms ' + settings.animationTimingFunc;
2814      }
2815
2816      return property + ' 0ms ' + settings.animationTimingFunc;
2817    },
2818
2819
2820    /**
2821     * Sets value of transition on HTML element.
2822     *
2823     * @param {String=} property
2824     * @return {Void}
2825     */
2826    set: function set() {
2827      var property = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';
2828
2829      Components.Html.wrapper.style.transition = this.compose(property);
2830    },
2831
2832
2833    /**
2834     * Removes value of transition from HTML element.
2835     *
2836     * @return {Void}
2837     */
2838    remove: function remove() {
2839      Components.Html.wrapper.style.transition = '';
2840    },
2841
2842
2843    /**
2844     * Runs callback after animation.
2845     *
2846     * @param  {Function} callback
2847     * @return {Void}
2848     */
2849    after: function after(callback) {
2850      setTimeout(function () {
2851        callback();
2852      }, this.duration);
2853    },
2854
2855
2856    /**
2857     * Enable transition.
2858     *
2859     * @return {Void}
2860     */
2861    enable: function enable() {
2862      disabled = false;
2863
2864      this.set();
2865    },
2866
2867
2868    /**
2869     * Disable transition.
2870     *
2871     * @return {Void}
2872     */
2873    disable: function disable() {
2874      disabled = true;
2875
2876      this.set();
2877    }
2878  };
2879
2880  define(Transition, 'duration', {
2881    /**
2882     * Gets duration of the transition based
2883     * on currently running animation type.
2884     *
2885     * @return {Number}
2886     */
2887    get: function get() {
2888      var settings = Glide.settings;
2889
2890      if (Glide.isType('slider') && Components.Run.offset) {
2891        return settings.rewindDuration;
2892      }
2893
2894      return settings.animationDuration;
2895    }
2896  });
2897
2898  /**
2899   * Set transition `style` value:
2900   * - on each moving, because it may be cleared by offset move
2901   */
2902  Events.on('move', function () {
2903    Transition.set();
2904  });
2905
2906  /**
2907   * Disable transition:
2908   * - before initial build to avoid transitioning from `0` to `startAt` index
2909   * - while resizing window and recalculating dimentions
2910   * - on jumping from offset transition at start and end edges in `carousel` type
2911   */
2912  Events.on(['build.before', 'resize', 'translate.jump'], function () {
2913    Transition.disable();
2914  });
2915
2916  /**
2917   * Enable transition:
2918   * - on each running, because it may be disabled by offset move
2919   */
2920  Events.on('run', function () {
2921    Transition.enable();
2922  });
2923
2924  /**
2925   * Remove transition:
2926   * - on destroying to bring markup to its inital state
2927   */
2928  Events.on('destroy', function () {
2929    Transition.remove();
2930  });
2931
2932  return Transition;
2933}
2934
2935/**
2936 * Test via a getter in the options object to see
2937 * if the passive property is accessed.
2938 *
2939 * @see https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection
2940 */
2941
2942var supportsPassive = false;
2943
2944try {
2945  var opts = Object.defineProperty({}, 'passive', {
2946    get: function get() {
2947      supportsPassive = true;
2948    }
2949  });
2950
2951  window.addEventListener('testPassive', null, opts);
2952  window.removeEventListener('testPassive', null, opts);
2953} catch (e) {}
2954
2955var supportsPassive$1 = supportsPassive;
2956
2957var START_EVENTS = ['touchstart', 'mousedown'];
2958var MOVE_EVENTS = ['touchmove', 'mousemove'];
2959var END_EVENTS = ['touchend', 'touchcancel', 'mouseup', 'mouseleave'];
2960var MOUSE_EVENTS = ['mousedown', 'mousemove', 'mouseup', 'mouseleave'];
2961
2962function Swipe (Glide, Components, Events) {
2963  /**
2964   * Instance of the binder for DOM Events.
2965   *
2966   * @type {EventsBinder}
2967   */
2968  var Binder = new EventsBinder();
2969
2970  var swipeSin = 0;
2971  var swipeStartX = 0;
2972  var swipeStartY = 0;
2973  var disabled = false;
2974  var capture = supportsPassive$1 ? { passive: true } : false;
2975
2976  var Swipe = {
2977    /**
2978     * Initializes swipe bindings.
2979     *
2980     * @return {Void}
2981     */
2982    mount: function mount() {
2983      this.bindSwipeStart();
2984    },
2985
2986
2987    /**
2988     * Handler for `swipestart` event. Calculates entry points of the user's tap.
2989     *
2990     * @param {Object} event
2991     * @return {Void}
2992     */
2993    start: function start(event) {
2994      if (!disabled && !Glide.disabled) {
2995        this.disable();
2996
2997        var swipe = this.touches(event);
2998
2999        swipeSin = null;
3000        swipeStartX = toInt(swipe.pageX);
3001        swipeStartY = toInt(swipe.pageY);
3002
3003        this.bindSwipeMove();
3004        this.bindSwipeEnd();
3005
3006        Events.emit('swipe.start');
3007      }
3008    },
3009
3010
3011    /**
3012     * Handler for `swipemove` event. Calculates user's tap angle and distance.
3013     *
3014     * @param {Object} event
3015     */
3016    move: function move(event) {
3017      if (!Glide.disabled) {
3018        var _Glide$settings = Glide.settings,
3019            touchAngle = _Glide$settings.touchAngle,
3020            touchRatio = _Glide$settings.touchRatio,
3021            classes = _Glide$settings.classes;
3022
3023
3024        var swipe = this.touches(event);
3025
3026        var subExSx = toInt(swipe.pageX) - swipeStartX;
3027        var subEySy = toInt(swipe.pageY) - swipeStartY;
3028        var powEX = Math.abs(subExSx << 2);
3029        var powEY = Math.abs(subEySy << 2);
3030        var swipeHypotenuse = Math.sqrt(powEX + powEY);
3031        var swipeCathetus = Math.sqrt(powEY);
3032
3033        swipeSin = Math.asin(swipeCathetus / swipeHypotenuse);
3034
3035        if (swipeSin * 180 / Math.PI < touchAngle) {
3036          event.stopPropagation();
3037
3038          Components.Move.make(subExSx * toFloat(touchRatio));
3039
3040          Components.Html.root.classList.add(classes.dragging);
3041
3042          Events.emit('swipe.move');
3043        }