https://www.linforme.com/bucket/9c498bb8ad0829f81b1635357e7261da65225d21/js/home.bundle.js

43/******/ 			var getter = module && module.__esModule ?
44/******/ 				() => (module['default']) :
45/******/ 				() => (module);
46/******/ 			__webpack_require__.d(getter, { a: getter });
47/******/ 			return getter;
48/******/ 		};
49/******/ 	})();
50/******/ 	
51/******/ 	/* webpack/runtime/define property getters */
52/******/ 	(() => {
53/******/ 		// define getter functions for harmony exports
54/******/ 		__webpack_require__.d = (exports, definition) => {
55/******/ 			for(var key in definition) {
56/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
57/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
58/******/ 				}
59/******/ 			}
60/******/ 		};
61/******/ 	})();
62/******/ 	
63/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
64/******/ 	(() => {
65/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
66/******/ 	})();
67/******/ 	
68/************************************************************************/
69var __webpack_exports__ = {};
70// This entry need to be wrapped in an IIFE because it need to be in strict mode.
71(() => {
72"use strict";
73
74// EXTERNAL MODULE: ../../node_modules/vanilla-lazyload/dist/lazyload.min.js
75var lazyload_min = __webpack_require__(9766);
76var lazyload_min_default = /*#__PURE__*/__webpack_require__.n(lazyload_min);
77;// CONCATENATED MODULE: ./assets/js/_pages/home/components/lazyload.js
78
79/* harmony default export */ const lazyload = (function () {
80  // eslint-disable-next-line no-new
81  new (lazyload_min_default())({
82    threshold: 0
83  });
84});
85;// CONCATENATED MODULE: ../../node_modules/@glidejs/glide/dist/glide.esm.js
86/*!
87 * Glide.js v3.5.2
88 * (c) 2013-2021 Jędrzej Chałubek (https://github.com/jedrzejchalubek/)
89 * Released under the MIT License.
90 */
91
92function _typeof(obj) {
93  "@babel/helpers - typeof";
94
95  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
96    _typeof = function (obj) {
97      return typeof obj;
98    };
99  } else {
100    _typeof = function (obj) {
101      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
102    };
103  }
104
105  return _typeof(obj);
106}
107
108function _classCallCheck(instance, Constructor) {
109  if (!(instance instanceof Constructor)) {
110    throw new TypeError("Cannot call a class as a function");
111  }
112}
113
114function _defineProperties(target, props) {
115  for (var i = 0; i < props.length; i++) {
116    var descriptor = props[i];
117    descriptor.enumerable = descriptor.enumerable || false;
118    descriptor.configurable = true;
119    if ("value" in descriptor) descriptor.writable = true;
120    Object.defineProperty(target, descriptor.key, descriptor);
121  }
122}
123
124function _createClass(Constructor, protoProps, staticProps) {
125  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
126  if (staticProps) _defineProperties(Constructor, staticProps);
127  return Constructor;
128}
129
130function _inherits(subClass, superClass) {
131  if (typeof superClass !== "function" && superClass !== null) {
132    throw new TypeError("Super expression must either be null or a function");
133  }
134
135  subClass.prototype = Object.create(superClass && superClass.prototype, {
136    constructor: {
137      value: subClass,
138      writable: true,
139      configurable: true
140    }
141  });
142  if (superClass) _setPrototypeOf(subClass, superClass);
143}
144
145function _getPrototypeOf(o) {
146  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
147    return o.__proto__ || Object.getPrototypeOf(o);
148  };
149  return _getPrototypeOf(o);
150}
151
152function _setPrototypeOf(o, p) {
153  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
154    o.__proto__ = p;
155    return o;
156  };
157
158  return _setPrototypeOf(o, p);
159}
160
161function _isNativeReflectConstruct() {
162  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
163  if (Reflect.construct.sham) return false;
164  if (typeof Proxy === "function") return true;
165
166  try {
167    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
168    return true;
169  } catch (e) {
170    return false;

171  }
172}
173
174function _assertThisInitialized(self) {
175  if (self === void 0) {
176    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
177  }
178
179  return self;
180}
181
182function _possibleConstructorReturn(self, call) {
183  if (call && (typeof call === "object" || typeof call === "function")) {
184    return call;
185  } else if (call !== void 0) {
186    throw new TypeError("Derived constructors may only return object or undefined");
187  }
188
189  return _assertThisInitialized(self);
190}
191
192function _createSuper(Derived) {
193  var hasNativeReflectConstruct = _isNativeReflectConstruct();
194
195  return function _createSuperInternal() {
196    var Super = _getPrototypeOf(Derived),
197        result;
198
199    if (hasNativeReflectConstruct) {
200      var NewTarget = _getPrototypeOf(this).constructor;
201
202      result = Reflect.construct(Super, arguments, NewTarget);
203    } else {
204      result = Super.apply(this, arguments);
205    }
206
207    return _possibleConstructorReturn(this, result);
208  };
209}
210
211function _superPropBase(object, property) {
212  while (!Object.prototype.hasOwnProperty.call(object, property)) {
213    object = _getPrototypeOf(object);
214    if (object === null) break;
215  }
216
217  return object;
218}
219
220function _get() {
221  if (typeof Reflect !== "undefined" && Reflect.get) {
222    _get = Reflect.get;
223  } else {
224    _get = function _get(target, property, receiver) {
225      var base = _superPropBase(target, property);
226
227      if (!base) return;
228      var desc = Object.getOwnPropertyDescriptor(base, property);
229
230      if (desc.get) {
231        return desc.get.call(arguments.length < 3 ? target : receiver);
232      }
233
234      return desc.value;
235    };
236  }
237
238  return _get.apply(this, arguments);
239}
240
241var defaults = {
242  /**
243   * Type of the movement.
244   *
245   * Available types:
246   * `slider` - Rewinds slider to the start/end when it reaches the first or last slide.
247   * `carousel` - Changes slides without starting over when it reaches the first or last slide.
248   *
249   * @type {String}
250   */
251  type: 'slider',
252
253  /**
254   * Start at specific slide number defined with zero-based index.
255   *
256   * @type {Number}
257   */
258  startAt: 0,
259
260  /**
261   * A number of slides visible on the single viewport.
262   *
263   * @type {Number}
264   */
265  perView: 1,
266
267  /**
268   * Focus currently active slide at a specified position in the track.
269   *
270   * Available inputs:
271   * `center` - Current slide will be always focused at the center of a track.
272   * `0,1,2,3...` - Current slide will be focused on the specified zero-based index.
273   *
274   * @type {String|Number}
275   */
276  focusAt: 0,
277
278  /**
279   * A size of the gap added between slides.
280   *
281   * @type {Number}
282   */
283  gap: 10,
284
285  /**
286   * Change slides after a specified interval. Use `false` for turning off autoplay.
287   *
288   * @type {Number|Boolean}
289   */
290  autoplay: false,
291
292  /**
293   * Stop autoplay on mouseover event.
294   *
295   * @type {Boolean}
296   */
297  hoverpause: true,
298
299  /**
300   * Allow for changing slides with left and right keyboard arrows.
301   *
302   * @type {Boolean}
303   */
304  keyboard: true,
305
306  /**
307   * Stop running `perView` number of slides from the end. Use this
308   * option if you don't want to have an empty space after
309   * a slider. Works only with `slider` type and a
310   * non-centered `focusAt` setting.
311   *
312   * @type {Boolean}
313   */
314  bound: false,
315
316  /**
317   * Minimal swipe distance needed to change the slide. Use `false` for turning off a swiping.
318   *
319   * @type {Number|Boolean}
320   */
321  swipeThreshold: 80,
322
323  /**
324   * Minimal mouse drag distance needed to change the slide. Use `false` for turning off a dragging.
325   *
326   * @type {Number|Boolean}
327   */
328  dragThreshold: 120,
329
330  /**
331   * A number of slides moved on single swipe.
332   *
333   * Available types:
334   * `` - Moves slider by one slide per swipe
335   * `|` - Moves slider between views per swipe (number of slides defined in `perView` options)
336   *
337   * @type {String}
338   */
339  perSwipe: '',
340
341  /**
342   * Moving distance ratio of the slides on a swiping and dragging.
343   *
344   * @type {Number}
345   */
346  touchRatio: 0.5,
347
348  /**
349   * Angle required to activate slides moving on swiping or dragging.
350   *
351   * @type {Number}
352   */
353  touchAngle: 45,
354
355  /**
356   * Duration of the animation in milliseconds.
357   *
358   * @type {Number}
359   */
360  animationDuration: 400,
361
362  /**
363   * Allows looping the `slider` type. Slider will rewind to the first/last slide when it's at the start/end.
364   *
365   * @type {Boolean}
366   */
367  rewind: true,
368
369  /**
370   * Duration of the rewinding animation of the `slider` type in milliseconds.
371   *
372   * @type {Number}
373   */
374  rewindDuration: 800,
375
376  /**
377   * Easing function for the animation.
378   *
379   * @type {String}
380   */
381  animationTimingFunc: 'cubic-bezier(.165, .840, .440, 1)',
382
383  /**
384   * Wait for the animation to finish until the next user input can be processed
385   *
386   * @type {boolean}
387   */
388  waitForTransition: true,
389
390  /**
391   * Throttle costly events at most once per every wait milliseconds.
392   *
393   * @type {Number}
394   */
395  throttle: 10,
396
397  /**
398   * Moving direction mode.
399   *
400   * Available inputs:
401   * - 'ltr' - left to right movement,
402   * - 'rtl' - right to left movement.
403   *
404   * @type {String}
405   */
406  direction: 'ltr',
407
408  /**
409   * The distance value of the next and previous viewports which
410   * have to peek in the current view. Accepts number and
411   * pixels as a string. Left and right peeking can be
412   * set up separately with a directions object.
413   *
414   * For example:
415   * `100` - Peek 100px on the both sides.
416   * { before: 100, after: 50 }` - Peek 100px on the left side and 50px on the right side.
417   *
418   * @type {Number|String|Object}
419   */
420  peek: 0,
421
422  /**
423   * Defines how many clones of current viewport will be generated.
424   *
425   * @type {Number}
426   */
427  cloningRatio: 1,
428
429  /**
430   * Collection of options applied at specified media breakpoints.
431   * For example: display two slides per view under 800px.
432   * `{
433   *   '800px': {
434   *     perView: 2
435   *   }
436   * }`
437   */
438  breakpoints: {},
439
440  /**
441   * Collection of internally used HTML classes.
442   *
443   * @todo Refactor `slider` and `carousel` properties to single `type: { slider: '', carousel: '' }` object
444   * @type {Object}
445   */
446  classes: {
447    swipeable: 'glide--swipeable',
448    dragging: 'glide--dragging',
449    direction: {
450      ltr: 'glide--ltr',
451      rtl: 'glide--rtl'
452    },
453    type: {
454      slider: 'glide--slider',
455      carousel: 'glide--carousel'
456    },
457    slide: {
458      clone: 'glide__slide--clone',
459      active: 'glide__slide--active'
460    },
461    arrow: {
462      disabled: 'glide__arrow--disabled'
463    },
464    nav: {
465      active: 'glide__bullet--active'
466    }
467  }
468};
469
470/**
471 * Outputs warning message to the bowser console.
472 *
473 * @param  {String} msg
474 * @return {Void}
475 */
476function warn(msg) {
477  console.error("[Glide warn]: ".concat(msg));
478}
479
480/**
481 * Converts value entered as number
482 * or string to integer value.
483 *
484 * @param {String} value
485 * @returns {Number}
486 */
487function toInt(value) {
488  return parseInt(value);
489}
490/**
491 * Converts value entered as number
492 * or string to flat value.
493 *
494 * @param {String} value
495 * @returns {Number}
496 */
497
498function toFloat(value) {
499  return parseFloat(value);
500}
501/**
502 * Indicates whether the specified value is a string.
503 *
504 * @param  {*}   value
505 * @return {Boolean}
506 */
507
508function isString(value) {
509  return typeof value === 'string';
510}
511/**
512 * Indicates whether the specified value is an object.
513 *
514 * @param  {*} value
515 * @return {Boolean}
516 *
517 * @see https://github.com/jashkenas/underscore
518 */
519
520function isObject(value) {
521  var type = _typeof(value);
522
523  return type === 'function' || type === 'object' && !!value; // eslint-disable-line no-mixed-operators
524}
525/**
526 * Indicates whether the specified value is a function.
527 *
528 * @param  {*} value
529 * @return {Boolean}
530 */
531
532function isFunction(value) {
533  return typeof value === 'function';
534}
535/**
536 * Indicates whether the specified value is undefined.
537 *
538 * @param  {*} value
539 * @return {Boolean}
540 */
541
542function isUndefined(value) {
543  return typeof value === 'undefined';
544}
545/**
546 * Indicates whether the specified value is an array.
547 *
548 * @param  {*} value
549 * @return {Boolean}
550 */
551
552function isArray(value) {
553  return value.constructor === Array;
554}
555
556/**
557 * Creates and initializes specified collection of extensions.
558 * Each extension receives access to instance of glide and rest of components.
559 *
560 * @param {Object} glide
561 * @param {Object} extensions
562 *
563 * @returns {Object}
564 */
565
566function mount(glide, extensions, events) {
567  var components = {};
568
569  for (var name in extensions) {
570    if (isFunction(extensions[name])) {
571      components[name] = extensions[name](glide, components, events);
572    } else {
573      warn('Extension must be a function');
574    }
575  }
576
577  for (var _name in components) {
578    if (isFunction(components[_name].mount)) {
579      components[_name].mount();
580    }
581  }
582
583  return components;
584}
585
586/**
587 * Defines getter and setter property on the specified object.
588 *
589 * @param  {Object} obj         Object where property has to be defined.
590 * @param  {String} prop        Name of the defined property.
591 * @param  {Object} definition  Get and set definitions for the property.
592 * @return {Void}
593 */
594function glide_esm_define(obj, prop, definition) {
595  Object.defineProperty(obj, prop, definition);
596}
597/**
598 * Sorts aphabetically object keys.
599 *
600 * @param  {Object} obj
601 * @return {Object}
602 */
603
604function sortKeys(obj) {
605  return Object.keys(obj).sort().reduce(function (r, k) {
606    r[k] = obj[k];
607    return r[k], r;
608  }, {});
609}
610/**
611 * Merges passed settings object with default options.
612 *
613 * @param  {Object} defaults
614 * @param  {Object} settings
615 * @return {Object}
616 */
617
618function mergeOptions(defaults, settings) {
619  var options = Object.assign({}, defaults, settings); // `Object.assign` do not deeply merge objects, so we
620  // have to do it manually for every nested object
621  // in options. Although it does not look smart,
622  // it's smaller and faster than some fancy
623  // merging deep-merge algorithm script.
624
625  if (settings.hasOwnProperty('classes')) {
626    options.classes = Object.assign({}, defaults.classes, settings.classes);
627
628    if (settings.classes.hasOwnProperty('direction')) {
629      options.classes.direction = Object.assign({}, defaults.classes.direction, settings.classes.direction);
630    }
631
632    if (settings.classes.hasOwnProperty('type')) {
633      options.classes.type = Object.assign({}, defaults.classes.type, settings.classes.type);
634    }
635
636    if (settings.classes.hasOwnProperty('slide')) {
637      options.classes.slide = Object.assign({}, defaults.classes.slide, settings.classes.slide);
638    }
639
640    if (settings.classes.hasOwnProperty('arrow')) {
641      options.classes.arrow = Object.assign({}, defaults.classes.arrow, settings.classes.arrow);
642    }
643
644    if (settings.classes.hasOwnProperty('nav')) {
645      options.classes.nav = Object.assign({}, defaults.classes.nav, settings.classes.nav);
646    }
647  }
648
649  if (settings.hasOwnProperty('breakpoints')) {
650    options.breakpoints = Object.assign({}, defaults.breakpoints, settings.breakpoints);
651  }
652
653  return options;
654}
655
656var EventsBus = /*#__PURE__*/function () {
657  /**
658   * Construct a EventBus instance.
659   *
660   * @param {Object} events
661   */
662  function EventsBus() {
663    var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
664
665    _classCallCheck(this, EventsBus);
666
667    this.events = events;
668    this.hop = events.hasOwnProperty;
669  }
670  /**
671   * Adds listener to the specifed event.
672   *
673   * @param {String|Array} event
674   * @param {Function} handler
675   */
676
677
678  _createClass(EventsBus, [{
679    key: "on",
680    value: function on(event, handler) {
681      if (isArray(event)) {
682        for (var i = 0; i < event.length; i++) {
683          this.on(event[i], handler);
684        }
685
686        return;
687      } // Create the event's object if not yet created
688
689
690      if (!this.hop.call(this.events, event)) {
691        this.events[event] = [];
692      } // Add the handler to queue
693
694
695      var index = this.events[event].push(handler) - 1; // Provide handle back for removal of event
696
697      return {
698        remove: function remove() {
699          delete this.events[event][index];
700        }
701      };
702    }
703    /**
704     * Runs registered handlers for specified event.
705     *
706     * @param {String|Array} event
707     * @param {Object=} context
708     */
709
710  }, {
711    key: "emit",
712    value: function emit(event, context) {
713      if (isArray(event)) {
714        for (var i = 0; i < event.length; i++) {
715          this.emit(event[i], context);
716        }
717
718        return;
719      } // If the event doesn't exist, or there's no handlers in queue, just leave
720
721
722      if (!this.hop.call(this.events, event)) {
723        return;
724      } // Cycle through events queue, fire!
725
726
727      this.events[event].forEach(function (item) {
728        item(context || {});
729      });
730    }
731  }]);
732
733  return EventsBus;
734}();
735
736var Glide$1 = /*#__PURE__*/function () {
737  /**
738   * Construct glide.
739   *
740   * @param  {String} selector
741   * @param  {Object} options
742   */
743  function Glide(selector) {
744    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
745
746    _classCallCheck(this, Glide);
747
748    this._c = {};
749    this._t = [];
750    this._e = new EventsBus();
751    this.disabled = false;
752    this.selector = selector;
753    this.settings = mergeOptions(defaults, options);
754    this.index = this.settings.startAt;
755  }
756  /**
757   * Initializes glide.
758   *
759   * @param {Object} extensions Collection of extensions to initialize.
760   * @return {Glide}
761   */
762
763
764  _createClass(Glide, [{
765    key: "mount",
766    value: function mount$1() {
767      var extensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
768
769      this._e.emit('mount.before');
770
771      if (isObject(extensions)) {
772        this._c = mount(this, extensions, this._e);
773      } else {
774        warn('You need to provide a object on `mount()`');
775      }
776
777      this._e.emit('mount.after');
778
779      return this;
780    }
781    /**
782     * Collects an instance `translate` transformers.
783     *
784     * @param  {Array} transformers Collection of transformers.
785     * @return {Void}
786     */
787
788  }, {
789    key: "mutate",
790    value: function mutate() {
791      var transformers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
792
793      if (isArray(transformers)) {
794        this._t = transformers;
795      } else {
796        warn('You need to provide a array on `mutate()`');
797      }
798
799      return this;
800    }
801    /**
802     * Updates glide with specified settings.
803     *
804     * @param {Object} settings
805     * @return {Glide}
806     */
807
808  }, {
809    key: "update",
810    value: function update() {
811      var settings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
812      this.settings = mergeOptions(this.settings, settings);
813
814      if (settings.hasOwnProperty('startAt')) {
815        this.index = settings.startAt;
816      }
817
818      this._e.emit('update');
819
820      return this;
821    }
822    /**
823     * Change slide with specified pattern. A pattern must be in the special format:
824     * `>` - Move one forward
825     * `<` - Move one backward
826     * `={i}` - Go to {i} zero-based slide (eq. '=1', will go to second slide)
827     * `>>` - Rewinds to end (last slide)
828     * `<<` - Rewinds to start (first slide)
829     * `|>` - Move one viewport forward
830     * `|<` - Move one viewport backward
831     *
832     * @param {String} pattern
833     * @return {Glide}
834     */
835
836  }, {
837    key: "go",
838    value: function go(pattern) {
839      this._c.Run.make(pattern);
840
841      return this;
842    }
843    /**
844     * Move track by specified distance.
845     *
846     * @param {String} distance
847     * @return {Glide}
848     */
849
850  }, {
851    key: "move",
852    value: function move(distance) {
853      this._c.Transition.disable();
854
855      this._c.Move.make(distance);
856
857      return this;
858    }
859    /**
860     * Destroy instance and revert all changes done by this._c.
861     *
862     * @return {Glide}
863     */
864
865  }, {
866    key: "destroy",
867    value: function destroy() {
868      this._e.emit('destroy');
869
870      return this;
871    }
872    /**
873     * Start instance autoplaying.
874     *
875     * @param {Boolean|Number} interval Run autoplaying with passed interval regardless of `autoplay` settings
876     * @return {Glide}
877     */
878
879  }, {
880    key: "play",
881    value: function play() {
882      var interval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
883
884      if (interval) {
885        this.settings.autoplay = interval;
886      }
887
888      this._e.emit('play');
889
890      return this;
891    }
892    /**
893     * Stop instance autoplaying.
894     *
895     * @return {Glide}
896     */
897
898  }, {
899    key: "pause",
900    value: function pause() {
901      this._e.emit('pause');
902
903      return this;
904    }
905    /**
906     * Sets glide into a idle status.
907     *
908     * @return {Glide}
909     */
910
911  }, {
912    key: "disable",
913    value: function disable() {
914      this.disabled = true;
915      return this;
916    }
917    /**
918     * Sets glide into a active status.
919     *
920     * @return {Glide}
921     */
922
923  }, {
924    key: "enable",
925    value: function enable() {
926      this.disabled = false;
927      return this;
928    }
929    /**
930     * Adds cuutom event listener with handler.
931     *
932     * @param  {String|Array} event
933     * @param  {Function} handler
934     * @return {Glide}
935     */
936
937  }, {
938    key: "on",
939    value: function on(event, handler) {
940      this._e.on(event, handler);
941
942      return this;
943    }
944    /**
945     * Checks if glide is a precised type.
946     *
947     * @param  {String} name
948     * @return {Boolean}
949     */
950
951  }, {
952    key: "isType",
953    value: function isType(name) {
954      return this.settings.type === name;
955    }
956    /**
957     * Gets value of the core options.
958     *
959     * @return {Object}
960     */
961
962  }, {
963    key: "settings",
964    get: function get() {
965      return this._o;
966    }
967    /**
968     * Sets value of the core options.
969     *
970     * @param  {Object} o
971     * @return {Void}
972     */
973    ,
974    set: function set(o) {
975      if (isObject(o)) {
976        this._o = o;
977      } else {
978        warn('Options must be an `object` instance.');
979      }
980    }
981    /**
982     * Gets current index of the slider.
983     *
984     * @return {Object}
985     */
986
987  }, {
988    key: "index",
989    get: function get() {
990      return this._i;
991    }
992    /**
993     * Sets current index a slider.
994     *
995     * @return {Object}
996     */
997    ,
998    set: function set(i) {
999      this._i = toInt(i);
1000    }
1001    /**
1002     * Gets type name of the slider.
1003     *
1004     * @return {String}
1005     */
1006
1007  }, {
1008    key: "type",
1009    get: function get() {
1010      return this.settings.type;
1011    }
1012    /**
1013     * Gets value of the idle status.
1014     *
1015     * @return {Boolean}
1016     */
1017
1018  }, {
1019    key: "disabled",
1020    get: function get() {
1021      return this._d;
1022    }
1023    /**
1024     * Sets value of the idle status.
1025     *
1026     * @return {Boolean}
1027     */
1028    ,
1029    set: function set(status) {
1030      this._d = !!status;
1031    }
1032  }]);
1033
1034  return Glide;
1035}();
1036
1037function Run (Glide, Components, Events) {
1038  var Run = {
1039    /**
1040     * Initializes autorunning of the glide.
1041     *
1042     * @return {Void}
1043     */
1044    mount: function mount() {
1045      this._o = false;
1046    },
1047
1048    /**
1049     * Makes glides running based on the passed moving schema.
1050     *
1051     * @param {String} move
1052     */
1053    make: function make(move) {
1054      var _this = this;
1055
1056      if (!Glide.disabled) {
1057        !Glide.settings.waitForTransition || Glide.disable();
1058        this.move = move;
1059        Events.emit('run.before', this.move);
1060        this.calculate();
1061        Events.emit('run', this.move);
1062        Components.Transition.after(function () {
1063          if (_this.isStart()) {
1064            Events.emit('run.start', _this.move);
1065          }
1066
1067          if (_this.isEnd()) {
1068            Events.emit('run.end', _this.move);
1069          }
1070
1071          if (_this.isOffset()) {
1072            _this._o = false;
1073            Events.emit('run.offset', _this.move);
1074          }
1075
1076          Events.emit('run.after', _this.move);
1077          Glide.enable();
1078        });
1079      }
1080    },
1081
1082    /**
1083     * Calculates current index based on defined move.
1084     *
1085     * @return {Number|Undefined}
1086     */
1087    calculate: function calculate() {
1088      var move = this.move,
1089          length = this.length;
1090      var steps = move.steps,
1091          direction = move.direction; // By default assume that size of view is equal to one slide
1092
1093      var viewSize = 1; // While direction is `=` we want jump to
1094      // a specified index described in steps.
1095
1096      if (direction === '=') {
1097        // Check if bound is true, 
1098        // as we want to avoid whitespaces.
1099        if (Glide.settings.bound && toInt(steps) > length) {
1100          Glide.index = length;
1101          return;
1102        }
1103
1104        Glide.index = steps;
1105        return;
1106      } // When pattern is equal to `>>` we want
1107      // fast forward to the last slide.
1108
1109
1110      if (direction === '>' && steps === '>') {
1111        Glide.index = length;
1112        return;
1113      } // When pattern is equal to `<<` we want
1114      // fast forward to the first slide.
1115
1116
1117      if (direction === '<' && steps === '<') {
1118        Glide.index = 0;
1119        return;
1120      } // pagination movement
1121
1122
1123      if (direction === '|') {
1124        viewSize = Glide.settings.perView || 1;
1125      } // we are moving forward
1126
1127
1128      if (direction === '>' || direction === '|' && steps === '>') {
1129        var index = calculateForwardIndex(viewSize);
1130
1131        if (index > length) {
1132          this._o = true;
1133        }
1134
1135        Glide.index = normalizeForwardIndex(index, viewSize);
1136        return;
1137      } // we are moving backward
1138
1139
1140      if (direction === '<' || direction === '|' && steps === '<') {
1141        var _index = calculateBackwardIndex(viewSize);
1142
1143        if (_index < 0) {
1144          this._o = true;
1145        }
1146
1147        Glide.index = normalizeBackwardIndex(_index, viewSize);
1148        return;
1149      }
1150
1151      warn("Invalid direction pattern [".concat(direction).concat(steps, "] has been used"));
1152    },
1153
1154    /**
1155     * Checks if we are on the first slide.
1156     *
1157     * @return {Boolean}
1158     */
1159    isStart: function isStart() {
1160      return Glide.index <= 0;
1161    },
1162
1163    /**
1164     * Checks if we are on the last slide.
1165     *
1166     * @return {Boolean}
1167     */
1168    isEnd: function isEnd() {
1169      return Glide.index >= this.length;
1170    },
1171
1172    /**
1173     * Checks if we are making a offset run.
1174     *
1175     * @param {String} direction
1176     * @return {Boolean}
1177     */
1178    isOffset: function isOffset() {
1179      var direction = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
1180
1181      if (!direction) {
1182        return this._o;
1183      }
1184
1185      if (!this._o) {
1186        return false;
1187      } // did we view to the right?
1188
1189
1190      if (direction === '|>') {
1191        return this.move.direction === '|' && this.move.steps === '>';
1192      } // did we view to the left?
1193
1194
1195      if (direction === '|<') {
1196        return this.move.direction === '|' && this.move.steps === '<';
1197      }
1198
1199      return this.move.direction === direction;
1200    },
1201
1202    /**
1203     * Checks if bound mode is active
1204     *
1205     * @return {Boolean}
1206     */
1207    isBound: function isBound() {
1208      return Glide.isType('slider') && Glide.settings.focusAt !== 'center' && Glide.settings.bound;
1209    }
1210  };
1211  /**
1212   * Returns index value to move forward/to the right
1213   *
1214   * @param viewSize
1215   * @returns {Number}
1216   */
1217
1218  function calculateForwardIndex(viewSize) {
1219    var index = Glide.index;
1220
1221    if (Glide.isType('carousel')) {
1222      return index + viewSize;
1223    }
1224
1225    return index + (viewSize - index % viewSize);
1226  }
1227  /**
1228   * Normalizes the given forward index based on glide settings, preventing it to exceed certain boundaries
1229   *
1230   * @param index
1231   * @param length
1232   * @param viewSize
1233   * @returns {Number}
1234   */
1235
1236
1237  function normalizeForwardIndex(index, viewSize) {
1238    var length = Run.length;
1239
1240    if (index <= length) {
1241      return index;
1242    }
1243
1244    if (Glide.isType('carousel')) {
1245      return index - (length + 1);
1246    }
1247
1248    if (Glide.settings.rewind) {
1249      // bound does funny things with the length, therefor we have to be certain
1250      // that we are on the last possible index value given by bound
1251      if (Run.isBound() && !Run.isEnd()) {
1252        return length;
1253      }
1254
1255      return 0;
1256    }
1257
1258    if (Run.isBound()) {
1259      return length;
1260    }
1261
1262    return Math.floor(length / viewSize) * viewSize;
1263  }
1264  /**
1265   * Calculates index value to move backward/to the left
1266   *
1267   * @param viewSize
1268   * @returns {Number}
1269   */
1270
1271
1272  function calculateBackwardIndex(viewSize) {
1273    var index = Glide.index;
1274
1275    if (Glide.isType('carousel')) {
1276      return index - viewSize;
1277    } // ensure our back navigation results in the same index as a forward navigation
1278    // to experience a homogeneous paging
1279
1280
1281    var view = Math.ceil(index / viewSize);
1282    return (view - 1) * viewSize;
1283  }
1284  /**
1285   * Normalizes the given backward index based on glide settings, preventing it to exceed certain boundaries
1286   *
1287   * @param index
1288   * @param length
1289   * @param viewSize
1290   * @returns {*}
1291   */
1292
1293
1294  function normalizeBackwardIndex(index, viewSize) {
1295    var length = Run.length;
1296
1297    if (index >= 0) {
1298      return index;
1299    }
1300
1301    if (Glide.isType('carousel')) {
1302      return index + (length + 1);
1303    }
1304
1305    if (Glide.settings.rewind) {
1306      // bound does funny things with the length, therefor we have to be certain
1307      // that we are on first possible index value before we to rewind to the length given by bound
1308      if (Run.isBound() && Run.isStart()) {
1309        return length;
1310      }
1311
1312      return Math.floor(length / viewSize) * viewSize;
1313    }
1314
1315    return 0;
1316  }
1317
1318  glide_esm_define(Run, 'move', {
1319    /**
1320     * Gets value of the move schema.
1321     *
1322     * @returns {Object}
1323     */
1324    get: function get() {
1325      return this._m;
1326    },
1327
1328    /**
1329     * Sets value of the move schema.
1330     *
1331     * @returns {Object}
1332     */
1333    set: function set(value) {
1334      var step = value.substr(1);
1335      this._m = {
1336        direction: value.substr(0, 1),
1337        steps: step ? toInt(step) ? toInt(step) : step : 0
1338      };
1339    }
1340  });
1341  glide_esm_define(Run, 'length', {
1342    /**
1343     * Gets value of the running distance based
1344     * on zero-indexing number of slides.
1345     *
1346     * @return {Number}
1347     */
1348    get: function get() {
1349      var settings = Glide.settings;
1350      var length = Components.Html.slides.length; // If the `bound` option is active, a maximum running distance should be
1351      // reduced by `perView` and `focusAt` settings. Running distance
1352      // should end before creating an empty space after instance.
1353
1354      if (this.isBound()) {
1355        return length - 1 - (toInt(settings.perView) - 1) + toInt(settings.focusAt);
1356      }
1357
1358      return length - 1;
1359    }
1360  });
1361  glide_esm_define(Run, 'offset', {
1362    /**
1363     * Gets status of the offsetting flag.
1364     *
1365     * @return {Boolean}
1366     */
1367    get: function get() {
1368      return this._o;
1369    }
1370  });
1371  return Run;
1372}
1373
1374/**
1375 * Returns a current time.
1376 *
1377 * @return {Number}
1378 */
1379function now() {
1380  return new Date().getTime();
1381}
1382
1383/**
1384 * Returns a function, that, when invoked, will only be triggered
1385 * at most once during a given window of time.
1386 *
1387 * @param {Function} func
1388 * @param {Number} wait
1389 * @param {Object=} options
1390 * @return {Function}
1391 *
1392 * @see https://github.com/jashkenas/underscore
1393 */
1394
1395function throttle(func, wait, options) {
1396  var timeout, context, args, result;
1397  var previous = 0;
1398  if (!options) options = {};
1399
1400  var later = function later() {
1401    previous = options.leading === false ? 0 : now();
1402    timeout = null;
1403    result = func.apply(context, args);
1404    if (!timeout) context = args = null;
1405  };
1406
1407  var throttled = function throttled() {
1408    var at = now();
1409    if (!previous && options.leading === false) previous = at;
1410    var remaining = wait - (at - previous);
1411    context = this;
1412    args = arguments;
1413
1414    if (remaining <= 0 || remaining > wait) {
1415      if (timeout) {
1416        clearTimeout(timeout);
1417        timeout = null;
1418      }
1419
1420      previous = at;
1421      result = func.apply(context, args);
1422      if (!timeout) context = args = null;
1423    } else if (!timeout && options.trailing !== false) {
1424      timeout = setTimeout(later, remaining);
1425    }
1426
1427    return result;
1428  };
1429
1430  throttled.cancel = function () {
1431    clearTimeout(timeout);
1432    previous = 0;
1433    timeout = context = args = null;
1434  };
1435
1436  return throttled;
1437}
1438
1439var MARGIN_TYPE = {
1440  ltr: ['marginLeft', 'marginRight'],
1441  rtl: ['marginRight', 'marginLeft']
1442};
1443function Gaps (Glide, Components, Events) {
1444  var Gaps = {
1445    /**
1446     * Applies gaps between slides. First and last
1447     * slides do not receive it's edge margins.
1448     *
1449     * @param {HTMLCollection} slides
1450     * @return {Void}
1451     */
1452    apply: function apply(slides) {
1453      for (var i = 0, len = slides.length; i < len; i++) {
1454        var style = slides[i].style;
1455        var direction = Components.Direction.value;
1456
1457        if (i !== 0) {
1458          style[MARGIN_TYPE[direction][0]] = "".concat(this.value / 2, "px");
1459        } else {
1460          style[MARGIN_TYPE[direction][0]] = '';
1461        }
1462
1463        if (i !== slides.length - 1) {
1464          style[MARGIN_TYPE[direction][1]] = "".concat(this.value / 2, "px");
1465        } else {
1466          style[MARGIN_TYPE[direction][1]] = '';
1467        }
1468      }
1469    },
1470
1471    /**
1472     * Removes gaps from the slides.
1473     *
1474     * @param {HTMLCollection} slides
1475     * @returns {Void}
1476    */
1477    remove: function remove(slides) {
1478      for (var i = 0, len = slides.length; i < len; i++) {
1479        var style = slides[i].style;
1480        style.marginLeft = '';
1481        style.marginRight = '';
1482      }
1483    }
1484  };
1485  glide_esm_define(Gaps, 'value', {
1486    /**
1487     * Gets value of the gap.
1488     *
1489     * @returns {Number}
1490     */
1491    get: function get() {
1492      return toInt(Glide.settings.gap);
1493    }
1494  });
1495  glide_esm_define(Gaps, 'grow', {
1496    /**
1497     * Gets additional dimensions value caused by gaps.
1498     * Used to increase width of the slides wrapper.
1499     *
1500     * @returns {Number}
1501     */
1502    get: function get() {
1503      return Gaps.value * Components.Sizes.length;
1504    }
1505  });
1506  glide_esm_define(Gaps, 'reductor', {
1507    /**
1508     * Gets reduction value caused by gaps.
1509     * Used to subtract width of the slides.
1510     *
1511     * @returns {Number}
1512     */
1513    get: function get() {
1514      var perView = Glide.settings.perView;
1515      return Gaps.value * (perView - 1) / perView;
1516    }
1517  });
1518  /**
1519   * Apply calculated gaps:
1520   * - after building, so slides (including clones) will receive proper margins
1521   * - on updating via API, to recalculate gaps with new options
1522   */
1523
1524  Events.on(['build.after', 'update'], throttle(function () {
1525    Gaps.apply(Components.Html.wrapper.children);
1526  }, 30));
1527  /**
1528   * Remove gaps:
1529   * - on destroying to bring markup to its inital state
1530   */
1531
1532  Events.on('destroy', function () {
1533    Gaps.remove(Components.Html.wrapper.children);
1534  });
1535  return Gaps;
1536}
1537
1538/**
1539 * Finds siblings nodes of the passed node.
1540 *
1541 * @param  {Element} node
1542 * @return {Array}
1543 */
1544function siblings(node) {
1545  if (node && node.parentNode) {
1546    var n = node.parentNode.firstChild;
1547    var matched = [];
1548
1549    for (; n; n = n.nextSibling) {
1550      if (n.nodeType === 1 && n !== node) {
1551        matched.push(n);
1552      }
1553    }
1554
1555    return matched;
1556  }
1557
1558  return [];
1559}
1560/**
1561 * Checks if passed node exist and is a valid element.
1562 *
1563 * @param  {Element} node
1564 * @return {Boolean}
1565 */
1566
1567function exist(node) {
1568  if (node && node instanceof window.HTMLElement) {
1569    return true;
1570  }
1571
1572  return false;
1573}
1574
1575var TRACK_SELECTOR = '[data-glide-el="track"]';
1576function Html (Glide, Components, Events) {
1577  var Html = {
1578    /**
1579     * Setup slider HTML nodes.
1580     *
1581     * @param {Glide} glide
1582     */
1583    mount: function mount() {
1584      this.root = Glide.selector;
1585      this.track = this.root.querySelector(TRACK_SELECTOR);
1586      this.collectSlides();
1587    },
1588
1589    /**
1590     * Collect slides
1591     */
1592    collectSlides: function collectSlides() {
1593      this.slides = Array.prototype.slice.call(this.wrapper.children).filter(function (slide) {
1594        return !slide.classList.contains(Glide.settings.classes.slide.clone);
1595      });
1596    }
1597  };
1598  glide_esm_define(Html, 'root', {
1599    /**
1600     * Gets node of the glide main element.
1601     *
1602     * @return {Object}
1603     */
1604    get: function get() {
1605      return Html._r;
1606    },
1607
1608    /**
1609     * Sets node of the glide main element.
1610     *
1611     * @return {Object}
1612     */
1613    set: function set(r) {
1614      if (isString(r)) {
1615        r = document.querySelector(r);
1616      }
1617
1618      if (exist(r)) {
1619        Html._r = r;
1620      } else {
1621        warn('Root element must be a existing Html node');
1622      }
1623    }
1624  });
1625  glide_esm_define(Html, 'track', {
1626    /**
1627     * Gets node of the glide track with slides.
1628     *
1629     * @return {Object}
1630     */
1631    get: function get() {
1632      return Html._t;
1633    },
1634
1635    /**
1636     * Sets node of the glide track with slides.
1637     *
1638     * @return {Object}
1639     */
1640    set: function set(t) {
1641      if (exist(t)) {
1642        Html._t = t;
1643      } else {
1644        warn("Could not find track element. Please use ".concat(TRACK_SELECTOR, " attribute."));
1645      }
1646    }
1647  });
1648  glide_esm_define(Html, 'wrapper', {
1649    /**
1650     * Gets node of the slides wrapper.
1651     *
1652     * @return {Object}
1653     */
1654    get: function get() {
1655      return Html.track.children[0];
1656    }
1657  });
1658  /**
1659   * Add/remove/reorder dynamic slides
1660   */
1661
1662  Events.on('update', function () {
1663    Html.collectSlides();
1664  });
1665  return Html;
1666}
1667
1668function Peek (Glide, Components, Events) {
1669  var Peek = {
1670    /**
1671     * Setups how much to peek based on settings.
1672     *
1673     * @return {Void}
1674     */
1675    mount: function mount() {
1676      this.value = Glide.settings.peek;
1677    }
1678  };
1679  glide_esm_define(Peek, 'value', {
1680    /**
1681     * Gets value of the peek.
1682     *
1683     * @returns {Number|Object}
1684     */
1685    get: function get() {
1686      return Peek._v;
1687    },
1688
1689    /**
1690     * Sets value of the peek.
1691     *
1692     * @param {Number|Object} value
1693     * @return {Void}
1694     */
1695    set: function set(value) {
1696      if (isObject(value)) {
1697        value.before = toInt(value.before);
1698        value.after = toInt(value.after);
1699      } else {
1700        value = toInt(value);
1701      }
1702
1703      Peek._v = value;
1704    }
1705  });
1706  glide_esm_define(Peek, 'reductor', {
1707    /**
1708     * Gets reduction value caused by peek.
1709     *
1710     * @returns {Number}
1711     */
1712    get: function get() {
1713      var value = Peek.value;
1714      var perView = Glide.settings.perView;
1715
1716      if (isObject(value)) {
1717        return value.before / perView + value.after / perView;
1718      }
1719
1720      return value * 2 / perView;
1721    }
1722  });
1723  /**
1724   * Recalculate peeking sizes on:
1725   * - when resizing window to update to proper percents
1726   */
1727
1728  Events.on(['resize', 'update'], function () {
1729    Peek.mount();
1730  });
1731  return Peek;
1732}
1733
1734function Move (Glide, Components, Events) {
1735  var Move = {
1736    /**
1737     * Constructs move component.
1738     *
1739     * @returns {Void}
1740     */
1741    mount: function mount() {
1742      this._o = 0;
1743    },
1744
1745    /**
1746     * Calculates a movement value based on passed offset and currently active index.
1747     *
1748     * @param  {Number} offset
1749     * @return {Void}
1750     */
1751    make: function make() {
1752      var _this = this;
1753
1754      var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
1755      this.offset = offset;
1756      Events.emit('move', {
1757        movement: this.value
1758      });
1759      Components.Transition.after(function () {
1760        Events.emit('move.after', {
1761          movement: _this.value
1762        });
1763      });
1764    }
1765  };
1766  glide_esm_define(Move, 'offset', {
1767    /**
1768     * Gets an offset value used to modify current translate.
1769     *
1770     * @return {Object}
1771     */
1772    get: function get() {
1773      return Move._o;
1774    },
1775
1776    /**
1777     * Sets an offset value used to modify current translate.
1778     *
1779     * @return {Object}
1780     */
1781    set: function set(value) {
1782      Move._o = !isUndefined(value) ? toInt(value) : 0;
1783    }
1784  });
1785  glide_esm_define(Move, 'translate', {
1786    /**
1787     * Gets a raw movement value.
1788     *
1789     * @return {Number}
1790     */
1791    get: function get() {
1792      return Components.Sizes.slideWidth * Glide.index;
1793    }
1794  });
1795  glide_esm_define(Move, 'value', {
1796    /**
1797     * Gets an actual movement value corrected by offset.
1798     *
1799     * @return {Number}
1800     */
1801    get: function get() {
1802      var offset = this.offset;
1803      var translate = this.translate;
1804
1805      if (Components.Direction.is('rtl')) {
1806        return translate + offset;
1807      }
1808
1809      return translate - offset;
1810    }
1811  });
1812  /**
1813   * Make movement to proper slide on:
1814   * - before build, so glide will start at `startAt` index
1815   * - on each standard run to move to newly calculated index
1816   */
1817
1818  Events.on(['build.before', 'run'], function () {
1819    Move.make();
1820  });
1821  return Move;
1822}
1823
1824function Sizes (Glide, Components, Events) {
1825  var Sizes = {
1826    /**
1827     * Setups dimensions of slides.
1828     *
1829     * @return {Void}
1830     */
1831    setupSlides: function setupSlides() {
1832      var width = "".concat(this.slideWidth, "px");
1833      var slides = Components.Html.slides;
1834
1835      for (var i = 0; i < slides.length; i++) {
1836        slides[i].style.width = width;
1837      }
1838    },
1839
1840    /**
1841     * Setups dimensions of slides wrapper.
1842     *
1843     * @return {Void}
1844     */
1845    setupWrapper: function setupWrapper() {
1846      Components.Html.wrapper.style.width = "".concat(this.wrapperSize, "px");
1847    },
1848
1849    /**
1850     * Removes applied styles from HTML elements.
1851     *
1852     * @returns {Void}
1853     */
1854    remove: function remove() {
1855      var slides = Components.Html.slides;
1856
1857      for (var i = 0; i < slides.length; i++) {
1858        slides[i].style.width = '';
1859      }
1860
1861      Components.Html.wrapper.style.width = '';
1862    }
1863  };
1864  glide_esm_define(Sizes, 'length', {
1865    /**
1866     * Gets count number of the slides.
1867     *
1868     * @return {Number}
1869     */
1870    get: function get() {
1871      return Components.Html.slides.length;
1872    }
1873  });
1874  glide_esm_define(Sizes, 'width', {
1875    /**
1876     * Gets width value of the slider (visible area).
1877     *
1878     * @return {Number}
1879     */
1880    get: function get() {
1881      return Components.Html.track.offsetWidth;
1882    }
1883  });
1884  glide_esm_define(Sizes, 'wrapperSize', {
1885    /**
1886     * Gets size of the slides wrapper.
1887     *
1888     * @return {Number}
1889     */
1890    get: function get() {
1891      return Sizes.slideWidth * Sizes.length + Components.Gaps.grow + Components.Clones.grow;
1892    }
1893  });
1894  glide_esm_define(Sizes, 'slideWidth', {
1895    /**
1896     * Gets width value of a single slide.
1897     *
1898     * @return {Number}
1899     */
1900    get: function get() {
1901      return Sizes.width / Glide.settings.perView - Components.Peek.reductor - Components.Gaps.reductor;
1902    }
1903  });
1904  /**
1905   * Apply calculated glide's dimensions:
1906   * - before building, so other dimensions (e.g. translate) will be calculated propertly
1907   * - when resizing window to recalculate sildes dimensions
1908   * - on updating via API, to calculate dimensions based on new options
1909   */
1910
1911  Events.on(['build.before', 'resize', 'update'], function () {
1912    Sizes.setupSlides();
1913    Sizes.setupWrapper();
1914  });
1915  /**
1916   * Remove calculated glide's dimensions:
1917   * - on destoting to bring markup to its inital state
1918   */
1919
1920  Events.on('destroy', function () {
1921    Sizes.remove();
1922  });
1923  return Sizes;
1924}
1925
1926function Build (Glide, Components, Events) {
1927  var Build = {
1928    /**
1929     * Init glide building. Adds classes, sets
1930     * dimensions and setups initial state.
1931     *
1932     * @return {Void}
1933     */
1934    mount: function mount() {
1935      Events.emit('build.before');
1936      this.typeClass();
1937      this.activeClass();
1938      Events.emit('build.after');
1939    },
1940
1941    /**
1942     * Adds `type` class to the glide element.
1943     *
1944     * @return {Void}
1945     */
1946    typeClass: function typeClass() {
1947      Components.Html.root.classList.add(Glide.settings.classes.type[Glide.settings.type]);
1948    },
1949
1950    /**
1951     * Sets active class to current slide.
1952     *
1953     * @return {Void}
1954     */
1955    activeClass: function activeClass() {
1956      var classes = Glide.settings.classes;
1957      var slide = Components.Html.slides[Glide.index];
1958
1959      if (slide) {
1960        slide.classList.add(classes.slide.active);
1961        siblings(slide).forEach(function (sibling) {
1962          sibling.classList.remove(classes.slide.active);
1963        });
1964      }
1965    },
1966
1967    /**
1968     * Removes HTML classes applied at building.
1969     *
1970     * @return {Void}
1971     */
1972    removeClasses: function removeClasses() {
1973      var _Glide$settings$class = Glide.settings.classes,
1974          type = _Glide$settings$class.type,
1975          slide = _Glide$settings$class.slide;
1976      Components.Html.root.classList.remove(type[Glide.settings.type]);
1977      Components.Html.slides.forEach(function (sibling) {
1978        sibling.classList.remove(slide.active);
1979      });
1980    }
1981  };
1982  /**
1983   * Clear building classes:
1984   * - on destroying to bring HTML to its initial state
1985   * - on updating to remove classes before remounting component
1986   */
1987
1988  Events.on(['destroy', 'update'], function () {
1989    Build.removeClasses();
1990  });
1991  /**
1992   * Remount component:
1993   * - on resizing of the window to calculate new dimensions
1994   * - on updating settings via API
1995   */
1996
1997  Events.on(['resize', 'update'], function () {
1998    Build.mount();
1999  });
2000  /**
2001   * Swap active class of current slide:
2002   * - after each move to the new index
2003   */
2004
2005  Events.on('move.after', function () {
2006    Build.activeClass();
2007  });
2008  return Build;
2009}
2010
2011function Clones (Glide, Components, Events) {
2012  var Clones = {
2013    /**
2014     * Create pattern map and collect slides to be cloned.
2015     */
2016    mount: function mount() {
2017      this.items = [];
2018
2019      if (Glide.isType('carousel')) {
2020        this.items = this.collect();
2021      }
2022    },
2023
2024    /**
2025     * Collect clones with pattern.
2026     *
2027     * @return {[]}
2028     */
2029    collect: function collect() {
2030      var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
2031      var slides = Components.Html.slides;
2032      var _Glide$settings = Glide.settings,
2033          perView = _Glide$settings.perView,
2034          classes = _Glide$settings.classes,
2035          cloningRatio = _Glide$settings.cloningRatio;
2036
2037      if (slides.length !== 0) {
2038        var peekIncrementer = +!!Glide.settings.peek;
2039        var cloneCount = perView + peekIncrementer + Math.round(perView / 2);
2040        var append = slides.slice(0, cloneCount).reverse();
2041        var prepend = slides.slice(cloneCount * -1);
2042
2043        for (var r = 0; r < Math.max(cloningRatio, Math.floor(perView / slides.length)); r++) {
2044          for (var i = 0; i < append.length; i++) {
2045            var clone = append[i].cloneNode(true);
2046            clone.classList.add(classes.slide.clone);
2047            items.push(clone);
2048          }
2049
2050          for (var _i = 0; _i < prepend.length; _i++) {
2051            var _clone = prepend[_i].cloneNode(true);
2052
2053            _clone.classList.add(classes.slide.clone);
2054
2055            items.unshift(_clone);
2056          }
2057        }
2058      }
2059
2060      return items;
2061    },
2062
2063    /**
2064     * Append cloned slides with generated pattern.
2065     *
2066     * @return {Void}
2067     */
2068    append: function append() {
2069      var items = this.items;
2070      var _Components$Html = Components.Html,
2071          wrapper = _Components$Html.wrapper,
2072          slides = _Components$Html.slides;
2073      var half = Math.floor(items.length / 2);
2074      var prepend = items.slice(0, half).reverse();
2075      var append = items.slice(half * -1).reverse();
2076      var width = "".concat(Components.Sizes.slideWidth, "px");
2077
2078      for (var i = 0; i < append.length; i++) {
2079        wrapper.appendChild(append[i]);
2080      }
2081
2082      for (var _i2 = 0; _i2 < prepend.length; _i2++) {
2083        wrapper.insertBefore(prepend[_i2], slides[0]);
2084      }
2085
2086      for (var _i3 = 0; _i3 < items.length; _i3++) {
2087        items[_i3].style.width = width;
2088      }
2089    },
2090
2091    /**
2092     * Remove all cloned slides.
2093     *
2094     * @return {Void}
2095     */
2096    remove: function remove() {
2097      var items = this.items;
2098
2099      for (var i = 0; i < items.length; i++) {
2100        Components.Html.wrapper.removeChild(items[i]);
2101      }
2102    }
2103  };
2104  glide_esm_define(Clones, 'grow', {
2105    /**
2106     * Gets additional dimensions value caused by clones.
2107     *
2108     * @return {Number}
2109     */
2110    get: function get() {
2111      return (Components.Sizes.slideWidth + Components.Gaps.value) * Clones.items.length;
2112    }
2113  });
2114  /**
2115   * Append additional slide's clones:
2116   * - while glide's type is `carousel`
2117   */
2118
2119  Events.on('update', function () {
2120    Clones.remove();
2121    Clones.mount();
2122    Clones.append();
2123  });
2124  /**
2125   * Append additional slide's clones:
2126   * - while glide's type is `carousel`
2127   */
2128
2129  Events.on('build.before', function () {
2130    if (Glide.isType('carousel')) {
2131      Clones.append();
2132    }
2133  });
2134  /**
2135   * Remove clones HTMLElements:
2136   * - on destroying, to bring HTML to its initial state
2137   */
2138
2139  Events.on('destroy', function () {
2140    Clones.remove();
2141  });
2142  return Clones;
2143}
2144
2145var EventsBinder = /*#__PURE__*/function () {
2146  /**
2147   * Construct a EventsBinder instance.
2148   */
2149  function EventsBinder() {
2150    var listeners = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2151
2152    _classCallCheck(this, EventsBinder);
2153
2154    this.listeners = listeners;
2155  }
2156  /**
2157   * Adds events listeners to arrows HTML elements.
2158   *
2159   * @param  {String|Array} events
2160   * @param  {Element|Window|Document} el
2161   * @param  {Function} closure
2162   * @param  {Boolean|Object} capture
2163   * @return {Void}
2164   */
2165
2166
2167  _createClass(EventsBinder, [{
2168    key: "on",
2169    value: function on(events, el, closure) {
2170      var capture = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
2171
2172      if (isString(events)) {
2173        events = [events];
2174      }
2175
2176      for (var i = 0; i < events.length; i++) {
2177        this.listeners[events[i]] = closure;
2178        el.addEventListener(events[i], this.listeners[events[i]], capture);
2179      }
2180    }
2181    /**
2182     * Removes event listeners from arrows HTML elements.
2183     *
2184     * @param  {String|Array} events
2185     * @param  {Element|Window|Document} el
2186     * @param  {Boolean|Object} capture
2187     * @return {Void}
2188     */
2189
2190  }, {
2191    key: "off",
2192    value: function off(events, el) {
2193      var capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
2194
2195      if (isString(events)) {
2196        events = [events];
2197      }
2198
2199      for (var i = 0; i < events.length; i++) {
2200        el.removeEventListener(events[i], this.listeners[events[i]], capture);
2201      }
2202    }
2203    /**
2204     * Destroy collected listeners.
2205     *
2206     * @returns {Void}
2207     */
2208
2209  }, {
2210    key: "destroy",
2211    value: function destroy() {
2212      delete this.listeners;
2213    }
2214  }]);
2215
2216  return EventsBinder;
2217}();
2218
2219function Resize (Glide, Components, Events) {
2220  /**
2221   * Instance of the binder for DOM Events.
2222   *
2223   * @type {EventsBinder}
2224   */
2225  var Binder = new EventsBinder();
2226  var Resize = {
2227    /**
2228     * Initializes window bindings.
2229     */
2230    mount: function mount() {
2231      this.bind();
2232    },
2233
2234    /**
2235     * Binds `rezsize` listener to the window.
2236     * It's a costly event, so we are debouncing it.
2237     *
2238     * @return {Void}
2239     */
2240    bind: function bind() {
2241      Binder.on('resize', window, throttle(function () {
2242        Events.emit('resize');
2243      }, Glide.settings.throttle));
2244    },
2245
2246    /**
2247     * Unbinds listeners from the window.
2248     *
2249     * @return {Void}
2250     */
2251    unbind: function unbind() {
2252      Binder.off('resize', window);
2253    }
2254  };
2255  /**
2256   * Remove bindings from window:
2257   * - on destroying, to remove added EventListener
2258   */
2259
2260  Events.on('destroy', function () {
2261    Resize.unbind();
2262    Binder.destroy();
2263  });
2264  return Resize;
2265}
2266
2267var VALID_DIRECTIONS = ['ltr', 'rtl'];
2268var FLIPED_MOVEMENTS = {
2269  '>': '<',
2270  '<': '>',
2271  '=': '='
2272};
2273function Direction (Glide, Components, Events) {
2274  var Direction = {
2275    /**
2276     * Setups gap value based on settings.
2277     *
2278     * @return {Void}
2279     */
2280    mount: function mount() {
2281      this.value = Glide.settings.direction;
2282    },
2283
2284    /**
2285     * Resolves pattern based on direction value
2286     *
2287     * @param {String} pattern
2288     * @returns {String}
2289     */
2290    resolve: function resolve(pattern) {
2291      var token = pattern.slice(0, 1);
2292
2293      if (this.is('rtl')) {
2294        return pattern.split(token).join(FLIPED_MOVEMENTS[token]);
2295      }
2296
2297      return pattern;
2298    },
2299
2300    /**
2301     * Checks value of direction mode.
2302     *
2303     * @param {String} direction
2304     * @returns {Boolean}
2305     */
2306    is: function is(direction) {
2307      return this.value === direction;
2308    },
2309
2310    /**
2311     * Applies direction class to the root HTML element.
2312     *
2313     * @return {Void}
2314     */
2315    addClass: function addClass() {
2316      Components.Html.root.classList.add(Glide.settings.classes.direction[this.value]);
2317    },
2318
2319    /**
2320     * Removes direction class from the root HTML element.
2321     *
2322     * @return {Void}
2323     */
2324    removeClass: function removeClass() {
2325      Components.Html.root.classList.remove(Glide.settings.classes.direction[this.value]);
2326    }
2327  };
2328  glide_esm_define(Direction, 'value', {
2329    /**
2330     * Gets value of the direction.
2331     *
2332     * @returns {Number}
2333     */
2334    get: function get() {
2335      return Direction._v;
2336    },
2337
2338    /**
2339     * Sets value of the direction.
2340     *
2341     * @param {String} value
2342     * @return {Void}
2343     */
2344    set: function set(value) {
2345      if (VALID_DIRECTIONS.indexOf(value) > -1) {
2346        Direction._v = value;
2347      } else {
2348        warn('Direction value must be `ltr` or `rtl`');
2349      }
2350    }
2351  });
2352  /**
2353   * Clear direction class:
2354   * - on destroy to bring HTML to its initial state
2355   * - on update to remove class before reappling bellow
2356   */
2357
2358  Events.on(['destroy', 'update'], function () {
2359    Direction.removeClass();
2360  });
2361  /**
2362   * Remount component:
2363   * - on update to reflect changes in direction value
2364   */
2365
2366  Events.on('update', function () {
2367    Direction.mount();
2368  });
2369  /**
2370   * Apply direction class:
2371   * - before building to apply class for the first time
2372   * - on updating to reapply direction class that may changed
2373   */
2374
2375  Events.on(['build.before', 'update'], function () {
2376    Direction.addClass();
2377  });
2378  return Direction;
2379}
2380
2381/**
2382 * Reflects value of glide movement.
2383 *
2384 * @param  {Object} Glide
2385 * @param  {Object} Components
2386 * @return {Object}
2387 */
2388function Rtl (Glide, Components) {
2389  return {
2390    /**
2391     * Negates the passed translate if glide is in RTL option.
2392     *
2393     * @param  {Number} translate
2394     * @return {Number}
2395     */
2396    modify: function modify(translate) {
2397      if (Components.Direction.is('rtl')) {
2398        return -translate;
2399      }
2400
2401      return translate;
2402    }
2403  };
2404}
2405
2406/**
2407 * Updates glide movement with a `gap` settings.
2408 *
2409 * @param  {Object} Glide
2410 * @param  {Object} Components
2411 * @return {Object}
2412 */
2413function Gap (Glide, Components) {
2414  return {
2415    /**
2416     * Modifies passed translate value with number in the `gap` settings.
2417     *
2418     * @param  {Number} translate
2419     * @return {Number}
2420     */
2421    modify: function modify(translate) {
2422      var multiplier = Math.floor(translate / Components.Sizes.slideWidth);
2423      return translate + Components.Gaps.value * multiplier;
2424    }
2425  };
2426}
2427
2428/**
2429 * Updates glide movement with width of additional clones width.
2430 *
2431 * @param  {Object} Glide
2432 * @param  {Object} Components
2433 * @return {Object}
2434 */
2435function Grow (Glide, Components) {
2436  return {
2437    /**
2438     * Adds to the passed translate width of the half of clones.
2439     *
2440     * @param  {Number} translate
2441     * @return {Number}
2442     */
2443    modify: function modify(translate) {
2444      return translate + Components.Clones.grow / 2;
2445    }
2446  };
2447}
2448
2449/**
2450 * Updates glide movement with a `peek` settings.
2451 *
2452 * @param  {Object} Glide
2453 * @param  {Object} Components
2454 * @return {Object}
2455 */
2456
2457function Peeking (Glide, Components) {
2458  return {
2459    /**
2460     * Modifies passed translate value with a `peek` setting.
2461     *
2462     * @param  {Number} translate
2463     * @return {Number}
2464     */
2465    modify: function modify(translate) {
2466      if (Glide.settings.focusAt >= 0) {
2467        var peek = Components.Peek.value;
2468
2469        if (isObject(peek)) {
2470          return translate - peek.before;
2471        }
2472
2473        return translate - peek;
2474      }
2475
2476      return translate;
2477    }
2478  };
2479}
2480
2481/**
2482 * Updates glide movement with a `focusAt` settings.
2483 *
2484 * @param  {Object} Glide
2485 * @param  {Object} Components
2486 * @return {Object}
2487 */
2488function Focusing (Glide, Components) {
2489  return {
2490    /**
2491     * Modifies passed translate value with index in the `focusAt` setting.
2492     *
2493     * @param  {Number} translate
2494     * @return {Number}
2495     */
2496    modify: function modify(translate) {
2497      var gap = Components.Gaps.value;
2498      var width = Components.Sizes.width;
2499      var focusAt = Glide.settings.focusAt;
2500      var slideWidth = Components.Sizes.slideWidth;
2501
2502      if (focusAt === 'center') {
2503        return translate - (width / 2 - slideWidth / 2);
2504      }
2505
2506      return translate - slideWidth * focusAt - gap * focusAt;
2507    }
2508  };
2509}
2510
2511/**
2512 * Applies diffrent transformers on translate value.
2513 *
2514 * @param  {Object} Glide
2515 * @param  {Object} Components
2516 * @return {Object}
2517 */
2518
2519function mutator (Glide, Components, Events) {
2520  /**
2521   * Merge instance transformers with collection of default transformers.
2522   * It's important that the Rtl component be last on the list,
2523   * so it reflects all previous transformations.
2524   *
2525   * @type {Array}
2526   */
2527  var TRANSFORMERS = [Gap, Grow, Peeking, Focusing].concat(Glide._t, [Rtl]);
2528  return {
2529    /**
2530     * Piplines translate value with registered transformers.
2531     *
2532     * @param  {Number} translate
2533     * @return {Number}
2534     */
2535    mutate: function mutate(translate) {
2536      for (var i = 0; i < TRANSFORMERS.length; i++) {
2537        var transformer = TRANSFORMERS[i];
2538
2539        if (isFunction(transformer) && isFunction(transformer().modify)) {
2540          translate = transformer(Glide, Components, Events).modify(translate);
2541        } else {
2542          warn('Transformer should be a function that returns an object with `modify()` method');
2543        }
2544      }
2545
2546      return translate;
2547    }
2548  };
2549}
2550
2551function Translate (Glide, Components, Events) {
2552  var Translate = {
2553    /**
2554     * Sets value of translate on HTML element.
2555     *
2556     * @param {Number} value
2557     * @return {Void}
2558     */
2559    set: function set(value) {
2560      var transform = mutator(Glide, Components).mutate(value);
2561      var translate3d = "translate3d(".concat(-1 * transform, "px, 0px, 0px)");
2562      Components.Html.wrapper.style.mozTransform = translate3d; // needed for supported Firefox 10-15
2563
2564      Components.Html.wrapper.style.webkitTransform = translate3d; // needed for supported Chrome 10-35, Safari 5.1-8, and Opera 15-22
2565
2566      Components.Html.wrapper.style.transform = translate3d;
2567    },
2568
2569    /**
2570     * Removes value of translate from HTML element.
2571     *
2572     * @return {Void}
2573     */
2574    remove: function remove() {
2575      Components.Html.wrapper.style.transform = '';
2576    },
2577
2578    /**
2579     * @return {number}
2580     */
2581    getStartIndex: function getStartIndex() {
2582      var length = Components.Sizes.length;
2583      var index = Glide.index;
2584      var perView = Glide.settings.perView;
2585
2586      if (Components.Run.isOffset('>') || Components.Run.isOffset('|>')) {
2587        return length + (index - perView);
2588      } // "modulo length" converts an index that equals length to zero
2589
2590
2591      return (index + perView) % length;
2592    },
2593
2594    /**
2595     * @return {number}
2596     */
2597    getTravelDistance: function getTravelDistance() {
2598      var travelDistance = Components.Sizes.slideWidth * Glide.settings.perView;
2599
2600      if (Components.Run.isOffset('>') || Components.Run.isOffset('|>')) {
2601        // reverse travel distance so that we don't have to change subtract operations
2602        return travelDistance * -1;
2603      }
2604
2605      return travelDistance;
2606    }
2607  };
2608  /**
2609   * Set new translate value:
2610   * - on move to reflect index change
2611   * - on updating via API to reflect possible changes in options
2612   */
2613
2614  Events.on('move', function (context) {
2615    if (!Glide.isType('carousel') || !Components.Run.isOffset()) {
2616      return Translate.set(context.movement);
2617    }
2618
2619    Components.Transition.after(function () {
2620      Events.emit('translate.jump');
2621      Translate.set(Components.Sizes.slideWidth * Glide.index);
2622    });
2623    var startWidth = Components.Sizes.slideWidth * Components.Translate.getStartIndex();
2624    return Translate.set(startWidth - Components.Translate.getTravelDistance());
2625  });
2626  /**
2627   * Remove translate:
2628   * - on destroying to bring markup to its inital state
2629   */
2630
2631  Events.on('destroy', function () {
2632    Translate.remove();
2633  });
2634  return Translate;
2635}
2636
2637function Transition (Glide, Components, Events) {
2638  /**
2639   * Holds inactivity status of transition.
2640   * When true transition is not applied.
2641   *
2642   * @type {Boolean}
2643   */
2644  var disabled = false;
2645  var Transition = {
2646    /**
2647     * Composes string of the CSS transition.
2648     *
2649     * @param {String} property
2650     * @return {String}
2651     */
2652    compose: function compose(property) {
2653      var settings = Glide.settings;
2654
2655      if (!disabled) {
2656        return "".concat(property, " ").concat(this.duration, "ms ").concat(settings.animationTimingFunc);
2657      }
2658
2659      return "".concat(property, " 0ms ").concat(settings.animationTimingFunc);
2660    },
2661
2662    /**
2663     * Sets value of transition on HTML element.
2664     *
2665     * @param {String=} property
2666     * @return {Void}
2667     */
2668    set: function set() {
2669      var property = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';
2670      Components.Html.wrapper.style.transition = this.compose(property);
2671    },
2672
2673    /**
2674     * Removes value of transition from HTML element.
2675     *
2676     * @return {Void}
2677     */
2678    remove: function remove() {
2679      Components.Html.wrapper.style.transition = '';
2680    },
2681
2682    /**
2683     * Runs callback after animation.
2684     *
2685     * @param  {Function} callback
2686     * @return {Void}
2687     */
2688    after: function after(callback) {
2689      setTimeout(function () {
2690        callback();
2691      }, this.duration);
2692    },
2693
2694    /**
2695     * Enable transition.
2696     *
2697     * @return {Void}
2698     */
2699    enable: function enable() {
2700      disabled = false;
2701      this.set();
2702    },
2703
2704    /**
2705     * Disable transition.
2706     *
2707     * @return {Void}
2708     */
2709    disable: function disable() {
2710      disabled = true;
2711      this.set();
2712    }
2713  };
2714  glide_esm_