uikit 3.11.2-dev.72dbb9a19 → 3.11.2-dev.92f357b93

package/dist/js/uikit.js

@@ -1,4 +1,4 @@
-/*! UIkit 3.11.2-dev.72dbb9a19 | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
+/*! UIkit 3.11.2-dev.92f357b93 | 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) {
@@ -756,7 +757,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);
 
@@ -782,9 +784,8 @@
           priority = value;
           each(property, (value, property) => css(element, property, value, priority));
         }
-
-        return element;
-      })[0];
+      }
+      return elements[0];
     }
 
     function getStyles(element, pseudoElt) {
@@ -1174,8 +1175,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;
@@ -1190,6 +1191,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, '');
     }
@@ -1198,34 +1203,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;
-    }
-
-    function before(ref, element) {
-      const nodes = $$(element);
-      $(ref).before(...nodes);
-      return nodes;
-    }
+    const replaceChildren = applyFn('replaceChildren');
+    const prepend = applyFn('prepend');
+    const append = applyFn('append');
+    const before = applyFn('before');
+    const after = applyFn('after');
 
-    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) {
@@ -1263,9 +1254,16 @@
 
     function fragment(html) {
       const template = document.createElement('template');
-      template.innerHTML = html;
-      const { childNodes } = template.content;
-      return childNodes.length > 1 ? toNodes(childNodes) : childNodes[0];
+      template.innerHTML = html.trim();
+      const nodes = toNodes(template.content.childNodes);
+      for (const node of nodes) {
+        document.adoptNode(node);
+      }
+      return unwrapSingle(nodes);
+    }
+
+    function unwrapSingle(nodes) {
+      return nodes.length > 1 ? nodes : nodes[0];
     }
 
     function apply(node, fn) {
@@ -1638,11 +1636,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) {
@@ -2042,6 +2040,7 @@
         flipPosition: flipPosition,
         toPx: toPx,
         ready: ready,
+        isTag: isTag,
         empty: empty,
         html: html,
         replaceChildren: replaceChildren,
@@ -2808,7 +2807,7 @@
     UIkit.data = '__uikit__';
     UIkit.prefix = 'uk-';
     UIkit.options = {};
-    UIkit.version = '3.11.2-dev.72dbb9a19';
+    UIkit.version = '3.11.2-dev.92f357b93';
 
     globalAPI(UIkit);
     hooksAPI(UIkit);
@@ -4460,6 +4459,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.');
         },
 
@@ -4559,7 +4564,7 @@
     }
 
     function insertSVG(el, root) {
-      if (isVoidElement(root) || root.tagName === 'CANVAS') {
+      if (isVoidElement(root) || isTag(root, 'canvas')) {
         root.hidden = true;
 
         const next = root.nextElementSibling;
@@ -4571,11 +4576,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) {
@@ -4762,120 +4763,95 @@
       return isRtl ? swap(swap(icon, 'left', 'right'), 'previous', 'next') : icon;
     }
 
+    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',
 
       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');
-        },
+          } } },
 
-        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' || !window.IntersectionObserver || !nativeIsIntersecting) {
+          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);
 
+        const rootMargin = toPx(this.offsetTop, 'height') + "px " + toPx(
+        this.offsetLeft,
+        'width') + "px";
 
-        requestAnimationFrame(this.observe);
-      },
+        this.observer = new IntersectionObserver(
+        (entries) => {
+          if (entries.some((entry) => entry.isIntersecting)) {
+            this.load();
+            this.observer.disconnect();
+          }
+        },
+        { rootMargin });
 
-      disconnected() {
-        this.observer && this.observer.disconnect();
+        this.observe();
       },
 
-      update: {
-        read(_ref8) {let { image } = _ref8;
-          if (!this.observer) {
-            return false;
-          }
+      disconnected() {var _this$observer;
+        if (this._data.image) {
+          this._data.image.onload = '';
+        }
 
-          if (!image && document.readyState === 'complete') {
-            this.load(this.observer.takeRecords());
-          }
+        (_this$observer = this.observer) == null ? void 0 : _this$observer.disconnect();
+      },
 
-          if (this.isImg) {
+      update: {
+        write(store) {
+          if (!this.observer || isImg(this.$el)) {
             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");
             }
           }
         },
@@ -4884,24 +4860,18 @@
 
 
       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();
+          removeAttr(image, 'loading');
+          setSrcAttrs(this.$el, image.currentSrc);
+          return this._data.image = image;
         },
 
         observe() {
@@ -4914,12 +4884,11 @@
 
 
 
-    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) {
@@ -4929,16 +4898,60 @@
       }
     }
 
-    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);
+      }
+
+      if (!isArray(sources)) {
+        sources = [sources];
       }
 
-      return "data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" + width + "\" height=\"" + height + "\"></svg>";
+      return sources.filter((source) => !isEmpty(source));
     }
 
     const sizesRe = /\s*(.*?)\s*(\w+|calc\(.*?\))\s*(?:,|$)/g;
@@ -4978,24 +4991,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 = {
@@ -6622,7 +6629,7 @@
             margin,
             width: dimensions$1(isVisible(this.widthElement) ? this.widthElement : this.$el).
             width,
-            top: offsetPosition(this.placeholder)[0] };
+            top: offsetPosition(referenceElement)[0] };
 
         },
 
@@ -7100,7 +7107,7 @@
         name: 'keydown',
 
         filter() {
-          return includes(this.mode, 'click') && this.$el.tagName !== 'INPUT';
+          return includes(this.mode, 'click') && isTag(this.$el, 'input');
         },
 
         handler(e) {
@@ -9188,39 +9195,35 @@
 
 
 
-    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);
@@ -9240,85 +9243,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);
@@ -9343,7 +9344,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";
@@ -9351,9 +9352,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)";
       };
     }
 
@@ -9387,27 +9388,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;
 
-      return steps.
-      slice(index, index + 2).
-      concat(percent === 1 ? 1 : percent % (1 / count) * count);
+        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 getValue(steps, percent) {
-      const [start, end, p] = getStep(steps, percent);
-      return isNumber(start) ? start + Math.abs(start - end) * p * (start < end ? 1 : -1) : +end;
+    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])];
+
     }
 
-    function getUnit(steps, defaultUnit) {
-      return (
-        steps.reduce(
-        (unit, step) => unit || isString(step) && step.replace(/[\d-]/g, '').trim(),
-        '') ||
-        defaultUnit);
+    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;
+    }
 
+    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) {
@@ -9519,6 +9564,42 @@
 
         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);
+        }
+      },
+
+      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'));
+      }
+    }
+
     function Transitioner (prev, next, dir, _ref) {let { center, easing, list } = _ref;
       const deferred = new Deferred();
 
@@ -9685,7 +9766,7 @@
     }
 
     var slider = {
-      mixins: [Class, Slider, SliderReactive],
+      mixins: [Class, Slider, SliderReactive, SliderPreload],
 
       props: {
         center: Boolean,
@@ -9922,6 +10003,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);
         } } };
 
 
@@ -10101,7 +10201,7 @@
         } } };
 
     var slideshow = {
-      mixins: [Class, Slideshow, SliderReactive],
+      mixins: [Class, Slideshow, SliderReactive, SliderPreload],
 
       props: {
         ratio: String,
@@ -10144,7 +10244,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],