uikit 3.11.2-dev.03e47c2ff → 3.11.2-dev.06fe7f1d0

package/dist/js/uikit.js

@@ -1,4 +1,4 @@
-/*! UIkit 3.11.2-dev.03e47c2ff | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
+/*! UIkit 3.11.2-dev.06fe7f1d0 | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
 
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -1470,6 +1470,41 @@
       return { x: x1 + ua * (x2 - x1), y: y1 + ua * (y2 - y1) };
     }
 
+    // Old chromium based browsers (UC Browser) did not implement `isIntersecting`
+    const hasIntersectionObserver =
+    window.IntersectionObserver && 'isIntersecting' in IntersectionObserverEntry.prototype;
+    function observeIntersection(targets, cb, options, intersecting) {if (intersecting === void 0) {intersecting = true;}
+      if (!hasIntersectionObserver) {
+        return;
+      }
+
+      const observer = new IntersectionObserver((entries, observer) => {
+        if (!intersecting || entries.some((entry) => entry.isIntersecting)) {
+          cb(entries, observer);
+        }
+      }, options);
+      for (const el of toNodes(targets)) {
+        observer.observe(el);
+      }
+      return observer;
+    }
+
+    const hasResizeObserver = window.ResizeObserver;
+    function observeResize(targets, cb, options) {if (options === void 0) {options = { box: 'border-box' };}
+      if (!hasResizeObserver) {
+        return;
+      }
+
+      const observer = new ResizeObserver((entries, observer) => {
+        cb(entries, observer);
+      });
+      for (const el of toNodes(targets)) {
+        observer.observe(el, options);
+      }
+
+      return observer;
+    }
+
     const strats = {};
 
     strats.events =
@@ -2147,6 +2182,9 @@
         memoize: memoize,
         Deferred: Deferred,
         MouseTracker: MouseTracker,
+        hasIntersectionObserver: hasIntersectionObserver,
+        observeIntersection: observeIntersection,
+        observeResize: observeResize,
         mergeOptions: mergeOptions,
         parseOptions: parseOptions,
         play: play,
@@ -2324,8 +2362,8 @@
       };
 
       function runUpdates(types) {
-        for (const { read, write, events } of this.$options.update) {
-          if (!types.has('update') && (!events || !events.some((type) => types.has(type)))) {
+        for (const { read, write, events = [] } of this.$options.update) {
+          if (!types.has('update') && !events.some((type) => types.has(type))) {
             continue;
           }
 
@@ -2419,7 +2457,7 @@
       UIkit.prototype._initProps = function (props) {
         let key;
 
-        props = props || getProps(this.$options, this.$name);
+        props = props || getProps$1(this.$options, this.$name);
 
         for (key in props) {
           if (!isUndefined(props[key])) {
@@ -2446,204 +2484,236 @@
             }
           }
         }
+        for (const { events = [] } of this.$options.update || []) {
+          if (includes(events, 'scroll')) {
+            registerScrollListener(this._uid, () => this.$emit('scroll'));
+            break;
+          }
+        }
       };
 
       UIkit.prototype._unbindEvents = function () {
         this._events.forEach((unbind) => unbind());
         delete this._events;
+        unregisterScrollListener(this._uid);
       };
 
       UIkit.prototype._initObservers = function () {
         this._observers = [initChildListObserver(this), initPropsObserver(this)];
       };
 
+      UIkit.prototype.registerObserver = function (observer) {
+        this._observers.push(observer);
+      };
+
       UIkit.prototype._disconnectObservers = function () {
         this._observers.forEach((observer) => observer == null ? void 0 : observer.disconnect());
       };
+    }
 
-      function getProps(opts, name) {
-        const data$1 = {};
-        const { args = [], props = {}, el } = opts;
-
-        if (!props) {
-          return data$1;
-        }
+    function getProps$1(opts, name) {
+      const data$1 = {};
+      const { args = [], props = {}, el } = opts;
 
-        for (const key in props) {
-          const prop = hyphenate(key);
-          let value = data(el, prop);
+      if (!props) {
+        return data$1;
+      }
 
-          if (isUndefined(value)) {
-            continue;
-          }
+      for (const key in props) {
+        const prop = hyphenate(key);
+        let value = data(el, prop);
 
-          value = props[key] === Boolean && value === '' ? true : coerce(props[key], value);
+        if (isUndefined(value)) {
+          continue;
+        }
 
-          if (prop === 'target' && (!value || startsWith(value, '_'))) {
-            continue;
-          }
+        value = props[key] === Boolean && value === '' ? true : coerce(props[key], value);
 
-          data$1[key] = value;
+        if (prop === 'target' && (!value || startsWith(value, '_'))) {
+          continue;
         }
 
-        const options = parseOptions(data(el, name), args);
+        data$1[key] = value;
+      }
 
-        for (const key in options) {
-          const prop = camelize(key);
-          if (props[prop] !== undefined) {
-            data$1[prop] = coerce(props[prop], options[key]);
-          }
-        }
+      const options = parseOptions(data(el, name), args);
 
-        return data$1;
+      for (const key in options) {
+        const prop = camelize(key);
+        if (props[prop] !== undefined) {
+          data$1[prop] = coerce(props[prop], options[key]);
+        }
       }
 
-      function registerComputed(component, key, cb) {
-        Object.defineProperty(component, key, {
-          enumerable: true,
+      return data$1;
+    }
 
-          get() {
-            const { _computeds, $props, $el } = component;
+    function registerComputed(component, key, cb) {
+      Object.defineProperty(component, key, {
+        enumerable: true,
 
-            if (!hasOwn(_computeds, key)) {
-              _computeds[key] = (cb.get || cb).call(component, $props, $el);
-            }
+        get() {
+          const { _computeds, $props, $el } = component;
 
-            return _computeds[key];
-          },
+          if (!hasOwn(_computeds, key)) {
+            _computeds[key] = (cb.get || cb).call(component, $props, $el);
+          }
 
-          set(value) {
-            const { _computeds } = component;
+          return _computeds[key];
+        },
 
-            _computeds[key] = cb.set ? cb.set.call(component, value) : value;
+        set(value) {
+          const { _computeds } = component;
 
-            if (isUndefined(_computeds[key])) {
-              delete _computeds[key];
-            }
-          } });
+          _computeds[key] = cb.set ? cb.set.call(component, value) : value;
+
+          if (isUndefined(_computeds[key])) {
+            delete _computeds[key];
+          }
+        } });
 
+    }
+
+    function registerEvent(component, event, key) {
+      if (!isPlainObject(event)) {
+        event = { name: key, handler: event };
       }
 
-      function registerEvent(component, event, key) {
-        if (!isPlainObject(event)) {
-          event = { name: key, handler: event };
-        }
+      let { name, el, handler, capture, passive, delegate, filter, self } = event;
+      el = isFunction(el) ? el.call(component) : el || component.$el;
 
-        let { name, el, handler, capture, passive, delegate, filter, self } = event;
-        el = isFunction(el) ? el.call(component) : el || component.$el;
+      if (isArray(el)) {
+        el.forEach((el) => registerEvent(component, { ...event, el }, key));
+        return;
+      }
 
-        if (isArray(el)) {
-          el.forEach((el) => registerEvent(component, { ...event, el }, key));
-          return;
-        }
+      if (!el || filter && !filter.call(component)) {
+        return;
+      }
 
-        if (!el || filter && !filter.call(component)) {
-          return;
-        }
+      component._events.push(
+      on(
+      el,
+      name,
+      delegate ? isString(delegate) ? delegate : delegate.call(component) : null,
+      isString(handler) ? component[handler] : handler.bind(component),
+      { passive, capture, self }));
 
-        component._events.push(
-        on(
-        el,
-        name,
-        delegate ? isString(delegate) ? delegate : delegate.call(component) : null,
-        isString(handler) ? component[handler] : handler.bind(component),
-        { passive, capture, self }));
 
+    }
 
-      }
+    function notIn(options, key) {
+      return options.every((arr) => !arr || !hasOwn(arr, key));
+    }
 
-      function notIn(options, key) {
-        return options.every((arr) => !arr || !hasOwn(arr, key));
+    function coerce(type, value) {
+      if (type === Boolean) {
+        return toBoolean(value);
+      } else if (type === Number) {
+        return toNumber(value);
+      } else if (type === 'list') {
+        return toList(value);
       }
 
-      function coerce(type, value) {
-        if (type === Boolean) {
-          return toBoolean(value);
-        } else if (type === Number) {
-          return toNumber(value);
-        } else if (type === 'list') {
-          return toList(value);
-        }
+      return type ? type(value) : value;
+    }
 
-        return type ? type(value) : value;
+    function toList(value) {
+      return isArray(value) ?
+      value :
+      isString(value) ?
+      value.
+      split(/,(?![^(]*\))/).
+      map((value) => isNumeric(value) ? toNumber(value) : toBoolean(value.trim())) :
+      [value];
+    }
+
+    function normalizeData(_ref, _ref2) {let { data = {} } = _ref;let { args = [], props = {} } = _ref2;
+      if (isArray(data)) {
+        data = data.slice(0, args.length).reduce((data, value, index) => {
+          if (isPlainObject(value)) {
+            assign(data, value);
+          } else {
+            data[args[index]] = value;
+          }
+          return data;
+        }, {});
       }
 
-      function toList(value) {
-        return isArray(value) ?
-        value :
-        isString(value) ?
-        value.
-        split(/,(?![^(]*\))/).
-        map((value) => isNumeric(value) ? toNumber(value) : toBoolean(value.trim())) :
-        [value];
+      for (const key in data) {
+        if (isUndefined(data[key])) {
+          delete data[key];
+        } else if (props[key]) {
+          data[key] = coerce(props[key], data[key]);
+        }
       }
 
-      function normalizeData(_ref, _ref2) {let { data = {} } = _ref;let { args = [], props = {} } = _ref2;
-        if (isArray(data)) {
-          data = data.slice(0, args.length).reduce((data, value, index) => {
-            if (isPlainObject(value)) {
-              assign(data, value);
-            } else {
-              data[args[index]] = value;
-            }
-            return data;
-          }, {});
-        }
+      return data;
+    }
 
-        for (const key in data) {
-          if (isUndefined(data[key])) {
-            delete data[key];
-          } else if (props[key]) {
-            data[key] = coerce(props[key], data[key]);
-          }
-        }
+    function initChildListObserver(component) {
+      const { el } = component.$options;
 
-        return data;
-      }
+      const observer = new MutationObserver(() => component.$emit());
+      observer.observe(el, {
+        childList: true,
+        subtree: true });
 
-      function initChildListObserver(component) {
-        const { el } = component.$options;
 
-        const observer = new MutationObserver(() => component.$emit());
-        observer.observe(el, {
-          childList: true,
-          subtree: true });
+      return observer;
+    }
 
+    function initPropsObserver(component) {
+      const { $name, $options, $props } = component;
+      const { attrs, props, el } = $options;
 
-        return observer;
+      if (!props || attrs === false) {
+        return;
       }
 
-      function initPropsObserver(component) {
-        const { $name, $options, $props } = component;
-        const { attrs, props, el } = $options;
+      const attributes = isArray(attrs) ? attrs : Object.keys(props);
+      const filter = attributes.map((key) => hyphenate(key)).concat($name);
 
-        if (!props || attrs === false) {
-          return;
+      const observer = new MutationObserver((records) => {
+        const data = getProps$1($options, $name);
+        if (
+        records.some((_ref3) => {let { attributeName } = _ref3;
+          const prop = attributeName.replace('data-', '');
+          return (
+          prop === $name ? attributes : [camelize(prop), camelize(attributeName)]).
+          some((prop) => !isUndefined(data[prop]) && data[prop] !== $props[prop]);
+        }))
+        {
+          component.$reset();
         }
+      });
 
-        const attributes = isArray(attrs) ? attrs : Object.keys(props);
-        const filter = attributes.map((key) => hyphenate(key)).concat($name);
+      observer.observe(el, {
+        attributes: true,
+        attributeFilter: filter.concat(filter.map((key) => "data-" + key)) });
 
-        const observer = new MutationObserver((records) => {
-          const data = getProps($options, $name);
-          if (
-          records.some((_ref3) => {let { attributeName } = _ref3;
-            const prop = attributeName.replace('data-', '');
-            return (
-            prop === $name ? attributes : [camelize(prop), camelize(attributeName)]).
-            some((prop) => !isUndefined(data[prop]) && data[prop] !== $props[prop]);
-          }))
-          {
-            component.$reset();
-          }
-        });
 
-        observer.observe(el, {
-          attributes: true,
-          attributeFilter: filter.concat(filter.map((key) => "data-" + key)) });
+      return observer;
+    }
+
+    const scrollListeners = new Map();
+    let unbindScrollListener;
+    function registerScrollListener(id, listener) {
+      unbindScrollListener =
+      unbindScrollListener ||
+      on(window, 'scroll', () => scrollListeners.forEach((listener) => listener()), {
+        passive: true,
+        capture: true });
 
 
-        return observer;
+      scrollListeners.set(id, listener);
+    }
+
+    function unregisterScrollListener(id) {
+      scrollListeners.delete(id);
+      if (unbindScrollListener && !scrollListeners.size) {
+        unbindScrollListener();
+        unbindScrollListener = null;
       }
     }
 
@@ -2820,7 +2890,7 @@
     UIkit.data = '__uikit__';
     UIkit.prefix = 'uk-';
     UIkit.options = {};
-    UIkit.version = '3.11.2-dev.03e47c2ff';
+    UIkit.version = '3.11.2-dev.06fe7f1d0';
 
     globalAPI(UIkit);
     hooksAPI(UIkit);
@@ -2846,27 +2916,7 @@
 
       on(window, 'load resize', handleResize);
       on(document, 'loadedmetadata load', handleResize, true);
-
-      if ('ResizeObserver' in window) {
-        new ResizeObserver(handleResize).observe(document.documentElement);
-      }
-
-      // throttle `scroll` event (Safari triggers multiple `scroll` events per frame)
-      let pending;
-      on(
-      window,
-      'scroll',
-      (e) => {
-        if (pending) {
-          return;
-        }
-        pending = true;
-        fastdom.read(() => pending = false);
-
-        UIkit.update(null, e.type);
-      },
-      { passive: true, capture: true });
-
+      observeResize(document.documentElement, handleResize);
 
       let started = 0;
       on(
@@ -2885,45 +2935,6 @@
       },
       true);
 
-
-      on(
-      document,
-      pointerDown,
-      (e) => {
-        if (!isTouch(e)) {
-          return;
-        }
-
-        // Handle Swipe Gesture
-        const pos = getEventPos(e);
-        const target = 'tagName' in e.target ? e.target : parent(e.target);
-        once(document, pointerUp + " " + pointerCancel + " scroll", (e) => {
-          const { x, y } = getEventPos(e);
-
-          // swipe
-          if (
-          e.type !== 'scroll' && target && x && Math.abs(pos.x - x) > 100 ||
-          y && Math.abs(pos.y - y) > 100)
-          {
-            setTimeout(() => {
-              trigger(target, 'swipe');
-              trigger(target, "swipe" + swipeDirection(pos.x, pos.y, x, y));
-            });
-          }
-        });
-      },
-      { passive: true });
-
-    }
-
-    function swipeDirection(x1, y1, x2, y2) {
-      return Math.abs(x1 - x2) >= Math.abs(y1 - y2) ?
-      x1 - x2 > 0 ?
-      'Left' :
-      'Right' :
-      y1 - y2 > 0 ?
-      'Up' :
-      'Down';
     }
 
     function boot (UIkit) {
@@ -2988,6 +2999,23 @@
         !hasClass(this.$el, this.$name) && addClass(this.$el, this.$name);
       } };
 
+    var Lazyload = {
+      methods: {
+        lazyload(observeTargets, targets) {if (observeTargets === void 0) {observeTargets = this.$el;}if (targets === void 0) {targets = this.$el;}
+          this.registerObserver(
+          observeIntersection(observeTargets, (entries, observer) => {
+            for (const el of toNodes(isFunction(targets) ? targets() : targets)) {
+              $$('[loading="lazy"]', el).forEach((el) => removeAttr(el, 'loading'));
+            }
+            for (const el of entries.
+            filter((_ref) => {let { isIntersecting } = _ref;return isIntersecting;}).
+            map((_ref2) => {let { target } = _ref2;return target;})) {
+              observer.unobserve(el);
+            }
+          }));
+
+        } } };
+
     var Togglable = {
       props: {
         cls: Boolean,
@@ -3175,7 +3203,7 @@
     }
 
     var Accordion = {
-      mixins: [Class, Togglable],
+      mixins: [Class, Lazyload, Togglable],
 
       props: {
         targets: String,
@@ -3231,6 +3259,10 @@
         } },
 
 
+      connected() {
+        this.lazyload();
+      },
+
       events: [
       {
         name: 'click',
@@ -3366,6 +3398,8 @@
         if (this.automute) {
           mute(this.$el);
         }
+
+        this.registerObserver(observeIntersection(this.$el, () => this.$emit('resize')));
       },
 
       update: {
@@ -3402,6 +3436,10 @@
         automute: true },
 
 
+      connected() {
+        this.registerObserver(observeResize(this.$el, () => this.$emit('resize')));
+      },
+
       update: {
         read() {
           const el = this.$el;
@@ -3527,7 +3565,7 @@
     let active$1;
 
     var drop = {
-      mixins: [Container, Position, Togglable],
+      mixins: [Container, Lazyload, Position, Togglable],
 
       args: 'pos',
 
@@ -3581,6 +3619,7 @@
             mode: this.mode }).
           $el;
           attr(this.target, 'aria-haspopup', true);
+          this.lazyload(this.target);
         }
       },
 
@@ -3956,7 +3995,7 @@
         name: 'change',
 
         handler() {
-          this.$update();
+          this.$emit();
         } },
 
 
@@ -3968,7 +4007,7 @@
         },
 
         handler() {
-          this.$update();
+          this.$emit();
         } }] };
 
     // Deprecated
@@ -4325,6 +4364,8 @@
     }
 
     var heightViewport = {
+      mixins: [Class],
+
       props: {
         expand: Boolean,
         offsetTop: Boolean,
@@ -4784,7 +4825,6 @@
     }
 
     const nativeLazyLoad = ('loading' in HTMLImageElement.prototype);
-    const nativeIsIntersecting = ('isIntersecting' in IntersectionObserverEntry.prototype); // Old chromium based browsers (UC Browser) did not implement `isIntersecting`
 
     var img = {
       args: 'dataSrc',
@@ -4814,13 +4854,13 @@
           },
 
           watch() {
-            this.observe();
+            this.$reset();
           } } },
 
 
 
       connected() {
-        if (this.loading !== 'lazy' || !window.IntersectionObserver || !nativeIsIntersecting) {
+        if (this.loading !== 'lazy' || !hasIntersectionObserver) {
           this.load();
           return;
         }
@@ -4836,28 +4876,27 @@
 
         ensureSrcAttribute(this.$el);
 
-        const rootMargin = toPx(this.offsetTop, 'height') + "px " + toPx(
-        this.offsetLeft,
-        'width') + "px";
-
-        this.observer = new IntersectionObserver(
-        (entries) => {
-          if (entries.some((entry) => entry.isIntersecting)) {
-            this.load();
-            this.observer.disconnect();
-          }
+        this.registerObserver(
+        observeIntersection(
+        this.target,
+        (entries, observer) => {
+          this.load();
+          observer.disconnect();
         },
-        { rootMargin });
+        {
+          rootMargin: toPx(this.offsetTop, 'height') + "px " + toPx(
+          this.offsetLeft,
+          'width') + "px" }));
+
+
+
 
-        this.observe();
       },
 
-      disconnected() {var _this$observer;
+      disconnected() {
         if (this._data.image) {
           this._data.image.onload = '';
         }
-
-        (_this$observer = this.observer) == null ? void 0 : _this$observer.disconnect();
       },
 
       update: {
@@ -4892,14 +4931,6 @@
           removeAttr(image, 'loading');
           setSrcAttrs(this.$el, image.currentSrc);
           return this._data.image = image;
-        },
-
-        observe() {
-          if (this._connected && !this._data.image) {
-            for (const el of this.target) {
-              this.observer.observe(el);
-            }
-          }
         } } };
 
 
@@ -5923,8 +5954,69 @@
       RIGHT: 39,
       DOWN: 40 };
 
+    var Swipe = {
+      props: {
+        swiping: Boolean },
+
+
+      data: {
+        swiping: true },
+
+
+      computed: {
+        swipeTarget(props, $el) {
+          return $el;
+        } },
+
+
+      connected() {
+        if (!this.swiping) {
+          return;
+        }
+
+        registerEvent(this, {
+          el: this.swipeTarget,
+          name: pointerDown,
+          passive: true,
+          handler(e) {
+            if (!isTouch(e)) {
+              return;
+            }
+
+            // Handle Swipe Gesture
+            const pos = getEventPos(e);
+            const target = 'tagName' in e.target ? e.target : parent(e.target);
+            once(document, pointerUp + " " + pointerCancel + " scroll", (e) => {
+              const { x, y } = getEventPos(e);
+
+              // swipe
+              if (
+              e.type !== 'scroll' && target && x && Math.abs(pos.x - x) > 100 ||
+              y && Math.abs(pos.y - y) > 100)
+              {
+                setTimeout(() => {
+                  trigger(target, 'swipe');
+                  trigger(target, "swipe" + swipeDirection(pos.x, pos.y, x, y));
+                });
+              }
+            });
+          } });
+
+      } };
+
+
+    function swipeDirection(x1, y1, x2, y2) {
+      return Math.abs(x1 - x2) >= Math.abs(y1 - y2) ?
+      x1 - x2 > 0 ?
+      'Left' :
+      'Right' :
+      y1 - y2 > 0 ?
+      'Up' :
+      'Down';
+    }
+
     var offcanvas = {
-      mixins: [Modal],
+      mixins: [Modal, Swipe],
 
       args: 'mode',
 
@@ -6557,34 +6649,29 @@
           return window;
         },
 
+        filter() {
+          return this.targetOffset !== false;
+        },
+
         handler() {
-          if (!(this.targetOffset !== false && location.hash && scrollTop(window) > 0)) {
+          if (!location.hash || scrollTop(window) === 0) {
             return;
           }
 
-          const target = $(location.hash);
+          fastdom.read(() => {
+            const targetOffset = offset($(location.hash));
+            const elOffset = offset(this.$el);
 
-          if (target) {
-            fastdom.read(() => {
-              const { top } = offset(target);
-              const elTop = offset(this.$el).top;
-              const elHeight = this.$el.offsetHeight;
+            if (this.isFixed && intersectRect(targetOffset, elOffset)) {
+              scrollTop(
+              window,
+              targetOffset.top -
+              elOffset.height -
+              toPx(this.targetOffset, 'height') -
+              toPx(this.offset, 'height'));
 
-              if (
-              this.isFixed &&
-              elTop + elHeight >= top &&
-              elTop <= top + target.offsetHeight)
-              {
-                scrollTop(
-                window,
-                top -
-                elHeight - (
-                isNumeric(this.targetOffset) ? this.targetOffset : 0) -
-                this._data.offset);
-
-              }
-            });
-          }
+            }
+          });
         } }],
 
 
@@ -6615,20 +6702,19 @@
           }
 
           const referenceElement = this.isFixed ? this.placeholder : this.$el;
+          const windowHeight = height(window);
 
           let position = this.position;
-
-          if (position === 'auto') {
-            position = height$1 > height(window) ? 'bottom' : 'top';
+          if (position === 'auto' && height$1 > windowHeight) {
+            position = 'bottom';
           }
 
-          let offset$1 = this.offset;
+          let offset$1 = toPx(this.offset, 'height', referenceElement);
           if (position === 'bottom') {
-            offset$1 += '+100vh-100%';
+            offset$1 += windowHeight - height$1;
           }
-          offset$1 = toPx(offset$1, 'height', referenceElement);
 
-          const overflow = Math.max(0, height$1 + offset$1 - height(window));
+          const overflow = Math.max(0, height$1 + offset$1 - windowHeight);
           const topOffset = offset(referenceElement).top;
           const offsetParentTop = offset(referenceElement.offsetParent).top;
 
@@ -6638,7 +6724,7 @@
           const start = Math.max(top, topOffset) - offset$1;
           const end = bottom ?
           bottom - offset(this.$el).height + overflow - offset$1 :
-          getScrollingElement(this.$el).scrollHeight - height(window);
+          getScrollingElement(this.$el).scrollHeight - windowHeight;
 
           return {
             start,
@@ -6844,7 +6930,7 @@
     }
 
     var Switcher = {
-      mixins: [Togglable],
+      mixins: [Lazyload, Swipe, Togglable],
 
       args: 'connect',
 
@@ -6852,8 +6938,7 @@
         connect: String,
         toggle: String,
         itemNav: String,
-        active: Number,
-        swiping: Boolean },
+        active: Number },
 
 
       data: {
@@ -6861,7 +6946,6 @@
         toggle: '> * > :first-child',
         itemNav: false,
         active: 0,
-        swiping: true,
         cls: 'uk-active',
         attrItem: 'uk-switcher-item' },
 
@@ -6905,9 +6989,17 @@
           return children(this.$el).filter((child) =>
           this.toggles.some((toggle) => within(toggle, child)));
 
+        },
+
+        swipeTarget() {
+          return this.connects;
         } },
 
 
+      connected() {
+        this.lazyload(this.$el, this.connects);
+      },
+
       events: [
       {
         name: 'click',
@@ -7016,7 +7108,7 @@
     const KEY_SPACE = 32;
 
     var toggle = {
-      mixins: [Media, Togglable],
+      mixins: [Lazyload, Media, Togglable],
 
       args: 'target',
 
@@ -7038,6 +7130,7 @@
         if (!includes(this.mode, 'media') && !isFocusable(this.$el)) {
           attr(this.$el, 'tabindex', '0');
         }
+        this.lazyload(this.$el, this.target);
       },
 
       computed: {
@@ -7390,8 +7483,8 @@
           this.stop();
 
           if (this.date && this.units.length) {
-            this.$update();
-            this.timer = setInterval(this.$update, 1000);
+            this.$emit();
+            this.timer = setInterval(() => this.$emit(), 1000);
           }
         },
 
@@ -8441,12 +8534,6 @@
         } },
 
 
-      events: {
-        itemshown() {
-          this.$update(this.list);
-        } },
-
-
       methods: {
         show(index, force) {if (force === void 0) {force = false;}
           if (this.dragging || !this.length) {
@@ -8608,19 +8695,15 @@
 
 
       events: {
-        'itemshow itemhide itemshown itemhidden'(_ref2) {let { target } = _ref2;
-          this.$update(target);
-        },
-
-        beforeitemshow(_ref3) {let { target } = _ref3;
+        beforeitemshow(_ref2) {let { target } = _ref2;
           addClass(target, this.clsActive);
         },
 
-        itemshown(_ref4) {let { target } = _ref4;
+        itemshown(_ref3) {let { target } = _ref3;
           addClass(target, this.clsActivated);
         },
 
-        itemhidden(_ref5) {let { target } = _ref5;
+        itemhidden(_ref4) {let { target } = _ref4;
           removeClass(target, this.clsActive, this.clsActivated);
         } } };
 
@@ -9195,7 +9278,7 @@
 
 
       events: {
-        bgimageload() {
+        load() {
           this.$emit();
         } },
 
@@ -9206,13 +9289,11 @@
         },
 
         getCss(percent) {
-          return keys(this.props).reduce(
-          (css, prop) => {
+          const css = { transform: '', filter: '' };
+          for (const prop in this.props) {
             this.props[prop](css, percent);
-            return css;
-          },
-          { transform: '', filter: '' });
-
+          }
+          return css;
         } } };
 
 
@@ -9395,8 +9476,9 @@
         if (!image.naturalWidth) {
           image.onload = () => {
             dimensions[src] = toDimensions(image);
-            trigger(el, 'bgimageload');
+            trigger(el, 'load');
           };
+          return toDimensions(image);
         }
       }
 
@@ -9587,40 +9669,11 @@
         events: ['resize'] } };
 
     var SliderPreload = {
-      connected() {
-        if (window.IntersectionObserver) {
-          this.observer = new IntersectionObserver(
-          (entries) => {
-            if (entries.some((entry) => entry.isIntersecting)) {
-              removeLazyLoad(this.getAdjacentSlides());
-            }
-          },
-          { rootMargin: '50% 50%' });
-
-          this.observer.observe(this.$el);
-        }
-      },
+      mixins: [Lazyload],
 
-      disconnected() {
-        this.observer && this.observer.disconnect();
-      },
-
-      update: {
-        read() {
-          if (isVisible(this.$el)) {
-            removeLazyLoad(this.getAdjacentSlides());
-          }
-        },
-
-        events: ['resize'] } };
-
-
-
-    function removeLazyLoad(elements) {if (elements === void 0) {elements = [];}
-      for (const el of elements) {
-        el && $$('img[loading="lazy"]', el).forEach((el) => removeAttr(el, 'loading'));
-      }
-    }
+      connected() {
+        this.lazyload(this.slides, this.getAdjacentSlides);
+      } };
 
     function Transitioner (prev, next, dir, _ref) {let { center, easing, list } = _ref;
       const deferred = new Deferred();
@@ -9840,48 +9893,39 @@
           return ~index ? index : this.length - 1;
         },
 
-        sets(_ref2) {let { sets } = _ref2;
-          if (!sets) {
+        sets(_ref2) {let { sets: enabled } = _ref2;
+          if (!enabled) {
             return;
           }
 
-          const width = dimensions$1(this.list).width / (this.center ? 2 : 1);
-
           let left = 0;
-          let leftCenter = width;
-          let slideLeft = 0;
+          const sets = [];
+          const width = dimensions$1(this.list).width;
+          for (let i in this.slides) {
+            const slideWidth = dimensions$1(this.slides[i]).width;
 
-          sets = sortBy$1(this.slides, 'offsetLeft').reduce((sets, slide, i) => {
-            const slideWidth = dimensions$1(slide).width;
-            const slideRight = slideLeft + slideWidth;
-
-            if (slideRight > left) {
-              if (!this.center && i > this.maxIndex) {
-                i = this.maxIndex;
-              }
+            if (left + slideWidth > width) {
+              left = 0;
+            }
 
-              if (!includes(sets, i)) {
-                const cmp = this.slides[i + 1];
-                if (
-                this.center &&
-                cmp &&
-                slideWidth < leftCenter - dimensions$1(cmp).width / 2)
-                {
-                  leftCenter -= slideWidth;
-                } else {
-                  leftCenter = width;
-                  sets.push(i);
-                  left = slideLeft + width + (this.center ? slideWidth / 2 : 0);
-                }
+            if (this.center) {
+              if (
+              left < width / 2 &&
+              left + slideWidth + dimensions$1(this.slides[+i + 1]).width / 2 > width / 2)
+              {
+                sets.push(+i);
+                left = width / 2 - slideWidth / 2;
               }
+            } else if (left === 0) {
+              sets.push(Math.min(+i, this.maxIndex));
             }
 
-            slideLeft += slideWidth;
+            left += slideWidth;
+          }
 
+          if (sets.length) {
             return sets;
-          }, []);
-
-          return !isEmpty(sets) && sets;
+          }
         },
 
         transitionOptions() {
@@ -9913,15 +9957,7 @@
             this._translate(1);
           }
 
-          const actives = this._getTransitioner(this.index).getActives();
-          const activeClasses = [
-          this.clsActive,
-          (!this.sets || includes(this.sets, toFloat(this.index))) && this.clsActivated ||
-          ''];
-
-          for (const slide of this.slides) {
-            toggleClass(slide, activeClasses, includes(actives, slide));
-          }
+          this.updateActiveClasses();
         },
 
         events: ['resize'] },
@@ -9969,6 +10005,10 @@
           if (~this.prevIndex) {
             addClass(this._getTransitioner().getItemIn(), this.clsActive);
           }
+        },
+
+        itemshown() {
+          this.updateActiveClasses();
         } },
 
 
@@ -10006,6 +10046,18 @@
           }
         },
 
+        updateActiveClasses() {
+          const actives = this._getTransitioner(this.index).getActives();
+          const activeClasses = [
+          this.clsActive,
+          (!this.sets || includes(this.sets, toFloat(this.index))) && this.clsActivated ||
+          ''];
+
+          for (const slide of this.slides) {
+            toggleClass(slide, activeClasses, includes(actives, slide));
+          }
+        },
+
         getValidIndex(index, prevIndex) {if (index === void 0) {index = this.index;}if (prevIndex === void 0) {prevIndex = this.prevIndex;}
           index = this.getIndex(index, prevIndex);
 
@@ -10986,6 +11038,7 @@
     }
 
     function chunk(files, size) {
+      files = toArray(files);
       const chunks = [];
       for (let i = 0; i < files.length; i += size) {
         chunks.push(files.slice(i, i + size));