text: /*! UIkit 3.0.0-beta.34 | http://www.getuikit.com | (c) 2014 - 2017 YOOtheme | MIT License */
  
  (function (global, factory) {
  	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  	typeof define === 'function' && define.amd ? define('uikitslideshow', factory) :
  	(global.UIkitSlideshow = factory());
  }(this, (function () { 'use strict';
  
  function plugin$2(UIkit) {
  
      if (plugin$2.installed) {
          return;
      }
  
      var mixin = UIkit.mixin;
      var util = UIkit.util;
      var clamp = util.clamp;
      var css = util.css;
      var Dimensions = util.Dimensions;
      var each = util.each;
      var getImage = util.getImage;
      var includes = util.includes;
      var isNumber = util.isNumber;
      var isUndefined = util.isUndefined;
      var scrolledOver = util.scrolledOver;
      var toFloat = util.toFloat;
      var query = util.query;
      var win = util.win;
  
      var props = ['x', 'y', 'bgx', 'bgy', 'rotate', 'scale', 'color', 'backgroundColor', 'borderColor', 'opacity', 'blur', 'hue', 'grayscale', 'invert', 'saturate', 'sepia', 'fopacity'];
  
      mixin.parallax = {
  
          props: props.reduce(function (props, prop) {
              props[prop] = 'list';
              return props;
          }, {
              media: 'media'
          }),
  
          defaults: props.reduce(function (defaults, prop) {
              defaults[prop] = undefined;
              return defaults;
          }, {
              media: false
          }),
  
          computed: {
  
              props: function props$1(properties, $el) {
                  var this$1 = this;
  
  
                  return props.reduce(function (props, prop) {
  
                      if (isUndefined(properties[prop])) {
                          return props;
                      }
  
                      var isColor = prop.match(/color/i),
                          isCssProp = isColor || prop === 'opacity',
                          steps = properties[prop].slice(0),
                          pos, bgPos, diff;
  
                      if (isCssProp) {
                          css($el, prop, '');
                      }
  
                      if (steps.length < 2) {
                          steps.unshift((prop === 'scale'
                              ? 1
                              : isCssProp
                                  ? css($el, prop)
                                  : 0) || 0);
                      }
  
                      var unit = includes(steps.join(''), '%') ? '%' : 'px';
  
                      if (isColor) {
  
                          var color = $el.style.color;
                          steps = steps.map(function (step) { return parseColor($el, step); });
                          $el.style.color = color;
  
                      } else {
  
                          steps = steps.map(toFloat);
  
                      }
  
                      if (prop.match(/^bg/)) {
  
                          css($el, ("background-position-" + (prop[2])), '');
                          bgPos = css($el, 'backgroundPosition').split(' ')[prop[2] === 'x' ? 0 : 1]; // IE 11 can't read background-position-[x|y]
  
                          if (this$1.covers) {
  
                              var min = Math.min.apply(Math, steps),
                                  max = Math.max.apply(Math, steps),
                                  down = steps.indexOf(min) < steps.indexOf(max);
  
                              diff = max - min;
  
                              steps = steps.map(function (step) { return step - (down ? min : max); });
                              pos = (down ? -diff : 0) + "px";
  
                          } else {
  
                              pos = bgPos;
  
                          }
                      }
  
                      props[prop] = {steps: steps, unit: unit, pos: pos, bgPos: bgPos, diff: diff};
  
                      return props;
  
                  }, {});
  
              },
  
              bgProps: function bgProps() {
                  var this$1 = this;
  
                  return ['bgx', 'bgy'].filter(function (bg) { return bg in this$1.props; });
              },
  
              covers: function covers(_, $el) {
                  return css($el.style.backgroundSize !== '' ? css($el, 'backgroundSize', '') : $el, 'backgroundSize') === 'cover';
              }
  
          },
  
          disconnected: function disconnected() {
              delete this._image;
          },
  
          update: [
  
              {
  
                  read: function read() {
                      var this$1 = this;
  
  
                      delete this._computeds.props;
  
                      this._active = !this.media || win.matchMedia(this.media).matches;
  
                      if (this._image) {
                          this._image.dimEl = {
                              width: this.$el.offsetWidth,
                              height: this.$el.offsetHeight
                          };
                      }
  
                      if (!isUndefined(this._image) || !this.covers || !this.bgProps.length) {
                          return;
                      }
  
                      var src = css(this.$el, 'backgroundImage').replace(/^none|url\(["']?(.+?)["']?\)$/, '$1');
  
                      if (!src) {
                          return;
                      }
  
                      this._image = false;
  
                      getImage(src).then(function (img) {
                          this$1._image = {
                              width: img.naturalWidth,
                              height: img.naturalHeight
                          };
  
                          this$1.$emit();
                      });
  
                  },
  
                  write: function write() {
                      var this$1 = this;
  
  
                      if (!this._image) {
                          return;
                      }
  
                      if (!this._active) {
                          css(this.$el, {backgroundSize: '', backgroundRepeat: ''});
                          return;
                      }
  
                      var image = this._image,
                          dimEl = image.dimEl,
                          dim = Dimensions.cover(image, dimEl);
  
                      this.bgProps.forEach(function (prop) {
  
                          var ref = this$1.props[prop];
                          var diff = ref.diff;
                          var bgPos = ref.bgPos;
                          var steps = ref.steps;
                          var attr = prop === 'bgy' ? 'height' : 'width',
                              span = dim[attr] - dimEl[attr];
  
                          if (!bgPos.match(/%$|0px/)) {
                              return;
                          }
  
                          if (span < diff) {
                              dimEl[attr] = dim[attr] + diff - span;
                          } else if (span > diff) {
  
                              bgPos = parseFloat(bgPos);
  
                              if (bgPos) {
                                  this$1.props[prop].steps = steps.map(function (step) { return step - (span - diff) / (100 / bgPos); });
                              }
                          }
  
                          dim = Dimensions.cover(image, dimEl);
                      });
  
                      css(this.$el, {
                          backgroundSize: ((dim.width) + "px " + (dim.height) + "px"),
                          backgroundRepeat: 'no-repeat'
                      });
  
                  },
  
                  events: ['load', 'resize']
  
              }
  
          ],
  
          methods: {
  
              reset: function reset() {
                  var this$1 = this;
  
                  each(this.getCss(0), function (_, prop) { return css(this$1.$el, prop, ''); });
              },
  
              getCss: function getCss(percent) {
  
                  var translated = false,
                      props = this.props;
  
                  return Object.keys(props).reduce(function (css, prop) {
  
                      var ref = props[prop];
                      var steps = ref.steps;
                      var unit = ref.unit;
                      var pos = ref.pos;
                      var value = getValue(steps, percent);
  
                      switch (prop) {
  
                          // transforms
                          case 'x':
                          case 'y':
  
                              if (translated) {
                                  break;
                              }
  
                              var ref$1 = ['x', 'y'].map(function (dir) { return prop === dir
                                  ? value + unit
                                  : props[dir]
                                      ? getValue(props[dir].steps, percent) + props[dir].unit
                                      : 0; }
                              );
                      var x = ref$1[0];
                      var y = ref$1[1];
  
                              translated = css.transform += " translate3d(" + x + ", " + y + ", 0)";
                              break;
                          case 'rotate':
                              css.transform += " rotate(" + value + "deg)";
                              break;
                          case 'scale':
                              css.transform += " scale(" + value + ")";
                              break;
  
                          // bg image
                          case 'bgy':
                          case 'bgx':
                              css[("background-position-" + (prop[2]))] = "calc(" + pos + " + " + (value + unit) + ")";
                              break;
  
                          // color
                          case 'color':
                          case 'backgroundColor':
                          case 'borderColor':
  
                              var ref$2 = getStep(steps, percent);
                      var start = ref$2[0];
                      var end = ref$2[1];
                      var p = ref$2[2];
  
                              css[prop] = "rgba(" + (start.map(function (value, i) {
                                      value = value + p * (end[i] - value);
                                      return i === 3 ? toFloat(value) : parseInt(value, 10);
                                  }).join(',')) + ")";
                              break;
  
                          // CSS Filter
                          case 'blur':
                              css.filter += " blur(" + value + "px)";
                              break;
                          case 'hue':
                              css.filter += " hue-rotate(" + value + "deg)";
                              break;
                          case 'fopacity':
                              css.filter += " opacity(" + value + "%)";
                              break;
                          case 'grayscale':
                          case 'invert':
                          case 'saturate':
                          case 'sepia':
                              css.filter += " " + prop + "(" + value + "%)";
                              break;
  
                          default:
                              css[prop] = value;
                      }
  
                      return css;
  
                  }, {transform: '', filter: ''});
  
              }
  
          }
  
      };
  
      UIkit.component('parallax', {
  
          mixins: [mixin.parallax],
  
          props: {
              target: String,
              viewport: Number,
              easing: Number,
          },
  
          defaults: {
              target: false,
              viewport: 1,
              easing: 1,
          },
  
          computed: {
  
              target: function target(ref, $el) {
                  var target = ref.target;
  
                  return target && query(target, $el) || $el;
              }
  
          },
  
          disconnected: function disconnected() {
              delete this._prev;
          },
  
          update: [
  
              {
  
                  read: function read() {
  
                      this._percent = ease(scrolledOver(this.target) / (this.viewport || 1), this.easing);
  
                  },
  
                  write: function write(ref) {
                      var type = ref.type;
  
  
                      if (type !== 'scroll') {
                          delete this._prev;
                      }
  
                      if (!this._active) {
                          this.reset();
                          return;
                      }
  
                      if (this._prev !== this._percent) {
                          css(this.$el, this.getCss(this._percent));
                          this._prev = this._percent;
                      }
  
                  },
  
                  events: ['scroll', 'load', 'resize']
              }
  
          ]
  
      });
  
      function ease(percent, easing) {
          return clamp(percent * (1 - (easing - easing * percent)))
      }
  
      function parseColor(el, color) {
          return css(css(el, 'color', color), 'color').split(/[(),]/g).slice(1, -1).concat(1).slice(0, 4).map(function (n) { return toFloat(n); });
      }
  
      function getStep(steps, percent) {
          var count = steps.length - 1,
              index = Math.min(Math.floor(count * percent), count - 1),
              step = steps.slice(index, index + 2);
  
          step.push(percent === 1 ? 1 : percent % (1 / count) * count);
  
          return step;
      }
  
      function getValue(steps, percent) {
          var ref = getStep(steps, percent);
          var start = ref[0];
          var end = ref[1];
          var p = ref[2];
          return (isNumber(start)
              ? start + Math.abs(start - end) * p * (start < end ? 1 : -1)
              : +end
          ).toFixed(2);
      }
  
  }
  
  if (!false && typeof window !== 'undefined' && window.UIkit) {
      window.UIkit.use(plugin$2);
  }
  
  var Animations = function (UIkit) {
  
      var ref = UIkit.util;
      var css = ref.css;
  
      var Animations = {
  
          slide: {
  
              show: function show(dir) {
                  return [
                      {transform: translate(dir * -100)},
                      {transform: translate()}
                  ];
              },
  
              percent: function percent(current) {
                  return Animations.translated(current);
              },
  
              translate: function translate$1(percent, dir) {
                  return [
                      {transform: translate(dir * -100 * percent)},
                      {transform: translate(dir * 100 * (1 - percent))}
                  ];
              }
  
          },
  
          translated: function translated(el) {
              return Math.abs(css(el, 'transform').split(',')[4] / el.offsetWidth)
          }
  
      };
  
      return Animations;
  
  };
  
  function translate(value) {
      if ( value === void 0 ) value = 0;
  
      return ("translate(" + value + (value ? '%' : '') + ", 0)"); // currently not translate3d to support IE, translate3d within translate3d does not work while transitioning
  }
  
  function scale3d(value) {
      return ("scale3d(" + value + ", " + value + ", 1)");
  }
  
  function plugin$3(UIkit) {
  
      if (plugin$3.installed) {
          return;
      }
  
      var ref = UIkit.util;
      var $$ = ref.$$;
      var $ = ref.$;
      var addClass = ref.addClass;
      var assign = ref.assign;
      var createEvent = ref.createEvent;
      var css = ref.css;
      var data = ref.data;
      var doc = ref.doc;
      var endsWith = ref.endsWith;
      var fastdom = ref.fastdom;
      var getIndex = ref.getIndex;
      var getPos = ref.getPos;
      var hasClass = ref.hasClass;
      var index = ref.index;
      var isTouch = ref.isTouch;
      var noop = ref.noop;
      var off = ref.off;
      var on = ref.on;
      var pointerDown = ref.pointerDown;
      var pointerMove = ref.pointerMove;
      var pointerUp = ref.pointerUp;
      var preventClick = ref.preventClick;
      var Promise = ref.Promise;
      var removeClass = ref.removeClass;
      var toggleClass = ref.toggleClass;
      var toNodes = ref.toNodes;
      var Transition = ref.Transition;
      var trigger = ref.trigger;
      var win = ref.win;
  
      var abs = Math.abs;
  
      UIkit.mixin.slideshow = {
  
          attrs: true,
  
          props: {
              autoplay: Boolean,
              autoplayInterval: Number,
              pauseOnHover: Boolean,
              animation: String,
              easing: String,
              velocity: Number
          },
  
          defaults: {
              autoplay: false,
              autoplayInterval: 7000,
              pauseOnHover: true,
              animation: 'slide',
              easing: 'ease',
              velocity: 1,
              index: 0,
              stack: [],
              threshold: 10,
              percent: 0,
              clsActive: 'uk-active',
              clsActivated: 'uk-transition-active',
              initialAnimation: false,
              Animations: Animations(UIkit)
          },
  
          computed: {
  
              list: function list(ref, $el) {
                  var selList = ref.selList;
  
                  return $(selList, $el);
              },
  
              slides: function slides() {
                  return toNodes(this.list.children);
              },
  
              animation: function animation(ref) {
                  var animation = ref.animation;
                  var Animations$$1 = ref.Animations;
  
                  return assign(animation in Animations$$1 ? Animations$$1[animation] : Animations$$1.slide, {name: animation});
              },
  
              duration: function duration(ref, $el) {
                  var velocity = ref.velocity;
  
                  return speedUp($el.offsetWidth / velocity);
              }
  
          },
  
          init: function init() {
              var this$1 = this;
  
              ['start', 'move', 'end'].forEach(function (key) {
                  var fn = this$1[key];
                  this$1[key] = function (e) {
  
                      var pos = getPos(e).x;
  
                      this$1.prevPos = pos !== this$1.pos ? this$1.pos : this$1.prevPos;
                      this$1.pos = pos;
  
                      fn(e);
                  };
              });
          },
  
          connected: function connected() {
              this.startAutoplay();
          },
  
          disconnected: function disconnected() {
              this.stopAutoplay();
          },
  
          update: [
  
              {
  
                  read: function read() {
                      delete this._computeds.duration;
                  },
  
                  events: ['load', 'resize']
  
              }
  
          ],
  
          events: [
  
              {
  
                  name: 'click',
  
                  delegate: function delegate() {
                      return ("[" + (this.attrItem) + "],[data-" + (this.attrItem) + "]");
                  },
  
                  handler: function handler(e) {
                      e.preventDefault();
                      e.current.blur();
                      this.show(data(e.current, this.attrItem));
                  }
  
              },
  
              {
  
                  name: pointerDown,
  
                  delegate: function delegate() {
                      return ((this.selList) + " > *");
                  },
  
                  handler: function handler(e) {
                      if (isTouch(e) || !hasTextNodesOnly(e.target)) {
                          this.start(e);
                      }
                  }
  
              },
  
              {
  
                  name: 'visibilitychange',
  
                  el: doc,
  
                  handler: function handler() {
                      if (doc.hidden) {
                          this.stopAutoplay();
                      } else  {
                          this.startAutoplay();
                      }
                  }
  
              },
  
              {
  
                  name: pointerDown,
                  handler: 'stopAutoplay'
  
              },
  
              {
  
                  name: 'mouseenter',
  
                  filter: function filter() {
                      return this.autoplay;
                  },
  
                  handler: function handler() {
                      this.isHovering = true;
                  }
  
              },
  
              {
  
                  name: 'mouseleave',
  
                  filter: function filter() {
                      return this.autoplay;
                  },
  
                  handler: function handler() {
                      this.isHovering = false;
                  }
  
              },
  
              {
  
                  name: 'beforeitemshow',
  
                  self: true,
  
                  delegate: function delegate() {
                      return ((this.selList) + " > *");
                  },
  
                  handler: function handler(ref) {
                      var target = ref.target;
  
                      addClass(target, this.clsActive);
                  }
  
              },
  
              {
  
                  name: 'itemshown',
  
                  self: true,
  
                  delegate: function delegate() {
                      return ((this.selList) + " > *");
                  },
  
                  handler: function handler(ref) {
                      var target = ref.target;
  
                      addClass(target, this.clsActivated);
                  }
  
              },
  
              {
  
                  name: 'itemshow itemhide',
  
                  self: true,
  
                  delegate: function delegate() {
                      return ((this.selList) + " > *");
                  },
  
                  handler: function handler(ref) {
                      var type = ref.type;
                      var target = ref.target;
  
                      toggleClass($$(("[" + (this.attrItem) + "=\"" + (index(target)) + "\"],[data-" + (this.attrItem) + "=\"" + (index(target)) + "\"]"), this.$el), this.clsActive, endsWith(type, 'show'));
                  }
  
              },
  
              {
  
                  name: 'itemhidden',
  
                  self: true,
  
                  delegate: function delegate() {
                      return ((this.selList) + " > *");
                  },
  
                  handler: function handler(ref) {
                      var target = ref.target;
  
                      removeClass(target, this.clsActive);
                      removeClass(target, this.clsActivated);
                  }
  
              },
  
              {
  
                  name: 'itemshow itemhide itemshown itemhidden',
  
                  self: true,
  
                  delegate: function delegate() {
                      return ((this.selList) + " > *");
                  },
  
                  handler: function handler(ref) {
                      var target = ref.target;
  
                      UIkit.update(null, target);
                  }
  
              },
  
              {
                  name: 'dragstart',
  
                  handler: function handler(e) {
                      e.preventDefault();
                  }
              }
  
          ],
  
          methods: {
  
              start: function start(e) {
  
                  if (e.button && e.button !== 0 || this.slides.length < 2) {
                      return;
                  }
  
                  if (this._animation && this._animation.animation !== this.animation) {
                      return;
                  }
  
                  var percent = 0;
                  if (this.stack.length) {
  
                      var ref = this._animation;
                      var dir = ref.dir;
                      var getPercent = ref.percent;
                      var cancel = ref.cancel;
                      var translate$$1 = ref.translate;
  
                      percent = getPercent() * dir;
  
                      this.percent = abs(percent) * -dir;
  
                      this.stack.splice(0, this.stack.length);
  
                      cancel();
                      translate$$1(abs(percent));
  
                      this.index = this.getIndex(this.index - dir);
                      this.dragging = true;
  
                  }
  
                  this.unbindMove = on(doc, pointerMove, this.move, {capture: true, passive: false});
                  on(win, 'scroll', this.unbindMove);
                  on(doc, pointerUp, this.end, true);
  
                  this.drag = this.pos + this.$el.offsetWidth * percent;
  
              },
  
              move: function move(e) {
                  var this$1 = this;
  
  
                  var distance = this.pos - this.drag;
  
                  if (this.prevPos === this.pos || !this.dragging && abs(distance) < this.threshold) {
                      return;
                  }
  
                  e.cancelable && e.preventDefault();
  
                  this.dragging = true;
  
                  var percent = distance / this.$el.offsetWidth;
  
                  if (this.percent === percent) {
                      return;
                  }
  
                  var prevIndex = this.getIndex(this.index - trunc(this.percent)),
                      index = this.getIndex(this.index - trunc(percent)),
                      current = this.slides[index],
                      dir = percent < 0 ? 1 : -1,
                      nextIndex = getIndex(percent < 0 ? 'next' : 'previous', this.slides, index),
                      next = this.slides[nextIndex];
  
                  this.slides.forEach(function (el, i) { return toggleClass(el, this$1.clsActive, i === index || i === nextIndex); });
  
                  this._animation && this._animation.reset();
  
                  if (index !== prevIndex) {
                      trigger(this.slides[prevIndex], 'itemhide', [this]);
                      trigger(current, 'itemshow', [this]);
                  }
  
                  this._animation = new Transitioner(this.animation, this.easing, current, next, dir, noop);
                  this._animation.translate(abs(percent % 1));
  
                  this.percent = percent;
  
                  UIkit.update(null, current);
                  UIkit.update(null, next);
              },
  
              end: function end() {
  
                  off(win, 'scroll', this.unbindMove);
                  this.unbindMove();
                  off(doc, pointerUp, this.end, true);
  
                  if (this.dragging) {
  
                      var percent = this.percent;
  
                      this.percent = abs(this.percent) % 1;
                      this.index = this.getIndex(this.index - trunc(percent));
  
                      if (this.percent < .1 || percent < 0 === this.pos > this.prevPos) {
                          this.index = this.getIndex(percent > 0 ? 'previous' : 'next');
                          this.percent = 1 - this.percent;
                          percent *= -1;
                      }
  
                      this._animation && this._animation.reset();
                      this.show(percent > 0 ? 'previous' : 'next', true);
  
                      preventClick();
  
                  }
  
                  this.drag
                      = this.dragging
                      = this.percent
                      = null;
  
              },
  
              show: function show(index, force) {
                  var this$1 = this;
                  if ( force === void 0 ) force = false;
  
  
                  if (!force && this.drag) {
                      return;
                  }
  
                  this.stack[force ? 'unshift' : 'push'](index);
  
                  if (!force && this.stack.length > 1) {
  
                      if (this.stack.length === 2) {
                          this._animation.forward(250);
                      }
  
                      return;
                  }
  
                  var prevIndex = this.index,
                      nextIndex = this.getIndex(index),
                      prev = hasClass(this.slides, 'uk-active') && this.slides[prevIndex],
                      next = this.slides[nextIndex];
  
                  if (prev === next) {
                      this.stack[force ? 'shift' : 'pop']();
                      return;
                  }
  
                  prev && trigger(prev, 'beforeitemhide', [this]);
                  trigger(next, 'beforeitemshow', [this]);
  
                  this.index = nextIndex;
  
                  var done = function () {
  
                      prev && trigger(prev, 'itemhidden', [this$1]);
                      trigger(next, 'itemshown', [this$1]);
  
                      fastdom.mutate(function () {
                          this$1.stack.shift();
                          if (this$1.stack.length) {
                              this$1.show(this$1.stack.shift(), true);
                          } else {
                              this$1._animation = null;
                          }
                      });
                  };
  
                  if (prev || this.initialAnimation) {
  
                      this._show(
                          !prev ? this.Animations[this.initialAnimation] : this.animation,
                          force ? 'cubic-bezier(0.165, 0.840, 0.440, 1.000)' : this.easing,
                          prev,
                          next,
                          getDirection(index, prevIndex),
                          this.stack.length > 1,
                          done
                      );
  
                  }
  
                  prev && trigger(prev, 'itemhide', [this]);
                  trigger(next, 'itemshow', [this]);
  
                  if (!prev && !this.initialAnimation) {
                      done();
                  }
  
                  prev && fastdom.flush(); // iOS 10+ will honor the video.play only if called from a gesture handler
  
              },
  
              _show: function _show(animation, easing, prev, next, dir, forward, done) {
  
                  this._animation = new Transitioner(
                      animation,
                      easing,
                      prev,
                      next,
                      dir,
                      done
                  );
  
                  this._animation.show(
                      prev === next
                          ? 300
                          : forward
                              ? 150
                              : this.duration,
                      this.percent,
                      forward
                  );
  
              },
  
              getIndex: function getIndex$1(index) {
                  if ( index === void 0 ) index = this.index;
  
                  return getIndex(index, this.slides, this.index);
              },
  
              startAutoplay: function startAutoplay() {
                  var this$1 = this;
  
  
                  this.stopAutoplay();
  
                  if (this.autoplay) {
                      this.interval = setInterval(function () {
                          if (!(this$1.isHovering && this$1.pauseOnHover) && !this$1.stack.length) {
                              this$1.show('next');
                          }
                      }, this.autoplayInterval);
                  }
  
              },
  
              stopAutoplay: function stopAutoplay() {
                  if (this.interval) {
                      clearInterval(this.interval);
                  }
              }
  
          }
  
      };
  
      function Transitioner(animation, easing, current, next, dir, cb) {
  
          var percent = animation.percent;
          var translate$$1 = animation.translate;
          var show = animation.show;
          var props = show(dir);
  
          return {
  
              animation: animation,
              dir: dir,
              current: current,
              next: next,
  
              show: function show(duration, percent, linear) {
                  var this$1 = this;
                  if ( percent === void 0 ) percent = 0;
  
  
                  var ease = linear ? 'linear' : easing;
                  duration -= Math.round(duration * percent);
  
                  this.translate(percent);
  
                  triggerUpdate(next, 'itemin', {percent: percent, duration: duration, ease: ease, dir: dir});
                  current && triggerUpdate(current, 'itemout', {percent: 1 - percent, duration: duration, ease: ease, dir: dir});
  
                  return Promise.all([
                      Transition.start(next, props[1], duration, ease),
                      current && Transition.start(current, props[0], duration, ease)
                  ]).then(function () {
                      this$1.reset();
                      cb();
                  }, noop);
              },
  
              stop: function stop() {
                  return Transition.stop([next, current]);
              },
  
              cancel: function cancel() {
                  Transition.cancel([next, current]);
              },
  
              reset: function reset() {
                  for (var prop in props[0]) {
                      css([next, current], prop, '');
                  }
              },
  
              forward: function forward(duration) {
  
                  var percent = this.percent();
                  Transition.cancel([next, current]);
                  this.show(duration, percent, true);
  
              },
  
              translate: function translate$1(percent) {
  
                  var props = translate$$1(percent, dir);
                  css(next, props[1]);
                  current && css(current, props[0]);
                  triggerUpdate(next, 'itemtranslatein', {percent: percent, dir: dir});
                  current && triggerUpdate(current, 'itemtranslateout', {percent: 1 - percent, dir: dir});
              },
  
              percent: function percent$1() {
                  return percent(current, next, dir);
              }
  
          }
  
      }
  
      function triggerUpdate(el, type, data) {
          trigger(el, createEvent(type, false, false, data));
      }
  
      // polyfill for Math.trunc (IE)
      function trunc(x) {
          return ~~x;
      }
  
      function getDirection(index, prevIndex) {
          return index === 'next'
              ? 1
              : index === 'previous'
                  ? -1
                  : index < prevIndex
                      ? -1
                      : 1;
      }
  
      function speedUp(x) {
          return .5 * x + 300; // parabola through (400,500; 600,600; 1800,1200)
      }
  
      function hasTextNodesOnly(el) {
          return !el.children.length && el.childNodes.length;
      }
  
  }
  
  var Animations$1 = function (UIkit) {
  
      var mixin = UIkit.mixin;
      var ref = UIkit.util;
      var assign = ref.assign;
      var css = ref.css;
  
      var Animations$$1 = assign({}, mixin.slideshow.defaults.Animations, {
  
          fade: {
  
              show: function show() {
                  return [
                      {opacity: 0, zIndex: 0},
                      {zIndex: -1}
                  ];
              },
  
              percent: function percent(current) {
                  return 1 - css(current, 'opacity');
              },
  
              translate: function translate$$1(percent) {
                  return [
                      {opacity: 1 - percent, zIndex: 0},
                      {zIndex: -1}
                  ];
              }
  
          },
  
          scale: {
  
              show: function show() {
                  return [
                      {opacity: 0, transform: scale3d(1 + .5), zIndex: 0},
                      {zIndex: -1}
                  ];
              },
  
              percent: function percent(current) {
                  return 1 - css(current, 'opacity');
              },
  
              translate: function translate$$1(percent) {
                  return [
                      {opacity: 1 - percent, transform: scale3d(1 + .5 * percent), zIndex: 0},
                      {zIndex: -1}
                  ];
              }
  
          },
  
          pull: {
  
              show: function show(dir) {
                  return dir < 0
                      ? [
                          {transform: translate(30), zIndex: -1},
                          {transform: translate(), zIndex: 0} ]
                      : [
                          {transform: translate(-100), zIndex: 0},
                          {transform: translate(), zIndex: -1}
                      ];
              },
  
              percent: function percent(current, next, dir) {
                  return dir < 0
                      ? 1 - Animations$$1.translated(next)
                      : Animations$$1.translated(current);
              },
  
              translate: function translate$1(percent, dir) {
                  return dir < 0
                      ? [
                          {transform: translate(30 * percent), zIndex: -1},
                          {transform: translate(-100 * (1 - percent)), zIndex: 0} ]
                      : [
                          {transform: translate(-percent * 100), zIndex: 0},
                          {transform: translate(30 * (1 - percent)), zIndex: -1}
                      ];
              }
  
          },
  
          push: {
  
              show: function show(dir) {
                  return dir < 0
                      ? [
                          {transform: translate(100), zIndex: 0},
                          {transform: translate(), zIndex: -1} ]
                      : [
                          {transform: translate(-30), zIndex: -1},
                          {transform: translate(), zIndex: 0}
                      ];
              },
  
              percent: function percent(current, next, dir) {
                  return dir > 0
                      ? 1 - Animations$$1.translated(next)
                      : Animations$$1.translated(current);
              },
  
              translate: function translate$2(percent, dir) {
                  return dir < 0
                      ? [
                          {transform: translate(percent * 100), zIndex: 0},
                          {transform: translate(-30 * (1 - percent)), zIndex: -1} ]
                      : [
                          {transform: translate(-30 * percent), zIndex: -1},
                          {transform: translate(100 * (1 - percent)), zIndex: 0}
                      ];
              }
  
          }
  
      });
  
      return Animations$$1;
  
  };
  
  function plugin(UIkit) {
  
      if (plugin.installed) {
          return;
      }
  
      UIkit.use(plugin$2);
      UIkit.use(plugin$3);
  
      var mixin = UIkit.mixin;
      var ref = UIkit.util;
      var closest = ref.closest;
      var css = ref.css;
      var fastdom = ref.fastdom;
      var endsWith = ref.endsWith;
      var height = ref.height;
      var noop = ref.noop;
      var Transition = ref.Transition;
  
      UIkit.component('slideshow', {
  
          mixins: [mixin.class, mixin.slideshow],
  
          props: {
              ratio: String,
              minHeight: Boolean,
              maxHeight: Boolean,
          },
  
          defaults: {
              ratio: '16:9',
              minHeight: false,
              maxHeight: false,
              selList: '.uk-slideshow-items',
              attrItem: 'uk-slideshow-item',
              Animations: Animations$1(UIkit)
          },
  
          ready: function ready() {
              var this$1 = this;
  
              fastdom.mutate(function () { return this$1.show(this$1.index); });
          },
  
          update: {
  
              read: function read() {
  
                  var ref = this.ratio.split(':').map(Number);
                  var width = ref[0];
                  var height = ref[1];
                  this.height = height * this.$el.offsetWidth / width;
  
                  if (this.minHeight) {
                      this.height = Math.max(this.minHeight, this.height);
                  }
  
                  if (this.maxHeight) {
                      this.height = Math.min(this.maxHeight, this.height);
                  }
  
              },
  
              write: function write() {
                  height(this.list, Math.floor(this.height));
              },
  
              events: ['load', 'resize']
  
          }
  
      });
  
      UIkit.component('slideshow-parallax', {
  
          mixins: [mixin.parallax],
  
          computed: {
  
              item: function item() {
                  var slideshow = UIkit.getComponent(closest(this.$el, '.uk-slideshow'), 'slideshow');
                  return slideshow && closest(this.$el, ((slideshow.selList) + " > *"));
              }
  
          },
  
          events: [
  
              {
  
                  name: 'itemshown',
  
                  self: true,
  
                  el: function el() {
                      return this.item;
                  },
  
                  handler: function handler() {
                      css(this.$el, this.getCss(.5));
                  }
  
              },
  
              {
                  name: 'itemin itemout',
  
                  self: true,
  
                  el: function el() {
                      return this.item;
                  },
  
                  handler: function handler(ref) {
                      var type = ref.type;
                      var ref_detail = ref.detail;
                      var percent = ref_detail.percent;
                      var duration = ref_detail.duration;
                      var ease = ref_detail.ease;
                      var dir = ref_detail.dir;
  
  
                      Transition.cancel(this.$el);
                      css(this.$el, this.getCss(getCurrent(type, dir, percent)));
  
                      Transition.start(this.$el, this.getCss(isIn(type)
                          ? .5
                          : dir > 0
                              ? 1
                              : 0
                      ), duration, ease).catch(noop);
  
                  }
              },
  
              {
                  name: 'transitioncanceled transitionend',
  
                  self: true,
  
                  el: function el() {
                      return this.item;
                  },
  
                  handler: function handler() {
                      Transition.cancel(this.$el);
                  }
  
              },
  
              {
                  name: 'itemtranslatein itemtranslateout',
  
                  self: true,
  
                  el: function el() {
                      return this.item;
                  },
  
                  handler: function handler(ref) {
                      var type = ref.type;
                      var ref_detail = ref.detail;
                      var percent = ref_detail.percent;
                      var dir = ref_detail.dir;
  
                      Transition.cancel(this.$el);
                      css(this.$el, this.getCss(getCurrent(type, dir, percent)));
                  }
              }
  
          ]
  
      });
  
      function isIn(type) {
          return endsWith(type, 'in');
      }
  
      function getCurrent(type, dir, percent) {
  
          percent /= 2;
  
          return !isIn(type)
              ? dir < 0
                  ? percent
                  : 1 - percent
              : dir < 0
                  ? 1 - percent
                  : percent;
      }
  
  }
  
  if (!false && typeof window !== 'undefined' && window.UIkit) {
      window.UIkit.use(plugin);
  }
  
  return plugin;
  
  })));
  