uikit 3.11.1 → 3.11.2-dev.03e47c2ff

package/dist/js/components/lightbox.js

@@ -1,4 +1,4 @@
-/*! UIkit 3.11.1 | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
+/*! UIkit 3.11.2-dev.03e47c2ff | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
 
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('uikit-util')) :
@@ -7,1840 +7,1591 @@
 })(this, (function (uikitUtil) { 'use strict';
 
     var Animations$1 = {
+      slide: {
+        show(dir) {
+          return [{ transform: translate(dir * -100) }, { transform: translate() }];
+        },
 
-        slide: {
+        percent(current) {
+          return translated(current);
+        },
 
-            show: function(dir) {
-                return [
-                    {transform: translate(dir * -100)},
-                    {transform: translate()}
-                ];
-            },
+        translate(percent, dir) {
+          return [
+          { transform: translate(dir * -100 * percent) },
+          { transform: translate(dir * 100 * (1 - percent)) }];
 
-            percent: function(current) {
-                return translated(current);
-            },
+        } } };
 
-            translate: function(percent, dir) {
-                return [
-                    {transform: translate(dir * -100 * percent)},
-                    {transform: translate(dir * 100 * (1 - percent))}
-                ];
-            }
-
-        }
 
-    };
 
     function translated(el) {
-        return Math.abs(uikitUtil.css(el, 'transform').split(',')[4] / el.offsetWidth) || 0;
+      return Math.abs(uikitUtil.css(el, 'transform').split(',')[4] / el.offsetWidth) || 0;
     }
 
-    function translate(value, unit) {
-        if ( value === void 0 ) value = 0;
-        if ( unit === void 0 ) unit = '%';
-
-        value += value ? unit : '';
-        return uikitUtil.isIE ? ("translateX(" + value + ")") : ("translate3d(" + value + ", 0, 0)"); // currently, not translate3d in IE, translate3d within translate3d does not work while transitioning
+    function translate(value, unit) {if (value === void 0) {value = 0;}if (unit === void 0) {unit = '%';}
+      value += value ? unit : '';
+      return "translate3d(" + value + ", 0, 0)";
     }
 
     function scale3d(value) {
-        return ("scale3d(" + value + ", " + value + ", 1)");
+      return "scale3d(" + value + ", " + value + ", 1)";
     }
 
-    var Animations = uikitUtil.assign({}, Animations$1, {
-
-        fade: {
-
-            show: function() {
-                return [
-                    {opacity: 0},
-                    {opacity: 1}
-                ];
-            },
-
-            percent: function(current) {
-                return 1 - uikitUtil.css(current, 'opacity');
-            },
-
-            translate: function(percent) {
-                return [
-                    {opacity: 1 - percent},
-                    {opacity: percent}
-                ];
-            }
-
+    var Animations = {
+      ...Animations$1,
+      fade: {
+        show() {
+          return [{ opacity: 0 }, { opacity: 1 }];
         },
 
-        scale: {
-
-            show: function() {
-                return [
-                    {opacity: 0, transform: scale3d(1 - .2)},
-                    {opacity: 1, transform: scale3d(1)}
-                ];
-            },
-
-            percent: function(current) {
-                return 1 - uikitUtil.css(current, 'opacity');
-            },
-
-            translate: function(percent) {
-                return [
-                    {opacity: 1 - percent, transform: scale3d(1 - .2 * percent)},
-                    {opacity: percent, transform: scale3d(1 - .2 + .2 * percent)}
-                ];
-            }
+        percent(current) {
+          return 1 - uikitUtil.css(current, 'opacity');
+        },
 
-        }
+        translate(percent) {
+          return [{ opacity: 1 - percent }, { opacity: percent }];
+        } },
 
-    });
 
-    var Container = {
+      scale: {
+        show() {
+          return [
+          { opacity: 0, transform: scale3d(1 - 0.2) },
+          { opacity: 1, transform: scale3d(1) }];
 
-        props: {
-            container: Boolean
         },
 
-        data: {
-            container: true
+        percent(current) {
+          return 1 - uikitUtil.css(current, 'opacity');
         },
 
-        computed: {
+        translate(percent) {
+          return [
+          { opacity: 1 - percent, transform: scale3d(1 - 0.2 * percent) },
+          { opacity: percent, transform: scale3d(1 - 0.2 + 0.2 * percent) }];
 
-            container: function(ref) {
-                var container = ref.container;
+        } } };
 
-                return container === true && this.$container || container && uikitUtil.$(container);
-            }
+    var Container = {
+      props: {
+        container: Boolean },
 
-        }
 
-    };
+      data: {
+        container: true },
 
-    var Class = {
 
-        connected: function() {
-            !uikitUtil.hasClass(this.$el, this.$name) && uikitUtil.addClass(this.$el, this.$name);
-        }
+      computed: {
+        container(_ref) {let { container } = _ref;
+          return container === true && this.$container || container && uikitUtil.$(container);
+        } } };
 
-    };
+    var Class = {
+      connected() {
+        !uikitUtil.hasClass(this.$el, this.$name) && uikitUtil.addClass(this.$el, this.$name);
+      } };
 
     var Togglable = {
-
-        props: {
-            cls: Boolean,
-            animation: 'list',
-            duration: Number,
-            origin: String,
-            transition: String
-        },
-
-        data: {
-            cls: false,
-            animation: [false],
-            duration: 200,
-            origin: false,
-            transition: 'linear',
-            clsEnter: 'uk-togglabe-enter',
-            clsLeave: 'uk-togglabe-leave',
-
-            initProps: {
-                overflow: '',
-                height: '',
-                paddingTop: '',
-                paddingBottom: '',
-                marginTop: '',
-                marginBottom: ''
-            },
-
-            hideProps: {
-                overflow: 'hidden',
-                height: 0,
-                paddingTop: 0,
-                paddingBottom: 0,
-                marginTop: 0,
-                marginBottom: 0
-            }
-
+      props: {
+        cls: Boolean,
+        animation: 'list',
+        duration: Number,
+        origin: String,
+        transition: String },
+
+
+      data: {
+        cls: false,
+        animation: [false],
+        duration: 200,
+        origin: false,
+        transition: 'linear',
+        clsEnter: 'uk-togglabe-enter',
+        clsLeave: 'uk-togglabe-leave',
+
+        initProps: {
+          overflow: '',
+          height: '',
+          paddingTop: '',
+          paddingBottom: '',
+          marginTop: '',
+          marginBottom: '' },
+
+
+        hideProps: {
+          overflow: 'hidden',
+          height: 0,
+          paddingTop: 0,
+          paddingBottom: 0,
+          marginTop: 0,
+          marginBottom: 0 } },
+
+
+
+      computed: {
+        hasAnimation(_ref) {let { animation } = _ref;
+          return !!animation[0];
         },
 
-        computed: {
+        hasTransition(_ref2) {let { animation } = _ref2;
+          return this.hasAnimation && animation[0] === true;
+        } },
 
-            hasAnimation: function(ref) {
-                var animation = ref.animation;
 
-                return !!animation[0];
-            },
+      methods: {
+        toggleElement(targets, toggle, animate) {
+          return new Promise((resolve) =>
+          Promise.all(
+          uikitUtil.toNodes(targets).map((el) => {
+            const show = uikitUtil.isBoolean(toggle) ? toggle : !this.isToggled(el);
 
-            hasTransition: function(ref) {
-                var animation = ref.animation;
-
-                return this.hasAnimation && animation[0] === true;
+            if (!uikitUtil.trigger(el, "before" + (show ? 'show' : 'hide'), [this])) {
+              return Promise.reject();
             }
 
-        },
-
-        methods: {
-
-            toggleElement: function(targets, toggle, animate) {
-                var this$1$1 = this;
-
-                return new uikitUtil.Promise(function (resolve) { return uikitUtil.Promise.all(uikitUtil.toNodes(targets).map(function (el) {
-
-                        var show = uikitUtil.isBoolean(toggle) ? toggle : !this$1$1.isToggled(el);
-
-                        if (!uikitUtil.trigger(el, ("before" + (show ? 'show' : 'hide')), [this$1$1])) {
-                            return uikitUtil.Promise.reject();
-                        }
-
-                        var promise = (
-                            uikitUtil.isFunction(animate)
-                                ? animate
-                                : animate === false || !this$1$1.hasAnimation
-                                ? this$1$1._toggle
-                                : this$1$1.hasTransition
-                                    ? toggleHeight(this$1$1)
-                                    : toggleAnimation(this$1$1)
-                        )(el, show);
-
-                        var cls = show ? this$1$1.clsEnter : this$1$1.clsLeave;
+            const promise = (
+            uikitUtil.isFunction(animate) ?
+            animate :
+            animate === false || !this.hasAnimation ?
+            this._toggle :
+            this.hasTransition ?
+            toggleHeight(this) :
+            toggleAnimation(this))(
+            el, show);
+
+            const cls = show ? this.clsEnter : this.clsLeave;
+
+            uikitUtil.addClass(el, cls);
+
+            uikitUtil.trigger(el, show ? 'show' : 'hide', [this]);
+
+            const done = () => {
+              uikitUtil.removeClass(el, cls);
+              uikitUtil.trigger(el, show ? 'shown' : 'hidden', [this]);
+              this.$update(el);
+            };
+
+            return promise ?
+            promise.then(done, () => {
+              uikitUtil.removeClass(el, cls);
+              return Promise.reject();
+            }) :
+            done();
+          })).
+          then(resolve, uikitUtil.noop));
 
-                        uikitUtil.addClass(el, cls);
-
-                        uikitUtil.trigger(el, show ? 'show' : 'hide', [this$1$1]);
-
-                        var done = function () {
-                            uikitUtil.removeClass(el, cls);
-                            uikitUtil.trigger(el, show ? 'shown' : 'hidden', [this$1$1]);
-                            this$1$1.$update(el);
-                        };
+        },
 
-                        return promise ? promise.then(done, function () {
-                            uikitUtil.removeClass(el, cls);
-                            return uikitUtil.Promise.reject();
-                        }) : done();
+        isToggled(el) {if (el === void 0) {el = this.$el;}
+          [el] = uikitUtil.toNodes(el);
+          return uikitUtil.hasClass(el, this.clsEnter) ?
+          true :
+          uikitUtil.hasClass(el, this.clsLeave) ?
+          false :
+          this.cls ?
+          uikitUtil.hasClass(el, this.cls.split(' ')[0]) :
+          uikitUtil.isVisible(el);
+        },
 
-                    })).then(resolve, uikitUtil.noop); }
-                );
-            },
+        _toggle(el, toggled) {
+          if (!el) {
+            return;
+          }
 
-            isToggled: function(el) {
-                var assign;
+          toggled = Boolean(toggled);
 
-                if ( el === void 0 ) el = this.$el;
-                (assign = uikitUtil.toNodes(el), el = assign[0]);
-                return uikitUtil.hasClass(el, this.clsEnter)
-                    ? true
-                    : uikitUtil.hasClass(el, this.clsLeave)
-                        ? false
-                        : this.cls
-                            ? uikitUtil.hasClass(el, this.cls.split(' ')[0])
-                            : uikitUtil.isVisible(el);
-            },
+          let changed;
+          if (this.cls) {
+            changed = uikitUtil.includes(this.cls, ' ') || toggled !== uikitUtil.hasClass(el, this.cls);
+            changed && uikitUtil.toggleClass(el, this.cls, uikitUtil.includes(this.cls, ' ') ? undefined : toggled);
+          } else {
+            changed = toggled === el.hidden;
+            changed && (el.hidden = !toggled);
+          }
 
-            _toggle: function(el, toggled) {
+          uikitUtil.$$('[autofocus]', el).some((el) => uikitUtil.isVisible(el) ? el.focus() || true : el.blur());
 
-                if (!el) {
-                    return;
-                }
+          if (changed) {
+            uikitUtil.trigger(el, 'toggled', [toggled, this]);
+            this.$update(el);
+          }
+        } } };
 
-                toggled = Boolean(toggled);
 
-                var changed;
-                if (this.cls) {
-                    changed = uikitUtil.includes(this.cls, ' ') || toggled !== uikitUtil.hasClass(el, this.cls);
-                    changed && uikitUtil.toggleClass(el, this.cls, uikitUtil.includes(this.cls, ' ') ? undefined : toggled);
-                } else {
-                    changed = toggled === el.hidden;
-                    changed && (el.hidden = !toggled);
-                }
 
-                uikitUtil.$$('[autofocus]', el).some(function (el) { return uikitUtil.isVisible(el) ? el.focus() || true : el.blur(); });
+    function toggleHeight(_ref3) {let { isToggled, duration, initProps, hideProps, transition, _toggle } = _ref3;
+      return (el, show) => {
+        const inProgress = uikitUtil.Transition.inProgress(el);
+        const inner = el.hasChildNodes ?
+        uikitUtil.toFloat(uikitUtil.css(el.firstElementChild, 'marginTop')) +
+        uikitUtil.toFloat(uikitUtil.css(el.lastElementChild, 'marginBottom')) :
+        0;
+        const currentHeight = uikitUtil.isVisible(el) ? uikitUtil.height(el) + (inProgress ? 0 : inner) : 0;
 
-                if (changed) {
-                    uikitUtil.trigger(el, 'toggled', [toggled, this]);
-                    this.$update(el);
-                }
-            }
+        uikitUtil.Transition.cancel(el);
 
+        if (!isToggled(el)) {
+          _toggle(el, true);
         }
 
-    };
-
-    function toggleHeight(ref) {
-        var isToggled = ref.isToggled;
-        var duration = ref.duration;
-        var initProps = ref.initProps;
-        var hideProps = ref.hideProps;
-        var transition = ref.transition;
-        var _toggle = ref._toggle;
-
-        return function (el, show) {
-
-            var inProgress = uikitUtil.Transition.inProgress(el);
-            var inner = el.hasChildNodes ? uikitUtil.toFloat(uikitUtil.css(el.firstElementChild, 'marginTop')) + uikitUtil.toFloat(uikitUtil.css(el.lastElementChild, 'marginBottom')) : 0;
-            var currentHeight = uikitUtil.isVisible(el) ? uikitUtil.height(el) + (inProgress ? 0 : inner) : 0;
-
-            uikitUtil.Transition.cancel(el);
-
-            if (!isToggled(el)) {
-                _toggle(el, true);
-            }
-
-            uikitUtil.height(el, '');
-
-            // Update child components first
-            uikitUtil.fastdom.flush();
-
-            var endHeight = uikitUtil.height(el) + (inProgress ? 0 : inner);
-            uikitUtil.height(el, currentHeight);
-
-            return (show
-                ? uikitUtil.Transition.start(el, uikitUtil.assign({}, initProps, {overflow: 'hidden', height: endHeight}), Math.round(duration * (1 - currentHeight / endHeight)), transition)
-                : uikitUtil.Transition.start(el, hideProps, Math.round(duration * (currentHeight / endHeight)), transition).then(function () { return _toggle(el, false); })
-            ).then(function () { return uikitUtil.css(el, initProps); });
-
-        };
+        uikitUtil.height(el, '');
+
+        // Update child components first
+        uikitUtil.fastdom.flush();
+
+        const endHeight = uikitUtil.height(el) + (inProgress ? 0 : inner);
+        uikitUtil.height(el, currentHeight);
+
+        return (
+        show ?
+        uikitUtil.Transition.start(
+        el,
+        { ...initProps, overflow: 'hidden', height: endHeight },
+        Math.round(duration * (1 - currentHeight / endHeight)),
+        transition) :
+
+        uikitUtil.Transition.start(
+        el,
+        hideProps,
+        Math.round(duration * (currentHeight / endHeight)),
+        transition).
+        then(() => _toggle(el, false))).
+        then(() => uikitUtil.css(el, initProps));
+      };
     }
 
     function toggleAnimation(cmp) {
-        return function (el, show) {
+      return (el, show) => {
+        uikitUtil.Animation.cancel(el);
 
-            uikitUtil.Animation.cancel(el);
+        const { animation, duration, _toggle } = cmp;
 
-            var animation = cmp.animation;
-            var duration = cmp.duration;
-            var _toggle = cmp._toggle;
+        if (show) {
+          _toggle(el, true);
+          return uikitUtil.Animation.in(el, animation[0], duration, cmp.origin);
+        }
 
-            if (show) {
-                _toggle(el, true);
-                return uikitUtil.Animation.in(el, animation[0], duration, cmp.origin);
-            }
+        return uikitUtil.Animation.out(el, animation[1] || animation[0], duration, cmp.origin).then(() =>
+        _toggle(el, false));
 
-            return uikitUtil.Animation.out(el, animation[1] || animation[0], duration, cmp.origin).then(function () { return _toggle(el, false); });
-        };
+      };
     }
 
-    var active = [];
+    const active = [];
 
     var Modal = {
+      mixins: [Class, Container, Togglable],
 
-        mixins: [Class, Container, Togglable],
-
-        props: {
-            selPanel: String,
-            selClose: String,
-            escClose: Boolean,
-            bgClose: Boolean,
-            stack: Boolean
-        },
-
-        data: {
-            cls: 'uk-open',
-            escClose: true,
-            bgClose: true,
-            overlay: true,
-            stack: false
-        },
-
-        computed: {
+      props: {
+        selPanel: String,
+        selClose: String,
+        escClose: Boolean,
+        bgClose: Boolean,
+        stack: Boolean },
 
-            panel: function(ref, $el) {
-                var selPanel = ref.selPanel;
 
-                return uikitUtil.$(selPanel, $el);
-            },
+      data: {
+        cls: 'uk-open',
+        escClose: true,
+        bgClose: true,
+        overlay: true,
+        stack: false },
 
-            transitionElement: function() {
-                return this.panel;
-            },
-
-            bgClose: function(ref) {
-                var bgClose = ref.bgClose;
-
-                return bgClose && this.panel;
-            }
 
+      computed: {
+        panel(_ref, $el) {let { selPanel } = _ref;
+          return uikitUtil.$(selPanel, $el);
         },
 
-        beforeDisconnect: function() {
-            if (uikitUtil.includes(active, this)) {
-                this.toggleElement(this.$el, false, false);
-            }
+        transitionElement() {
+          return this.panel;
         },
 
-        events: [
-
-            {
-
-                name: 'click',
-
-                delegate: function() {
-                    return this.selClose;
-                },
-
-                handler: function(e) {
-                    e.preventDefault();
-                    this.hide();
-                }
-
-            },
-
-            {
+        bgClose(_ref2) {let { bgClose } = _ref2;
+          return bgClose && this.panel;
+        } },
 
-                name: 'toggle',
 
-                self: true,
-
-                handler: function(e, toggle) {
-
-                    if (e.defaultPrevented) {
-                        return;
-                    }
-
-                    e.preventDefault();
-
-                    if (this.isToggled() === uikitUtil.includes(active, this)) {
-                        this.toggle();
-                    }
-                }
+      beforeDisconnect() {
+        if (uikitUtil.includes(active, this)) {
+          this.toggleElement(this.$el, false, false);
+        }
+      },
 
-            },
+      events: [
+      {
+        name: 'click',
 
-            {
-                name: 'beforeshow',
+        delegate() {
+          return this.selClose;
+        },
 
-                self: true,
+        handler(e) {
+          e.preventDefault();
+          this.hide();
+        } },
 
-                handler: function(e) {
 
-                    if (uikitUtil.includes(active, this)) {
-                        return false;
-                    }
+      {
+        name: 'toggle',
 
-                    if (!this.stack && active.length) {
-                        uikitUtil.Promise.all(active.map(function (modal) { return modal.hide(); })).then(this.show);
-                        e.preventDefault();
-                    } else {
-                        active.push(this);
-                    }
-                }
+        self: true,
 
-            },
+        handler(e) {
+          if (e.defaultPrevented) {
+            return;
+          }
 
-            {
+          e.preventDefault();
 
-                name: 'show',
+          if (this.isToggled() === uikitUtil.includes(active, this)) {
+            this.toggle();
+          }
+        } },
 
-                self: true,
 
-                handler: function() {
-                    var this$1$1 = this;
+      {
+        name: 'beforeshow',
 
+        self: true,
 
-                    var docEl = document.documentElement;
+        handler(e) {
+          if (uikitUtil.includes(active, this)) {
+            return false;
+          }
 
-                    if (uikitUtil.width(window) > docEl.clientWidth && this.overlay) {
-                        uikitUtil.css(document.body, 'overflowY', 'scroll');
-                    }
+          if (!this.stack && active.length) {
+            Promise.all(active.map((modal) => modal.hide())).then(this.show);
+            e.preventDefault();
+          } else {
+            active.push(this);
+          }
+        } },
 
-                    if (this.stack) {
-                        uikitUtil.css(this.$el, 'zIndex', uikitUtil.toFloat(uikitUtil.css(this.$el, 'zIndex')) + active.length);
-                    }
 
-                    uikitUtil.addClass(docEl, this.clsPage);
+      {
+        name: 'show',
 
-                    if (this.bgClose) {
-                        uikitUtil.once(this.$el, 'hide', uikitUtil.on(document, uikitUtil.pointerDown, function (ref) {
-                            var target = ref.target;
+        self: true,
 
+        handler() {
+          const docEl = document.documentElement;
 
-                            if (uikitUtil.last(active) !== this$1$1 || this$1$1.overlay && !uikitUtil.within(target, this$1$1.$el) || uikitUtil.within(target, this$1$1.panel)) {
-                                return;
-                            }
+          if (uikitUtil.width(window) > docEl.clientWidth && this.overlay) {
+            uikitUtil.css(document.body, 'overflowY', 'scroll');
+          }
 
-                            uikitUtil.once(document, (uikitUtil.pointerUp + " " + uikitUtil.pointerCancel + " scroll"), function (ref) {
-                                var defaultPrevented = ref.defaultPrevented;
-                                var type = ref.type;
-                                var newTarget = ref.target;
+          if (this.stack) {
+            uikitUtil.css(this.$el, 'zIndex', uikitUtil.toFloat(uikitUtil.css(this.$el, 'zIndex')) + active.length);
+          }
 
-                                if (!defaultPrevented && type === uikitUtil.pointerUp && target === newTarget) {
-                                    this$1$1.hide();
-                                }
-                            }, true);
+          uikitUtil.addClass(docEl, this.clsPage);
 
-                        }), {self: true});
-                    }
+          if (this.bgClose) {
+            uikitUtil.once(
+            this.$el,
+            'hide',
+            uikitUtil.on(document, uikitUtil.pointerDown, (_ref3) => {let { target } = _ref3;
+              if (
+              uikitUtil.last(active) !== this ||
+              this.overlay && !uikitUtil.within(target, this.$el) ||
+              uikitUtil.within(target, this.panel))
+              {
+                return;
+              }
 
-                    if (this.escClose) {
-                        uikitUtil.once(this.$el, 'hide', uikitUtil.on(document, 'keydown', function (e) {
-                            if (e.keyCode === 27 && uikitUtil.last(active) === this$1$1) {
-                                this$1$1.hide();
-                            }
-                        }), {self: true});
-                    }
+              uikitUtil.once(
+              document,
+              uikitUtil.pointerUp + " " + uikitUtil.pointerCancel + " scroll",
+              (_ref4) => {let { defaultPrevented, type, target: newTarget } = _ref4;
+                if (
+                !defaultPrevented &&
+                type === uikitUtil.pointerUp &&
+                target === newTarget)
+                {
+                  this.hide();
                 }
+              },
+              true);
 
-            },
+            }),
+            { self: true });
 
-            {
-                name: 'shown',
+          }
 
-                self: true,
+          if (this.escClose) {
+            uikitUtil.once(
+            this.$el,
+            'hide',
+            uikitUtil.on(document, 'keydown', (e) => {
+              if (e.keyCode === 27 && uikitUtil.last(active) === this) {
+                this.hide();
+              }
+            }),
+            { self: true });
 
-                handler: function() {
-                    if (!uikitUtil.isFocusable(this.$el)) {
-                        uikitUtil.attr(this.$el, 'tabindex', '-1');
-                    }
+          }
+        } },
 
-                    if (!uikitUtil.$(':focus', this.$el)) {
-                        this.$el.focus();
-                    }
-                }
-            },
 
-            {
+      {
+        name: 'shown',
 
-                name: 'hidden',
+        self: true,
 
-                self: true,
+        handler() {
+          if (!uikitUtil.isFocusable(this.$el)) {
+            uikitUtil.attr(this.$el, 'tabindex', '-1');
+          }
 
-                handler: function() {
-                    var this$1$1 = this;
+          if (!uikitUtil.$(':focus', this.$el)) {
+            this.$el.focus();
+          }
+        } },
 
 
-                    if (uikitUtil.includes(active, this)) {
-                        active.splice(active.indexOf(this), 1);
-                    }
+      {
+        name: 'hidden',
 
-                    if (!active.length) {
-                        uikitUtil.css(document.body, 'overflowY', '');
-                    }
+        self: true,
 
-                    uikitUtil.css(this.$el, 'zIndex', '');
+        handler() {
+          if (uikitUtil.includes(active, this)) {
+            active.splice(active.indexOf(this), 1);
+          }
 
-                    if (!active.some(function (modal) { return modal.clsPage === this$1$1.clsPage; })) {
-                        uikitUtil.removeClass(document.documentElement, this.clsPage);
-                    }
+          if (!active.length) {
+            uikitUtil.css(document.body, 'overflowY', '');
+          }
 
-                }
+          uikitUtil.css(this.$el, 'zIndex', '');
 
-            }
+          if (!active.some((modal) => modal.clsPage === this.clsPage)) {
+            uikitUtil.removeClass(document.documentElement, this.clsPage);
+          }
+        } }],
 
-        ],
 
-        methods: {
 
-            toggle: function() {
-                return this.isToggled() ? this.hide() : this.show();
-            },
+      methods: {
+        toggle() {
+          return this.isToggled() ? this.hide() : this.show();
+        },
 
-            show: function() {
-                var this$1$1 = this;
+        show() {
+          if (this.container && uikitUtil.parent(this.$el) !== this.container) {
+            uikitUtil.append(this.container, this.$el);
+            return new Promise((resolve) =>
+            requestAnimationFrame(() => this.show().then(resolve)));
 
-                if (this.container && uikitUtil.parent(this.$el) !== this.container) {
-                    uikitUtil.append(this.container, this.$el);
-                    return new uikitUtil.Promise(function (resolve) { return requestAnimationFrame(function () { return this$1$1.show().then(resolve); }
-                        ); }
-                    );
-                }
+          }
 
-                return this.toggleElement(this.$el, true, animate(this));
-            },
+          return this.toggleElement(this.$el, true, animate(this));
+        },
 
-            hide: function() {
-                return this.toggleElement(this.$el, false, animate(this));
-            }
+        hide() {
+          return this.toggleElement(this.$el, false, animate(this));
+        } } };
 
-        }
 
-    };
 
-    function animate(ref) {
-        var transitionElement = ref.transitionElement;
-        var _toggle = ref._toggle;
+    function animate(_ref5) {let { transitionElement, _toggle } = _ref5;
+      return (el, show) =>
+      new Promise((resolve, reject) =>
+      uikitUtil.once(el, 'show hide', () => {
+        el._reject && el._reject();
+        el._reject = reject;
 
-        return function (el, show) { return new uikitUtil.Promise(function (resolve, reject) { return uikitUtil.once(el, 'show hide', function () {
-                    el._reject && el._reject();
-                    el._reject = reject;
+        _toggle(el, show);
 
-                    _toggle(el, show);
+        const off = uikitUtil.once(
+        transitionElement,
+        'transitionstart',
+        () => {
+          uikitUtil.once(transitionElement, 'transitionend transitioncancel', resolve, {
+            self: true });
 
-                    var off = uikitUtil.once(transitionElement, 'transitionstart', function () {
-                        uikitUtil.once(transitionElement, 'transitionend transitioncancel', resolve, {self: true});
-                        clearTimeout(timer);
-                    }, {self: true});
+          clearTimeout(timer);
+        },
+        { self: true });
 
-                    var timer = setTimeout(function () {
-                        off();
-                        resolve();
-                    }, uikitUtil.toMs(uikitUtil.css(transitionElement, 'transitionDuration')));
 
-                }); }
-            ).then(function () { return delete el._reject; }); };
+        const timer = setTimeout(() => {
+          off();
+          resolve();
+        }, uikitUtil.toMs(uikitUtil.css(transitionElement, 'transitionDuration')));
+      })).
+      then(() => delete el._reject);
     }
 
-    function Transitioner(prev, next, dir, ref) {
-        var animation = ref.animation;
-        var easing = ref.easing;
-
-
-        var percent = animation.percent;
-        var translate = animation.translate;
-        var show = animation.show; if ( show === void 0 ) show = uikitUtil.noop;
-        var props = show(dir);
-        var deferred = new uikitUtil.Deferred();
-
-        return {
+    function Transitioner(prev, next, dir, _ref) {let { animation, easing } = _ref;
+      const { percent, translate, show = uikitUtil.noop } = animation;
+      const props = show(dir);
+      const deferred = new uikitUtil.Deferred();
 
-            dir: dir,
+      return {
+        dir,
 
-            show: function(duration, percent, linear) {
-                var this$1$1 = this;
-                if ( percent === void 0 ) percent = 0;
+        show(duration, percent, linear) {if (percent === void 0) {percent = 0;}
+          const timing = linear ? 'linear' : easing;
+          duration -= Math.round(duration * uikitUtil.clamp(percent, -1, 1));
 
+          this.translate(percent);
 
-                var timing = linear ? 'linear' : easing;
-                duration -= Math.round(duration * uikitUtil.clamp(percent, -1, 1));
+          triggerUpdate(next, 'itemin', { percent, duration, timing, dir });
+          triggerUpdate(prev, 'itemout', { percent: 1 - percent, duration, timing, dir });
 
-                this.translate(percent);
+          Promise.all([
+          uikitUtil.Transition.start(next, props[1], duration, timing),
+          uikitUtil.Transition.start(prev, props[0], duration, timing)]).
+          then(() => {
+            this.reset();
+            deferred.resolve();
+          }, uikitUtil.noop);
 
-                triggerUpdate(next, 'itemin', {percent: percent, duration: duration, timing: timing, dir: dir});
-                triggerUpdate(prev, 'itemout', {percent: 1 - percent, duration: duration, timing: timing, dir: dir});
-
-                uikitUtil.Promise.all([
-                    uikitUtil.Transition.start(next, props[1], duration, timing),
-                    uikitUtil.Transition.start(prev, props[0], duration, timing)
-                ]).then(function () {
-                    this$1$1.reset();
-                    deferred.resolve();
-                }, uikitUtil.noop);
-
-                return deferred.promise;
-            },
-
-            cancel: function() {
-                uikitUtil.Transition.cancel([next, prev]);
-            },
-
-            reset: function() {
-                for (var prop in props[0]) {
-                    uikitUtil.css([next, prev], prop, '');
-                }
-            },
-
-            forward: function(duration, percent) {
-                if ( percent === void 0 ) percent = this.percent();
-
-                uikitUtil.Transition.cancel([next, prev]);
-                return this.show(duration, percent, true);
-            },
-
-            translate: function(percent) {
-
-                this.reset();
-
-                var props = translate(percent, dir);
-                uikitUtil.css(next, props[1]);
-                uikitUtil.css(prev, props[0]);
-                triggerUpdate(next, 'itemtranslatein', {percent: percent, dir: dir});
-                triggerUpdate(prev, 'itemtranslateout', {percent: 1 - percent, dir: dir});
-
-            },
-
-            percent: function() {
-                return percent(prev || next, next, dir);
-            },
-
-            getDistance: function() {
-                return prev && prev.offsetWidth;
-            }
-
-        };
-
-    }
-
-    function triggerUpdate(el, type, data) {
-        uikitUtil.trigger(el, uikitUtil.createEvent(type, false, false, data));
-    }
-
-    var SliderAutoplay = {
-
-        props: {
-            autoplay: Boolean,
-            autoplayInterval: Number,
-            pauseOnHover: Boolean
-        },
-
-        data: {
-            autoplay: false,
-            autoplayInterval: 7000,
-            pauseOnHover: true
+          return deferred.promise;
         },
 
-        connected: function() {
-            this.autoplay && this.startAutoplay();
+        cancel() {
+          uikitUtil.Transition.cancel([next, prev]);
         },
 
-        disconnected: function() {
-            this.stopAutoplay();
+        reset() {
+          for (const prop in props[0]) {
+            uikitUtil.css([next, prev], prop, '');
+          }
         },
 
-        update: function() {
-            uikitUtil.attr(this.slides, 'tabindex', '-1');
+        forward(duration, percent) {if (percent === void 0) {percent = this.percent();}
+          uikitUtil.Transition.cancel([next, prev]);
+          return this.show(duration, percent, true);
         },
 
-        events: [
-
-            {
-
-                name: 'visibilitychange',
-
-                el: function() {
-                    return document;
-                },
+        translate(percent) {
+          this.reset();
 
-                filter: function() {
-                    return this.autoplay;
-                },
-
-                handler: function() {
-                    if (document.hidden) {
-                        this.stopAutoplay();
-                    } else {
-                        this.startAutoplay();
-                    }
-                }
+          const props = translate(percent, dir);
+          uikitUtil.css(next, props[1]);
+          uikitUtil.css(prev, props[0]);
+          triggerUpdate(next, 'itemtranslatein', { percent, dir });
+          triggerUpdate(prev, 'itemtranslateout', { percent: 1 - percent, dir });
+        },
 
-            }
+        percent() {
+          return percent(prev || next, next, dir);
+        },
 
-        ],
+        getDistance() {
+          return prev == null ? void 0 : prev.offsetWidth;
+        } };
 
-        methods: {
+    }
 
-            startAutoplay: function() {
-                var this$1$1 = this;
+    function triggerUpdate(el, type, data) {
+      uikitUtil.trigger(el, uikitUtil.createEvent(type, false, false, data));
+    }
 
+    var SliderAutoplay = {
+      props: {
+        autoplay: Boolean,
+        autoplayInterval: Number,
+        pauseOnHover: Boolean },
 
-                this.stopAutoplay();
 
-                this.interval = setInterval(
-                    function () { return (!this$1$1.draggable || !uikitUtil.$(':focus', this$1$1.$el))
-                        && (!this$1$1.pauseOnHover || !uikitUtil.matches(this$1$1.$el, ':hover'))
-                        && !this$1$1.stack.length
-                        && this$1$1.show('next'); },
-                    this.autoplayInterval
-                );
+      data: {
+        autoplay: false,
+        autoplayInterval: 7000,
+        pauseOnHover: true },
 
-            },
 
-            stopAutoplay: function() {
-                this.interval && clearInterval(this.interval);
-            }
+      connected() {
+        this.autoplay && this.startAutoplay();
+      },
 
-        }
+      disconnected() {
+        this.stopAutoplay();
+      },
 
-    };
+      update() {
+        uikitUtil.attr(this.slides, 'tabindex', '-1');
+      },
 
-    var SliderDrag = {
+      events: [
+      {
+        name: 'visibilitychange',
 
-        props: {
-            draggable: Boolean
+        el() {
+          return document;
         },
 
-        data: {
-            draggable: true,
-            threshold: 10
+        filter() {
+          return this.autoplay;
         },
 
-        created: function() {
-            var this$1$1 = this;
-
-
-            ['start', 'move', 'end'].forEach(function (key) {
-
-                var fn = this$1$1[key];
-                this$1$1[key] = function (e) {
+        handler() {
+          if (document.hidden) {
+            this.stopAutoplay();
+          } else {
+            this.startAutoplay();
+          }
+        } }],
 
-                    var pos = uikitUtil.getEventPos(e).x * (uikitUtil.isRtl ? -1 : 1);
 
-                    this$1$1.prevPos = pos !== this$1$1.pos ? this$1$1.pos : this$1$1.prevPos;
-                    this$1$1.pos = pos;
 
-                    fn(e);
-                };
+      methods: {
+        startAutoplay() {
+          this.stopAutoplay();
 
-            });
+          this.interval = setInterval(
+          () =>
+          (!this.draggable || !uikitUtil.$(':focus', this.$el)) && (
+          !this.pauseOnHover || !uikitUtil.matches(this.$el, ':hover')) &&
+          !this.stack.length &&
+          this.show('next'),
+          this.autoplayInterval);
 
         },
 
-        events: [
-
-            {
-
-                name: uikitUtil.pointerDown,
+        stopAutoplay() {
+          this.interval && clearInterval(this.interval);
+        } } };
 
-                delegate: function() {
-                    return this.selSlides;
-                },
-
-                handler: function(e) {
-
-                    if (!this.draggable
-                        || !uikitUtil.isTouch(e) && hasTextNodesOnly(e.target)
-                        || uikitUtil.closest(e.target, uikitUtil.selInput)
-                        || e.button > 0
-                        || this.length < 2
-                    ) {
-                        return;
-                    }
-
-                    this.start(e);
-                }
-
-            },
-
-            {
-                name: 'dragstart',
-
-                handler: function(e) {
-                    e.preventDefault();
-                }
-            }
-
-        ],
-
-        methods: {
-
-            start: function() {
-
-                this.drag = this.pos;
-
-                if (this._transitioner) {
+    var SliderDrag = {
+      props: {
+        draggable: Boolean },
 
-                    this.percent = this._transitioner.percent();
-                    this.drag += this._transitioner.getDistance() * this.percent * this.dir;
 
-                    this._transitioner.cancel();
-                    this._transitioner.translate(this.percent);
+      data: {
+        draggable: true,
+        threshold: 10 },
 
-                    this.dragging = true;
 
-                    this.stack = [];
+      created() {
+        for (const key of ['start', 'move', 'end']) {
+          const fn = this[key];
+          this[key] = (e) => {
+            const pos = uikitUtil.getEventPos(e).x * (uikitUtil.isRtl ? -1 : 1);
 
-                } else {
-                    this.prevIndex = this.index;
-                }
+            this.prevPos = pos === this.pos ? this.prevPos : this.pos;
+            this.pos = pos;
 
-                uikitUtil.on(document, uikitUtil.pointerMove, this.move, {passive: false});
+            fn(e);
+          };
+        }
+      },
 
-                // 'input' event is triggered by video controls
-                uikitUtil.on(document, (uikitUtil.pointerUp + " " + uikitUtil.pointerCancel + " input"), this.end, true);
+      events: [
+      {
+        name: uikitUtil.pointerDown,
 
-                uikitUtil.css(this.list, 'userSelect', 'none');
+        delegate() {
+          return this.selSlides;
+        },
 
-            },
+        handler(e) {
+          if (
+          !this.draggable ||
+          !uikitUtil.isTouch(e) && hasTextNodesOnly(e.target) ||
+          uikitUtil.closest(e.target, uikitUtil.selInput) ||
+          e.button > 0 ||
+          this.length < 2)
+          {
+            return;
+          }
 
-            move: function(e) {
-                var this$1$1 = this;
+          this.start(e);
+        } },
 
 
-                var distance = this.pos - this.drag;
+      {
+        name: 'dragstart',
 
-                if (distance === 0 || this.prevPos === this.pos || !this.dragging && Math.abs(distance) < this.threshold) {
-                    return;
-                }
+        handler(e) {
+          e.preventDefault();
+        } }],
 
-                // prevent click event
-                uikitUtil.css(this.list, 'pointerEvents', 'none');
 
-                e.cancelable && e.preventDefault();
 
-                this.dragging = true;
-                this.dir = (distance < 0 ? 1 : -1);
+      methods: {
+        start() {
+          this.drag = this.pos;
 
-                var ref = this;
-                var slides = ref.slides;
-                var ref$1 = this;
-                var prevIndex = ref$1.prevIndex;
-                var dis = Math.abs(distance);
-                var nextIndex = this.getIndex(prevIndex + this.dir, prevIndex);
-                var width = this._getDistance(prevIndex, nextIndex) || slides[prevIndex].offsetWidth;
+          if (this._transitioner) {
+            this.percent = this._transitioner.percent();
+            this.drag += this._transitioner.getDistance() * this.percent * this.dir;
 
-                while (nextIndex !== prevIndex && dis > width) {
+            this._transitioner.cancel();
+            this._transitioner.translate(this.percent);
 
-                    this.drag -= width * this.dir;
+            this.dragging = true;
 
-                    prevIndex = nextIndex;
-                    dis -= width;
-                    nextIndex = this.getIndex(prevIndex + this.dir, prevIndex);
-                    width = this._getDistance(prevIndex, nextIndex) || slides[prevIndex].offsetWidth;
+            this.stack = [];
+          } else {
+            this.prevIndex = this.index;
+          }
 
-                }
+          uikitUtil.on(document, uikitUtil.pointerMove, this.move, { passive: false });
 
-                this.percent = dis / width;
+          // 'input' event is triggered by video controls
+          uikitUtil.on(document, uikitUtil.pointerUp + " " + uikitUtil.pointerCancel + " input", this.end, true);
 
-                var prev = slides[prevIndex];
-                var next = slides[nextIndex];
-                var changed = this.index !== nextIndex;
-                var edge = prevIndex === nextIndex;
+          uikitUtil.css(this.list, 'userSelect', 'none');
+        },
 
-                var itemShown;
+        move(e) {
+          const distance = this.pos - this.drag;
 
-                [this.index, this.prevIndex].filter(function (i) { return !uikitUtil.includes([nextIndex, prevIndex], i); }).forEach(function (i) {
-                    uikitUtil.trigger(slides[i], 'itemhidden', [this$1$1]);
+          if (
+          distance === 0 ||
+          this.prevPos === this.pos ||
+          !this.dragging && Math.abs(distance) < this.threshold)
+          {
+            return;
+          }
 
-                    if (edge) {
-                        itemShown = true;
-                        this$1$1.prevIndex = prevIndex;
-                    }
+          // prevent click event
+          uikitUtil.css(this.list, 'pointerEvents', 'none');
 
-                });
+          e.cancelable && e.preventDefault();
 
-                if (this.index === prevIndex && this.prevIndex !== prevIndex || itemShown) {
-                    uikitUtil.trigger(slides[this.index], 'itemshown', [this]);
-                }
+          this.dragging = true;
+          this.dir = distance < 0 ? 1 : -1;
 
-                if (changed) {
-                    this.prevIndex = prevIndex;
-                    this.index = nextIndex;
+          const { slides } = this;
+          let { prevIndex } = this;
+          let dis = Math.abs(distance);
+          let nextIndex = this.getIndex(prevIndex + this.dir, prevIndex);
+          let width = this._getDistance(prevIndex, nextIndex) || slides[prevIndex].offsetWidth;
 
-                    !edge && uikitUtil.trigger(prev, 'beforeitemhide', [this]);
-                    uikitUtil.trigger(next, 'beforeitemshow', [this]);
-                }
+          while (nextIndex !== prevIndex && dis > width) {
+            this.drag -= width * this.dir;
 
-                this._transitioner = this._translate(Math.abs(this.percent), prev, !edge && next);
+            prevIndex = nextIndex;
+            dis -= width;
+            nextIndex = this.getIndex(prevIndex + this.dir, prevIndex);
+            width = this._getDistance(prevIndex, nextIndex) || slides[prevIndex].offsetWidth;
+          }
 
-                if (changed) {
-                    !edge && uikitUtil.trigger(prev, 'itemhide', [this]);
-                    uikitUtil.trigger(next, 'itemshow', [this]);
-                }
+          this.percent = dis / width;
 
-            },
+          const prev = slides[prevIndex];
+          const next = slides[nextIndex];
+          const changed = this.index !== nextIndex;
+          const edge = prevIndex === nextIndex;
 
-            end: function() {
+          let itemShown;
 
-                uikitUtil.off(document, uikitUtil.pointerMove, this.move, {passive: false});
-                uikitUtil.off(document, (uikitUtil.pointerUp + " " + uikitUtil.pointerCancel + " input"), this.end, true);
+          [this.index, this.prevIndex].
+          filter((i) => !uikitUtil.includes([nextIndex, prevIndex], i)).
+          forEach((i) => {
+            uikitUtil.trigger(slides[i], 'itemhidden', [this]);
 
-                if (this.dragging) {
+            if (edge) {
+              itemShown = true;
+              this.prevIndex = prevIndex;
+            }
+          });
 
-                    this.dragging = null;
+          if (this.index === prevIndex && this.prevIndex !== prevIndex || itemShown) {
+            uikitUtil.trigger(slides[this.index], 'itemshown', [this]);
+          }
 
-                    if (this.index === this.prevIndex) {
-                        this.percent = 1 - this.percent;
-                        this.dir *= -1;
-                        this._show(false, this.index, true);
-                        this._transitioner = null;
-                    } else {
+          if (changed) {
+            this.prevIndex = prevIndex;
+            this.index = nextIndex;
 
-                        var dirChange = (uikitUtil.isRtl ? this.dir * (uikitUtil.isRtl ? 1 : -1) : this.dir) < 0 === this.prevPos > this.pos;
-                        this.index = dirChange ? this.index : this.prevIndex;
+            !edge && uikitUtil.trigger(prev, 'beforeitemhide', [this]);
+            uikitUtil.trigger(next, 'beforeitemshow', [this]);
+          }
 
-                        if (dirChange) {
-                            this.percent = 1 - this.percent;
-                        }
+          this._transitioner = this._translate(Math.abs(this.percent), prev, !edge && next);
 
-                        this.show(this.dir > 0 && !dirChange || this.dir < 0 && dirChange ? 'next' : 'previous', true);
-                    }
+          if (changed) {
+            !edge && uikitUtil.trigger(prev, 'itemhide', [this]);
+            uikitUtil.trigger(next, 'itemshow', [this]);
+          }
+        },
 
-                }
+        end() {
+          uikitUtil.off(document, uikitUtil.pointerMove, this.move, { passive: false });
+          uikitUtil.off(document, uikitUtil.pointerUp + " " + uikitUtil.pointerCancel + " input", this.end, true);
+
+          if (this.dragging) {
+            this.dragging = null;
+
+            if (this.index === this.prevIndex) {
+              this.percent = 1 - this.percent;
+              this.dir *= -1;
+              this._show(false, this.index, true);
+              this._transitioner = null;
+            } else {
+              const dirChange =
+              (uikitUtil.isRtl ? this.dir * (uikitUtil.isRtl ? 1 : -1) : this.dir) < 0 ===
+              this.prevPos > this.pos;
+              this.index = dirChange ? this.index : this.prevIndex;
+
+              if (dirChange) {
+                this.percent = 1 - this.percent;
+              }
+
+              this.show(
+              this.dir > 0 && !dirChange || this.dir < 0 && dirChange ?
+              'next' :
+              'previous',
+              true);
 
-                uikitUtil.css(this.list, {userSelect: '', pointerEvents: ''});
+            }
+          }
 
-                this.drag
-                    = this.percent
-                    = null;
+          uikitUtil.css(this.list, { userSelect: '', pointerEvents: '' });
 
-            }
+          this.drag = this.percent = null;
+        } } };
 
-        }
 
-    };
 
     function hasTextNodesOnly(el) {
-        return !el.children.length && el.childNodes.length;
+      return !el.children.length && el.childNodes.length;
     }
 
     var SliderNav = {
+      data: {
+        selNav: false },
 
-        data: {
-            selNav: false
-        },
-
-        computed: {
-
-            nav: function(ref, $el) {
-                var selNav = ref.selNav;
-
-                return uikitUtil.$(selNav, $el);
-            },
-
-            selNavItem: function(ref) {
-                var attrItem = ref.attrItem;
-
-                return ("[" + attrItem + "],[data-" + attrItem + "]");
-            },
-
-            navItems: function(_, $el) {
-                return uikitUtil.$$(this.selNavItem, $el);
-            }
 
+      computed: {
+        nav(_ref, $el) {let { selNav } = _ref;
+          return uikitUtil.$(selNav, $el);
         },
 
-        update: {
-
-            write: function() {
-                var this$1$1 = this;
-
-
-                if (this.nav && this.length !== this.nav.children.length) {
-                    uikitUtil.html(this.nav, this.slides.map(function (_, i) { return ("<li " + (this$1$1.attrItem) + "=\"" + i + "\"><a href></a></li>"); }).join(''));
-                }
-
-                this.navItems.concat(this.nav).forEach(function (el) { return el && (el.hidden = !this$1$1.maxIndex); });
-
-                this.updateNav();
-
-            },
-
-            events: ['resize']
-
+        selNavItem(_ref2) {let { attrItem } = _ref2;
+          return "[" + attrItem + "],[data-" + attrItem + "]";
         },
 
-        events: [
-
-            {
+        navItems(_, $el) {
+          return uikitUtil.$$(this.selNavItem, $el);
+        } },
 
-                name: 'click',
 
-                delegate: function() {
-                    return this.selNavItem;
-                },
+      update: {
+        write() {
+          if (this.nav && this.length !== this.nav.children.length) {
+            uikitUtil.html(
+            this.nav,
+            this.slides.
+            map((_, i) => "<li " + this.attrItem + "=\"" + i + "\"><a href></a></li>").
+            join(''));
 
-                handler: function(e) {
-                    e.preventDefault();
-                    this.show(uikitUtil.data(e.current, this.attrItem));
-                }
+          }
 
-            },
+          this.navItems.concat(this.nav).forEach((el) => el && (el.hidden = !this.maxIndex));
 
-            {
+          this.updateNav();
+        },
 
-                name: 'itemshow',
-                handler: 'updateNav'
+        events: ['resize'] },
 
-            }
 
-        ],
+      events: [
+      {
+        name: 'click',
 
-        methods: {
+        delegate() {
+          return this.selNavItem;
+        },
 
-            updateNav: function() {
-                var this$1$1 = this;
+        handler(e) {
+          e.preventDefault();
+          this.show(uikitUtil.data(e.current, this.attrItem));
+        } },
 
 
-                var i = this.getValidIndex();
-                this.navItems.forEach(function (el) {
+      {
+        name: 'itemshow',
+        handler: 'updateNav' }],
 
-                    var cmd = uikitUtil.data(el, this$1$1.attrItem);
 
-                    uikitUtil.toggleClass(el, this$1$1.clsActive, uikitUtil.toNumber(cmd) === i);
-                    uikitUtil.toggleClass(el, 'uk-invisible', this$1$1.finite && (cmd === 'previous' && i === 0 || cmd === 'next' && i >= this$1$1.maxIndex));
-                });
 
-            }
+      methods: {
+        updateNav() {
+          const i = this.getValidIndex();
+          for (const el of this.navItems) {
+            const cmd = uikitUtil.data(el, this.attrItem);
 
-        }
+            uikitUtil.toggleClass(el, this.clsActive, uikitUtil.toNumber(cmd) === i);
+            uikitUtil.toggleClass(
+            el,
+            'uk-invisible',
+            this.finite && (
+            cmd === 'previous' && i === 0 || cmd === 'next' && i >= this.maxIndex));
 
-    };
+          }
+        } } };
 
     var Slider = {
-
-        mixins: [SliderAutoplay, SliderDrag, SliderNav],
-
-        props: {
-            clsActivated: Boolean,
-            easing: String,
-            index: Number,
-            finite: Boolean,
-            velocity: Number,
-            selSlides: String
+      mixins: [SliderAutoplay, SliderDrag, SliderNav],
+
+      props: {
+        clsActivated: Boolean,
+        easing: String,
+        index: Number,
+        finite: Boolean,
+        velocity: Number,
+        selSlides: String },
+
+
+      data: () => ({
+        easing: 'ease',
+        finite: false,
+        velocity: 1,
+        index: 0,
+        prevIndex: -1,
+        stack: [],
+        percent: 0,
+        clsActive: 'uk-active',
+        clsActivated: false,
+        Transitioner: false,
+        transitionOptions: {} }),
+
+
+      connected() {
+        this.prevIndex = -1;
+        this.index = this.getValidIndex(this.$props.index);
+        this.stack = [];
+      },
+
+      disconnected() {
+        uikitUtil.removeClass(this.slides, this.clsActive);
+      },
+
+      computed: {
+        duration(_ref, $el) {let { velocity } = _ref;
+          return speedUp($el.offsetWidth / velocity);
         },
 
-        data: function () { return ({
-            easing: 'ease',
-            finite: false,
-            velocity: 1,
-            index: 0,
-            prevIndex: -1,
-            stack: [],
-            percent: 0,
-            clsActive: 'uk-active',
-            clsActivated: false,
-            Transitioner: false,
-            transitionOptions: {}
-        }); },
-
-        connected: function() {
-            this.prevIndex = -1;
-            this.index = this.getValidIndex(this.$props.index);
-            this.stack = [];
+        list(_ref2, $el) {let { selList } = _ref2;
+          return uikitUtil.$(selList, $el);
         },
 
-        disconnected: function() {
-            uikitUtil.removeClass(this.slides, this.clsActive);
+        maxIndex() {
+          return this.length - 1;
         },
 
-        computed: {
-
-            duration: function(ref, $el) {
-                var velocity = ref.velocity;
-
-                return speedUp($el.offsetWidth / velocity);
-            },
+        selSlides(_ref3) {let { selList, selSlides } = _ref3;
+          return selList + " " + (selSlides || '> *');
+        },
 
-            list: function(ref, $el) {
-                var selList = ref.selList;
+        slides: {
+          get() {
+            return uikitUtil.$$(this.selSlides, this.$el);
+          },
 
-                return uikitUtil.$(selList, $el);
-            },
+          watch() {
+            this.$reset();
+          } },
 
-            maxIndex: function() {
-                return this.length - 1;
-            },
 
-            selSlides: function(ref) {
-                var selList = ref.selList;
-                var selSlides = ref.selSlides;
+        length() {
+          return this.slides.length;
+        } },
 
-                return (selList + " " + (selSlides || '> *'));
-            },
 
-            slides: {
+      events: {
+        itemshown() {
+          this.$update(this.list);
+        } },
 
-                get: function() {
-                    return uikitUtil.$$(this.selSlides, this.$el);
-                },
 
-                watch: function() {
-                    this.$reset();
-                }
+      methods: {
+        show(index, force) {if (force === void 0) {force = false;}
+          if (this.dragging || !this.length) {
+            return;
+          }
 
-            },
+          const { stack } = this;
+          const queueIndex = force ? 0 : stack.length;
+          const reset = () => {
+            stack.splice(queueIndex, 1);
 
-            length: function() {
-                return this.slides.length;
+            if (stack.length) {
+              this.show(stack.shift(), true);
             }
+          };
 
-        },
-
-        events: {
+          stack[force ? 'unshift' : 'push'](index);
 
-            itemshown: function() {
-                this.$update(this.list);
+          if (!force && stack.length > 1) {
+            if (stack.length === 2) {
+              this._transitioner.forward(Math.min(this.duration, 200));
             }
 
-        },
-
-        methods: {
-
-            show: function(index, force) {
-                var this$1$1 = this;
-                if ( force === void 0 ) force = false;
-
-
-                if (this.dragging || !this.length) {
-                    return;
-                }
-
-                var ref = this;
-                var stack = ref.stack;
-                var queueIndex = force ? 0 : stack.length;
-                var reset = function () {
-                    stack.splice(queueIndex, 1);
-
-                    if (stack.length) {
-                        this$1$1.show(stack.shift(), true);
-                    }
-                };
-
-                stack[force ? 'unshift' : 'push'](index);
-
-                if (!force && stack.length > 1) {
-
-                    if (stack.length === 2) {
-                        this._transitioner.forward(Math.min(this.duration, 200));
-                    }
-
-                    return;
-                }
-
-                var prevIndex = this.getIndex(this.index);
-                var prev = uikitUtil.hasClass(this.slides, this.clsActive) && this.slides[prevIndex];
-                var nextIndex = this.getIndex(index, this.index);
-                var next = this.slides[nextIndex];
-
-                if (prev === next) {
-                    reset();
-                    return;
-                }
-
-                this.dir = getDirection(index, prevIndex);
-                this.prevIndex = prevIndex;
-                this.index = nextIndex;
-
-                if (prev && !uikitUtil.trigger(prev, 'beforeitemhide', [this])
-                    || !uikitUtil.trigger(next, 'beforeitemshow', [this, prev])
-                ) {
-                    this.index = this.prevIndex;
-                    reset();
-                    return;
+            return;
+          }
+
+          const prevIndex = this.getIndex(this.index);
+          const prev = uikitUtil.hasClass(this.slides, this.clsActive) && this.slides[prevIndex];
+          const nextIndex = this.getIndex(index, this.index);
+          const next = this.slides[nextIndex];
+
+          if (prev === next) {
+            reset();
+            return;
+          }
+
+          this.dir = getDirection(index, prevIndex);
+          this.prevIndex = prevIndex;
+          this.index = nextIndex;
+
+          if (
+          prev && !uikitUtil.trigger(prev, 'beforeitemhide', [this]) ||
+          !uikitUtil.trigger(next, 'beforeitemshow', [this, prev]))
+          {
+            this.index = this.prevIndex;
+            reset();
+            return;
+          }
+
+          const promise = this._show(prev, next, force).then(() => {
+            prev && uikitUtil.trigger(prev, 'itemhidden', [this]);
+            uikitUtil.trigger(next, 'itemshown', [this]);
+
+            return new Promise((resolve) => {
+              uikitUtil.fastdom.write(() => {
+                stack.shift();
+                if (stack.length) {
+                  this.show(stack.shift(), true);
+                } else {
+                  this._transitioner = null;
                 }
+                resolve();
+              });
+            });
+          });
 
-                var promise = this._show(prev, next, force).then(function () {
-
-                    prev && uikitUtil.trigger(prev, 'itemhidden', [this$1$1]);
-                    uikitUtil.trigger(next, 'itemshown', [this$1$1]);
-
-                    return new uikitUtil.Promise(function (resolve) {
-                        uikitUtil.fastdom.write(function () {
-                            stack.shift();
-                            if (stack.length) {
-                                this$1$1.show(stack.shift(), true);
-                            } else {
-                                this$1$1._transitioner = null;
-                            }
-                            resolve();
-                        });
-                    });
+          prev && uikitUtil.trigger(prev, 'itemhide', [this]);
+          uikitUtil.trigger(next, 'itemshow', [this]);
 
-                });
+          return promise;
+        },
 
-                prev && uikitUtil.trigger(prev, 'itemhide', [this]);
-                uikitUtil.trigger(next, 'itemshow', [this]);
+        getIndex(index, prev) {if (index === void 0) {index = this.index;}if (prev === void 0) {prev = this.index;}
+          return uikitUtil.clamp(uikitUtil.getIndex(index, this.slides, prev, this.finite), 0, this.maxIndex);
+        },
 
-                return promise;
+        getValidIndex(index, prevIndex) {if (index === void 0) {index = this.index;}if (prevIndex === void 0) {prevIndex = this.prevIndex;}
+          return this.getIndex(index, prevIndex);
+        },
 
-            },
+        _show(prev, next, force) {
+          this._transitioner = this._getTransitioner(prev, next, this.dir, {
+            easing: force ?
+            next.offsetWidth < 600 ?
+            'cubic-bezier(0.25, 0.46, 0.45, 0.94)' /* easeOutQuad */ :
+            'cubic-bezier(0.165, 0.84, 0.44, 1)' /* easeOutQuart */ :
+            this.easing,
+            ...this.transitionOptions });
 
-            getIndex: function(index, prev) {
-                if ( index === void 0 ) index = this.index;
-                if ( prev === void 0 ) prev = this.index;
 
-                return uikitUtil.clamp(uikitUtil.getIndex(index, this.slides, prev, this.finite), 0, this.maxIndex);
-            },
+          if (!force && !prev) {
+            this._translate(1);
+            return Promise.resolve();
+          }
 
-            getValidIndex: function(index, prevIndex) {
-                if ( index === void 0 ) index = this.index;
-                if ( prevIndex === void 0 ) prevIndex = this.prevIndex;
+          const { length } = this.stack;
+          return this._transitioner[length > 1 ? 'forward' : 'show'](
+          length > 1 ? Math.min(this.duration, 75 + 75 / (length - 1)) : this.duration,
+          this.percent);
 
-                return this.getIndex(index, prevIndex);
-            },
+        },
 
-            _show: function(prev, next, force) {
+        _getDistance(prev, next) {
+          return this._getTransitioner(prev, prev !== next && next).getDistance();
+        },
 
-                this._transitioner = this._getTransitioner(
-                    prev,
-                    next,
-                    this.dir,
-                    uikitUtil.assign({
-                        easing: force
-                            ? next.offsetWidth < 600
-                                ? 'cubic-bezier(0.25, 0.46, 0.45, 0.94)' /* easeOutQuad */
-                                : 'cubic-bezier(0.165, 0.84, 0.44, 1)' /* easeOutQuart */
-                            : this.easing
-                    }, this.transitionOptions)
-                );
+        _translate(percent, prev, next) {if (prev === void 0) {prev = this.prevIndex;}if (next === void 0) {next = this.index;}
+          const transitioner = this._getTransitioner(prev !== next ? prev : false, next);
+          transitioner.translate(percent);
+          return transitioner;
+        },
 
-                if (!force && !prev) {
-                    this._translate(1);
-                    return uikitUtil.Promise.resolve();
-                }
+        _getTransitioner(
+        prev,
+        next,
+        dir,
+        options)
+        {if (prev === void 0) {prev = this.prevIndex;}if (next === void 0) {next = this.index;}if (dir === void 0) {dir = this.dir || 1;}if (options === void 0) {options = this.transitionOptions;}
+          return new this.Transitioner(
+          uikitUtil.isNumber(prev) ? this.slides[prev] : prev,
+          uikitUtil.isNumber(next) ? this.slides[next] : next,
+          dir * (uikitUtil.isRtl ? -1 : 1),
+          options);
 
-                var ref = this.stack;
-                var length = ref.length;
-                return this._transitioner[length > 1 ? 'forward' : 'show'](length > 1 ? Math.min(this.duration, 75 + 75 / (length - 1)) : this.duration, this.percent);
-
-            },
-
-            _getDistance: function(prev, next) {
-                return this._getTransitioner(prev, prev !== next && next).getDistance();
-            },
-
-            _translate: function(percent, prev, next) {
-                if ( prev === void 0 ) prev = this.prevIndex;
-                if ( next === void 0 ) next = this.index;
-
-                var transitioner = this._getTransitioner(prev !== next ? prev : false, next);
-                transitioner.translate(percent);
-                return transitioner;
-            },
-
-            _getTransitioner: function(prev, next, dir, options) {
-                if ( prev === void 0 ) prev = this.prevIndex;
-                if ( next === void 0 ) next = this.index;
-                if ( dir === void 0 ) dir = this.dir || 1;
-                if ( options === void 0 ) options = this.transitionOptions;
-
-                return new this.Transitioner(
-                    uikitUtil.isNumber(prev) ? this.slides[prev] : prev,
-                    uikitUtil.isNumber(next) ? this.slides[next] : next,
-                    dir * (uikitUtil.isRtl ? -1 : 1),
-                    options
-                );
-            }
+        } } };
 
-        }
 
-    };
 
     function getDirection(index, prevIndex) {
-        return index === 'next'
-            ? 1
-            : index === 'previous'
-                ? -1
-                : index < prevIndex
-                    ? -1
-                    : 1;
+      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)
+      return 0.5 * x + 300; // parabola through (400,500; 600,600; 1800,1200)
     }
 
     var Slideshow = {
+      mixins: [Slider],
 
-        mixins: [Slider],
+      props: {
+        animation: String },
 
-        props: {
-            animation: String
-        },
-
-        data: {
-            animation: 'slide',
-            clsActivated: 'uk-transition-active',
-            Animations: Animations$1,
-            Transitioner: Transitioner
-        },
 
-        computed: {
+      data: {
+        animation: 'slide',
+        clsActivated: 'uk-transition-active',
+        Animations: Animations$1,
+        Transitioner },
 
-            animation: function(ref) {
-                var animation = ref.animation;
-                var Animations = ref.Animations;
-
-                return uikitUtil.assign(Animations[animation] || Animations.slide, {name: animation});
-            },
-
-            transitionOptions: function() {
-                return {animation: this.animation};
-            }
 
+      computed: {
+        animation(_ref) {let { animation, Animations } = _ref;
+          return { ...(Animations[animation] || Animations.slide), name: animation };
         },
 
-        events: {
-
-            'itemshow itemhide itemshown itemhidden': function(ref) {
-                var target = ref.target;
-
-                this.$update(target);
-            },
-
-            beforeitemshow: function(ref) {
-                var target = ref.target;
+        transitionOptions() {
+          return { animation: this.animation };
+        } },
 
-                uikitUtil.addClass(target, this.clsActive);
-            },
 
-            itemshown: function(ref) {
-                var target = ref.target;
-
-                uikitUtil.addClass(target, this.clsActivated);
-            },
-
-            itemhidden: function(ref) {
-                var target = ref.target;
+      events: {
+        'itemshow itemhide itemshown itemhidden'(_ref2) {let { target } = _ref2;
+          this.$update(target);
+        },
 
-                uikitUtil.removeClass(target, this.clsActive, this.clsActivated);
-            }
+        beforeitemshow(_ref3) {let { target } = _ref3;
+          uikitUtil.addClass(target, this.clsActive);
+        },
 
-        }
+        itemshown(_ref4) {let { target } = _ref4;
+          uikitUtil.addClass(target, this.clsActivated);
+        },
 
-    };
+        itemhidden(_ref5) {let { target } = _ref5;
+          uikitUtil.removeClass(target, this.clsActive, this.clsActivated);
+        } } };
 
     var LightboxPanel = {
+      mixins: [Container, Modal, Togglable, Slideshow],
 
-        mixins: [Container, Modal, Togglable, Slideshow],
+      functional: true,
 
-        functional: true,
+      props: {
+        delayControls: Number,
+        preload: Number,
+        videoAutoplay: Boolean,
+        template: String },
 
-        props: {
-            delayControls: Number,
-            preload: Number,
-            videoAutoplay: Boolean,
-            template: String
-        },
 
-        data: function () { return ({
-            preload: 1,
-            videoAutoplay: false,
-            delayControls: 3000,
-            items: [],
-            cls: 'uk-open',
-            clsPage: 'uk-lightbox-page',
-            selList: '.uk-lightbox-items',
-            attrItem: 'uk-lightbox-item',
-            selClose: '.uk-close-large',
-            selCaption: '.uk-lightbox-caption',
-            pauseOnHover: false,
-            velocity: 2,
-            Animations: Animations,
-            template: "<div class=\"uk-lightbox uk-overflow-hidden\"> <ul class=\"uk-lightbox-items\"></ul> <div class=\"uk-lightbox-toolbar uk-position-top uk-text-right uk-transition-slide-top uk-transition-opaque\"> <button class=\"uk-lightbox-toolbar-icon uk-close-large\" type=\"button\" uk-close></button> </div> <a class=\"uk-lightbox-button uk-position-center-left uk-position-medium uk-transition-fade\" href uk-slidenav-previous uk-lightbox-item=\"previous\"></a> <a class=\"uk-lightbox-button uk-position-center-right uk-position-medium uk-transition-fade\" href uk-slidenav-next uk-lightbox-item=\"next\"></a> <div class=\"uk-lightbox-toolbar uk-lightbox-caption uk-position-bottom uk-text-center uk-transition-slide-bottom uk-transition-opaque\"></div> </div>"
-        }); },
-
-        created: function() {
-
-            var $el = uikitUtil.$(this.template);
-            var list = uikitUtil.$(this.selList, $el);
-            this.items.forEach(function () { return uikitUtil.append(list, '<li>'); });
-
-            this.$mount(uikitUtil.append(this.container, $el));
+      data: () => ({
+        preload: 1,
+        videoAutoplay: false,
+        delayControls: 3000,
+        items: [],
+        cls: 'uk-open',
+        clsPage: 'uk-lightbox-page',
+        selList: '.uk-lightbox-items',
+        attrItem: 'uk-lightbox-item',
+        selClose: '.uk-close-large',
+        selCaption: '.uk-lightbox-caption',
+        pauseOnHover: false,
+        velocity: 2,
+        Animations,
+        template: "<div class=\"uk-lightbox uk-overflow-hidden\"> <ul class=\"uk-lightbox-items\"></ul> <div class=\"uk-lightbox-toolbar uk-position-top uk-text-right uk-transition-slide-top uk-transition-opaque\"> <button class=\"uk-lightbox-toolbar-icon uk-close-large\" type=\"button\" uk-close></button> </div> <a class=\"uk-lightbox-button uk-position-center-left uk-position-medium uk-transition-fade\" href uk-slidenav-previous uk-lightbox-item=\"previous\"></a> <a class=\"uk-lightbox-button uk-position-center-right uk-position-medium uk-transition-fade\" href uk-slidenav-next uk-lightbox-item=\"next\"></a> <div class=\"uk-lightbox-toolbar uk-lightbox-caption uk-position-bottom uk-text-center uk-transition-slide-bottom uk-transition-opaque\"></div> </div>" }),
 
-        },
 
-        computed: {
 
-            caption: function(ref, $el) {
-                var selCaption = ref.selCaption;
 
-                return uikitUtil.$(selCaption, $el);
-            }
 
-        },
 
-        events: [
 
-            {
 
-                name: (uikitUtil.pointerMove + " " + uikitUtil.pointerDown + " keydown"),
 
-                handler: 'showControls'
 
-            },
+      created() {
+        const $el = uikitUtil.$(this.template);
+        const list = uikitUtil.$(this.selList, $el);
+        this.items.forEach(() => uikitUtil.append(list, '<li>'));
 
-            {
+        this.$mount(uikitUtil.append(this.container, $el));
+      },
 
-                name: 'click',
+      computed: {
+        caption(_ref, $el) {let { selCaption } = _ref;
+          return uikitUtil.$(selCaption, $el);
+        } },
 
-                self: true,
 
-                delegate: function() {
-                    return this.selSlides;
-                },
+      events: [
+      {
+        name: uikitUtil.pointerMove + " " + uikitUtil.pointerDown + " keydown",
 
-                handler: function(e) {
+        handler: 'showControls' },
 
-                    if (e.defaultPrevented) {
-                        return;
-                    }
 
-                    this.hide();
-                }
+      {
+        name: 'click',
 
-            },
+        self: true,
 
-            {
+        delegate() {
+          return this.selSlides;
+        },
 
-                name: 'shown',
+        handler(e) {
+          if (e.defaultPrevented) {
+            return;
+          }
 
-                self: true,
+          this.hide();
+        } },
 
-                handler: function() {
-                    this.showControls();
-                }
 
-            },
+      {
+        name: 'shown',
 
-            {
+        self: true,
 
-                name: 'hide',
+        handler() {
+          this.showControls();
+        } },
 
-                self: true,
 
-                handler: function() {
+      {
+        name: 'hide',
 
-                    this.hideControls();
+        self: true,
 
-                    uikitUtil.removeClass(this.slides, this.clsActive);
-                    uikitUtil.Transition.stop(this.slides);
+        handler() {
+          this.hideControls();
 
-                }
-            },
+          uikitUtil.removeClass(this.slides, this.clsActive);
+          uikitUtil.Transition.stop(this.slides);
+        } },
 
-            {
 
-                name: 'hidden',
+      {
+        name: 'hidden',
 
-                self: true,
+        self: true,
 
-                handler: function() {
-                    this.$destroy(true);
-                }
-
-            },
+        handler() {
+          this.$destroy(true);
+        } },
 
-            {
 
-                name: 'keyup',
+      {
+        name: 'keyup',
 
-                el: function() {
-                    return document;
-                },
-
-                handler: function(e) {
+        el() {
+          return document;
+        },
 
-                    if (!this.isToggled(this.$el) || !this.draggable) {
-                        return;
-                    }
+        handler(e) {
+          if (!this.isToggled(this.$el) || !this.draggable) {
+            return;
+          }
 
-                    switch (e.keyCode) {
-                        case 37:
-                            this.show('previous');
-                            break;
-                        case 39:
-                            this.show('next');
-                            break;
-                    }
-                }
-            },
+          switch (e.keyCode) {
+            case 37:
+              this.show('previous');
+              break;
+            case 39:
+              this.show('next');
+              break;}
 
-            {
+        } },
 
-                name: 'beforeitemshow',
 
-                handler: function(e) {
+      {
+        name: 'beforeitemshow',
 
-                    if (this.isToggled()) {
-                        return;
-                    }
+        handler(e) {
+          if (this.isToggled()) {
+            return;
+          }
 
-                    this.draggable = false;
+          this.draggable = false;
 
-                    e.preventDefault();
+          e.preventDefault();
 
-                    this.toggleElement(this.$el, true, false);
+          this.toggleElement(this.$el, true, false);
 
-                    this.animation = Animations['scale'];
-                    uikitUtil.removeClass(e.target, this.clsActive);
-                    this.stack.splice(1, 0, this.index);
+          this.animation = Animations['scale'];
+          uikitUtil.removeClass(e.target, this.clsActive);
+          this.stack.splice(1, 0, this.index);
+        } },
 
-                }
 
-            },
+      {
+        name: 'itemshow',
 
-            {
+        handler() {
+          uikitUtil.html(this.caption, this.getItem().caption || '');
 
-                name: 'itemshow',
+          for (let j = -this.preload; j <= this.preload; j++) {
+            this.loadItem(this.index + j);
+          }
+        } },
 
-                handler: function() {
 
-                    uikitUtil.html(this.caption, this.getItem().caption || '');
+      {
+        name: 'itemshown',
 
-                    for (var j = -this.preload; j <= this.preload; j++) {
-                        this.loadItem(this.index + j);
-                    }
+        handler() {
+          this.draggable = this.$props.draggable;
+        } },
 
-                }
 
-            },
+      {
+        name: 'itemload',
 
-            {
+        async handler(_, item) {
+          const { source: src, type, alt = '', poster, attrs = {} } = item;
 
-                name: 'itemshown',
+          this.setItem(item, '<span uk-spinner></span>');
 
-                handler: function() {
-                    this.draggable = this.$props.draggable;
-                }
+          if (!src) {
+            return;
+          }
 
-            },
-
-            {
-
-                name: 'itemload',
-
-                handler: function(_, item) {
-                    var this$1$1 = this;
-
-
-                    var src = item.source;
-                    var type = item.type;
-                    var alt = item.alt; if ( alt === void 0 ) alt = '';
-                    var poster = item.poster;
-                    var attrs = item.attrs; if ( attrs === void 0 ) attrs = {};
-
-                    this.setItem(item, '<span uk-spinner></span>');
-
-                    if (!src) {
-                        return;
-                    }
-
-                    var matches;
-                    var iframeAttrs = {
-                        frameborder: '0',
-                        allow: 'autoplay',
-                        allowfullscreen: '',
-                        style: 'max-width: 100%; box-sizing: border-box;',
-                        'uk-responsive': '',
-                        'uk-video': ("" + (this.videoAutoplay))
-                    };
-
-                    // Image
-                    if (type === 'image' || src.match(/\.(avif|jpe?g|a?png|gif|svg|webp)($|\?)/i)) {
-
-                        uikitUtil.getImage(src, attrs.srcset, attrs.size).then(
-                            function (ref) {
-                                var width = ref.width;
-                                var height = ref.height;
-
-                                return this$1$1.setItem(item, createEl('img', uikitUtil.assign({src: src, width: width, height: height, alt: alt}, attrs)));
-                        },
-                            function () { return this$1$1.setError(item); }
-                        );
-
-                    // Video
-                    } else if (type === 'video' || src.match(/\.(mp4|webm|ogv)($|\?)/i)) {
-
-                        var video = createEl('video', uikitUtil.assign({
-                            src: src,
-                            poster: poster,
-                            controls: '',
-                            playsinline: '',
-                            'uk-video': ("" + (this.videoAutoplay))
-                        }, attrs));
-
-                        uikitUtil.on(video, 'loadedmetadata', function () {
-                            uikitUtil.attr(video, {width: video.videoWidth, height: video.videoHeight});
-                            this$1$1.setItem(item, video);
-                        });
-                        uikitUtil.on(video, 'error', function () { return this$1$1.setError(item); });
-
-                    // Iframe
-                    } else if (type === 'iframe' || src.match(/\.(html|php)($|\?)/i)) {
-
-                        this.setItem(item, createEl('iframe', uikitUtil.assign({
-                            src: src,
-                            frameborder: '0',
-                            allowfullscreen: '',
-                            class: 'uk-lightbox-iframe'
-                        }, attrs)));
-
-                    // YouTube
-                    } else if ((matches = src.match(/\/\/(?:.*?youtube(-nocookie)?\..*?[?&]v=|youtu\.be\/)([\w-]{11})[&?]?(.*)?/))) {
-
-                        this.setItem(item, createEl('iframe', uikitUtil.assign({
-                            src: ("https://www.youtube" + (matches[1] || '') + ".com/embed/" + (matches[2]) + (matches[3] ? ("?" + (matches[3])) : '')),
-                            width: 1920,
-                            height: 1080
-                        }, iframeAttrs, attrs)));
-
-                    // Vimeo
-                    } else if ((matches = src.match(/\/\/.*?vimeo\.[a-z]+\/(\d+)[&?]?(.*)?/))) {
-
-                        uikitUtil.ajax(("https://vimeo.com/api/oembed.json?maxwidth=1920&url=" + (encodeURI(src))), {
-                            responseType: 'json',
-                            withCredentials: false
-                        }).then(
-                            function (ref) {
-                                var ref_response = ref.response;
-                                var height = ref_response.height;
-                                var width = ref_response.width;
-
-                                return this$1$1.setItem(item, createEl('iframe', uikitUtil.assign({
-                                src: ("https://player.vimeo.com/video/" + (matches[1]) + (matches[2] ? ("?" + (matches[2])) : '')),
-                                width: width,
-                                height: height
-                            }, iframeAttrs, attrs)));
-                        },
-                            function () { return this$1$1.setError(item); }
-                        );
-
-                    }
+          let matches;
+          const iframeAttrs = {
+            frameborder: '0',
+            allow: 'autoplay',
+            allowfullscreen: '',
+            style: 'max-width: 100%; box-sizing: border-box;',
+            'uk-responsive': '',
+            'uk-video': "" + this.videoAutoplay };
 
-                }
 
+          // Image
+          if (type === 'image' || src.match(/\.(avif|jpe?g|a?png|gif|svg|webp)($|\?)/i)) {
+            try {
+              const { width, height } = await uikitUtil.getImage(src, attrs.srcset, attrs.size);
+              this.setItem(item, createEl('img', { src, width, height, alt, ...attrs }));
+            } catch (e) {
+              this.setError(item);
             }
 
-        ],
+            // Video
+          } else if (type === 'video' || src.match(/\.(mp4|webm|ogv)($|\?)/i)) {
+            const video = createEl('video', {
+              src,
+              poster,
+              controls: '',
+              playsinline: '',
+              'uk-video': "" + this.videoAutoplay,
+              ...attrs });
 
-        methods: {
 
-            loadItem: function(index) {
-                if ( index === void 0 ) index = this.index;
+            uikitUtil.on(video, 'loadedmetadata', () => {
+              uikitUtil.attr(video, { width: video.videoWidth, height: video.videoHeight });
+              this.setItem(item, video);
+            });
+            uikitUtil.on(video, 'error', () => this.setError(item));
 
+            // Iframe
+          } else if (type === 'iframe' || src.match(/\.(html|php)($|\?)/i)) {
+            this.setItem(
+            item,
+            createEl('iframe', {
+              src,
+              frameborder: '0',
+              allowfullscreen: '',
+              class: 'uk-lightbox-iframe',
+              ...attrs }));
 
-                var item = this.getItem(index);
 
-                if (!this.getSlide(item).childElementCount) {
-                    uikitUtil.trigger(this.$el, 'itemload', [item]);
-                }
-            },
 
-            getItem: function(index) {
-                if ( index === void 0 ) index = this.index;
+            // YouTube
+          } else if (
+          matches = src.match(
+          /\/\/(?:.*?youtube(-nocookie)?\..*?[?&]v=|youtu\.be\/)([\w-]{11})[&?]?(.*)?/))
 
-                return this.items[uikitUtil.getIndex(index, this.slides)];
-            },
+          {
+            this.setItem(
+            item,
+            createEl('iframe', {
+              src: "https://www.youtube" + (matches[1] || '') + ".com/embed/" + matches[2] + (
+              matches[3] ? "?" + matches[3] : ''),
 
-            setItem: function(item, content) {
-                uikitUtil.trigger(this.$el, 'itemloaded', [this, uikitUtil.html(this.getSlide(item), content) ]);
-            },
+              width: 1920,
+              height: 1080,
+              ...iframeAttrs,
+              ...attrs }));
 
-            getSlide: function(item) {
-                return this.slides[this.items.indexOf(item)];
-            },
 
-            setError: function(item) {
-                this.setItem(item, '<span uk-icon="icon: bolt; ratio: 2"></span>');
-            },
 
-            showControls: function() {
+            // Vimeo
+          } else if (matches = src.match(/\/\/.*?vimeo\.[a-z]+\/(\d+)[&?]?(.*)?/)) {
+            try {
+              const { height, width } = await (
+              await fetch("https://vimeo.com/api/oembed.json?maxwidth=1920&url=" +
+              encodeURI(
+              src),
 
-                clearTimeout(this.controlsTimer);
-                this.controlsTimer = setTimeout(this.hideControls, this.delayControls);
+              {
+                credentials: 'omit' })).
 
-                uikitUtil.addClass(this.$el, 'uk-active', 'uk-transition-active');
 
-            },
+              json();
 
-            hideControls: function() {
-                uikitUtil.removeClass(this.$el, 'uk-active', 'uk-transition-active');
-            }
+              this.setItem(
+              item,
+              createEl('iframe', {
+                src: "https://player.vimeo.com/video/" + matches[1] + (
+                matches[2] ? "?" + matches[2] : ''),
 
-        }
+                width,
+                height,
+                ...iframeAttrs,
+                ...attrs }));
 
-    };
 
-    function createEl(tag, attrs) {
-        var el = uikitUtil.fragment(("<" + tag + ">"));
-        uikitUtil.attr(el, attrs);
-        return el;
-    }
-
-    var Component = {
+            } catch (e) {
+              this.setError(item);
+            }
+          }
+        } }],
 
-        install: install,
 
-        props: {toggle: String},
 
-        data: {toggle: 'a'},
+      methods: {
+        loadItem(index) {if (index === void 0) {index = this.index;}
+          const item = this.getItem(index);
 
-        computed: {
+          if (!this.getSlide(item).childElementCount) {
+            uikitUtil.trigger(this.$el, 'itemload', [item]);
+          }
+        },
 
-            toggles: {
+        getItem(index) {if (index === void 0) {index = this.index;}
+          return this.items[uikitUtil.getIndex(index, this.slides)];
+        },
 
-                get: function(ref, $el) {
-                    var toggle = ref.toggle;
+        setItem(item, content) {
+          uikitUtil.trigger(this.$el, 'itemloaded', [this, uikitUtil.html(this.getSlide(item), content)]);
+        },
 
-                    return uikitUtil.$$(toggle, $el);
-                },
+        getSlide(item) {
+          return this.slides[this.items.indexOf(item)];
+        },
 
-                watch: function() {
-                    this.hide();
-                }
+        setError(item) {
+          this.setItem(item, '<span uk-icon="icon: bolt; ratio: 2"></span>');
+        },
 
-            }
+        showControls() {
+          clearTimeout(this.controlsTimer);
+          this.controlsTimer = setTimeout(this.hideControls, this.delayControls);
 
+          uikitUtil.addClass(this.$el, 'uk-active', 'uk-transition-active');
         },
 
-        disconnected: function() {
-            this.hide();
-        },
+        hideControls() {
+          uikitUtil.removeClass(this.$el, 'uk-active', 'uk-transition-active');
+        } } };
 
-        events: [
 
-            {
 
-                name: 'click',
+    function createEl(tag, attrs) {
+      const el = uikitUtil.fragment("<" + tag + ">");
+      uikitUtil.attr(el, attrs);
+      return el;
+    }
 
-                delegate: function() {
-                    return ((this.toggle) + ":not(.uk-disabled)");
-                },
+    var Component = {
+      install,
 
-                handler: function(e) {
-                    e.preventDefault();
-                    this.show(e.current);
-                }
+      props: { toggle: String },
 
-            }
+      data: { toggle: 'a' },
 
-        ],
+      computed: {
+        toggles: {
+          get(_ref, $el) {let { toggle } = _ref;
+            return uikitUtil.$$(toggle, $el);
+          },
 
-        methods: {
+          watch() {
+            this.hide();
+          } } },
 
-            show: function(index) {
-                var this$1$1 = this;
 
 
-                var items = uikitUtil.uniqueBy(this.toggles.map(toItem), 'source');
+      disconnected() {
+        this.hide();
+      },
 
-                if (uikitUtil.isElement(index)) {
-                    var ref = toItem(index);
-                    var source = ref.source;
-                    index = uikitUtil.findIndex(items, function (ref) {
-                        var src = ref.source;
+      events: [
+      {
+        name: 'click',
 
-                        return source === src;
-                    });
-                }
+        delegate() {
+          return this.toggle + ":not(.uk-disabled)";
+        },
 
-                this.panel = this.panel || this.$create('lightboxPanel', uikitUtil.assign({}, this.$props, {items: items}));
+        handler(e) {
+          e.preventDefault();
+          this.show(e.current);
+        } }],
 
-                uikitUtil.on(this.panel.$el, 'hidden', function () { return this$1$1.panel = false; });
 
-                return this.panel.show(index);
 
-            },
+      methods: {
+        show(index) {
+          const items = uikitUtil.uniqueBy(this.toggles.map(toItem), 'source');
 
-            hide: function() {
+          if (uikitUtil.isElement(index)) {
+            const { source } = toItem(index);
+            index = uikitUtil.findIndex(items, (_ref2) => {let { source: src } = _ref2;return source === src;});
+          }
 
-                return this.panel && this.panel.hide();
+          this.panel = this.panel || this.$create('lightboxPanel', { ...this.$props, items });
 
-            }
+          uikitUtil.on(this.panel.$el, 'hidden', () => this.panel = false);
 
-        }
+          return this.panel.show(index);
+        },
 
-    };
+        hide() {
+          return this.panel && this.panel.hide();
+        } } };
 
-    function install(UIkit, Lightbox) {
 
-        if (!UIkit.lightboxPanel) {
-            UIkit.component('lightboxPanel', LightboxPanel);
-        }
 
-        uikitUtil.assign(
-            Lightbox.props,
-            UIkit.component('lightboxPanel').options.props
-        );
+    function install(UIkit, Lightbox) {
+      if (!UIkit.lightboxPanel) {
+        UIkit.component('lightboxPanel', LightboxPanel);
+      }
 
+      uikitUtil.assign(Lightbox.props, UIkit.component('lightboxPanel').options.props);
     }
 
     function toItem(el) {
+      const item = {};
 
-        var item = {};
-
-        ['href', 'caption', 'type', 'poster', 'alt', 'attrs'].forEach(function (attr) {
-            item[attr === 'href' ? 'source' : attr] = uikitUtil.data(el, attr);
-        });
+      for (const attr of ['href', 'caption', 'type', 'poster', 'alt', 'attrs']) {
+        item[attr === 'href' ? 'source' : attr] = uikitUtil.data(el, attr);
+      }
 
-        item.attrs = uikitUtil.parseOptions(item.attrs);
+      item.attrs = uikitUtil.parseOptions(item.attrs);
 
-        return item;
+      return item;
     }
 
     if (typeof window !== 'undefined' && window.UIkit) {
-        window.UIkit.component('lightbox', Component);
+      window.UIkit.component('lightbox', Component);
     }
 
     return Component;