https://www.xanten.de/themes/custom/m190_www_theme/js/base.js?tluvz3

261        }
262      });
263    }
264
265    return data;
266  }
267
268  function addEvent(eventName) {
269    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
270        onElement = _ref.onElement,
271        withCallback = _ref.withCallback,
272        _ref$avoidDuplicate = _ref.avoidDuplicate,
273        avoidDuplicate = _ref$avoidDuplicate === void 0 ? true : _ref$avoidDuplicate,
274        _ref$once = _ref.once,
275        once = _ref$once === void 0 ? false : _ref$once,
276        _ref$useCapture = _ref.useCapture,
277        useCapture = _ref$useCapture === void 0 ? false : _ref$useCapture;
278
279    var thisArg = arguments.length > 2 ? arguments[2] : undefined;
280    var element = onElement || [];
281
282    if (isString(element)) {
283      element = document.querySelectorAll(element);
284    }
285
286    function handler(event) {
287      if (isFunction(withCallback)) {
288        withCallback.call(thisArg, event, this);
289      }
290
291      if (once) {
292        handler.destroy();
293      }
294    }
295
296    handler.destroy = function () {
297      each(element, function (el) {
298        var events = getNodeEvents(el, eventName, handler);
299
300        if (events.found) {
301          events.all.splice(events.evt, 1);
302        }
303
304        if (el.removeEventListener) {
305          el.removeEventListener(eventName, handler, useCapture);
306        }
307      });
308    };
309
310    each(element, function (el) {
311      var events = getNodeEvents(el, eventName, handler);
312
313      if (el.addEventListener && avoidDuplicate && !events.found || !avoidDuplicate) {
314        el.addEventListener(eventName, handler, useCapture);
315        events.all.push({
316          eventName: eventName,
317          fn: handler
318        });
319      }
320    });
321    return handler;
322  }
323
324  function addClass(node, name) {
325    each(name.split(' '), function (cl) {
326      return node.classList.add(cl);
327    });
328  }
329
330  function removeClass(node, name) {
331    each(name.split(' '), function (cl) {
332      return node.classList.remove(cl);
333    });
334  }
335
336  function hasClass(node, name) {
337    return node.classList.contains(name);
338  }
339
340  function closest(elem, selector) {
341    while (elem !== document.body) {
342      elem = elem.parentElement;
343
344      if (!elem) {
345        return false;
346      }
347
348      var matches = typeof elem.matches == 'function' ? elem.matches(selector) : elem.msMatchesSelector(selector);
349
350      if (matches) {
351        return elem;
352      }
353    }
354  }
355
356  function animateElement(element) {
357    var animation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
358    var callback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
359
360    if (!element || animation === '') {
361      return false;
362    }
363
364    if (animation == 'none') {
365      if (isFunction(callback)) {
366        callback();
367      }
368
369      return false;
370    }
371
372    var animationEnd = whichAnimationEvent();
373    var animationNames = animation.split(' ');
374    each(animationNames, function (name) {
375      addClass(element, 'g' + name);
376    });
377    addEvent(animationEnd, {
378      onElement: element,
379      avoidDuplicate: false,
380      once: true,
381      withCallback: function withCallback(event, target) {
382        each(animationNames, function (name) {
383          removeClass(target, 'g' + name);
384        });
385
386        if (isFunction(callback)) {
387          callback();
388        }
389      }
390    });
391  }
392
393  function cssTransform(node) {
394    var translate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
395
396    if (translate == '') {
397      node.style.webkitTransform = '';
398      node.style.MozTransform = '';
399      node.style.msTransform = '';
400      node.style.OTransform = '';
401      node.style.transform = '';
402      return false;
403    }
404
405    node.style.webkitTransform = translate;
406    node.style.MozTransform = translate;
407    node.style.msTransform = translate;
408    node.style.OTransform = translate;
409    node.style.transform = translate;
410  }
411
412  function show(element) {
413    element.style.display = 'block';
414  }
415
416  function hide(element) {
417    element.style.display = 'none';
418  }
419
420  function createHTML(htmlStr) {
421    var frag = document.createDocumentFragment(),
422        temp = document.createElement('div');
423    temp.innerHTML = htmlStr;
424
425    while (temp.firstChild) {
426      frag.appendChild(temp.firstChild);
427    }
428
429    return frag;
430  }
431
432  function windowSize() {
433    return {
434      width: window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth,
435      height: window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight
436    };
437  }
438
439  function whichAnimationEvent() {
440    var t,
441        el = document.createElement('fakeelement');
442    var animations = {
443      animation: 'animationend',
444      OAnimation: 'oAnimationEnd',
445      MozAnimation: 'animationend',
446      WebkitAnimation: 'webkitAnimationEnd'
447    };
448
449    for (t in animations) {
450      if (el.style[t] !== undefined) {
451        return animations[t];
452      }
453    }
454  }
455
456  function whichTransitionEvent() {
457    var t,
458        el = document.createElement('fakeelement');
459    var transitions = {
460      transition: 'transitionend',
461      OTransition: 'oTransitionEnd',
462      MozTransition: 'transitionend',
463      WebkitTransition: 'webkitTransitionEnd'
464    };
465
466    for (t in transitions) {
467      if (el.style[t] !== undefined) {
468        return transitions[t];
469      }
470    }
471  }
472
473  function createIframe(config) {
474    var url = config.url,
475        allow = config.allow,
476        callback = config.callback,
477        appendTo = config.appendTo;
478    var iframe = document.createElement('iframe');
479    iframe.className = 'vimeo-video gvideo';
480    iframe.src = url;
481    iframe.style.width = '100%';
482    iframe.style.height = '100%';
483
484    if (allow) {
485      iframe.setAttribute('allow', allow);
486    }
487
488    iframe.onload = function () {
489      addClass(iframe, 'node-ready');
490
491      if (isFunction(callback)) {
492        callback();
493      }
494    };
495
496    if (appendTo) {
497      appendTo.appendChild(iframe);
498    }
499
500    return iframe;
501  }
502
503  function waitUntil(check, onComplete, delay, timeout) {
504    if (check()) {
505      onComplete();
506      return;
507    }
508
509    if (!delay) {
510      delay = 100;
511    }
512
513    var timeoutPointer;
514    var intervalPointer = setInterval(function () {
515      if (!check()) {
516        return;
517      }
518
519      clearInterval(intervalPointer);
520
521      if (timeoutPointer) {
522        clearTimeout(timeoutPointer);
523      }
524
525      onComplete();
526    }, delay);
527
528    if (timeout) {
529      timeoutPointer = setTimeout(function () {
530        clearInterval(intervalPointer);
531      }, timeout);
532    }
533  }
534
535  function injectAssets(url, waitFor, callback) {
536    if (isNil(url)) {
537      console.error('Inject assets error');
538      return;
539    }
540
541    if (isFunction(waitFor)) {
542      callback = waitFor;
543      waitFor = false;
544    }
545
546    if (isString(waitFor) && waitFor in window) {
547      if (isFunction(callback)) {
548        callback();
549      }
550
551      return;
552    }
553
554    var found;
555
556    if (url.indexOf('.css') !== -1) {
557      found = document.querySelectorAll('link[href="' + url + '"]');
558
559      if (found && found.length > 0) {
560        if (isFunction(callback)) {
561          callback();
562        }
563
564        return;
565      }
566
567      var head = document.getElementsByTagName('head')[0];
568      var headStyles = head.querySelectorAll('link[rel="stylesheet"]');
569      var link = document.createElement('link');
570      link.rel = 'stylesheet';
571      link.type = 'text/css';
572      link.href = url;
573      link.media = 'all';
574
575      if (headStyles) {
576        head.insertBefore(link, headStyles[0]);
577      } else {
578        head.appendChild(link);
579      }
580
581      if (isFunction(callback)) {
582        callback();
583      }
584
585      return;
586    }
587
588    found = document.querySelectorAll('script[src="' + url + '"]');
589
590    if (found && found.length > 0) {
591      if (isFunction(callback)) {
592        if (isString(waitFor)) {
593          waitUntil(function () {
594            return typeof window[waitFor] !== 'undefined';
595          }, function () {
596            callback();
597          });
598          return false;
599        }
600
601        callback();
602      }
603
604      return;
605    }
606
607    var script = document.createElement('script');
608    script.type = 'text/javascript';
609    script.src = url;
610
611    script.onload = function () {
612      if (isFunction(callback)) {
613        if (isString(waitFor)) {
614          waitUntil(function () {
615            return typeof window[waitFor] !== 'undefined';
616          }, function () {
617            callback();
618          });
619          return false;
620        }
621
622        callback();
623      }
624    };
625
626    document.body.appendChild(script);
627    return;
628  }
629
630  function isMobile() {
631    return 'navigator' in window && window.navigator.userAgent.match(/(iPad)|(iPhone)|(iPod)|(Android)|(PlayBook)|(BB10)|(BlackBerry)|(Opera Mini)|(IEMobile)|(webOS)|(MeeGo)/i);
632  }
633
634  function isTouch() {
635    return isMobile() !== null || document.createTouch !== undefined || 'ontouchstart' in window || 'onmsgesturechange' in window || navigator.msMaxTouchPoints;
636  }
637
638  function isFunction(f) {
639    return typeof f === 'function';
640  }
641
642  function isString(s) {
643    return typeof s === 'string';
644  }
645
646  function isNode(el) {
647    return !!(el && el.nodeType && el.nodeType == 1);
648  }
649
650  function isArray(ar) {
651    return Array.isArray(ar);
652  }
653
654  function isArrayLike(ar) {
655    return ar && ar.length && isFinite(ar.length);
656  }
657
658  function isObject(o) {
659    var type = _typeof(o);
660
661    return type === 'object' && o != null && !isFunction(o) && !isArray(o);
662  }
663
664  function isNil(o) {
665    return o == null;
666  }
667
668  function has(obj, key) {
669    return obj !== null && hasOwnProperty.call(obj, key);
670  }
671
672  function size(o) {
673    if (isObject(o)) {
674      if (o.keys) {
675        return o.keys().length;
676      }
677
678      var l = 0;
679
680      for (var k in o) {
681        if (has(o, k)) {
682          l++;
683        }
684      }
685
686      return l;
687    } else {
688      return o.length;
689    }
690  }
691
692  function isNumber(n) {
693    return !isNaN(parseFloat(n)) && isFinite(n);
694  }
695
696  function getNextFocusElement() {
697    var current = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : -1;
698    var btns = document.querySelectorAll('.gbtn[data-taborder]:not(.disabled)');
699
700    if (!btns.length) {
701      return false;
702    }
703
704    if (btns.length == 1) {
705      return btns[0];
706    }
707
708    if (typeof current == 'string') {
709      current = parseInt(current);
710    }
711
712    var newIndex = current < 0 ? 1 : current + 1;
713
714    if (newIndex > btns.length) {
715      newIndex = '1';
716    }
717
718    var orders = [];
719    each(btns, function (btn) {
720      orders.push(btn.getAttribute('data-taborder'));
721    });
722    var nextOrders = orders.filter(function (el) {
723      return el >= parseInt(newIndex);
724    });
725    var nextFocus = nextOrders.sort()[0];
726    return document.querySelector(".gbtn[data-taborder=\"".concat(nextFocus, "\"]"));
727  }
728
729  function keyboardNavigation(instance) {
730    if (instance.events.hasOwnProperty('keyboard')) {
731      return false;
732    }
733
734    instance.events['keyboard'] = addEvent('keydown', {
735      onElement: window,
736      withCallback: function withCallback(event, target) {
737        event = event || window.event;
738        var key = event.keyCode;
739
740        if (key == 9) {
741          var focusedButton = document.querySelector('.gbtn.focused');
742
743          if (!focusedButton) {
744            var activeElement = document.activeElement && document.activeElement.nodeName ? document.activeElement.nodeName.toLocaleLowerCase() : false;
745
746            if (activeElement == 'input' || activeElement == 'textarea' || activeElement == 'button') {
747              return;
748            }
749          }
750
751          event.preventDefault();
752          var btns = document.querySelectorAll('.gbtn[data-taborder]');
753
754          if (!btns || btns.length <= 0) {
755            return;
756          }
757
758          if (!focusedButton) {
759            var first = getNextFocusElement();
760
761            if (first) {
762              first.focus();
763              addClass(first, 'focused');
764            }
765
766            return;
767          }
768
769          var currentFocusOrder = focusedButton.getAttribute('data-taborder');
770          var nextFocus = getNextFocusElement(currentFocusOrder);
771          removeClass(focusedButton, 'focused');
772
773          if (nextFocus) {
774            nextFocus.focus();
775            addClass(nextFocus, 'focused');
776          }
777        }
778
779        if (key == 39) {
780          instance.nextSlide();
781        }
782
783        if (key == 37) {
784          instance.prevSlide();
785        }
786
787        if (key == 27) {
788          instance.close();
789        }
790      }
791    });
792  }
793
794  function getLen(v) {
795    return Math.sqrt(v.x * v.x + v.y * v.y);
796  }
797
798  function dot(v1, v2) {
799    return v1.x * v2.x + v1.y * v2.y;
800  }
801
802  function getAngle(v1, v2) {
803    var mr = getLen(v1) * getLen(v2);
804
805    if (mr === 0) {
806      return 0;
807    }
808
809    var r = dot(v1, v2) / mr;
810
811    if (r > 1) {
812      r = 1;
813    }
814
815    return Math.acos(r);
816  }
817
818  function cross(v1, v2) {
819    return v1.x * v2.y - v2.x * v1.y;
820  }
821
822  function getRotateAngle(v1, v2) {
823    var angle = getAngle(v1, v2);
824
825    if (cross(v1, v2) > 0) {
826      angle *= -1;
827    }
828
829    return angle * 180 / Math.PI;
830  }
831
832  var EventsHandlerAdmin = function () {
833    function EventsHandlerAdmin(el) {
834      _classCallCheck(this, EventsHandlerAdmin);
835
836      this.handlers = [];
837      this.el = el;
838    }
839
840    _createClass(EventsHandlerAdmin, [{
841      key: "add",
842      value: function add(handler) {
843        this.handlers.push(handler);
844      }
845    }, {
846      key: "del",
847      value: function del(handler) {
848        if (!handler) {
849          this.handlers = [];
850        }
851
852        for (var i = this.handlers.length; i >= 0; i--) {
853          if (this.handlers[i] === handler) {
854            this.handlers.splice(i, 1);
855          }
856        }
857      }
858    }, {
859      key: "dispatch",
860      value: function dispatch() {
861        for (var i = 0, len = this.handlers.length; i < len; i++) {
862          var handler = this.handlers[i];
863
864          if (typeof handler === 'function') {
865            handler.apply(this.el, arguments);
866          }
867        }
868      }
869    }]);
870
871    return EventsHandlerAdmin;
872  }();
873
874  function wrapFunc(el, handler) {
875    var EventshandlerAdmin = new EventsHandlerAdmin(el);
876    EventshandlerAdmin.add(handler);
877    return EventshandlerAdmin;
878  }
879
880  var TouchEvents = function () {
881    function TouchEvents(el, option) {
882      _classCallCheck(this, TouchEvents);
883
884      this.element = typeof el == 'string' ? document.querySelector(el) : el;
885      this.start = this.start.bind(this);
886      this.move = this.move.bind(this);
887      this.end = this.end.bind(this);
888      this.cancel = this.cancel.bind(this);
889      this.element.addEventListener('touchstart', this.start, false);
890      this.element.addEventListener('touchmove', this.move, false);
891      this.element.addEventListener('touchend', this.end, false);
892      this.element.addEventListener('touchcancel', this.cancel, false);
893      this.preV = {
894        x: null,
895        y: null
896      };
897      this.pinchStartLen = null;
898      this.zoom = 1;
899      this.isDoubleTap = false;
900
901      var noop = function noop() {};
902
903      this.rotate = wrapFunc(this.element, option.rotate || noop);
904      this.touchStart = wrapFunc(this.element, option.touchStart || noop);
905      this.multipointStart = wrapFunc(this.element, option.multipointStart || noop);
906      this.multipointEnd = wrapFunc(this.element, option.multipointEnd || noop);
907      this.pinch = wrapFunc(this.element, option.pinch || noop);
908      this.swipe = wrapFunc(this.element, option.swipe || noop);
909      this.tap = wrapFunc(this.element, option.tap || noop);
910      this.doubleTap = wrapFunc(this.element, option.doubleTap || noop);
911      this.longTap = wrapFunc(this.element, option.longTap || noop);
912      this.singleTap = wrapFunc(this.element, option.singleTap || noop);
913      this.pressMove = wrapFunc(this.element, option.pressMove || noop);
914      this.twoFingerPressMove = wrapFunc(this.element, option.twoFingerPressMove || noop);
915      this.touchMove = wrapFunc(this.element, option.touchMove || noop);
916      this.touchEnd = wrapFunc(this.element, option.touchEnd || noop);
917      this.touchCancel = wrapFunc(this.element, option.touchCancel || noop);
918      this.translateContainer = this.element;
919      this._cancelAllHandler = this.cancelAll.bind(this);
920      window.addEventListener('scroll', this._cancelAllHandler);
921      this.delta = null;
922      this.last = null;
923      this.now = null;
924      this.tapTimeout = null;
925      this.singleTapTimeout = null;
926      this.longTapTimeout = null;
927      this.swipeTimeout = null;
928      this.x1 = this.x2 = this.y1 = this.y2 = null;
929      this.preTapPosition = {
930        x: null,
931        y: null
932      };
933    }
934
935    _createClass(TouchEvents, [{
936      key: "start",
937      value: function start(evt) {
938        if (!evt.touches) {
939          return;
940        }
941
942        var ignoreDragFor = ['a', 'button', 'input'];
943
944        if (evt.target && evt.target.nodeName && ignoreDragFor.indexOf(evt.target.nodeName.toLowerCase()) >= 0) {
945          console.log('ignore drag for this touched element', evt.target.nodeName.toLowerCase());
946          return;
947        }
948
949        this.now = Date.now();
950        this.x1 = evt.touches[0].pageX;
951        this.y1 = evt.touches[0].pageY;
952        this.delta = this.now - (this.last || this.now);
953        this.touchStart.dispatch(evt, this.element);
954
955        if (this.preTapPosition.x !== null) {
956          this.isDoubleTap = this.delta > 0 && this.delta <= 250 && Math.abs(this.preTapPosition.x - this.x1) < 30 && Math.abs(this.preTapPosition.y - this.y1) < 30;
957
958          if (this.isDoubleTap) {
959            clearTimeout(this.singleTapTimeout);
960          }
961        }
962
963        this.preTapPosition.x = this.x1;
964        this.preTapPosition.y = this.y1;
965        this.last = this.now;
966        var preV = this.preV,
967            len = evt.touches.length;
968
969        if (len > 1) {
970          this._cancelLongTap();
971
972          this._cancelSingleTap();
973
974          var v = {
975            x: evt.touches[1].pageX - this.x1,
976            y: evt.touches[1].pageY - this.y1
977          };
978          preV.x = v.x;
979          preV.y = v.y;
980          this.pinchStartLen = getLen(preV);
981          this.multipointStart.dispatch(evt, this.element);
982        }
983
984        this._preventTap = false;
985        this.longTapTimeout = setTimeout(function () {
986          this.longTap.dispatch(evt, this.element);
987          this._preventTap = true;
988        }.bind(this), 750);
989      }
990    }, {
991      key: "move",
992      value: function move(evt) {
993        if (!evt.touches) {
994          return;
995        }
996
997        var preV = this.preV,
998            len = evt.touches.length,
999            currentX = evt.touches[0].pageX,
1000            currentY = evt.touches[0].pageY;
1001        this.isDoubleTap = false;
1002
1003        if (len > 1) {
1004          var sCurrentX = evt.touches[1].pageX,
1005              sCurrentY = evt.touches[1].pageY;
1006          var v = {
1007            x: evt.touches[1].pageX - currentX,
1008            y: evt.touches[1].pageY - currentY
1009          };
1010
1011          if (preV.x !== null) {
1012            if (this.pinchStartLen > 0) {
1013              evt.zoom = getLen(v) / this.pinchStartLen;
1014              this.pinch.dispatch(evt, this.element);
1015            }
1016
1017            evt.angle = getRotateAngle(v, preV);
1018            this.rotate.dispatch(evt, this.element);
1019          }
1020
1021          preV.x = v.x;
1022          preV.y = v.y;
1023
1024          if (this.x2 !== null && this.sx2 !== null) {
1025            evt.deltaX = (currentX - this.x2 + sCurrentX - this.sx2) / 2;
1026            evt.deltaY = (currentY - this.y2 + sCurrentY - this.sy2) / 2;
1027          } else {
1028            evt.deltaX = 0;
1029            evt.deltaY = 0;
1030          }
1031
1032          this.twoFingerPressMove.dispatch(evt, this.element);
1033          this.sx2 = sCurrentX;
1034          this.sy2 = sCurrentY;
1035        } else {
1036          if (this.x2 !== null) {
1037            evt.deltaX = currentX - this.x2;
1038            evt.deltaY = currentY - this.y2;
1039            var movedX = Math.abs(this.x1 - this.x2),
1040                movedY = Math.abs(this.y1 - this.y2);
1041
1042            if (movedX > 10 || movedY > 10) {
1043              this._preventTap = true;
1044            }
1045          } else {
1046            evt.deltaX = 0;
1047            evt.deltaY = 0;
1048          }
1049
1050          this.pressMove.dispatch(evt, this.element);
1051        }
1052
1053        this.touchMove.dispatch(evt, this.element);
1054
1055        this._cancelLongTap();
1056
1057        this.x2 = currentX;
1058        this.y2 = currentY;
1059
1060        if (len > 1) {
1061          evt.preventDefault();
1062        }
1063      }
1064    }, {
1065      key: "end",
1066      value: function end(evt) {
1067        if (!evt.changedTouches) {
1068          return;
1069        }
1070
1071        this._cancelLongTap();
1072
1073        var self = this;
1074
1075        if (evt.touches.length < 2) {
1076          this.multipointEnd.dispatch(evt, this.element);
1077          this.sx2 = this.sy2 = null;
1078        }
1079
1080        if (this.x2 && Math.abs(this.x1 - this.x2) > 30 || this.y2 && Math.abs(this.y1 - this.y2) > 30) {
1081          evt.direction = this._swipeDirection(this.x1, this.x2, this.y1, this.y2);
1082          this.swipeTimeout = setTimeout(function () {
1083            self.swipe.dispatch(evt, self.element);
1084          }, 0);
1085        } else {
1086          this.tapTimeout = setTimeout(function () {
1087            if (!self._preventTap) {
1088              self.tap.dispatch(evt, self.element);
1089            }
1090
1091            if (self.isDoubleTap) {
1092              self.doubleTap.dispatch(evt, self.element);
1093              self.isDoubleTap = false;
1094            }
1095          }, 0);
1096
1097          if (!self.isDoubleTap) {
1098            self.singleTapTimeout = setTimeout(function () {
1099              self.singleTap.dispatch(evt, self.element);
1100            }, 250);
1101          }
1102        }
1103
1104        this.touchEnd.dispatch(evt, this.element);
1105        this.preV.x = 0;
1106        this.preV.y = 0;
1107        this.zoom = 1;
1108        this.pinchStartLen = null;
1109        this.x1 = this.x2 = this.y1 = this.y2 = null;
1110      }
1111    }, {
1112      key: "cancelAll",
1113      value: function cancelAll() {
1114        this._preventTap = true;
1115        clearTimeout(this.singleTapTimeout);
1116        clearTimeout(this.tapTimeout);
1117        clearTimeout(this.longTapTimeout);
1118        clearTimeout(this.swipeTimeout);
1119      }
1120    }, {
1121      key: "cancel",
1122      value: function cancel(evt) {
1123        this.cancelAll();
1124        this.touchCancel.dispatch(evt, this.element);
1125      }
1126    }, {
1127      key: "_cancelLongTap",
1128      value: function _cancelLongTap() {
1129        clearTimeout(this.longTapTimeout);
1130      }
1131    }, {
1132      key: "_cancelSingleTap",
1133      value: function _cancelSingleTap() {
1134        clearTimeout(this.singleTapTimeout);
1135      }
1136    }, {
1137      key: "_swipeDirection",
1138      value: function _swipeDirection(x1, x2, y1, y2) {
1139        return Math.abs(x1 - x2) >= Math.abs(y1 - y2) ? x1 - x2 > 0 ? 'Left' : 'Right' : y1 - y2 > 0 ? 'Up' : 'Down';
1140      }
1141    }, {
1142      key: "on",
1143      value: function on(evt, handler) {
1144        if (this[evt]) {
1145          this[evt].add(handler);
1146        }
1147      }
1148    }, {
1149      key: "off",
1150      value: function off(evt, handler) {
1151        if (this[evt]) {
1152          this[evt].del(handler);
1153        }
1154      }
1155    }, {
1156      key: "destroy",
1157      value: function destroy() {
1158        if (this.singleTapTimeout) {
1159          clearTimeout(this.singleTapTimeout);
1160        }
1161
1162        if (this.tapTimeout) {
1163          clearTimeout(this.tapTimeout);
1164        }
1165
1166        if (this.longTapTimeout) {
1167          clearTimeout(this.longTapTimeout);
1168        }
1169
1170        if (this.swipeTimeout) {
1171          clearTimeout(this.swipeTimeout);
1172        }
1173
1174        this.element.removeEventListener('touchstart', this.start);
1175        this.element.removeEventListener('touchmove', this.move);
1176        this.element.removeEventListener('touchend', this.end);
1177        this.element.removeEventListener('touchcancel', this.cancel);
1178        this.rotate.del();
1179        this.touchStart.del();
1180        this.multipointStart.del();
1181        this.multipointEnd.del();
1182        this.pinch.del();
1183        this.swipe.del();
1184        this.tap.del();
1185        this.doubleTap.del();
1186        this.longTap.del();
1187        this.singleTap.del();
1188        this.pressMove.del();
1189        this.twoFingerPressMove.del();
1190        this.touchMove.del();
1191        this.touchEnd.del();
1192        this.touchCancel.del();
1193        this.preV = this.pinchStartLen = this.zoom = this.isDoubleTap = this.delta = this.last = this.now = this.tapTimeout = this.singleTapTimeout = this.longTapTimeout = this.swipeTimeout = this.x1 = this.x2 = this.y1 = this.y2 = this.preTapPosition = this.rotate = this.touchStart = this.multipointStart = this.multipointEnd = this.pinch = this.swipe = this.tap = this.doubleTap = this.longTap = this.singleTap = this.pressMove = this.touchMove = this.touchEnd = this.touchCancel = this.twoFingerPressMove = null;
1194        window.removeEventListener('scroll', this._cancelAllHandler);
1195        return null;
1196      }
1197    }]);
1198
1199    return TouchEvents;
1200  }();
1201
1202  function resetSlideMove(slide) {
1203    var transitionEnd = whichTransitionEvent();
1204    var windowWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
1205    var media = hasClass(slide, 'gslide-media') ? slide : slide.querySelector('.gslide-media');
1206    var container = closest(media, '.ginner-container');
1207    var desc = slide.querySelector('.gslide-description');
1208
1209    if (windowWidth > 769) {
1210      media = container;
1211    }
1212
1213    addClass(media, 'greset');
1214    cssTransform(media, 'translate3d(0, 0, 0)');
1215    addEvent(transitionEnd, {
1216      onElement: media,
1217      once: true,
1218      withCallback: function withCallback(event, target) {
1219        removeClass(media, 'greset');
1220      }
1221    });
1222    media.style.opacity = '';
1223
1224    if (desc) {
1225      desc.style.opacity = '';
1226    }
1227  }
1228
1229  function touchNavigation(instance) {
1230    if (instance.events.hasOwnProperty('touch')) {
1231      return false;
1232    }
1233
1234    var winSize = windowSize();
1235    var winWidth = winSize.width;
1236    var winHeight = winSize.height;
1237    var process = false;
1238    var currentSlide = null;
1239    var media = null;
1240    var mediaImage = null;
1241    var doingMove = false;
1242    var initScale = 1;
1243    var maxScale = 4.5;
1244    var currentScale = 1;
1245    var doingZoom = false;
1246    var imageZoomed = false;
1247    var zoomedPosX = null;
1248    var zoomedPosY = null;
1249    var lastZoomedPosX = null;
1250    var lastZoomedPosY = null;
1251    var hDistance;
1252    var vDistance;
1253    var hDistancePercent = 0;
1254    var vDistancePercent = 0;
1255    var vSwipe = false;
1256    var hSwipe = false;
1257    var startCoords = {};
1258    var endCoords = {};
1259    var xDown = 0;
1260    var yDown = 0;
1261    var isInlined;
1262    var sliderWrapper = document.getElementById('glightbox-slider');
1263    var overlay = document.querySelector('.goverlay');
1264    var touchInstance = new TouchEvents(sliderWrapper, {
1265      touchStart: function touchStart(e) {
1266        process = true;
1267
1268        if (hasClass(e.targetTouches[0].target, 'ginner-container') || closest(e.targetTouches[0].target, '.gslide-desc') || e.targetTouches[0].target.nodeName.toLowerCase() == 'a') {
1269          process = false;
1270        }
1271
1272        if (closest(e.targetTouches[0].target, '.gslide-inline') && !hasClass(e.targetTouches[0].target.parentNode, 'gslide-inline')) {
1273          process = false;
1274        }
1275
1276        if (process) {
1277          endCoords = e.targetTouches[0];
1278          startCoords.pageX = e.targetTouches[0].pageX;
1279          startCoords.pageY = e.targetTouches[0].pageY;
1280          xDown = e.targetTouches[0].clientX;
1281          yDown = e.targetTouches[0].clientY;
1282          currentSlide = instance.activeSlide;
1283          media = currentSlide.querySelector('.gslide-media');
1284          isInlined = currentSlide.querySelector('.gslide-inline');
1285          mediaImage = null;
1286
1287          if (hasClass(media, 'gslide-image')) {
1288            mediaImage = media.querySelector('img');
1289          }
1290
1291          var windowWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
1292
1293          if (windowWidth > 769) {
1294            media = currentSlide.querySelector('.ginner-container');
1295          }
1296
1297          removeClass(overlay, 'greset');
1298
1299          if (e.pageX > 20 && e.pageX < window.innerWidth - 20) {
1300            return;
1301          }
1302
1303          e.preventDefault();
1304        }
1305      },
1306      touchMove: function touchMove(e) {
1307        if (!process) {
1308          return;
1309        }
1310
1311        endCoords = e.targetTouches[0];
1312
1313        if (doingZoom || imageZoomed) {
1314          return;
1315        }
1316
1317        if (isInlined && isInlined.offsetHeight > winHeight) {
1318          var moved = startCoords.pageX - endCoords.pageX;
1319
1320          if (Math.abs(moved) <= 13) {
1321            return false;
1322          }
1323        }
1324
1325        doingMove = true;
1326        var xUp = e.targetTouches[0].clientX;
1327        var yUp = e.targetTouches[0].clientY;
1328        var xDiff = xDown - xUp;
1329        var yDiff = yDown - yUp;
1330
1331        if (Math.abs(xDiff) > Math.abs(yDiff)) {
1332          vSwipe = false;
1333          hSwipe = true;
1334        } else {
1335          hSwipe = false;
1336          vSwipe = true;
1337        }
1338
1339        hDistance = endCoords.pageX - startCoords.pageX;
1340        hDistancePercent = hDistance * 100 / winWidth;
1341        vDistance = endCoords.pageY - startCoords.pageY;
1342        vDistancePercent = vDistance * 100 / winHeight;
1343        var opacity;
1344
1345        if (vSwipe && mediaImage) {
1346          opacity = 1 - Math.abs(vDistance) / winHeight;
1347          overlay.style.opacity = opacity;
1348
1349          if (instance.settings.touchFollowAxis) {
1350            hDistancePercent = 0;
1351          }
1352        }
1353
1354        if (hSwipe) {
1355          opacity = 1 - Math.abs(hDistance) / winWidth;
1356          media.style.opacity = opacity;
1357
1358          if (instance.settings.touchFollowAxis) {
1359            vDistancePercent = 0;
1360          }
1361        }
1362
1363        if (!mediaImage) {
1364          return cssTransform(media, "translate3d(".concat(hDistancePercent, "%, 0, 0)"));
1365        }
1366
1367        cssTransform(media, "translate3d(".concat(hDistancePercent, "%, ").concat(vDistancePercent, "%, 0)"));
1368      },
1369      touchEnd: function touchEnd() {
1370        if (!process) {
1371          return;
1372        }
1373
1374        doingMove = false;
1375
1376        if (imageZoomed || doingZoom) {
1377          lastZoomedPosX = zoomedPosX;
1378          lastZoomedPosY = zoomedPosY;
1379          return;
1380        }
1381
1382        var v = Math.abs(parseInt(vDistancePercent));
1383        var h = Math.abs(parseInt(hDistancePercent));
1384
1385        if (v > 29 && mediaImage) {
1386          instance.close();
1387          return;
1388        }
1389
1390        if (v < 29 && h < 25) {
1391          addClass(overlay, 'greset');
1392          overlay.style.opacity = 1;
1393          return resetSlideMove(media);
1394        }
1395      },
1396      multipointEnd: function multipointEnd() {
1397        setTimeout(function () {
1398          doingZoom = false;
1399        }, 50);
1400      },
1401      multipointStart: function multipointStart() {
1402        doingZoom = true;
1403        initScale = currentScale ? currentScale : 1;
1404      },
1405      pinch: function pinch(evt) {
1406        if (!mediaImage || doingMove) {
1407          return false;
1408        }
1409
1410        doingZoom = true;
1411        mediaImage.scaleX = mediaImage.scaleY = initScale * evt.zoom;
1412        var scale = initScale * evt.zoom;
1413        imageZoomed = true;
1414
1415        if (scale <= 1) {
1416          imageZoomed = false;
1417          scale = 1;
1418          lastZoomedPosY = null;
1419          lastZoomedPosX = null;
1420          zoomedPosX = null;
1421          zoomedPosY = null;
1422          mediaImage.setAttribute('style', '');
1423          return;
1424        }
1425
1426        if (scale > maxScale) {
1427          scale = maxScale;
1428        }
1429
1430        mediaImage.style.transform = "scale3d(".concat(scale, ", ").concat(scale, ", 1)");
1431        currentScale = scale;
1432      },
1433      pressMove: function pressMove(e) {
1434        if (imageZoomed && !doingZoom) {
1435          var mhDistance = endCoords.pageX - startCoords.pageX;
1436          var mvDistance = endCoords.pageY - startCoords.pageY;
1437
1438          if (lastZoomedPosX) {
1439            mhDistance = mhDistance + lastZoomedPosX;
1440          }
1441
1442          if (lastZoomedPosY) {
1443            mvDistance = mvDistance + lastZoomedPosY;
1444          }
1445
1446          zoomedPosX = mhDistance;
1447          zoomedPosY = mvDistance;
1448          var style = "translate3d(".concat(mhDistance, "px, ").concat(mvDistance, "px, 0)");
1449
1450          if (currentScale) {
1451            style += " scale3d(".concat(currentScale, ", ").concat(currentScale, ", 1)");
1452          }
1453
1454          cssTransform(mediaImage, style);
1455        }
1456      },
1457      swipe: function swipe(evt) {
1458        if (imageZoomed) {
1459          return;
1460        }
1461
1462        if (doingZoom) {
1463          doingZoom = false;
1464          return;
1465        }
1466
1467        if (evt.direction == 'Left') {
1468          if (instance.index == instance.elements.length - 1) {
1469            return resetSlideMove(media);
1470          }
1471
1472          instance.nextSlide();
1473        }
1474
1475        if (evt.direction == 'Right') {
1476          if (instance.index == 0) {
1477            return resetSlideMove(media);
1478          }
1479
1480          instance.prevSlide();
1481        }
1482      }
1483    });
1484    instance.events['touch'] = touchInstance;
1485  }
1486
1487  var ZoomImages = function () {
1488    function ZoomImages(el, slide) {
1489      var _this = this;
1490
1491      var onclose = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
1492
1493      _classCallCheck(this, ZoomImages);
1494
1495      this.img = el;
1496      this.slide = slide;
1497      this.onclose = onclose;
1498
1499      if (this.img.setZoomEvents) {
1500        return false;
1501      }
1502
1503      this.active = false;
1504      this.zoomedIn = false;
1505      this.dragging = false;
1506      this.currentX = null;
1507      this.currentY = null;
1508      this.initialX = null;
1509      this.initialY = null;
1510      this.xOffset = 0;
1511      this.yOffset = 0;
1512      this.img.addEventListener('mousedown', function (e) {
1513        return _this.dragStart(e);
1514      }, false);
1515      this.img.addEventListener('mouseup', function (e) {
1516        return _this.dragEnd(e);
1517      }, false);
1518      this.img.addEventListener('mousemove', function (e) {
1519        return _this.drag(e);
1520      }, false);
1521      this.img.addEventListener('click', function (e) {
1522        if (_this.slide.classList.contains('dragging-nav')) {
1523          _this.zoomOut();
1524
1525          return false;
1526        }
1527
1528        if (!_this.zoomedIn) {
1529          return _this.zoomIn();
1530        }
1531
1532        if (_this.zoomedIn && !_this.dragging) {
1533          _this.zoomOut();
1534        }
1535      }, false);
1536      this.img.setZoomEvents = true;
1537    }
1538
1539    _createClass(ZoomImages, [{
1540      key: "zoomIn",
1541      value: function zoomIn() {
1542        var winWidth = this.widowWidth();
1543
1544        if (this.zoomedIn || winWidth <= 768) {
1545          return;
1546        }
1547
1548        var img = this.img;
1549        img.setAttribute('data-style', img.getAttribute('style'));
1550        img.style.maxWidth = img.naturalWidth + 'px';
1551        img.style.maxHeight = img.naturalHeight + 'px';
1552
1553        if (img.naturalWidth > winWidth) {
1554          var centerX = winWidth / 2 - img.naturalWidth / 2;
1555          this.setTranslate(this.img.parentNode, centerX, 0);
1556        }
1557
1558        this.slide.classList.add('zoomed');
1559        this.zoomedIn = true;
1560      }
1561    }, {
1562      key: "zoomOut",
1563      value: function zoomOut() {
1564        this.img.parentNode.setAttribute('style', '');
1565        this.img.setAttribute('style', this.img.getAttribute('data-style'));
1566        this.slide.classList.remove('zoomed');
1567        this.zoomedIn = false;
1568        this.currentX = null;
1569        this.currentY = null;
1570        this.initialX = null;
1571        this.initialY = null;
1572        this.xOffset = 0;
1573        this.yOffset = 0;
1574
1575        if (this.onclose && typeof this.onclose == 'function') {
1576          this.onclose();
1577        }
1578      }
1579    }, {
1580      key: "dragStart",
1581      value: function dragStart(e) {
1582        e.preventDefault();
1583
1584        if (!this.zoomedIn) {
1585          this.active = false;
1586          return;
1587        }
1588
1589        if (e.type === 'touchstart') {
1590          this.initialX = e.touches[0].clientX - this.xOffset;
1591          this.initialY = e.touches[0].clientY - this.yOffset;
1592        } else {
1593          this.initialX = e.clientX - this.xOffset;
1594          this.initialY = e.clientY - this.yOffset;
1595        }
1596
1597        if (e.target === this.img) {
1598          this.active = true;
1599          this.img.classList.add('dragging');
1600        }
1601      }
1602    }, {
1603      key: "dragEnd",
1604      value: function dragEnd(e) {
1605        var _this2 = this;
1606
1607        e.preventDefault();
1608        this.initialX = this.currentX;
1609        this.initialY = this.currentY;
1610        this.active = false;
1611        setTimeout(function () {
1612          _this2.dragging = false;
1613          _this2.img.isDragging = false;
1614
1615          _this2.img.classList.remove('dragging');
1616        }, 100);
1617      }
1618    }, {
1619      key: "drag",
1620      value: function drag(e) {
1621        if (this.active) {
1622          e.preventDefault();
1623
1624          if (e.type === 'touchmove') {
1625            this.currentX = e.touches[0].clientX - this.initialX;
1626            this.currentY = e.touches[0].clientY - this.initialY;
1627          } else {
1628            this.currentX = e.clientX - this.initialX;
1629            this.currentY = e.clientY - this.initialY;
1630          }
1631
1632          this.xOffset = this.currentX;
1633          this.yOffset = this.currentY;
1634          this.img.isDragging = true;
1635          this.dragging = true;
1636          this.setTranslate(this.img, this.currentX, this.currentY);
1637        }
1638      }
1639    }, {
1640      key: "onMove",
1641      value: function onMove(e) {
1642        if (!this.zoomedIn) {
1643          return;
1644        }
1645
1646        var xOffset = e.clientX - this.img.naturalWidth / 2;
1647        var yOffset = e.clientY - this.img.naturalHeight / 2;
1648        this.setTranslate(this.img, xOffset, yOffset);
1649      }
1650    }, {
1651      key: "setTranslate",
1652      value: function setTranslate(node, xPos, yPos) {
1653        node.style.transform = 'translate3d(' + xPos + 'px, ' + yPos + 'px, 0)';
1654      }
1655    }, {
1656      key: "widowWidth",
1657      value: function widowWidth() {
1658        return window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
1659      }
1660    }]);
1661
1662    return ZoomImages;
1663  }();
1664
1665  var DragSlides = function () {
1666    function DragSlides() {
1667      var _this = this;
1668
1669      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1670
1671      _classCallCheck(this, DragSlides);
1672
1673      var dragEl = config.dragEl,
1674          _config$toleranceX = config.toleranceX,
1675          toleranceX = _config$toleranceX === void 0 ? 40 : _config$toleranceX,
1676          _config$toleranceY = config.toleranceY,
1677          toleranceY = _config$toleranceY === void 0 ? 65 : _config$toleranceY,
1678          _config$slide = config.slide,
1679          slide = _config$slide === void 0 ? null : _config$slide,
1680          _config$instance = config.instance,
1681          instance = _config$instance === void 0 ? null : _config$instance;
1682      this.el = dragEl;
1683      this.active = false;
1684      this.dragging = false;
1685      this.currentX = null;
1686      this.currentY = null;
1687      this.initialX = null;
1688      this.initialY = null;
1689      this.xOffset = 0;
1690      this.yOffset = 0;
1691      this.direction = null;
1692      this.lastDirection = null;
1693      this.toleranceX = toleranceX;
1694      this.toleranceY = toleranceY;
1695      this.toleranceReached = false;
1696      this.dragContainer = this.el;
1697      this.slide = slide;
1698      this.instance = instance;
1699      this.el.addEventListener('mousedown', function (e) {
1700        return _this.dragStart(e);
1701      }, false);
1702      this.el.addEventListener('mouseup', function (e) {
1703        return _this.dragEnd(e);
1704      }, false);
1705      this.el.addEventListener('mousemove', function (e) {
1706        return _this.drag(e);
1707      }, false);
1708    }
1709
1710    _createClass(DragSlides, [{
1711      key: "dragStart",
1712      value: function dragStart(e) {
1713        if (this.slide.classList.contains('zoomed')) {
1714          this.active = false;
1715          return;
1716        }
1717
1718        if (e.type === 'touchstart') {
1719          this.initialX = e.touches[0].clientX - this.xOffset;
1720          this.initialY = e.touches[0].clientY - this.yOffset;
1721        } else {
1722          this.initialX = e.clientX - this.xOffset;
1723          this.initialY = e.clientY - this.yOffset;
1724        }
1725
1726        var clicked = e.target.nodeName.toLowerCase();
1727        var exludeClicks = ['input', 'select', 'textarea', 'button', 'a'];
1728
1729        if (e.target.classList.contains('nodrag') || closest(e.target, '.nodrag') || exludeClicks.indexOf(clicked) !== -1) {
1730          this.active = false;
1731          return;
1732        }
1733
1734        e.preventDefault();
1735
1736        if (e.target === this.el || clicked !== 'img' && closest(e.target, '.gslide-inline')) {
1737          this.active = true;
1738          this.el.classList.add('dragging');
1739          this.dragContainer = closest(e.target, '.ginner-container');
1740        }
1741      }
1742    }, {
1743      key: "dragEnd",
1744      value: function dragEnd(e) {
1745        var _this2 = this;
1746
1747        e && e.preventDefault();
1748        this.initialX = 0;
1749        this.initialY = 0;
1750        this.currentX = null;
1751        this.currentY = null;
1752        this.initialX = null;
1753        this.initialY = null;
1754        this.xOffset = 0;
1755        this.yOffset = 0;
1756        this.active = false;
1757
1758        if (this.doSlideChange) {
1759          this.instance.preventOutsideClick = true;
1760          this.doSlideChange == 'right' && this.instance.prevSlide();
1761          this.doSlideChange == 'left' && this.instance.nextSlide();
1762        }
1763
1764        if (this.doSlideClose) {
1765          this.instance.close();
1766        }
1767
1768        if (!this.toleranceReached) {
1769          this.setTranslate(this.dragContainer, 0, 0, true);
1770        }
1771
1772        setTimeout(function () {
1773          _this2.instance.preventOutsideClick = false;
1774          _this2.toleranceReached = false;
1775          _this2.lastDirection = null;
1776          _this2.dragging = false;
1777          _this2.el.isDragging = false;
1778
1779          _this2.el.classList.remove('dragging');
1780
1781          _this2.slide.classList.remove('dragging-nav');
1782
1783          _this2.dragContainer.style.transform = '';
1784          _this2.dragContainer.style.transition = '';
1785        }, 100);
1786      }
1787    }, {
1788      key: "drag",
1789      value: function drag(e) {
1790        if (this.active) {
1791          e.preventDefault();
1792          this.slide.classList.add('dragging-nav');
1793
1794          if (e.type === 'touchmove') {
1795            this.currentX = e.touches[0].clientX - this.initialX;
1796            this.currentY = e.touches[0].clientY - this.initialY;
1797          } else {
1798            this.currentX = e.clientX - this.initialX;
1799            this.currentY = e.clientY - this.initialY;
1800          }
1801
1802          this.xOffset = this.currentX;
1803          this.yOffset = this.currentY;
1804          this.el.isDragging = true;
1805          this.dragging = true;
1806          this.doSlideChange = false;
1807          this.doSlideClose = false;
1808          var currentXInt = Math.abs(this.currentX);
1809          var currentYInt = Math.abs(this.currentY);
1810
1811          if (currentXInt > 0 && currentXInt >= Math.abs(this.currentY) && (!this.lastDirection || this.lastDirection == 'x')) {
1812            this.yOffset = 0;
1813            this.lastDirection = 'x';
1814            this.setTranslate(this.dragContainer, this.currentX, 0);
1815            var doChange = this.shouldChange();
1816
1817            if (!this.instance.settings.dragAutoSnap && doChange) {
1818              this.doSlideChange = doChange;
1819            }
1820
1821            if (this.instance.settings.dragAutoSnap && doChange) {
1822              this.instance.preventOutsideClick = true;
1823              this.toleranceReached = true;
1824              this.active = false;
1825              this.instance.preventOutsideClick = true;
1826              this.dragEnd(null);
1827              doChange == 'right' && this.instance.prevSlide();
1828              doChange == 'left' && this.instance.nextSlide();
1829              return;
1830            }
1831          }
1832
1833          if (this.toleranceY > 0 && currentYInt > 0 && currentYInt >= currentXInt && (!this.lastDirection || this.lastDirection == 'y')) {
1834            this.xOffset = 0;
1835            this.lastDirection = 'y';
1836            this.setTranslate(this.dragContainer, 0, this.currentY);
1837            var doClose = this.shouldClose();
1838
1839            if (!this.instance.settings.dragAutoSnap && doClose) {
1840              this.doSlideClose = true;
1841            }
1842
1843            if (this.instance.settings.dragAutoSnap && doClose) {
1844              this.instance.close();
1845            }
1846
1847            return;
1848          }
1849        }
1850      }
1851    }, {
1852      key: "shouldChange",
1853      value: function shouldChange() {
1854        var doChange = false;
1855        var currentXInt = Math.abs(this.currentX);
1856
1857        if (currentXInt >= this.toleranceX) {
1858          var dragDir = this.currentX > 0 ? 'right' : 'left';
1859
1860          if (dragDir == 'left' && this.slide !== this.slide.parentNode.lastChild || dragDir == 'right' && this.slide !== this.slide.parentNode.firstChild) {
1861            doChange = dragDir;
1862          }
1863        }
1864
1865        return doChange;
1866      }
1867    }, {

2206      key: "parseConfig",
2207      value: function parseConfig(element, settings) {
2208        var _this = this;
2209
2210        var data = extend({
2211          descPosition: settings.descPosition
2212        }, this.defaults);
2213
2214        if (isObject(element) && !isNode(element)) {
2215          if (!has(element, 'type')) {
2216            if (has(element, 'content') && element.content) {
2217              element.type = 'inline';
2218            } else if (has(element, 'href')) {
2219              element.type = this.sourceType(element.href);
2220            }
2221          }
2222
2223          var objectData = extend(data, element);
2224          this.setSize(objectData, settings);
2225          return objectData;
2226        }
2227
2228        var url = '';
2229        var config = element.getAttribute('data-glightbox');
2230        var nodeType = element.nodeName.toLowerCase();
2231
2232        if (nodeType === 'a') {
2233          url = element.href;
2234        }
2235
2236        if (nodeType === 'img') {
2237          url = element.src;
2238          data.alt = element.alt;
2239        }
2240
2241        data.href = url;
2242        each(data, function (val, key) {
2243          if (has(settings, key) && key !== 'width') {
2244            data[key] = settings[key];
2245          }
2246
2247          var nodeData = element.dataset[key];
2248
2249          if (!isNil(nodeData)) {
2250            data[key] = _this.sanitizeValue(nodeData);
2251          }
2252        });
2253
2254        if (data.content) {
2255          data.type = 'inline';
2256        }
2257
2258        if (!data.type && url) {
2259          data.type = this.sourceType(url);
2260        }
2261
2262        if (!isNil(config)) {
2263          var cleanKeys = [];
2264          each(data, function (v, k) {
2265            cleanKeys.push(';\\s?' + k);
2266          });
2267          cleanKeys = cleanKeys.join('\\s?:|');
2268
2269          if (config.trim() !== '') {
2270            each(data, function (val, key) {
2271              var str = config;
2272              var match = 's?' + key + 's?:s?(.*?)(' + cleanKeys + 's?:|$)';
2273              var regex = new RegExp(match);
2274              var matches = str.match(regex);
2275
2276              if (matches && matches.length && matches[1]) {
2277                var value = matches[1].trim().replace(/;\s*$/, '');
2278                data[key] = _this.sanitizeValue(value);
2279              }
2280            });
2281          }
2282        } else {
2283          if (!data.title && nodeType == 'a') {
2284            var title = element.title;
2285
2286            if (!isNil(title) && title !== '') {
2287              data.title = title;
2288            }
2289          }
2290
2291          if (!data.title && nodeType == 'img') {
2292            var alt = element.alt;
2293
2294            if (!isNil(alt) && alt !== '') {
2295              data.title = alt;
2296            }
2297          }
2298        }
2299
2300        if (data.description && data.description.substring(0, 1) === '.') {
2301          var description;
2302
2303          try {
2304            description = document.querySelector(data.description).innerHTML;
2305          } catch (error) {
2306            if (!(error instanceof DOMException)) {
2307              throw error;
2308            }
2309          }
2310
2311          if (description) {
2312            data.description = description;
2313          }
2314        }
2315
2316        if (!data.description) {
2317          var nodeDesc = element.querySelector('.glightbox-desc');
2318
2319          if (nodeDesc) {
2320            data.description = nodeDesc.innerHTML;
2321          }
2322        }
2323
2324        this.setSize(data, settings, element);
2325        this.slideConfig = data;
2326        return data;
2327      }
2328    }, {
2329      key: "setSize",
2330      value: function setSize(data, settings) {
2331        var element = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
2332        var defaultWith = data.type == 'video' ? this.checkSize(settings.videosWidth) : this.checkSize(settings.width);
2333        var defaultHeight = this.checkSize(settings.height);
2334        data.width = has(data, 'width') && data.width !== '' ? this.checkSize(data.width) : defaultWith;
2335        data.height = has(data, 'height') && data.height !== '' ? this.checkSize(data.height) : defaultHeight;
2336
2337        if (element && data.type == 'image') {
2338          data._hasCustomWidth = element.dataset.width ? true : false;
2339          data._hasCustomHeight = element.dataset.height ? true : false;
2340        }
2341
2342        return data;
2343      }
2344    }, {
2345      key: "checkSize",
2346      value: function checkSize(size) {
2347        return isNumber(size) ? "".concat(size, "px") : size;
2348      }
2349    }, {
2350      key: "sanitizeValue",
2351      value: function sanitizeValue(val) {
2352        if (val !== 'true' && val !== 'false') {
2353          return val;
2354        }
2355
2356        return val === 'true';
2357      }
2358    }]);
2359
2360    return SlideConfigParser;
2361  }();
2362
2363  var Slide = function () {
2364    function Slide(el, instance, index) {
2365      _classCallCheck(this, Slide);
2366
2367      this.element = el;
2368      this.instance = instance;
2369      this.index = index;
2370    }
2371
2372    _createClass(Slide, [{
2373      key: "setContent",
2374      value: function setContent() {
2375        var _this = this;
2376
2377        var slide = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
2378        var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
2379
2380        if (hasClass(slide, 'loaded')) {
2381          return false;
2382        }
2383
2384        var settings = this.instance.settings;
2385        var slideConfig = this.slideConfig;
2386        var isMobileDevice = isMobile();
2387
2388        if (isFunction(settings.beforeSlideLoad)) {
2389          settings.beforeSlideLoad({
2390            index: this.index,
2391            slide: slide,
2392            player: false
2393          });
2394        }
2395
2396        var type = slideConfig.type;
2397        var position = slideConfig.descPosition;
2398        var slideMedia = slide.querySelector('.gslide-media');
2399        var slideTitle = slide.querySelector('.gslide-title');
2400        var slideText = slide.querySelector('.gslide-desc');
2401        var slideDesc = slide.querySelector('.gdesc-inner');
2402        var finalCallback = callback;
2403        var titleID = 'gSlideTitle_' + this.index;
2404        var textID = 'gSlideDesc_' + this.index;
2405
2406        if (isFunction(settings.afterSlideLoad)) {
2407          finalCallback = function finalCallback() {
2408            if (isFunction(callback)) {
2409              callback();
2410            }
2411
2412            settings.afterSlideLoad({
2413              index: _this.index,
2414              slide: slide,
2415              player: _this.instance.getSlidePlayerInstance(_this.index)
2416            });
2417          };
2418        }
2419
2420        if (slideConfig.title == '' && slideConfig.description == '') {
2421          if (slideDesc) {
2422            slideDesc.parentNode.parentNode.removeChild(slideDesc.parentNode);
2423          }
2424        } else {
2425          if (slideTitle && slideConfig.title !== '') {
2426            slideTitle.id = titleID;
2427            slideTitle.innerHTML = slideConfig.title;
2428          } else {
2429            slideTitle.parentNode.removeChild(slideTitle);
2430          }
2431
2432          if (slideText && slideConfig.description !== '') {
2433            slideText.id = textID;
2434
2435            if (isMobileDevice && settings.moreLength > 0) {
2436              slideConfig.smallDescription = this.slideShortDesc(slideConfig.description, settings.moreLength, settings.moreText);
2437              slideText.innerHTML = slideConfig.smallDescription;
2438              this.descriptionEvents(slideText, slideConfig);
2439            } else {
2440              slideText.innerHTML = slideConfig.description;
2441            }
2442          } else {
2443            slideText.parentNode.removeChild(slideText);
2444          }
2445
2446          addClass(slideMedia.parentNode, "desc-".concat(position));
2447          addClass(slideDesc.parentNode, "description-".concat(position));
2448        }
2449
2450        addClass(slideMedia, "gslide-".concat(type));
2451        addClass(slide, 'loaded');
2452
2453        if (type === 'video') {
2454          slideVideo.apply(this.instance, [slide, slideConfig, this.index, finalCallback]);
2455          return;
2456        }
2457
2458        if (type === 'external') {
2459          slideIframe.apply(this, [slide, slideConfig, this.index, finalCallback]);
2460          return;
2461        }
2462
2463        if (type === 'inline') {
2464          slideInline.apply(this.instance, [slide, slideConfig, this.index, finalCallback]);
2465
2466          if (slideConfig.draggable) {
2467            new DragSlides({
2468              dragEl: slide.querySelector('.gslide-inline'),
2469              toleranceX: settings.dragToleranceX,
2470              toleranceY: settings.dragToleranceY,
2471              slide: slide,
2472              instance: this.instance
2473            });
2474          }
2475
2476          return;
2477        }
2478
2479        if (type === 'image') {
2480          slideImage(slide, slideConfig, this.index, function () {
2481            var img = slide.querySelector('img');
2482
2483            if (slideConfig.draggable) {
2484              new DragSlides({
2485                dragEl: img,
2486                toleranceX: settings.dragToleranceX,
2487                toleranceY: settings.dragToleranceY,
2488                slide: slide,
2489                instance: _this.instance
2490              });
2491            }
2492
2493            if (slideConfig.zoomable && img.naturalWidth > img.offsetWidth) {
2494              addClass(img, 'zoomable');
2495              new ZoomImages(img, slide, function () {
2496                _this.instance.resize();
2497              });
2498            }
2499
2500            if (isFunction(finalCallback)) {
2501              finalCallback();
2502            }
2503          });
2504          return;
2505        }
2506
2507        if (isFunction(finalCallback)) {
2508          finalCallback();
2509        }
2510      }
2511    }, {
2512      key: "slideShortDesc",
2513      value: function slideShortDesc(string) {
2514        var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 50;
2515        var wordBoundary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
2516        var div = document.createElement('div');
2517        div.innerHTML = string;
2518        var cleanedString = div.innerText;
2519        var useWordBoundary = wordBoundary;
2520        string = cleanedString.trim();
2521
2522        if (string.length <= n) {
2523          return string;
2524        }
2525
2526        var subString = string.substr(0, n - 1);
2527
2528        if (!useWordBoundary) {
2529          return subString;
2530        }
2531
2532        div = null;
2533        return subString + '... <a href="#" class="desc-more">' + wordBoundary + '</a>';
2534      }
2535    }, {
2536      key: "descriptionEvents",
2537      value: function descriptionEvents(desc, data) {
2538        var _this2 = this;
2539
2540        var moreLink = desc.querySelector('.desc-more');
2541
2542        if (!moreLink) {
2543          return false;
2544        }
2545
2546        addEvent('click', {
2547          onElement: moreLink,
2548          withCallback: function withCallback(event, target) {
2549            event.preventDefault();
2550            var body = document.body;
2551            var desc = closest(target, '.gslide-desc');
2552
2553            if (!desc) {
2554              return false;
2555            }
2556
2557            desc.innerHTML = data.description;
2558            addClass(body, 'gdesc-open');
2559            var shortEvent = addEvent('click', {
2560              onElement: [body, closest(desc, '.gslide-description')],
2561              withCallback: function withCallback(event, target) {
2562                if (event.target.nodeName.toLowerCase() !== 'a') {
2563                  removeClass(body, 'gdesc-open');
2564                  addClass(body, 'gdesc-closed');
2565                  desc.innerHTML = data.smallDescription;
2566
2567                  _this2.descriptionEvents(desc, data);
2568
2569                  setTimeout(function () {
2570                    removeClass(body, 'gdesc-closed');
2571                  }, 400);
2572                  shortEvent.destroy();
2573                }
2574              }
2575            });
2576          }
2577        });
2578      }
2579    }, {
2580      key: "create",
2581      value: function create() {
2582        return createHTML(this.instance.settings.slideHTML);
2583      }
2584    }, {
2585      key: "getConfig",
2586      value: function getConfig() {
2587        if (!isNode(this.element) && !this.element.hasOwnProperty('draggable')) {
2588          this.element.draggable = this.instance.settings.draggable;
2589        }
2590
2591        var parser = new SlideConfigParser(this.instance.settings.slideExtraAttributes);
2592        this.slideConfig = parser.parseConfig(this.element, this.instance.settings);
2593        return this.slideConfig;
2594      }
2595    }]);
2596
2597    return Slide;
2598  }();
2599
2600  var _version = '3.1.1';
2601  var isMobile$1 = isMobile();
2602  var isTouch$1 = isTouch();
2603  var html = document.getElementsByTagName('html')[0];
2604  var defaults = {
2605    selector: '.glightbox',
2606    elements: null,
2607    skin: 'clean',
2608    theme: 'clean',
2609    closeButton: true,
2610    startAt: null,
2611    autoplayVideos: true,
2612    autofocusVideos: true,
2613    descPosition: 'bottom',
2614    width: '900px',
2615    height: '506px',
2616    videosWidth: '960px',
2617    beforeSlideChange: null,
2618    afterSlideChange: null,
2619    beforeSlideLoad: null,
2620    afterSlideLoad: null,
2621    slideInserted: null,
2622    slideRemoved: null,
2623    slideExtraAttributes: null,
2624    onOpen: null,
2625    onClose: null,
2626    loop: false,
2627    zoomable: true,
2628    draggable: true,
2629    dragAutoSnap: false,
2630    dragToleranceX: 40,
2631    dragToleranceY: 65,
2632    preload: true,
2633    oneSlidePerOpen: false,
2634    touchNavigation: true,
2635    touchFollowAxis: true,
2636    keyboardNavigation: true,
2637    closeOnOutsideClick: true,
2638    plugins: false,
2639    plyr: {
2640      css: 'https://cdn.plyr.io/3.6.8/plyr.css',
2641      js: 'https://cdn.plyr.io/3.6.8/plyr.js',
2642      config: {
2643        ratio: '16:9',
2644        fullscreen: {
2645          enabled: true,
2646          iosNative: true
2647        },
2648        youtube: {
2649          noCookie: true,
2650          rel: 0,
2651          showinfo: 0,
2652          iv_load_policy: 3
2653        },
2654        vimeo: {
2655          byline: false,
2656          portrait: false,
2657          title: false,
2658          transparent: false
2659        }
2660      }
2661    },
2662    openEffect: 'zoom',
2663    closeEffect: 'zoom',
2664    slideEffect: 'slide',
2665    moreText: 'See more',
2666    moreLength: 60,
2667    cssEfects: {
2668      fade: {
2669        "in": 'fadeIn',
2670        out: 'fadeOut'
2671      },
2672      zoom: {
2673        "in": 'zoomIn',
2674        out: 'zoomOut'
2675      },
2676      slide: {
2677        "in": 'slideInRight',
2678        out: 'slideOutLeft'
2679      },
2680      slideBack: {
2681        "in": 'slideInLeft',
2682        out: 'slideOutRight'
2683      },
2684      none: {
2685        "in": 'none',
2686        out: 'none'
2687      }
2688    },
2689    svg: {
2690      close: '<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 512 512" xml:space="preserve"><g><g><path d="M505.943,6.058c-8.077-8.077-21.172-8.077-29.249,0L6.058,476.693c-8.077,8.077-8.077,21.172,0,29.249C10.096,509.982,15.39,512,20.683,512c5.293,0,10.586-2.019,14.625-6.059L505.943,35.306C514.019,27.23,514.019,14.135,505.943,6.058z"/></g></g><g><g><path d="M505.942,476.694L35.306,6.059c-8.076-8.077-21.172-8.077-29.248,0c-8.077,8.076-8.077,21.171,0,29.248l470.636,470.636c4.038,4.039,9.332,6.058,14.625,6.058c5.293,0,10.587-2.019,14.624-6.057C514.018,497.866,514.018,484.771,505.942,476.694z"/></g></g></svg>',
2691      next: '<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 477.175 477.175" xml:space="preserve"> <g><path d="M360.731,229.075l-225.1-225.1c-5.3-5.3-13.8-5.3-19.1,0s-5.3,13.8,0,19.1l215.5,215.5l-215.5,215.5c-5.3,5.3-5.3,13.8,0,19.1c2.6,2.6,6.1,4,9.5,4c3.4,0,6.9-1.3,9.5-4l225.1-225.1C365.931,242.875,365.931,234.275,360.731,229.075z"/></g></svg>',
2692      prev: '<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 477.175 477.175" xml:space="preserve"><g><path d="M145.188,238.575l215.5-215.5c5.3-5.3,5.3-13.8,0-19.1s-13.8-5.3-19.1,0l-225.1,225.1c-5.3,5.3-5.3,13.8,0,19.1l225.1,225c2.6,2.6,6.1,4,9.5,4s6.9-1.3,9.5-4c5.3-5.3,5.3-13.8,0-19.1L145.188,238.575z"/></g></svg>'
2693    }
2694  };
2695  defaults.slideHTML = "<div class=\"gslide\">\n    <div class=\"gslide-inner-content\">\n        <div class=\"ginner-container\">\n            <div class=\"gslide-media\">\n            </div>\n            <div class=\"gslide-description\">\n                <div class=\"gdesc-inner\">\n                    <h4 class=\"gslide-title\"></h4>\n                    <div class=\"gslide-desc\"></div>\n                </div>\n            </div>\n        </div>\n    </div>\n</div>";
2696  defaults.lightboxHTML = "<div id=\"glightbox-body\" class=\"glightbox-container\" tabindex=\"-1\" role=\"dialog\" aria-hidden=\"false\">\n    <div class=\"gloader visible\"></div>\n    <div class=\"goverlay\"></div>\n    <div class=\"gcontainer\">\n    <div id=\"glightbox-slider\" class=\"gslider\"></div>\n    <button class=\"gclose gbtn\" aria-label=\"Close\" data-taborder=\"3\">{closeSVG}</button>\n    <button class=\"gprev gbtn\" aria-label=\"Previous\" data-taborder=\"2\">{prevSVG}</button>\n    <button class=\"gnext gbtn\" aria-label=\"Next\" data-taborder=\"1\">{nextSVG}</button>\n</div>\n</div>";
2697
2698  var GlightboxInit = function () {
2699    function GlightboxInit() {
2700      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2701
2702      _classCallCheck(this, GlightboxInit);
2703
2704      this.customOptions = options;
2705      this.settings = extend(defaults, options);
2706      this.effectsClasses = this.getAnimationClasses();
2707      this.videoPlayers = {};
2708      this.apiEvents = [];
2709      this.fullElementsList = false;
2710    }
2711
2712    _createClass(GlightboxInit, [{
2713      key: "init",
2714      value: function init() {
2715        var _this = this;
2716
2717        var selector = this.getSelector();
2718
2719        if (selector) {
2720          this.baseEvents = addEvent('click', {
2721            onElement: selector,
2722            withCallback: function withCallback(e, target) {
2723              e.preventDefault();
2724
2725              _this.open(target);
2726            }
2727          });
2728        }
2729
2730        this.elements = this.getElements();
2731      }
2732    }, {
2733      key: "open",
2734      value: function open() {
2735        var element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
2736        var startAt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
2737
2738        if (this.elements.length == 0) {
2739          return false;
2740        }
2741
2742        this.activeSlide = null;
2743        this.prevActiveSlideIndex = null;
2744        this.prevActiveSlide = null;
2745        var index = isNumber(startAt) ? startAt : this.settings.startAt;
2746
2747        if (isNode(element)) {
2748          var gallery = element.getAttribute('data-gallery');
2749
2750          if (gallery) {
2751            this.fullElementsList = this.elements;
2752            this.elements = this.getGalleryElements(this.elements, gallery);
2753          }
2754
2755          if (isNil(index)) {
2756            index = this.getElementIndex(element);
2757
2758            if (index < 0) {
2759              index = 0;
2760            }
2761          }
2762        }
2763
2764        if (!isNumber(index)) {
2765          index = 0;
2766        }
2767
2768        this.build();
2769        animateElement(this.overlay, this.settings.openEffect == 'none' ? 'none' : this.settings.cssEfects.fade["in"]);
2770        var body = document.body;
2771        var scrollBar = window.innerWidth - document.documentElement.clientWidth;
2772
2773        if (scrollBar > 0) {
2774          var styleSheet = document.createElement('style');
2775          styleSheet.type = 'text/css';
2776          styleSheet.className = 'gcss-styles';
2777          styleSheet.innerText = ".gscrollbar-fixer {margin-right: ".concat(scrollBar, "px}");
2778          document.head.appendChild(styleSheet);
2779          addClass(body, 'gscrollbar-fixer');
2780        }
2781
2782        addClass(body, 'glightbox-open');
2783        addClass(html, 'glightbox-open');
2784
2785        if (isMobile$1) {
2786          addClass(document.body, 'glightbox-mobile');
2787          this.settings.slideEffect = 'slide';
2788        }
2789
2790        this.showSlide(index, true);
2791
2792        if (this.elements.length == 1) {
2793          addClass(this.prevButton, 'glightbox-button-hidden');
2794          addClass(this.nextButton, 'glightbox-button-hidden');
2795        } else {
2796          removeClass(this.prevButton, 'glightbox-button-hidden');
2797          removeClass(this.nextButton, 'glightbox-button-hidden');
2798        }
2799
2800        this.lightboxOpen = true;
2801        this.trigger('open');
2802
2803        if (isFunction(this.settings.onOpen)) {
2804          this.settings.onOpen();
2805        }
2806
2807        if (isTouch$1 && this.settings.touchNavigation) {
2808          touchNavigation(this);
2809        }
2810
2811        if (this.settings.keyboardNavigation) {
2812          keyboardNavigation(this);
2813        }
2814      }
2815    }, {
2816      key: "openAt",
2817      value: function openAt() {
2818        var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
2819        this.open(null, index);
2820      }
2821    }, {
2822      key: "showSlide",
2823      value: function showSlide() {
2824        var _this2 = this;
2825
2826        var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
2827        var first = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
2828        show(this.loader);
2829        this.index = parseInt(index);
2830        var current = this.slidesContainer.querySelector('.current');
2831
2832        if (current) {
2833          removeClass(current, 'current');
2834        }
2835
2836        this.slideAnimateOut();
2837        var slideNode = this.slidesContainer.querySelectorAll('.gslide')[index];
2838
2839        if (hasClass(slideNode, 'loaded')) {
2840          this.slideAnimateIn(slideNode, first);
2841          hide(this.loader);
2842        } else {
2843          show(this.loader);
2844          var slide = this.elements[index];
2845          var slideData = {
2846            index: this.index,
2847            slide: slideNode,
2848            slideNode: slideNode,
2849            slideConfig: slide.slideConfig,
2850            slideIndex: this.index,
2851            trigger: slide.node,
2852            player: null
2853          };
2854          this.trigger('slide_before_load', slideData);
2855          slide.instance.setContent(slideNode, function () {
2856            hide(_this2.loader);
2857
2858            _this2.resize();
2859
2860            _this2.slideAnimateIn(slideNode, first);
2861
2862            _this2.trigger('slide_after_load', slideData);
2863          });
2864        }
2865
2866        this.slideDescription = slideNode.querySelector('.gslide-description');
2867        this.slideDescriptionContained = this.slideDescription && hasClass(this.slideDescription.parentNode, 'gslide-media');
2868
2869        if (this.settings.preload) {
2870          this.preloadSlide(index + 1);
2871          this.preloadSlide(index - 1);
2872        }
2873
2874        this.updateNavigationClasses();
2875        this.activeSlide = slideNode;
2876      }
2877    }, {
2878      key: "preloadSlide",
2879      value: function preloadSlide(index) {
2880        var _this3 = this;
2881
2882        if (index < 0 || index > this.elements.length - 1) {
2883          return false;
2884        }
2885
2886        if (isNil(this.elements[index])) {
2887          return false;
2888        }
2889
2890        var slideNode = this.slidesContainer.querySelectorAll('.gslide')[index];
2891
2892        if (hasClass(slideNode, 'loaded')) {
2893          return false;
2894        }
2895
2896        var slide = this.elements[index];
2897        var type = slide.type;
2898        var slideData = {
2899          index: index,
2900          slide: slideNode,
2901          slideNode: slideNode,
2902          slideConfig: slide.slideConfig,
2903          slideIndex: index,
2904          trigger: slide.node,
2905          player: null
2906        };
2907        this.trigger('slide_before_load', slideData);
2908
2909        if (type == 'video' || type == 'external') {
2910          setTimeout(function () {
2911            slide.instance.setContent(slideNode, function () {
2912              _this3.trigger('slide_after_load', slideData);
2913            });
2914          }, 200);
2915        } else {
2916          slide.instance.setContent(slideNode, function () {
2917            _this3.trigger('slide_after_load', slideData);
2918          });
2919        }
2920      }
2921    }, {
2922      key: "prevSlide",
2923      value: function prevSlide() {
2924        this.goToSlide(this.index - 1);
2925      }
2926    }, {
2927      key: "nextSlide",
2928      value: function nextSlide() {
2929        this.goToSlide(this.index + 1);
2930      }
2931    }, {
2932      key: "goToSlide",
2933      value: function goToSlide() {
2934        var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
2935        this.prevActiveSlide = this.activeSlide;
2936        this.prevActiveSlideIndex = this.index;
2937
2938        if (!this.loop() && (index < 0 || index > this.elements.length - 1)) {
2939          return false;
2940        }
2941
2942        if (index < 0) {
2943          index = this.elements.length - 1;
2944        } else if (index >= this.elements.length) {
2945          index = 0;
2946        }
2947
2948        this.showSlide(index);
2949      }
2950    }, {
2951      key: "insertSlide",
2952      value: function insertSlide() {
2953        var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2954        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
2955
2956        if (index < 0) {
2957          index = this.elements.length;
2958        }
2959
2960        var slide = new Slide(config, this, index);
2961        var data = slide.getConfig();
2962        var slideInfo = extend({}, data);
2963        var newSlide = slide.create();
2964        var totalSlides = this.elements.length - 1;
2965        slideInfo.index = index;
2966        slideInfo.node = false;
2967        slideInfo.instance = slide;
2968        slideInfo.slideConfig = data;
2969        this.elements.splice(index, 0, slideInfo);
2970        var addedSlideNode = null;
2971        var addedSlidePlayer = null;
2972
2973        if (this.slidesContainer) {
2974          if (index > totalSlides) {
2975            this.slidesContainer.appendChild(newSlide);
2976          } else {
2977            var existingSlide = this.slidesContainer.querySelectorAll('.gslide')[index];
2978            this.slidesContainer.insertBefore(newSlide, existingSlide);
2979          }
2980
2981          if (this.settings.preload && this.index == 0 && index == 0 || this.index - 1 == index || this.index + 1 == index) {
2982            this.preloadSlide(index);
2983          }
2984
2985          if (this.index == 0 && index == 0) {
2986            this.index = 1;
2987          }
2988
2989          this.updateNavigationClasses();
2990          addedSlideNode = this.slidesContainer.querySelectorAll('.gslide')[index];
2991          addedSlidePlayer = this.getSlidePlayerInstance(index);
2992          slideInfo.slideNode = addedSlideNode;
2993        }
2994
2995        this.trigger('slide_inserted', {
2996          index: index,
2997          slide: addedSlideNode,
2998          slideNode: addedSlideNode,
2999          slideConfig: data,
3000          slideIndex: index,
3001          trigger: null,
3002          player: addedSlidePlayer
3003        });
3004
3005        if (isFunction(this.settings.slideInserted)) {
3006          this.settings.slideInserted({
3007            index: index,
3008            slide: addedSlideNode,
3009            player: addedSlidePlayer
3010          });
3011        }
3012      }
3013    }, {
3014      key: "removeSlide",
3015      value: function removeSlide() {
3016        var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : -1;
3017
3018        if (index < 0 || index > this.elements.length - 1) {
3019          return false;
3020        }
3021
3022        var slide = this.slidesContainer && this.slidesContainer.querySelectorAll('.gslide')[index];
3023
3024        if (slide) {
3025          if (this.getActiveSlideIndex() == index) {
3026            if (index == this.elements.length - 1) {
3027              this.prevSlide();
3028            } else {
3029              this.nextSlide();
3030            }
3031          }
3032
3033          slide.parentNode.removeChild(slide);
3034        }
3035
3036        this.elements.splice(index, 1);
3037        this.trigger('slide_removed', index);
3038
3039        if (isFunction(this.settings.slideRemoved)) {
3040          this.settings.slideRemoved(index);
3041        }
3042      }
3043    }, {
3044      key: "slideAnimateIn",
3045      value: function slideAnimateIn(slide, first) {
3046        var _this4 = this;
3047
3048        var slideMedia = slide.querySelector('.gslide-media');
3049        var slideDesc = slide.querySelector('.gslide-description');
3050        var prevData = {
3051          index: this.prevActiveSlideIndex,
3052          slide: this.prevActiveSlide,
3053          slideNode: this.prevActiveSlide,
3054          slideIndex: this.prevActiveSlide,
3055          slideConfig: isNil(this.prevActiveSlideIndex) ? null : this.elements[this.prevActiveSlideIndex].slideConfig,
3056          trigger: isNil(this.prevActiveSlideIndex) ? null : this.elements[this.prevActiveSlideIndex].node,
3057          player: this.getSlidePlayerInstance(this.prevActiveSlideIndex)
3058        };
3059        var nextData = {
3060          index: this.index,
3061          slide: this.activeSlide,
3062          slideNode: this.activeSlide,
3063          slideConfig: this.elements[this.index].slideConfig,
3064          slideIndex: this.index,
3065          trigger: this.elements[this.index].node,
3066          player: this.getSlidePlayerInstance(this.index)
3067        };
3068
3069        if (slideMedia.offsetWidth > 0 && slideDesc) {
3070          hide(slideDesc);
3071          slideDesc.style.display = '';
3072        }
3073
3074        removeClass(slide, this.effectsClasses);
3075
3076        if (first) {
3077          animateElement(slide, this.settings.cssEfects[this.settings.openEffect]["in"], function () {
3078            if (_this4.settings.autoplayVideos) {
3079              _this4.slidePlayerPlay(slide);
3080            }
3081
3082            _this4.trigger('slide_changed', {
3083              prev: prevData,
3084              current: nextData
3085            });
3086
3087            if (isFunction(_this4.settings.afterSlideChange)) {
3088              _this4.settings.afterSlideChange.apply(_this4, [prevData, nextData]);
3089            }
3090          });
3091        } else {
3092          var effectName = this.settings.slideEffect;
3093          var animIn = effectName !== 'none' ? this.settings.cssEfects[effectName]["in"] : effectName;
3094
3095          if (this.prevActiveSlideIndex > this.index) {
3096            if (this.settings.slideEffect == 'slide') {
3097              animIn = this.settings.cssEfects.slideBack["in"];
3098            }
3099          }
3100
3101          animateElement(slide, animIn, function () {
3102            if (_this4.settings.autoplayVideos) {
3103              _this4.slidePlayerPlay(slide);
3104            }
3105
3106            _this4.trigger('slide_changed', {
3107              prev: prevData,
3108              current: nextData
3109            });
3110
3111            if (isFunction(_this4.settings.afterSlideChange)) {
3112              _this4.settings.afterSlideChange.apply(_this4, [prevData, nextData]);
3113            }
3114          });
3115        }
3116
3117        setTimeout(function () {
3118          _this4.resize(slide);
3119        }, 100);
3120        addClass(slide, 'current');
3121      }
3122    }, {
3123      key: "slideAnimateOut",
3124      value: function slideAnimateOut() {
3125        if (!this.prevActiveSlide) {
3126          return false;
3127        }
3128
3129        var prevSlide = this.prevActiveSlide;
3130        removeClass(prevSlide, this.effectsClasses);
3131        addClass(prevSlide, 'prev');
3132        var animation = this.settings.slideEffect;
3133        var animOut = animation !== 'none' ? this.settings.cssEfects[animation].out : animation;
3134        this.slidePlayerPause(prevSlide);
3135        this.trigger('slide_before_change', {
3136          prev: {
3137            index: this.prevActiveSlideIndex,
3138            slide: this.prevActiveSlide,
3139            slideNode: this.prevActiveSlide,
3140            slideIndex: this.prevActiveSlideIndex,
3141            slideConfig: isNil(this.prevActiveSlideIndex) ? null : this.elements[this.prevActiveSlideIndex].slideConfig,
3142            trigger: isNil(this.prevActiveSlideIndex) ? null : this.elements[this.prevActiveSlideIndex].node,
3143            player: this.getSlidePlayerInstance(this.prevActiveSlideIndex)
3144          },
3145          current: {
3146            index: this.index,
3147            slide: this.activeSlide,
3148            slideNode: this.activeSlide,
3149            slideIndex: this.index,
3150            slideConfig: this.elements[this.index].slideConfig,
3151            trigger: this.elements[this.index].node,
3152            player: this.getSlidePlayerInstance(this.index)
3153          }
3154        });
3155
3156        if (isFunction(this.settings.beforeSlideChange)) {
3157          this.settings.beforeSlideChange.apply(this, [{
3158            index: this.prevActiveSlideIndex,
3159            slide: this.prevActiveSlide,
3160            player: this.getSlidePlayerInstance(this.prevActiveSlideIndex)
3161          }, {
3162            index: this.index,
3163            slide: this.activeSlide,
3164            player: this.getSlidePlayerInstance(this.index)
3165          }]);
3166        }
3167
3168        if (this.prevActiveSlideIndex > this.index && this.settings.slideEffect == 'slide') {
3169          animOut = this.settings.cssEfects.slideBack.out;
3170        }
3171
3172        animateElement(prevSlide, animOut, function () {
3173          var container = prevSlide.querySelector('.ginner-container');
3174          var media = prevSlide.querySelector('.gslide-media');
3175          var desc = prevSlide.querySelector('.gslide-description');
3176          container.style.transform = '';
3177          media.style.transform = '';
3178          removeClass(media, 'greset');
3179          media.style.opacity = '';
3180
3181          if (desc) {
3182            desc.style.opacity = '';
3183          }
3184
3185          removeClass(prevSlide, 'prev');
3186        });
3187      }
3188    }, {
3189      key: "getAllPlayers",
3190      value: function getAllPlayers() {
3191        return this.videoPlayers;
3192      }
3193    }, {
3194      key: "getSlidePlayerInstance",
3195      value: function getSlidePlayerInstance(index) {
3196        var id = 'gvideo' + index;
3197        var videoPlayers = this.getAllPlayers();
3198
3199        if (has(videoPlayers, id) && videoPlayers[id]) {
3200          return videoPlayers[id];
3201        }
3202
3203        return false;
3204      }
3205    }, {
3206      key: "stopSlideVideo",
3207      value: function stopSlideVideo(slide) {
3208        if (isNode(slide)) {
3209          var node = slide.querySelector('.gvideo-wrapper');
3210
3211          if (node) {
3212            slide = node.getAttribute('data-index');
3213          }
3214        }
3215
3216        console.log('stopSlideVideo is deprecated, use slidePlayerPause');
3217        var player = this.getSlidePlayerInstance(slide);
3218
3219        if (player && player.playing) {
3220          player.pause();
3221        }
3222      }
3223    }, {
3224      key: "slidePlayerPause",
3225      value: function slidePlayerPause(slide) {
3226        if (isNode(slide)) {
3227          var node = slide.querySelector('.gvideo-wrapper');
3228
3229          if (node) {
3230            slide = node.getAttribute('data-index');
3231          }
3232        }
3233
3234        var player = this.getSlidePlayerInstance(slide);
3235
3236        if (player && player.playing) {
3237          player.pause();
3238        }
3239      }
3240    }, {
3241      key: "playSlideVideo",
3242      value: function playSlideVideo(slide) {
3243        if (isNode(slide)) {
3244          var node = slide.querySelector('.gvideo-wrapper');
3245
3246          if (node) {
3247            slide = node.getAttribute('data-index');
3248          }
3249        }
3250
3251        console.log('playSlideVideo is deprecated, use slidePlayerPlay');
3252        var player = this.getSlidePlayerInstance(slide);
3253
3254        if (player && !player.playing) {
3255          player.play();
3256        }
3257      }
3258    }, {
3259      key: "slidePlayerPlay",
3260      value: function slidePlayerPlay(slide) {
3261        if (isNode(slide)) {
3262          var node = slide.querySelector('.gvideo-wrapper');
3263
3264          if (node) {
3265            slide = node.getAttribute('data-index');
3266          }
3267        }
3268
3269        var player = this.getSlidePlayerInstance(slide);
3270
3271        if (player && !player.playing) {
3272          player.play();
3273
3274          if (this.settings.autofocusVideos) {
3275            player.elements.container.focus();
3276          }
3277        }
3278      }
3279    }, {
3280      key: "setElements",
3281      value: function setElements(elements) {
3282        var _this5 = this;
3283
3284        this.settings.elements = false;
3285        var newElements = [];
3286
3287        if (elements && elements.length) {
3288          each(elements, function (el, i) {
3289            var slide = new Slide(el, _this5, i);
3290            var data = slide.getConfig();
3291            var slideInfo = extend({}, data);
3292            slideInfo.slideConfig = data;
3293            slideInfo.instance = slide;
3294            slideInfo.index = i;
3295            newElements.push(slideInfo);
3296          });
3297        }
3298
3299        this.elements = newElements;
3300
3301        if (this.lightboxOpen) {
3302          this.slidesContainer.innerHTML = '';
3303
3304          if (this.elements.length) {
3305            each(this.elements, function () {
3306              var slide = createHTML(_this5.settings.slideHTML);
3307
3308              _this5.slidesContainer.appendChild(slide);
3309            });
3310            this.showSlide(0, true);
3311          }
3312        }
3313      }
3314    }, {
3315      key: "getElementIndex",
3316      value: function getElementIndex(node) {
3317        var index = false;
3318        each(this.elements, function (el, i) {
3319          if (has(el, 'node') && el.node == node) {
3320            index = i;
3321            return true;
3322          }
3323        });
3324        return index;
3325      }
3326    }, {
3327      key: "getElements",
3328      value: function getElements() {
3329        var _this6 = this;
3330
3331        var list = [];
3332        this.elements = this.elements ? this.elements : [];
3333
3334        if (!isNil(this.settings.elements) && isArray(this.settings.elements) && this.settings.elements.length) {
3335          each(this.settings.elements, function (el, i) {
3336            var slide = new Slide(el, _this6, i);
3337            var elData = slide.getConfig();
3338            var slideInfo = extend({}, elData);
3339            slideInfo.node = false;
3340            slideInfo.index = i;
3341            slideInfo.instance = slide;
3342            slideInfo.slideConfig = elData;
3343            list.push(slideInfo);
3344          });
3345        }
3346
3347        var nodes = false;
3348        var selector = this.getSelector();
3349
3350        if (selector) {
3351          nodes = document.querySelectorAll(this.getSelector());
3352        }
3353
3354        if (!nodes) {
3355          return list;
3356        }
3357
3358        each(nodes, function (el, i) {
3359          var slide = new Slide(el, _this6, i);
3360          var elData = slide.getConfig();
3361          var slideInfo = extend({}, elData);
3362          slideInfo.node = el;
3363          slideInfo.index = i;
3364          slideInfo.instance = slide;
3365          slideInfo.slideConfig = elData;
3366          slideInfo.gallery = el.getAttribute('data-gallery');
3367          list.push(slideInfo);
3368        });
3369        return list;
3370      }
3371    }, {
3372      key: "getGalleryElements",
3373      value: function getGalleryElements(list, gallery) {
3374        return list.filter(function (el) {
3375          return el.gallery == gallery;
3376        });
3377      }
3378    }, {
3379      key: "getSelector",
3380      value: function getSelector() {
3381        if (this.settings.elements) {
3382          return false;
3383        }
3384
3385        if (this.settings.selector && this.settings.selector.substring(0, 5) == 'data-') {
3386          return "*[".concat(this.settings.selector, "]");
3387        }
3388
3389        return this.settings.selector;
3390      }
3391    }, {
3392      key: "getActiveSlide",
3393      value: function getActiveSlide() {
3394        return this.slidesContainer.querySelectorAll('.gslide')[this.index];
3395      }
3396    }, {
3397      key: "getActiveSlideIndex",
3398      value: function getActiveSlideIndex() {
3399        return this.index;
3400      }
3401    }, {
3402      key: "getAnimationClasses",
3403      value: function getAnimationClasses() {
3404        var effects = [];
3405
3406        for (var key in this.settings.cssEfects) {
3407          if (this.settings.cssEfects.hasOwnProperty(key)) {
3408            var effect = this.settings.cssEfects[key];
3409            effects.push("g".concat(effect["in"]));
3410            effects.push("g".concat(effect.out));
3411          }
3412        }
3413
3414        return effects.join(' ');
3415      }
3416    }, {
3417      key: "build",
3418      value: function build() {
3419        var _this7 = this;
3420
3421        if (this.built) {
3422          return false;
3423        }
3424
3425        var children = document.body.childNodes;
3426        var bodyChildElms = [];
3427        each(children, function (el) {
3428          if (el.parentNode == document.body && el.nodeName.charAt(0) !== '#' && el.hasAttribute && !el.hasAttribute('aria-hidden')) {
3429            bodyChildElms.push(el);
3430            el.setAttribute('aria-hidden', 'true');
3431          }
3432        });
3433        var nextSVG = has(this.settings.svg, 'next') ? this.settings.svg.next : '';
3434        var prevSVG = has(this.settings.svg, 'prev') ? this.settings.svg.prev : '';
3435        var closeSVG = has(this.settings.svg, 'close') ? this.settings.svg.close : '';
3436        var lightboxHTML = this.settings.lightboxHTML;
3437        lightboxHTML = lightboxHTML.replace(/{nextSVG}/g, nextSVG);
3438        lightboxHTML = lightboxHTML.replace(/{prevSVG}/g, prevSVG);
3439        lightboxHTML = lightboxHTML.replace(/{closeSVG}/g, closeSVG);
3440        lightboxHTML = createHTML(lightboxHTML);
3441        document.body.appendChild(lightboxHTML);
3442        var modal = document.getElementById('glightbox-body');
3443        this.modal = modal;
3444        var closeButton = modal.querySelector('.gclose');
3445        this.prevButton = modal.querySelector('.gprev');
3446        this.nextButton = modal.querySelector('.gnext');
3447        this.overlay = modal.querySelector('.goverlay');
3448        this.loader = modal.querySelector('.gloader');
3449        this.slidesContainer = document.getElementById('glightbox-slider');
3450        this.bodyHiddenChildElms = bodyChildElms;
3451        this.events = {};
3452        addClass(this.modal, 'glightbox-' + this.settings.skin);
3453
3454        if (this.settings.closeButton && closeButton) {
3455          this.events['close'] = addEvent('click', {
3456            onElement: closeButton,
3457            withCallback: function withCallback(e, target) {
3458              e.preventDefault();
3459
3460              _this7.close();
3461            }
3462          });
3463        }
3464
3465        if (closeButton && !this.settings.closeButton) {
3466          closeButton.parentNode.removeChild(closeButton);
3467        }
3468
3469        if (this.nextButton) {
3470          this.events['next'] = addEvent('click', {
3471            onElement: this.nextButton,
3472            withCallback: function withCallback(e, target) {
3473              e.preventDefault();
3474
3475              _this7.nextSlide();
3476            }
3477          });
3478        }
3479
3480        if (this.prevButton) {
3481          this.events['prev'] = addEvent('click', {
3482            onElement: this.prevButton,
3483            withCallback: function withCallback(e, target) {
3484              e.preventDefault();
3485
3486              _this7.prevSlide();
3487            }
3488          });
3489        }
3490
3491        if (this.settings.closeOnOutsideClick) {
3492          this.events['outClose'] = addEvent('click', {
3493            onElement: modal,
3494            withCallback: function withCallback(e, target) {
3495              if (!_this7.preventOutsideClick && !hasClass(document.body, 'glightbox-mobile') && !closest(e.target, '.ginner-container')) {
3496                if (!closest(e.target, '.gbtn') && !hasClass(e.target, 'gnext') && !hasClass(e.target, 'gprev')) {
3497                  _this7.close();
3498                }
3499              }
3500            }
3501          });
3502        }
3503
3504        each(this.elements, function (slide, i) {
3505          _this7.slidesContainer.appendChild(slide.instance.create());
3506
3507          slide.slideNode = _this7.slidesContainer.querySelectorAll('.gslide')[i];
3508        });
3509
3510        if (isTouch$1) {
3511          addClass(document.body, 'glightbox-touch');
3512        }
3513
3514        this.events['resize'] = addEvent('resize', {
3515          onElement: window,
3516          withCallback: function withCallback() {
3517            _this7.resize();
3518          }
3519        });
3520        this.built = true;
3521      }
3522    }, {
3523      key: "resize",
3524      value: function resize() {
3525        var slide = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
3526        slide = !slide ? this.activeSlide : slide;
3527
3528        if (!slide || hasClass(slide, 'zoomed')) {
3529          return;
3530        }
3531
3532        var winSize = windowSize();
3533        var video = slide.querySelector('.gvideo-wrapper');
3534        var image = slide.querySelector('.gslide-image');
3535        var description = this.slideDescription;
3536        var winWidth = winSize.width;
3537        var winHeight = winSize.height;
3538
3539        if (winWidth <= 768) {
3540          addClass(document.body, 'glightbox-mobile');
3541        } else {
3542          removeClass(document.body, 'glightbox-mobile');
3543        }
3544
3545        if (!video && !image) {
3546          return;
3547        }
3548
3549        var descriptionResize = false;
3550
3551        if (description && (hasClass(description, 'description-bottom') || hasClass(description, 'description-top')) && !hasClass(description, 'gabsolute')) {
3552          descriptionResize = true;
3553        }
3554
3555        if (image) {
3556          if (winWidth <= 768) {
3557            var imgNode = image.querySelector('img');
3558          } else if (descriptionResize) {
3559            var descHeight = description.offsetHeight;
3560
3561            var _imgNode = image.querySelector('img');
3562
3563            _imgNode.setAttribute('style', "max-height: calc(100vh - ".concat(descHeight, "px)"));
3564
3565            description.setAttribute('style', "max-width: ".concat(_imgNode.offsetWidth, "px;"));
3566          }
3567        }
3568
3569        if (video) {
3570          var ratio = has(this.settings.plyr.config, 'ratio') ? this.settings.plyr.config.ratio : '';
3571
3572          if (!ratio) {
3573            var containerWidth = video.clientWidth;
3574            var containerHeight = video.clientHeight;
3575            var divisor = containerWidth / containerHeight;
3576            ratio = "".concat(containerWidth / divisor, ":").concat(containerHeight / divisor);
3577          }
3578
3579          var videoRatio = ratio.split(':');
3580          var videoWidth = this.settings.videosWidth;
3581          var maxWidth = this.settings.videosWidth;
3582
3583          if (isNumber(videoWidth) || videoWidth.indexOf('px') !== -1) {
3584            maxWidth = parseInt(videoWidth);
3585          } else {
3586            if (videoWidth.indexOf('vw') !== -1) {
3587              maxWidth = winWidth * parseInt(videoWidth) / 100;
3588            } else if (videoWidth.indexOf('vh') !== -1) {
3589              maxWidth = winHeight * parseInt(videoWidth) / 100;
3590            } else if (videoWidth.indexOf('%') !== -1) {
3591              maxWidth = winWidth * parseInt(videoWidth) / 100;
3592            } else {
3593              maxWidth = parseInt(video.clientWidth);
3594            }
3595          }
3596
3597          var maxHeight = maxWidth / (parseInt(videoRatio[0]) / parseInt(videoRatio[1]));
3598          maxHeight = Math.floor(maxHeight);
3599
3600          if (descriptionResize) {
3601            winHeight = winHeight - description.offsetHeight;
3602          }
3603
3604          if (maxWidth > winWidth || maxHeight > winHeight || winHeight < maxHeight && winWidth > maxWidth) {
3605            var vwidth = video.offsetWidth;
3606            var vheight = video.offsetHeight;
3607
3608            var _ratio = winHeight / vheight;
3609
3610            var vsize = {
3611              width: vwidth * _ratio,
3612              height: vheight * _ratio
3613            };
3614            video.parentNode.setAttribute('style', "max-width: ".concat(vsize.width, "px"));
3615
3616            if (descriptionResize) {
3617              description.setAttribute('style', "max-width: ".concat(vsize.width, "px;"));
3618            }
3619          } else {
3620            video.parentNode.style.maxWidth = "".concat(videoWidth);
3621
3622            if (descriptionResize) {
3623              description.setAttribute('style', "max-width: ".concat(videoWidth, ";"));
3624            }
3625          }
3626        }
3627      }
3628    }, {
3629      key: "reload",
3630      value: function reload() {
3631        this.init();
3632      }
3633    }, {
3634      key: "updateNavigationClasses",
3635      value: function updateNavigationClasses() {
3636        var loop = this.loop();
3637        removeClass(this.nextButton, 'disabled');
3638        removeClass(this.prevButton, 'disabled');
3639
3640        if (this.index == 0 && this.elements.length - 1 == 0) {
3641          addClass(this.prevButton, 'disabled');
3642          addClass(this.nextButton, 'disabled');
3643        } else if (this.index === 0 && !loop) {
3644          addClass(this.prevButton, 'disabled');
3645        } else if (this.index === this.elements.length - 1 && !loop) {
3646          addClass(this.nextButton, 'disabled');
3647        }
3648      }
3649    }, {
3650      key: "loop",
3651      value: function loop() {
3652        var loop = has(this.settings, 'loopAtEnd') ? this.settings.loopAtEnd : null;
3653        loop = has(this.settings, 'loop') ? this.settings.loop : loop;
3654        return loop;
3655      }
3656    }, {
3657      key: "close",
3658      value: function close() {
3659        var _this8 = this;
3660
3661        if (!this.lightboxOpen) {
3662          if (this.events) {
3663            for (var key in this.events) {
3664              if (this.events.hasOwnProperty(key)) {
3665                this.events[key].destroy();
3666              }
3667            }
3668
3669            this.events = null;
3670          }
3671
3672          return false;
3673        }
3674
3675        if (this.closing) {
3676          return false;
3677        }
3678
3679        this.closing = true;
3680        this.slidePlayerPause(this.activeSlide);
3681
3682        if (this.fullElementsList) {
3683          this.elements = this.fullElementsList;
3684        }
3685
3686        if (this.bodyHiddenChildElms.length) {
3687          each(this.bodyHiddenChildElms, function (el) {
3688            el.removeAttribute('aria-hidden');
3689          });
3690        }
3691
3692        addClass(this.modal, 'glightbox-closing');
3693        animateElement(this.overlay, this.settings.openEffect == 'none' ? 'none' : this.settings.cssEfects.fade.out);
3694        animateElement(this.activeSlide, this.settings.cssEfects[this.settings.closeEffect].out, function () {
3695          _this8.activeSlide = null;
3696          _this8.prevActiveSlideIndex = null;
3697          _this8.prevActiveSlide = null;
3698          _this8.built = false;
3699
3700          if (_this8.events) {
3701            for (var _key in _this8.events) {
3702              if (_this8.events.hasOwnProperty(_key)) {
3703                _this8.events[_key].destroy();
3704              }
3705            }
3706
3707            _this8.events = null;
3708          }
3709
3710          var body = document.body;
3711          removeClass(html, 'glightbox-open');
3712          removeClass(body, 'glightbox-open touching gdesc-open glightbox-touch glightbox-mobile gscrollbar-fixer');
3713
3714          _this8.modal.parentNode.removeChild(_this8.modal);
3715
3716          _this8.trigger('close');
3717
3718          if (isFunction(_this8.settings.onClose)) {
3719            _this8.settings.onClose();
3720          }
3721
3722          var styles = document.querySelector('.gcss-styles');
3723
3724          if (styles) {
3725            styles.parentNode.removeChild(styles);
3726          }
3727
3728          _this8.lightboxOpen = false;
3729          _this8.closing = null;
3730        });
3731      }
3732    }, {
3733      key: "destroy",
3734      value: function destroy() {
3735        this.close();
3736        this.clearAllEvents();
3737
3738        if (this.baseEvents) {
3739          this.baseEvents.destroy();
3740        }
3741      }
3742    }, {
3743      key: "on",
3744      value: function on(evt, callback) {
3745        var once = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
3746
3747        if (!evt || !isFunction(callback)) {
3748          throw new TypeError('Event name and callback must be defined');
3749        }
3750
3751        this.apiEvents.push({
3752          evt: evt,
3753          once: once,
3754          callback: callback
3755        });
3756      }
3757    }, {
3758      key: "once",
3759      value: function once(evt, callback) {
3760        this.on(evt, callback, true);
3761      }
3762    }, {
3763      key: "trigger",
3764      value: function trigger(eventName) {
3765        var _this9 = this;
3766
3767        var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
3768        var onceTriggered = [];
3769        each(this.apiEvents, function (event, i) {
3770          var evt = event.evt,
3771              once = event.once,
3772              callback = event.callback;
3773
3774          if (evt == eventName) {
3775            callback(data);
3776
3777            if (once) {
3778              onceTriggered.push(i);
3779            }
3780          }
3781        });
3782
3783        if (onceTriggered.length) {
3784          each(onceTriggered, function (i) {
3785            return _this9.apiEvents.splice(i, 1);
3786          });
3787        }
3788      }
3789    }, {
3790      key: "clearAllEvents",
3791      value: function clearAllEvents() {
3792        this.apiEvents.splice(0, this.apiEvents.length);
3793      }
3794    }, {
3795      key: "version",
3796      value: function version() {
3797        return _version;
3798      }
3799    }]);
3800
3801    return GlightboxInit;
3802  }();
3803
3804  function glightbox() {
3805    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
3806    var instance = new GlightboxInit(options);
3807    instance.init();
3808    return instance;
3809  }
3810
3811  return glightbox;
3812});
3813
3814},{}],3:[function(require,module,exports){
3815"use strict";
3816
3817(function () {
3818  L.Control.FullScreen = L.Control.extend({
3819    options: {
3820      position: 'topleft',
3821      title: 'Full Screen',
3822      titleCancel: 'Exit Full Screen',