uikit 3.11.2-dev.3dfa2c50b → 3.11.2-dev.45194f70c

package/dist/js/uikit.js

@@ -1,4 +1,4 @@
-/*! UIkit 3.11.2-dev.3dfa2c50b | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
+/*! UIkit 3.11.2-dev.45194f70c | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
 
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -29,19 +29,19 @@
     }
 
     function startsWith(str, search) {
-      return str.startsWith(search);
+      return str == null ? void 0 : str.startsWith == null ? void 0 : str.startsWith(search);
     }
 
     function endsWith(str, search) {
-      return str.endsWith(search);
+      return str == null ? void 0 : str.endsWith == null ? void 0 : str.endsWith(search);
     }
 
     function includes(obj, search) {
-      return obj && obj.includes(search);
+      return obj == null ? void 0 : obj.includes == null ? void 0 : obj.includes(search);
     }
 
     function findIndex(array, predicate) {
-      return array.findIndex(predicate);
+      return array == null ? void 0 : array.findIndex == null ? void 0 : array.findIndex(predicate);
     }
 
     const { isArray, from: toArray } = Array;
@@ -130,14 +130,15 @@
       return element && (isNode(element) ? [element] : Array.from(element).filter(isNode)) || [];
     }
 
-    function toWindow(element) {
+    function toWindow(element) {var _element;
       if (isWindow(element)) {
         return element;
       }
 
       element = toNode(element);
+      const document = isDocument(element) ? element : (_element = element) == null ? void 0 : _element.ownerDocument;
 
-      return element ? (isDocument(element) ? element : element.ownerDocument).defaultView : window;
+      return (document == null ? void 0 : document.defaultView) || window;
     }
 
     function toMs(time) {
@@ -224,7 +225,7 @@
       },
 
       contain(dimensions, maxDimensions) {
-        dimensions = assign({}, dimensions);
+        dimensions = { ...dimensions };
 
         each(
         dimensions,
@@ -339,19 +340,6 @@
       }
     }
 
-    const inBrowser = typeof window !== 'undefined';
-    const isRtl = inBrowser && attr(document.documentElement, 'dir') === 'rtl';
-
-    const hasTouch = inBrowser && 'ontouchstart' in window;
-    const hasPointerEvents = inBrowser && window.PointerEvent;
-
-    const pointerDown = hasPointerEvents ? 'pointerdown' : hasTouch ? 'touchstart' : 'mousedown';
-    const pointerMove = hasPointerEvents ? 'pointermove' : hasTouch ? 'touchmove' : 'mousemove';
-    const pointerUp = hasPointerEvents ? 'pointerup' : hasTouch ? 'touchend' : 'mouseup';
-    const pointerEnter = hasPointerEvents ? 'pointerenter' : hasTouch ? '' : 'mouseenter';
-    const pointerLeave = hasPointerEvents ? 'pointerleave' : hasTouch ? '' : 'mouseleave';
-    const pointerCancel = hasPointerEvents ? 'pointercancel' : 'touchcancel';
-
     const voidElements = {
       area: true,
       base: true,
@@ -451,12 +439,6 @@
       return findAll(selector, getContext(selector, context));
     }
 
-    function getContext(selector, context) {if (context === void 0) {context = document;}
-      return isString(selector) && isContextSelector(selector) || isDocument(context) ?
-      context :
-      context.ownerDocument;
-    }
-
     function find(selector, context) {
       return toNode(_query(selector, context, 'querySelector'));
     }
@@ -465,6 +447,17 @@
       return toNodes(_query(selector, context, 'querySelectorAll'));
     }
 
+    const contextSelectorRe = /(^|[^\\],)\s*[!>+~-]/;
+    const isContextSelector = memoize((selector) => selector.match(contextSelectorRe));
+
+    function getContext(selector, context) {if (context === void 0) {context = document;}
+      return isString(selector) && isContextSelector(selector) || isDocument(context) ?
+      context :
+      context.ownerDocument;
+    }
+
+    const contextSanitizeRe = /([!>+~-])(?=\s+[!>+~-]|\s*$)/g;
+
     function _query(selector, context, queryFn) {if (context === void 0) {context = document;}
       if (!selector || !isString(selector)) {
         return selector;
@@ -509,11 +502,6 @@
       }
     }
 
-    const contextSelectorRe = /(^|[^\\],)\s*[!>+~-]/;
-    const contextSanitizeRe = /([!>+~-])(?=\s+[!>+~-]|\s*$)/g;
-
-    const isContextSelector = memoize((selector) => selector.match(contextSelectorRe));
-
     const selectorRe = /.*?[^\\](?:,|$)/g;
 
     const splitSelector = memoize((selector) =>
@@ -539,13 +527,8 @@
       return names.join(' > ');
     }
 
-    const escapeFn =
-    inBrowser && window.CSS && CSS.escape ||
-    function (css) {
-      return css.replace(/([^\x7f-\uFFFF\w-])/g, (match) => "\\" + match);
-    };
     function escape(css) {
-      return isString(css) ? escapeFn.call(null, css) : '';
+      return isString(css) ? CSS.escape(css) : '';
     }
 
     function on() {for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {args[_key] = arguments[_key];}
@@ -688,17 +671,14 @@
     }
 
     function ajax(url, options) {
-      const env = assign(
-      {
+      const env = {
         data: null,
         method: 'GET',
         headers: {},
         xhr: new XMLHttpRequest(),
         beforeSend: noop,
-        responseType: '' },
-
-      options);
-
+        responseType: '',
+        ...options };
 
       return Promise.resolve().
       then(() => env.beforeSend(env)).
@@ -749,8 +729,12 @@
       return new Promise((resolve, reject) => {
         const img = new Image();
 
-        img.onerror = (e) => reject(e);
-        img.onload = () => resolve(img);
+        img.onerror = (e) => {
+          reject(e);
+        };
+        img.onload = () => {
+          resolve(img);
+        };
 
         sizes && (img.sizes = sizes);
         srcset && (img.srcset = srcset);
@@ -777,7 +761,8 @@
 
 
     function css(element, property, value, priority) {if (priority === void 0) {priority = '';}
-      return toNodes(element).map((element) => {
+      const elements = toNodes(element);
+      for (const element of elements) {
         if (isString(property)) {
           property = propName(property);
 
@@ -803,9 +788,8 @@
           priority = value;
           each(property, (value, property) => css(element, property, value, priority));
         }
-
-        return element;
-      })[0];
+      }
+      return elements[0];
     }
 
     function getStyles(element, pseudoElt) {
@@ -932,16 +916,11 @@
 
 
         addClass(element, 'uk-transition');
-        css(
-        element,
-        assign(
-        {
+        css(element, {
           transitionProperty: Object.keys(props).map(propName).join(','),
           transitionDuration: duration + "ms",
-          transitionTimingFunction: timing },
-
-        props));
-
+          transitionTimingFunction: timing,
+          ...props });
 
       })));
 
@@ -1041,8 +1020,8 @@
       const currentOffset = dimensions$1(element);
 
       if (element) {
-        const { pageYOffset, pageXOffset } = toWindow(element);
-        const offsetBy = { height: pageYOffset, width: pageXOffset };
+        const { scrollY, scrollX } = toWindow(element);
+        const offsetBy = { height: scrollY, width: scrollX };
 
         for (const dir in dirs$1) {
           for (const i in dirs$1[dir]) {
@@ -1108,8 +1087,8 @@
 
         if (css(element, 'position') === 'fixed') {
           const win = toWindow(element);
-          offset[0] += win.pageYOffset;
-          offset[1] += win.pageXOffset;
+          offset[0] += win.scrollY;
+          offset[1] += win.scrollX;
           return offset;
         }
       } while (element = element.offsetParent);
@@ -1200,8 +1179,8 @@
 
     const calcRe = /-?\d+(?:\.\d+)?(?:v[wh]|%|px)?/g;
     const parseCalc = memoize((calc) => calc.toString().replace(/\s/g, '').match(calcRe) || []);
-    const unitRe = /(?:v[hw]|%)$/;
-    const parseUnit = memoize((str) => (str.match(unitRe) || [])[0]);
+    const unitRe$1 = /(?:v[hw]|%)$/;
+    const parseUnit = memoize((str) => (str.match(unitRe$1) || [])[0]);
 
     function percent(base, value) {
       return base * toFloat(value) / 100;
@@ -1216,6 +1195,10 @@
       once(document, 'DOMContentLoaded', fn);
     }
 
+    function isTag(element, tagName) {var _element$tagName;
+      return (element == null ? void 0 : (_element$tagName = element.tagName) == null ? void 0 : _element$tagName.toLowerCase()) === tagName.toLowerCase();
+    }
+
     function empty(element) {
       return replaceChildren(element, '');
     }
@@ -1224,34 +1207,20 @@
       return isUndefined(html) ? $(parent).innerHTML : replaceChildren(parent, html);
     }
 
-    function replaceChildren(parent, element) {
-      const nodes = $$(element);
-      $(parent).replaceChildren(...nodes);
-      return nodes;
-    }
-
-    function prepend(parent, element) {
-      const nodes = $$(element);
-      $(parent).prepend(...nodes);
-      return nodes;
-    }
-
-    function append(parent, element) {
-      const nodes = $$(element);
-      $(parent).append(...nodes);
-      return nodes;
-    }
+    const replaceChildren = applyFn('replaceChildren');
+    const prepend = applyFn('prepend');
+    const append = applyFn('append');
+    const before = applyFn('before');
+    const after = applyFn('after');
 
-    function before(ref, element) {
-      const nodes = $$(element);
-      $(ref).before(...nodes);
-      return nodes;
-    }
-
-    function after(ref, element) {
-      const nodes = $$(element);
-      $(ref).after(...nodes);
-      return nodes;
+    function applyFn(fn) {
+      return function (ref, element) {
+        const nodes = toNodes(isString(element) ? fragment(element) : element);
+        if (nodes.length) {
+          $(ref)[fn](...nodes);
+        }
+        return unwrapSingle(nodes);
+      };
     }
 
     function remove$1(element) {
@@ -1287,11 +1256,27 @@
       forEach((parent) => parent.replaceWith(...parent.childNodes));
     }
 
+    const fragmentRe = /^\s*<(\w+|!)[^>]*>/;
+    const singleTagRe = /^<(\w+)\s*\/?>(?:<\/\1>)?$/;
+
     function fragment(html) {
-      const template = document.createElement('template');
-      template.innerHTML = html;
-      const { childNodes } = template.content;
-      return childNodes.length > 1 ? toNodes(childNodes) : childNodes[0];
+      const matches = singleTagRe.exec(html);
+      if (matches) {
+        return document.createElement(matches[1]);
+      }
+
+      const container = document.createElement('div');
+      if (fragmentRe.test(html)) {
+        container.insertAdjacentHTML('beforeend', html.trim());
+      } else {
+        container.textContent = html;
+      }
+
+      return unwrapSingle(container.childNodes);
+    }
+
+    function unwrapSingle(nodes) {
+      return nodes.length > 1 ? nodes : nodes[0];
     }
 
     function apply(node, fn) {
@@ -1320,6 +1305,19 @@
       return isString(str) && startsWith(str.trim(), '<');
     }
 
+    const inBrowser = typeof window !== 'undefined';
+    const isRtl = inBrowser && attr(document.documentElement, 'dir') === 'rtl';
+
+    const hasTouch = inBrowser && 'ontouchstart' in window;
+    const hasPointerEvents = inBrowser && window.PointerEvent;
+
+    const pointerDown = hasPointerEvents ? 'pointerdown' : hasTouch ? 'touchstart' : 'mousedown';
+    const pointerMove = hasPointerEvents ? 'pointermove' : hasTouch ? 'touchmove' : 'mousemove';
+    const pointerUp = hasPointerEvents ? 'pointerup' : hasTouch ? 'touchend' : 'mouseup';
+    const pointerEnter = hasPointerEvents ? 'pointerenter' : hasTouch ? '' : 'mouseenter';
+    const pointerLeave = hasPointerEvents ? 'pointerleave' : hasTouch ? '' : 'mouseleave';
+    const pointerCancel = hasPointerEvents ? 'pointercancel' : 'touchcancel';
+
     /*
         Based on:
         Copyright (c) 2016 Wilson Page wilsonpage@me.com
@@ -1472,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 isArray(targets) ? targets : [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 isArray(targets) ? targets : [targets]) {
+        observer.observe(el, options);
+      }
+
+      return observer;
+    }
+
     const strats = {};
 
     strats.events =
@@ -1511,7 +1544,7 @@
 
     // extend strategy
     strats.computed = strats.methods = function (parentVal, childVal) {
-      return childVal ? parentVal ? assign({}, parentVal, childVal) : childVal : parentVal;
+      return childVal ? parentVal ? { ...parentVal, ...childVal } : childVal : parentVal;
     };
 
     // data strategy
@@ -1651,11 +1684,11 @@
     }
 
     function isHTML5(el) {
-      return (el == null ? void 0 : el.tagName) === 'VIDEO';
+      return isTag(el, 'video');
     }
 
     function isIFrame(el) {
-      return (el == null ? void 0 : el.tagName) === 'IFRAME' && (isYoutube(el) || isVimeo(el));
+      return isTag(el, 'iframe') && (isYoutube(el) || isVimeo(el));
     }
 
     function isYoutube(el) {
@@ -1675,7 +1708,7 @@
 
     function post(el, cmd) {
       try {
-        el.contentWindow.postMessage(JSON.stringify(assign({ event: 'command' }, cmd)), '*');
+        el.contentWindow.postMessage(JSON.stringify({ event: 'command', ...cmd }), '*');
       } catch (e) {
         // noop
       }
@@ -2055,6 +2088,7 @@
         flipPosition: flipPosition,
         toPx: toPx,
         ready: ready,
+        isTag: isTag,
         empty: empty,
         html: html,
         replaceChildren: replaceChildren,
@@ -2148,6 +2182,9 @@
         memoize: memoize,
         Deferred: Deferred,
         MouseTracker: MouseTracker,
+        hasIntersectionObserver: hasIntersectionObserver,
+        observeIntersection: observeIntersection,
+        observeResize: observeResize,
         mergeOptions: mergeOptions,
         parseOptions: parseOptions,
         play: play,
@@ -2325,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;
           }
 
@@ -2349,7 +2386,7 @@
         const {
           $options: { computed } } =
         this;
-        const values = assign({}, this._computeds);
+        const values = { ...this._computeds };
         this._computeds = {};
 
         for (const key in computed) {
@@ -2447,17 +2484,28 @@
             }
           }
         }
+        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());
       };
@@ -2534,7 +2582,7 @@
         el = isFunction(el) ? el.call(component) : el || component.$el;
 
         if (isArray(el)) {
-          el.forEach((el) => registerEvent(component, assign({}, event, { el }), key));
+          el.forEach((el) => registerEvent(component, { ...event, el }, key));
           return;
         }
 
@@ -2646,6 +2694,27 @@
 
         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 });
+
+
+        scrollListeners.set(id, listener);
+      }
+
+      function unregisterScrollListener(id) {
+        scrollListeners.delete(id);
+        if (unbindScrollListener && !scrollListeners.size) {
+          unbindScrollListener();
+          unbindScrollListener = null;
+        }
+      }
     }
 
     function instanceAPI (UIkit) {
@@ -2768,7 +2837,7 @@
           }
         };
 
-        const opt = isPlainObject(options) ? assign({}, options) : options.options;
+        const opt = isPlainObject(options) ? { ...options } : options.options;
 
         opt.name = name;
 
@@ -2821,7 +2890,7 @@
     UIkit.data = '__uikit__';
     UIkit.prefix = 'uk-';
     UIkit.options = {};
-    UIkit.version = '3.11.2-dev.3dfa2c50b';
+    UIkit.version = '3.11.2-dev.45194f70c';
 
     globalAPI(UIkit);
     hooksAPI(UIkit);
@@ -2846,28 +2915,8 @@
       };
 
       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(
@@ -2989,6 +3038,19 @@
         !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 isArray(targets) ? targets : [targets]) {
+              $$('img[loading="lazy"]', el).forEach((el) => removeAttr(el, 'loading'));
+            }
+            observer.disconnect();
+          }));
+
+        } } };
+
     var Togglable = {
       props: {
         cls: Boolean,
@@ -3144,7 +3206,7 @@
         show ?
         Transition.start(
         el,
-        assign({}, initProps, { overflow: 'hidden', height: endHeight }),
+        { ...initProps, overflow: 'hidden', height: endHeight },
         Math.round(duration * (1 - currentHeight / endHeight)),
         transition) :
 
@@ -3176,7 +3238,7 @@
     }
 
     var Accordion = {
-      mixins: [Class, Togglable],
+      mixins: [Class, Lazyload, Togglable],
 
       props: {
         targets: String,
@@ -3232,6 +3294,10 @@
         } },
 
 
+      connected() {
+        this.lazyload();
+      },
+
       events: [
       {
         name: 'click',
@@ -3316,7 +3382,7 @@
         animation: [true],
         selClose: '.uk-alert-close',
         duration: 150,
-        hideProps: assign({ opacity: 0 }, Togglable.data.hideProps) },
+        hideProps: { opacity: 0, ...Togglable.data.hideProps } },
 
 
       events: [
@@ -3367,6 +3433,8 @@
         if (this.automute) {
           mute(this.$el);
         }
+
+        this.registerObserver(observeIntersection(this.$el, () => this.$emit('resize')));
       },
 
       update: {
@@ -3403,6 +3471,10 @@
         automute: true },
 
 
+      connected() {
+        this.registerObserver(observeResize(this.$el, () => this.$emit('resize')));
+      },
+
       update: {
         read() {
           const el = this.$el;
@@ -3528,7 +3600,7 @@
     let active$1;
 
     var drop = {
-      mixins: [Container, Position, Togglable],
+      mixins: [Container, Lazyload, Position, Togglable],
 
       args: 'pos',
 
@@ -3582,6 +3654,7 @@
             mode: this.mode }).
           $el;
           attr(this.target, 'aria-haspopup', true);
+          this.lazyload(this.target);
         }
       },
 
@@ -3957,7 +4030,7 @@
         name: 'change',
 
         handler() {
-          this.$update();
+          this.$emit();
         } },
 
 
@@ -3969,7 +4042,7 @@
         },
 
         handler() {
-          this.$update();
+          this.$emit();
         } }] };
 
     // Deprecated
@@ -4326,6 +4399,8 @@
     }
 
     var heightViewport = {
+      mixins: [Class],
+
       props: {
         expand: Boolean,
         offsetTop: Boolean,
@@ -4473,6 +4548,12 @@
 
       methods: {
         async getSvg() {
+          if (isTag(this.$el, 'img') && !this.$el.complete && this.$el.loading === 'lazy') {
+            return new Promise((resolve) =>
+            once(this.$el, 'load', () => resolve(this.getSvg())));
+
+          }
+
           return parseSVG(await loadSVG(this.src), this.icon) || Promise.reject('SVG not found.');
         },
 
@@ -4572,7 +4653,7 @@
     }
 
     function insertSVG(el, root) {
-      if (isVoidElement(root) || root.tagName === 'CANVAS') {
+      if (isVoidElement(root) || isTag(root, 'canvas')) {
         root.hidden = true;
 
         const next = root.nextElementSibling;
@@ -4584,11 +4665,7 @@
     }
 
     function equals(el, other) {
-      return isSVG(el) && isSVG(other) && innerHTML(el) === innerHTML(other);
-    }
-
-    function isSVG(el) {
-      return (el == null ? void 0 : el.tagName) === 'svg';
+      return isTag(el, 'svg') && isTag(other, 'svg') && innerHTML(el) === innerHTML(other);
     }
 
     function innerHTML(el) {
@@ -4669,14 +4746,14 @@
       },
 
       methods: {
-        getSvg() {
+        async getSvg() {
           const icon = getIcon(this.icon);
 
           if (!icon) {
-            return Promise.reject('Icon not found.');
+            throw 'Icon not found.';
           }
 
-          return Promise.resolve(icon);
+          return icon;
         } } };
 
     const IconComponent = {
@@ -4734,10 +4811,17 @@
     const Spinner = {
       extends: IconComponent,
 
-      async connected() {
-        const svg = await this.svg;
-        svg && this.ratio !== 1 && css($('circle', svg), 'strokeWidth', 1 / this.ratio);
-      } };
+      methods: {
+        async getSvg() {
+          const icon = await Icon.methods.getSvg.call(this);
+
+          if (this.ratio !== 1) {
+            css($('circle', icon), 'strokeWidth', 1 / this.ratio);
+          }
+
+          return icon;
+        } } };
+
 
 
     const parsed = {};
@@ -4775,120 +4859,93 @@
       return isRtl ? swap(swap(icon, 'left', 'right'), 'previous', 'next') : icon;
     }
 
+    const nativeLazyLoad = ('loading' in HTMLImageElement.prototype);
+
     var img = {
       args: 'dataSrc',
 
       props: {
         dataSrc: String,
-        dataSrcset: Boolean,
-        sizes: String,
-        width: Number,
-        height: Number,
+        sources: String,
         offsetTop: String,
         offsetLeft: String,
-        target: String },
+        target: String,
+        loading: String },
 
 
       data: {
         dataSrc: '',
-        dataSrcset: false,
-        sizes: false,
-        width: false,
-        height: false,
+        sources: false,
         offsetTop: '50vh',
         offsetLeft: '50vw',
-        target: false },
+        target: false,
+        loading: 'lazy' },
 
 
       computed: {
-        cacheKey(_ref) {let { dataSrc } = _ref;
-          return this.$name + "." + dataSrc;
-        },
-
-        width(_ref2) {let { width, dataWidth } = _ref2;
-          return width || dataWidth;
-        },
-
-        height(_ref3) {let { height, dataHeight } = _ref3;
-          return height || dataHeight;
-        },
-
-        sizes(_ref4) {let { sizes, dataSizes } = _ref4;
-          return sizes || dataSizes;
-        },
-
-        isImg(_, $el) {
-          return isImg($el);
-        },
-
         target: {
-          get(_ref5) {let { target } = _ref5;
+          get(_ref) {let { target } = _ref;
             return [this.$el, ...queryAll(target, this.$el)];
           },
 
           watch() {
-            this.observe();
-          } },
-
-
-        offsetTop(_ref6) {let { offsetTop } = _ref6;
-          return toPx(offsetTop, 'height');
-        },
+            this.$reset();
+          } } },
 
-        offsetLeft(_ref7) {let { offsetLeft } = _ref7;
-          return toPx(offsetLeft, 'width');
-        } },
 
 
       connected() {
-        if (!window.IntersectionObserver) {
-          setSrcAttrs(this.$el, this.dataSrc, this.dataSrcset, this.sizes);
+        if (this.loading !== 'lazy' || !hasIntersectionObserver) {
+          this.load();
           return;
         }
 
-        if (storage[this.cacheKey]) {
-          setSrcAttrs(this.$el, storage[this.cacheKey], this.dataSrcset, this.sizes);
-        } else if (this.isImg && this.width && this.height) {
-          setSrcAttrs(this.$el, getPlaceholderImage(this.width, this.height, this.sizes));
+        if (nativeLazyLoad && isImg(this.$el)) {
+          this.$el.loading = 'lazy';
+          setSrcAttrs(this.$el);
+
+          if (this.target.length === 1) {
+            return;
+          }
         }
 
-        this.observer = new IntersectionObserver(this.load, {
-          rootMargin: this.offsetTop + "px " + this.offsetLeft + "px" });
+        ensureSrcAttribute(this.$el);
+
+        this.registerObserver(
+        observeIntersection(
+        this.target,
+        (entries, observer) => {
+          this.load();
+          observer.disconnect();
+        },
+        {
+          rootMargin: toPx(this.offsetTop, 'height') + "px " + toPx(
+          this.offsetLeft,
+          'width') + "px" }));
+
+
 
 
-        requestAnimationFrame(this.observe);
       },
 
       disconnected() {
-        this.observer && this.observer.disconnect();
+        if (this._data.image) {
+          this._data.image.onload = '';
+        }
       },
 
       update: {
-        read(_ref8) {let { image } = _ref8;
-          if (!this.observer) {
+        write(store) {
+          if (!this.observer || isImg(this.$el)) {
             return false;
           }
 
-          if (!image && document.readyState === 'complete') {
-            this.load(this.observer.takeRecords());
-          }
-
-          if (this.isImg) {
-            return false;
-          }
-
-          image &&
-          image.then(
-          (img) => img && img.currentSrc !== '' && setSrcAttrs(this.$el, currentSrc(img)));
-
-        },
-
-        write(data) {
-          if (this.dataSrcset && window.devicePixelRatio !== 1) {
+          const srcset = data(this.$el, 'data-srcset');
+          if (srcset && window.devicePixelRatio !== 1) {
             const bgSize = css(this.$el, 'backgroundSize');
-            if (bgSize.match(/^(auto\s?)+$/) || toFloat(bgSize) === data.bgSize) {
-              data.bgSize = getSourceSize(this.dataSrcset, this.sizes);
-              css(this.$el, 'backgroundSize', data.bgSize + "px");
+            if (bgSize.match(/^(auto\s?)+$/) || toFloat(bgSize) === store.bgSize) {
+              store.bgSize = getSourceSize(srcset, data(this.$el, 'sizes'));
+              css(this.$el, 'backgroundSize', store.bgSize + "px");
             }
           }
         },
@@ -4897,42 +4954,27 @@
 
 
       methods: {
-        load(entries) {
-          // Old chromium based browsers (UC Browser) did not implement `isIntersecting`
-          if (
-          !entries.some((entry) => isUndefined(entry.isIntersecting) || entry.isIntersecting))
-          {
-            return;
+        load() {
+          if (this._data.image) {
+            return this._data.image;
           }
 
-          this._data.image = getImage(this.dataSrc, this.dataSrcset, this.sizes).then(
-          (img) => {
-            setSrcAttrs(this.$el, currentSrc(img), img.srcset, img.sizes);
-            storage[this.cacheKey] = currentSrc(img);
-            return img;
-          },
-          (e) => trigger(this.$el, new e.constructor(e.type, e)));
-
+          const image = isImg(this.$el) ?
+          this.$el :
+          getImageFromElement(this.$el, this.dataSrc, this.sources);
 
-          this.observer.disconnect();
-        },
-
-        observe() {
-          if (this._connected && !this._data.image) {
-            for (const el of this.target) {
-              this.observer.observe(el);
-            }
-          }
+          removeAttr(image, 'loading');
+          setSrcAttrs(this.$el, image.currentSrc);
+          return this._data.image = image;
         } } };
 
 
 
-    function setSrcAttrs(el, src, srcset, sizes) {
+    function setSrcAttrs(el, src) {
       if (isImg(el)) {
-        const set = (prop, val) => val && val !== el[prop] && (el[prop] = val);
-        set('sizes', sizes);
-        set('srcset', srcset);
-        set('src', src);
+        const parentNode = parent(el);
+        const elements = isPicture(parentNode) ? children(parentNode) : [el];
+        elements.forEach((el) => setSourceProps(el, el));
       } else if (src) {
         const change = !includes(el.style.backgroundImage, src);
         if (change) {
@@ -4942,16 +4984,62 @@
       }
     }
 
-    function getPlaceholderImage(width, height, sizes) {
-      if (sizes) {
-        ({ width, height } = Dimensions.ratio(
-        { width, height },
-        'width',
-        toPx(sizesToPixel(sizes))));
+    const srcProps = ['data-src', 'data-srcset', 'sizes'];
+    function setSourceProps(sourceEl, targetEl) {
+      srcProps.forEach((prop) => {
+        const value = data(sourceEl, prop);
+        if (value) {
+          attr(targetEl, prop.replace(/^(data-)+/, ''), value);
+        }
+      });
+    }
+
+    function getImageFromElement(el, src, sources) {
+      const img = new Image();
+
+      wrapInPicture(img, sources);
+      setSourceProps(el, img);
+      img.onload = () => {
+        setSrcAttrs(el, img.currentSrc);
+      };
+      attr(img, 'src', src);
+      return img;
+    }
+
+    function wrapInPicture(img, sources) {
+      sources = parseSources(sources);
+
+      if (sources.length) {
+        const picture = fragment('<picture>');
+        for (const attrs of sources) {
+          const source = fragment('<source>');
+          attr(source, attrs);
+          append(picture, source);
+        }
+        append(picture, img);
+      }
+    }
+
+    function parseSources(sources) {
+      if (!sources) {
+        return [];
+      }
 
+      if (startsWith(sources, '[')) {
+        try {
+          sources = JSON.parse(sources);
+        } catch (e) {
+          sources = [];
+        }
+      } else {
+        sources = parseOptions(sources);
       }
 
-      return "data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" + width + "\" height=\"" + height + "\"></svg>";
+      if (!isArray(sources)) {
+        sources = [sources];
+      }
+
+      return sources.filter((source) => !isEmpty(source));
     }
 
     const sizesRe = /\s*(.*?)\s*(\w+|calc\(.*?\))\s*(?:,|$)/g;
@@ -4991,24 +5079,18 @@
       return descriptors.filter((size) => size >= srcSize)[0] || descriptors.pop() || '';
     }
 
-    function isImg(el) {
-      return el.tagName === 'IMG';
+    function ensureSrcAttribute(el) {
+      if (isImg(el) && !hasAttr(el, 'src')) {
+        attr(el, 'src', 'data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"></svg>');
+      }
     }
 
-    function currentSrc(el) {
-      return el.currentSrc || el.src;
+    function isPicture(el) {
+      return isTag(el, 'picture');
     }
 
-    const key = '__test__';
-    let storage;
-
-    // workaround for Safari's private browsing mode and accessing sessionStorage in Blink
-    try {
-      storage = window.sessionStorage || {};
-      storage[key] = 1;
-      delete storage[key];
-    } catch (e) {
-      storage = {};
+    function isImg(el) {
+      return isTag(el, 'img');
     }
 
     var Media = {
@@ -5464,7 +5546,7 @@
 
 
       function openDialog(tmpl, options, hideFn, submitFn) {
-        options = assign({ bgClose: false, escClose: true, labels: modal.labels }, options);
+        options = { bgClose: false, escClose: true, labels: modal.labels, ...options };
 
         const dialog = modal.dialog(tmpl(options), options);
         const deferred = new Deferred();
@@ -5593,10 +5675,11 @@
             this.$create(
             'drop',
             dropdowns.filter((el) => !this.getDropdown(el)),
-            assign({}, this.$props, {
+            {
+              ...this.$props,
               boundary: this.boundary,
               pos: this.pos,
-              offset: this.dropbar || this.offset }));
+              offset: this.dropbar || this.offset });
 
 
           },
@@ -6488,26 +6571,11 @@
 
 
       computed: {
-        position(_ref, $el) {let { position } = _ref;
-          return position === 'auto' ?
-          (this.isFixed ? this.placeholder : $el).offsetHeight > height(window) ?
-          'bottom' :
-          'top' :
-          position;
-        },
-
-        offset(_ref2, $el) {let { offset } = _ref2;
-          if (this.position === 'bottom') {
-            offset += '+100vh-100%';
-          }
-          return toPx(offset, 'height', $el);
-        },
-
-        selTarget(_ref3, $el) {let { selTarget } = _ref3;
+        selTarget(_ref, $el) {let { selTarget } = _ref;
           return selTarget && $(selTarget, $el) || $el;
         },
 
-        widthElement(_ref4, $el) {let { widthElement } = _ref4;
+        widthElement(_ref2, $el) {let { widthElement } = _ref2;
           return query(widthElement, $el) || this.placeholder;
         },
 
@@ -6555,41 +6623,36 @@
           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);
-
-          if (target) {
-            fastdom.read(() => {
-              const { top } = offset(target);
-              const elTop = offset(this.$el).top;
-              const elHeight = this.$el.offsetHeight;
+          fastdom.read(() => {
+            const targetOffset = offset($(location.hash));
+            const elOffset = offset(this.$el);
 
-              if (
-              this.isFixed &&
-              elTop + elHeight >= top &&
-              elTop <= top + target.offsetHeight)
-              {
-                scrollTop(
-                window,
-                top -
-                elHeight - (
-                isNumeric(this.targetOffset) ? this.targetOffset : 0) -
-                this.offset);
+            if (this.isFixed && intersectRect(targetOffset, elOffset)) {
+              scrollTop(
+              window,
+              targetOffset.top -
+              elOffset.height -
+              toPx(this.targetOffset, 'height') -
+              toPx(this.offset, 'height'));
 
-              }
-            });
-          }
+            }
+          });
         } }],
 
 
 
       update: [
       {
-        read(_ref5, types) {let { height: height$1, margin } = _ref5;
+        read(_ref3, types) {let { height: height$1, margin } = _ref3;
           this.inactive = !this.matchMedia || !isVisible(this.$el);
 
           if (this.inactive) {
@@ -6598,35 +6661,49 @@
 
           const hide = this.isActive && types.has('resize');
           if (hide) {
+            css(this.selTarget, 'transition', '0s');
             this.hide();
           }
 
           if (!this.isActive) {
-            height$1 = this.$el.offsetHeight;
+            height$1 = offset(this.$el).height;
             margin = css(this.$el, 'margin');
           }
 
           if (hide) {
             this.show();
+            fastdom.write(() => css(this.selTarget, 'transition', ''));
           }
 
-          const overflow = Math.max(0, height$1 + this.offset - height(window));
-
           const referenceElement = this.isFixed ? this.placeholder : this.$el;
+          const windowHeight = height(window);
+
+          let position = this.position;
+          if (position === 'auto' && height$1 > windowHeight) {
+            position = 'bottom';
+          }
+
+          let offset$1 = toPx(this.offset, 'height', referenceElement);
+          if (position === 'bottom') {
+            offset$1 += windowHeight - height$1;
+          }
+
+          const overflow = Math.max(0, height$1 + offset$1 - windowHeight);
           const topOffset = offset(referenceElement).top;
           const offsetParentTop = offset(referenceElement.offsetParent).top;
 
           const top = parseProp(this.top, this.$el, topOffset);
           const bottom = parseProp(this.bottom, this.$el, topOffset + height$1, true);
 
-          const start = Math.max(top, topOffset) - this.offset;
+          const start = Math.max(top, topOffset) - offset$1;
           const end = bottom ?
-          bottom - this.$el.offsetHeight + overflow - this.offset :
-          getScrollingElement(this.$el).scrollHeight - height(window);
+          bottom - offset(this.$el).height + overflow - offset$1 :
+          getScrollingElement(this.$el).scrollHeight - windowHeight;
 
           return {
             start,
             end,
+            offset: offset$1,
             overflow,
             topOffset,
             offsetParentTop,
@@ -6634,11 +6711,11 @@
             margin,
             width: dimensions$1(isVisible(this.widthElement) ? this.widthElement : this.$el).
             width,
-            top: offsetPosition(this.placeholder)[0] };
+            top: offsetPosition(referenceElement)[0] };
 
         },
 
-        write(_ref6) {let { height, margin } = _ref6;
+        write(_ref4) {let { height, margin } = _ref4;
           const { placeholder } = this;
 
           css(placeholder, { height, margin });
@@ -6655,14 +6732,14 @@
 
 
       {
-        read(_ref7)
+        read(_ref5)
 
 
 
 
 
 
-        {let { scroll: prevScroll = 0, dir: prevDir = 'down', overflow, overflowScroll = 0, start, end } = _ref7;
+        {let { scroll: prevScroll = 0, dir: prevDir = 'down', overflow, overflowScroll = 0, start, end } = _ref5;
           const scroll = scrollTop(window);
           const dir = prevScroll <= scroll ? 'down' : 'up';
 
@@ -6743,7 +6820,7 @@
             }
           } else if (this.isFixed) {
             this.update();
-          } else if (this.animation) {
+          } else if (this.animation && scroll > topOffset) {
             Animation.cancel(this.$el);
             this.show();
             Animation.in(this.$el, this.animation).catch(noop);
@@ -6771,33 +6848,33 @@
         },
 
         update() {
-          const {
+          let {
             width,
             scroll = 0,
             overflow,
             overflowScroll = 0,
             start,
             end,
+            offset,
             topOffset,
             height,
             offsetParentTop } =
           this._data;
           const active = start !== 0 || scroll > start;
-          let top = this.offset;
           let position = 'fixed';
 
           if (scroll > end) {
-            top = end + this.offset - offsetParentTop;
+            offset += end - offsetParentTop;
             position = 'absolute';
           }
 
           if (overflow) {
-            top -= overflowScroll;
+            offset -= overflowScroll;
           }
 
           css(this.$el, {
             position,
-            top: top + "px",
+            top: offset + "px",
             width });
 
 
@@ -6827,7 +6904,7 @@
     }
 
     var Switcher = {
-      mixins: [Togglable],
+      mixins: [Lazyload, Togglable],
 
       args: 'connect',
 
@@ -6891,6 +6968,10 @@
         } },
 
 
+      connected() {
+        this.lazyload(this.$el, this.connects);
+      },
+
       events: [
       {
         name: 'click',
@@ -6999,7 +7080,7 @@
     const KEY_SPACE = 32;
 
     var toggle = {
-      mixins: [Media, Togglable],
+      mixins: [Lazyload, Media, Togglable],
 
       args: 'target',
 
@@ -7021,6 +7102,7 @@
         if (!includes(this.mode, 'media') && !isFocusable(this.$el)) {
           attr(this.$el, 'tabindex', '0');
         }
+        this.lazyload(this.$el, this.target);
       },
 
       computed: {
@@ -7112,7 +7194,7 @@
         name: 'keydown',
 
         filter() {
-          return includes(this.mode, 'click') && this.$el.tagName !== 'INPUT';
+          return includes(this.mode, 'click') && !isTag(this.$el, 'input');
         },
 
         handler(e) {
@@ -7373,8 +7455,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);
           }
         },
 
@@ -7556,7 +7638,7 @@
 
           // Reset to previous state
           nodes.forEach((el, i) => propsFrom[i] && css(el, propsFrom[i]));
-          css(target, assign({ display: 'block' }, targetProps));
+          css(target, { display: 'block', ...targetProps });
 
           // Start transitions on next frame
           requestAnimationFrame(() => {
@@ -7588,15 +7670,13 @@
       const zIndex = css(el, 'zIndex');
 
       return isVisible(el) ?
-      assign(
       {
         display: '',
         opacity: opacity ? css(el, 'opacity') : '0',
         pointerEvents: 'none',
         position: 'absolute',
-        zIndex: zIndex === 'auto' ? index(el) : zIndex },
-
-      getPositionWithMargin(el)) :
+        zIndex: zIndex === 'auto' ? index(el) : zIndex,
+        ...getPositionWithMargin(el) } :
 
       false;
     }
@@ -7780,7 +7860,7 @@
         },
 
         setState(state, animate) {if (animate === void 0) {animate = true;}
-          state = assign({ filter: { '': '' }, sort: [] }, state);
+          state = { filter: { '': '' }, sort: [], ...state };
 
           trigger(this.$el, 'beforeFilter', [this, state]);
 
@@ -7880,7 +7960,7 @@
     }
 
     function sortItems(nodes, sort, order) {
-      return assign([], nodes).sort(
+      return [...nodes].sort(
       (a, b) =>
       data(a, sort).localeCompare(data(b, sort), undefined, { numeric: true }) * (
       order === 'asc' || -1));
@@ -7919,7 +7999,8 @@
       return "scale3d(" + value + ", " + value + ", 1)";
     }
 
-    var Animations$1 = assign({}, Animations$2, {
+    var Animations$1 = {
+      ...Animations$2,
       fade: {
         show() {
           return [{ opacity: 0 }, { opacity: 1 }];
@@ -7951,7 +8032,7 @@
           { opacity: 1 - percent, transform: scale3d(1 - 0.2 * percent) },
           { opacity: percent, transform: scale3d(1 - 0.2 + 0.2 * percent) }];
 
-        } } });
+        } } };
 
     function Transitioner$1(prev, next, dir, _ref) {let { animation, easing } = _ref;
       const { percent, translate, show = noop } = animation;
@@ -8425,12 +8506,6 @@
         } },
 
 
-      events: {
-        itemshown() {
-          this.$update(this.list);
-        } },
-
-
       methods: {
         show(index, force) {if (force === void 0) {force = false;}
           if (this.dragging || !this.length) {
@@ -8512,20 +8587,13 @@
         },
 
         _show(prev, next, force) {
-          this._transitioner = this._getTransitioner(
-          prev,
-          next,
-          this.dir,
-          assign(
-          {
+          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));
-
+            this.easing,
+            ...this.transitionOptions });
 
 
           if (!force && !prev) {
@@ -8590,7 +8658,7 @@
 
       computed: {
         animation(_ref) {let { animation, Animations } = _ref;
-          return assign(Animations[animation] || Animations.slide, { name: animation });
+          return { ...(Animations[animation] || Animations.slide), name: animation };
         },
 
         transitionOptions() {
@@ -8599,19 +8667,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);
         } } };
 
@@ -8813,28 +8877,20 @@
           if (type === 'image' || src.match(/\.(avif|jpe?g|a?png|gif|svg|webp)($|\?)/i)) {
             try {
               const { width, height } = await getImage(src, attrs.srcset, attrs.size);
-              this.setItem(
-              item,
-              createEl('img', assign({ src, width, height, alt }, attrs)));
-
+              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',
-            assign(
-            {
+            const video = createEl('video', {
               src,
               poster,
               controls: '',
               playsinline: '',
-              'uk-video': "" + this.videoAutoplay },
-
-            attrs));
-
+              'uk-video': "" + this.videoAutoplay,
+              ...attrs });
 
 
             on(video, 'loadedmetadata', () => {
@@ -8847,17 +8903,12 @@
           } else if (type === 'iframe' || src.match(/\.(html|php)($|\?)/i)) {
             this.setItem(
             item,
-            createEl(
-            'iframe',
-            assign(
-            {
+            createEl('iframe', {
               src,
               frameborder: '0',
               allowfullscreen: '',
-              class: 'uk-lightbox-iframe' },
-
-            attrs)));
-
+              class: 'uk-lightbox-iframe',
+              ...attrs }));
 
 
 
@@ -8869,19 +8920,14 @@
           {
             this.setItem(
             item,
-            createEl(
-            'iframe',
-            assign(
-            {
-              src: "https://www.youtube" + (matches[1] || '') + ".com/embed/" +
-              matches[2] + (
+            createEl('iframe', {
+              src: "https://www.youtube" + (matches[1] || '') + ".com/embed/" + matches[2] + (
               matches[3] ? "?" + matches[3] : ''),
-              width: 1920,
-              height: 1080 },
-
-            iframeAttrs,
-            attrs)));
 
+              width: 1920,
+              height: 1080,
+              ...iframeAttrs,
+              ...attrs }));
 
 
 
@@ -8901,19 +8947,14 @@
 
               this.setItem(
               item,
-              createEl(
-              'iframe',
-              assign(
-              {
+              createEl('iframe', {
                 src: "https://player.vimeo.com/video/" + matches[1] + (
                 matches[2] ? "?" + matches[2] : ''),
 
                 width,
-                height },
-
-              iframeAttrs,
-              attrs)));
-
+                height,
+                ...iframeAttrs,
+                ...attrs }));
 
 
             } catch (e) {
@@ -9015,8 +9056,7 @@
             index = findIndex(items, (_ref2) => {let { source: src } = _ref2;return source === src;});
           }
 
-          this.panel =
-          this.panel || this.$create('lightboxPanel', assign({}, this.$props, { items }));
+          this.panel = this.panel || this.$create('lightboxPanel', { ...this.$props, items });
 
           on(this.panel.$el, 'hidden', () => this.panel = false);
 
@@ -9221,50 +9261,44 @@
         },
 
         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;
         } } };
 
 
 
-    function transformFn(prop, el, steps) {
-      const unit = getUnit(steps) || { x: 'px', y: 'px', rotate: 'deg' }[prop] || '';
+    function transformFn(prop, el, stops) {
+      const unit = getUnit(stops) || { x: 'px', y: 'px', rotate: 'deg' }[prop] || '';
+      let transformFn;
 
       if (prop === 'x' || prop === 'y') {
         prop = "translate" + ucfirst(prop);
+        transformFn = (stop) => toFloat(toFloat(stop).toFixed(unit === 'px' ? 0 : 6));
       }
 
-      steps = steps.map(toFloat);
-
-      if (steps.length === 1) {
-        steps.unshift(prop === 'scale' ? 1 : 0);
+      if (stops.length === 1) {
+        stops.unshift(prop === 'scale' ? 1 : 0);
       }
 
-      return (css, percent) => {
-        let value = getValue(steps, percent);
+      stops = parseStops(stops, transformFn);
 
-        if (startsWith(prop, 'translate')) {
-          value = toFloat(value).toFixed(unit === 'px' ? 0 : 6);
-        }
-
-        css.transform += " " + prop + "(" + value + unit + ")";
+      return (css, percent) => {
+        css.transform += " " + prop + "(" + getValue(stops, percent) + unit + ")";
       };
     }
 
-    function colorFn(prop, el, steps) {
-      if (steps.length === 1) {
-        steps.unshift(getCssValue(el, prop, ''));
+    function colorFn(prop, el, stops) {
+      if (stops.length === 1) {
+        stops.unshift(getCssValue(el, prop, ''));
       }
 
-      steps = steps.map((step) => parseColor(el, step));
+      stops = parseStops(stops, (stop) => parseColor(el, stop));
 
       return (css, percent) => {
-        const [start, end, p] = getStep(steps, percent);
+        const [start, end, p] = getStop(stops, percent);
         const value = start.
         map((value, i) => {
           value += p * (end[i] - value);
@@ -9284,85 +9318,83 @@
       map(toFloat);
     }
 
-    function filterFn(prop, el, steps) {
-      if (steps.length === 1) {
-        steps.unshift(0);
+    function filterFn(prop, el, stops) {
+      if (stops.length === 1) {
+        stops.unshift(0);
       }
 
-      const unit = getUnit(steps) || { blur: 'px', hue: 'deg' }[prop] || '%';
+      const unit = getUnit(stops) || { blur: 'px', hue: 'deg' }[prop] || '%';
       prop = { fopacity: 'opacity', hue: 'hue-rotate' }[prop] || prop;
-      steps = steps.map(toFloat);
+      stops = parseStops(stops);
 
       return (css, percent) => {
-        const value = getValue(steps, percent);
+        const value = getValue(stops, percent);
         css.filter += " " + prop + "(" + (value + unit) + ")";
       };
     }
 
-    function cssPropFn(prop, el, steps) {
-      if (steps.length === 1) {
-        steps.unshift(getCssValue(el, prop, ''));
+    function cssPropFn(prop, el, stops) {
+      if (stops.length === 1) {
+        stops.unshift(getCssValue(el, prop, ''));
       }
 
-      steps = steps.map(toFloat);
+      stops = parseStops(stops);
 
       return (css, percent) => {
-        css[prop] = getValue(steps, percent);
+        css[prop] = getValue(stops, percent);
       };
     }
 
-    function strokeFn(prop, el, steps) {
-      if (steps.length === 1) {
-        steps.unshift(0);
+    function strokeFn(prop, el, stops) {
+      if (stops.length === 1) {
+        stops.unshift(0);
       }
 
-      const unit = getUnit(steps);
-      steps = steps.map(toFloat);
+      const unit = getUnit(stops);
+      const length = getMaxPathLength(el);
+      stops = parseStops(stops.reverse(), (stop) => {
+        stop = toFloat(stop);
+        return unit === '%' ? stop * length / 100 : stop;
+      });
 
-      if (!steps.some((step) => step)) {
+      if (!stops.some((_ref) => {let [value] = _ref;return value;})) {
         return noop;
       }
 
-      const length = getMaxPathLength(el);
       css(el, 'strokeDasharray', length);
 
-      if (unit === '%') {
-        steps = steps.map((step) => step * length / 100);
-      }
-
-      steps = steps.reverse();
-
       return (css, percent) => {
-        css.strokeDashoffset = getValue(steps, percent);
+        css.strokeDashoffset = getValue(stops, percent);
       };
     }
 
-    function backgroundFn(prop, el, steps) {
-      if (steps.length === 1) {
-        steps.unshift(0);
+    function backgroundFn(prop, el, stops) {
+      if (stops.length === 1) {
+        stops.unshift(0);
       }
 
       prop = prop.substr(-1);
       const attr = prop === 'y' ? 'height' : 'width';
-      steps = steps.map((step) => toPx(step, attr, el));
+      stops = parseStops(stops, (stop) => toPx(stop, attr, el));
 
       const bgPos = getCssValue(el, "background-position-" + prop, '');
 
       return getCssValue(el, 'backgroundSize', '') === 'cover' ?
-      backgroundCoverFn(prop, el, steps, bgPos, attr) :
-      setBackgroundPosFn(prop, steps, bgPos);
+      backgroundCoverFn(prop, el, stops, bgPos, attr) :
+      setBackgroundPosFn(prop, stops, bgPos);
     }
 
-    function backgroundCoverFn(prop, el, steps, bgPos, attr) {
+    function backgroundCoverFn(prop, el, stops, bgPos, attr) {
       const dimImage = getBackgroundImageDimensions(el);
 
       if (!dimImage.width) {
         return noop;
       }
 
-      const min = Math.min(...steps);
-      const max = Math.max(...steps);
-      const down = steps.indexOf(min) < steps.indexOf(max);
+      const values = stops.map((_ref2) => {let [value] = _ref2;return value;});
+      const min = Math.min(...values);
+      const max = Math.max(...values);
+      const down = values.indexOf(min) < values.indexOf(max);
 
       const diff = max - min;
       let pos = (down ? -diff : 0) - (down ? min : max);
@@ -9387,7 +9419,7 @@
 
       const dim = Dimensions.cover(dimImage, dimEl);
 
-      const fn = setBackgroundPosFn(prop, steps, pos + "px");
+      const fn = setBackgroundPosFn(prop, stops, pos + "px");
       return (css, percent) => {
         fn(css, percent);
         css.backgroundSize = dim.width + "px " + dim.height + "px";
@@ -9395,9 +9427,9 @@
       };
     }
 
-    function setBackgroundPosFn(prop, steps, pos) {
+    function setBackgroundPosFn(prop, stops, pos) {
       return function (css, percent) {
-        css["background-position-" + prop] = "calc(" + pos + " + " + getValue(steps, percent) + "px)";
+        css["background-position-" + prop] = "calc(" + pos + " + " + getValue(stops, percent) + "px)";
       };
     }
 
@@ -9418,6 +9450,7 @@
             dimensions[src] = toDimensions(image);
             trigger(el, 'bgimageload');
           };
+          return toDimensions(image);
         }
       }
 
@@ -9431,27 +9464,71 @@
 
     }
 
-    function getStep(steps, percent) {
-      const count = steps.length - 1;
-      const index = Math.min(Math.floor(count * percent), count - 1);
+    function parseStops(stops, fn) {if (fn === void 0) {fn = toFloat;}
+      const result = [];
+      const { length } = stops;
+      let nullIndex = 0;
+      for (let i = 0; i < length; i++) {
+        let [value, percent] = isString(stops[i]) ? stops[i].trim().split(' ') : [stops[i]];
+        value = fn(value);
+        percent = percent ? toFloat(percent) / 100 : null;
+
+        if (i === 0) {
+          if (percent === null) {
+            percent = 0;
+          } else if (percent) {
+            result.push([value, 0]);
+          }
+        } else if (i === length - 1) {
+          if (percent === null) {
+            percent = 1;
+          } else if (percent !== 1) {
+            result.push([value, percent]);
+            percent = 1;
+          }
+        }
+
+        result.push([value, percent]);
+
+        if (percent === null) {
+          nullIndex++;
+        } else if (nullIndex) {
+          const leftPercent = result[i - nullIndex - 1][1];
+          const p = (percent - leftPercent) / (nullIndex + 1);
+          for (let j = nullIndex; j > 0; j--) {
+            result[i - j][1] = leftPercent + p * (nullIndex - j + 1);
+          }
+
+          nullIndex = 0;
+        }
+      }
+
+      return result;
+    }
+
+    function getStop(stops, percent) {
+      const index = findIndex(stops.slice(1), (_ref3) => {let [, targetPercent] = _ref3;return percent <= targetPercent;}) + 1;
+      return [
+      stops[index - 1][0],
+      stops[index][0],
+      (percent - stops[index - 1][1]) / (stops[index][1] - stops[index - 1][1])];
 
-      return steps.
-      slice(index, index + 2).
-      concat(percent === 1 ? 1 : percent % (1 / count) * count);
     }
 
-    function getValue(steps, percent) {
-      const [start, end, p] = getStep(steps, percent);
+    function getValue(stops, percent) {
+      const [start, end, p] = getStop(stops, percent);
       return isNumber(start) ? start + Math.abs(start - end) * p * (start < end ? 1 : -1) : +end;
     }
 
-    function getUnit(steps, defaultUnit) {
-      return (
-        steps.reduce(
-        (unit, step) => unit || isString(step) && step.replace(/[\d-]/g, '').trim(),
-        '') ||
-        defaultUnit);
-
+    const unitRe = /^-?\d+([^\s]*)/;
+    function getUnit(stops, defaultUnit) {
+      for (const stop of stops) {
+        const match = stop.match == null ? void 0 : stop.match(unitRe);
+        if (match) {
+          return match[1];
+        }
+      }
+      return defaultUnit;
     }
 
     function getCssValue(el, prop, value) {
@@ -9563,6 +9640,22 @@
 
         events: ['resize'] } };
 
+    var SliderPreload = {
+      connected() {
+        this.registerObserver(
+        observeIntersection(
+        this.slides.concat(this.$el),
+        (entries, observer) => {
+          for (const el of this.getAdjacentSlides()) {
+            $$('img[loading="lazy"]', el).forEach((el) => removeAttr(el, 'loading'));
+            observer.unobserve(el);
+          }
+        },
+        { rootMargin: '50% 50%' }));
+
+
+      } };
+
     function Transitioner (prev, next, dir, _ref) {let { center, easing, list } = _ref;
       const deferred = new Deferred();
 
@@ -9729,7 +9822,7 @@
     }
 
     var slider = {
-      mixins: [Class, Slider, SliderReactive],
+      mixins: [Class, Slider, SliderReactive, SliderPreload],
 
       props: {
         center: Boolean,
@@ -9781,48 +9874,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;
-
-          sets = sortBy$1(this.slides, 'offsetLeft').reduce((sets, slide, i) => {
-            const slideWidth = dimensions$1(slide).width;
-            const slideRight = slideLeft + slideWidth;
+          const sets = [];
+          const width = dimensions$1(this.list).width;
+          for (let i in this.slides) {
+            const slideWidth = dimensions$1(this.slides[i]).width;
 
-            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() {
@@ -9854,15 +9938,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'] },
@@ -9910,6 +9986,10 @@
           if (~this.prevIndex) {
             addClass(this._getTransitioner().getItemIn(), this.clsActive);
           }
+        },
+
+        itemshown() {
+          this.updateActiveClasses();
         } },
 
 
@@ -9947,6 +10027,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);
 
@@ -9966,6 +10058,25 @@
           } while (index !== prev);
 
           return index;
+        },
+
+        getAdjacentSlides() {
+          const { width } = dimensions$1(this.list);
+          const left = -width;
+          const right = width * 2;
+          const slideWidth = dimensions$1(this.slides[this.index]).width;
+          const slideLeft = this.center ? width / 2 - slideWidth / 2 : 0;
+          const slides = new Set();
+          for (const i of [-1, 1]) {
+            let currentLeft = slideLeft + (i > 0 ? slideWidth : 0);
+            let j = 0;
+            do {
+              const slide = this.slides[this.getIndex(this.index + i + j++ * i)];
+              currentLeft += dimensions$1(slide).width * i;
+              slides.add(slide);
+            } while (this.slides.length > j && currentLeft > left && currentLeft < right);
+          }
+          return Array.from(slides);
         } } };
 
 
@@ -10052,7 +10163,8 @@
       return isIn(type) ^ dir < 0 ? percent : 1 - percent;
     }
 
-    var Animations = assign({}, Animations$2, {
+    var Animations = {
+      ...Animations$2,
       fade: {
         show() {
           return [{ opacity: 0, zIndex: 0 }, { zIndex: -1 }];
@@ -10141,10 +10253,10 @@
           { transform: translate(-30 * percent), zIndex: -1 },
           { transform: translate(100 * (1 - percent)), zIndex: 0 }];
 
-        } } });
+        } } };
 
     var slideshow = {
-      mixins: [Class, Slideshow, SliderReactive],
+      mixins: [Class, Slideshow, SliderReactive, SliderPreload],
 
       props: {
         ratio: String,
@@ -10187,7 +10299,13 @@
           height > 0 && css(this.list, 'minHeight', height);
         },
 
-        events: ['resize'] } };
+        events: ['resize'] },
+
+
+      methods: {
+        getAdjacentSlides() {
+          return [1, -1].map((i) => this.slides[this.getIndex(this.index + i)]);
+        } } };
 
     var sortable = {
       mixins: [Class, Animate],
@@ -10360,7 +10478,7 @@
 
           this.touched = new Set([this]);
           this.placeholder = placeholder;
-          this.origin = assign({ target, index: index(placeholder) }, this.pos);
+          this.origin = { target, index: index(placeholder), ...this.pos };
 
           on(document, pointerMove, this.move);
           on(document, pointerUp, this.end);