uikit 3.10.2-dev.c8aa7eda2 → 3.11.1

package/dist/js/uikit.js

@@ -1,4 +1,4 @@
-/*! UIkit 3.10.2-dev.c8aa7eda2 | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
+/*! UIkit 3.11.1 | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
 
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -1745,9 +1745,10 @@
         return pos;
     }
 
-    function toPx(value, property, element) {
+    function toPx(value, property, element, offsetDim) {
         if ( property === void 0 ) property = 'width';
         if ( element === void 0 ) element = window;
+        if ( offsetDim === void 0 ) offsetDim = false;
 
         return isNumeric(value)
             ? +value
@@ -1756,7 +1757,9 @@
                 : endsWith(value, 'vw')
                     ? percent(width(toWindow(element)), value)
                     : endsWith(value, '%')
-                        ? percent(dimensions(element)[property], value)
+                        ? percent(offsetDim
+                            ? element[("offset" + (ucfirst(property)))]
+                            : dimensions(element)[property], value)
                         : toFloat(value);
     }
 
@@ -2316,8 +2319,9 @@
 
     }
 
-    function scrolledOver(element, heightOffset) {
-        if ( heightOffset === void 0 ) heightOffset = 0;
+    function scrolledOver(element, startOffset, endOffset) {
+        if ( startOffset === void 0 ) startOffset = 0;
+        if ( endOffset === void 0 ) endOffset = 0;
 
 
         if (!isVisible(element)) {
@@ -2328,18 +2332,14 @@
         var scrollElement = ref[0];
         var scrollHeight = scrollElement.scrollHeight;
         var scrollTop = scrollElement.scrollTop;
-        var clientHeight = getViewportClientHeight(scrollElement);
-        var viewportTop = offsetPosition(element)[0] - scrollTop - offsetPosition(scrollElement)[0];
-        var viewportDist = Math.min(clientHeight, viewportTop + scrollTop);
-
-        var top = viewportTop - viewportDist;
-        var dist = Math.min(
-            element.offsetHeight + heightOffset + viewportDist,
-            scrollHeight - (viewportTop + scrollTop),
-            scrollHeight - clientHeight
-        );
+        var viewportHeight = getViewportClientHeight(scrollElement);
+        var maxScroll = scrollHeight - viewportHeight;
+        var elementOffsetTop = offsetPosition(element)[0] - offsetPosition(scrollElement)[0];
+
+        var start = Math.max(0, elementOffsetTop - viewportHeight + startOffset);
+        var end = Math.min(maxScroll, elementOffsetTop + element.offsetHeight - endOffset);
 
-        return clamp(-1 * top / dist);
+        return clamp((scrollTop - start) / (end - start));
     }
 
     function scrollParents(element, overflowRe, scrollable) {
@@ -3462,7 +3462,7 @@
     UIkit.data = '__uikit__';
     UIkit.prefix = 'uk-';
     UIkit.options = {};
-    UIkit.version = '3.10.2-dev.c8aa7eda2';
+    UIkit.version = '3.11.1';
 
     globalAPI(UIkit);
     hooksAPI(UIkit);
@@ -5007,7 +5007,7 @@
             {
 
                 read: function(ref) {
-                    var height$1 = ref.height;
+                    ref.height;
 
 
                     if (positionedAbsolute(this.$el)) {
@@ -5016,7 +5016,7 @@
 
                     return {
                         scrolled: this.parallax
-                            ? scrolledOver(this.$el, height$1 ? height$1 - height(this.$el) : 0) * Math.abs(this.parallax)
+                            ? scrolledOver(this.$el) * Math.abs(this.parallax)
                             : false
                     };
                 },
@@ -5389,15 +5389,17 @@
 
 
             this.svg.then(function (svg) {
-                if (!this$1$1._connected) {
-
-                    if (isVoidElement(this$1$1.$el)) {
-                        this$1$1.$el.hidden = false;
-                    }
+                if (this$1$1._connected) {
+                    return;
+                }
 
-                    remove$1(svg);
-                    this$1$1.svgEl = null;
+                if (isVoidElement(this$1$1.$el)) {
+                    this$1$1.$el.hidden = false;
                 }
+
+                remove$1(svg);
+                this$1$1.svgEl = null;
+
             });
 
             this.svg = null;
@@ -10698,357 +10700,315 @@
         };
     }
 
-    var props = ['x', 'y', 'bgx', 'bgy', 'rotate', 'scale', 'color', 'backgroundColor', 'borderColor', 'opacity', 'blur', 'hue', 'grayscale', 'invert', 'saturate', 'sepia', 'fopacity', 'stroke'];
+    var props = {
+        x: transformFn,
+        y: transformFn,
+        rotate: transformFn,
+        scale: transformFn,
+        color: colorFn,
+        backgroundColor: colorFn,
+        borderColor: colorFn,
+        blur: filterFn,
+        hue: filterFn,
+        fopacity: filterFn,
+        grayscale: filterFn,
+        invert: filterFn,
+        saturate: filterFn,
+        sepia: filterFn,
+        opacity: cssPropFn,
+        stroke: strokeFn,
+        bgx: backgroundFn,
+        bgy: backgroundFn
+    };
+
+    var keys = Object.keys;
 
     var Parallax = {
 
         mixins: [Media],
 
-        props: props.reduce(function (props, prop) {
-            props[prop] = 'list';
-            return props;
-        }, {}),
+        props: fillObject(keys(props), 'list'),
 
-        data: props.reduce(function (data, prop) {
-            data[prop] = undefined;
-            return data;
-        }, {}),
+        data: fillObject(keys(props), undefined),
 
         computed: {
 
             props: function(properties, $el) {
                 var this$1$1 = this;
 
-
-                return props.reduce(function (props, prop) {
-
-                    if (isUndefined(properties[prop])) {
-                        return props;
+                return keys(props).reduce(function (result, prop) {
+                    if (!isUndefined(properties[prop])) {
+                        result[prop] = props[prop].call(this$1$1, prop, $el, properties[prop].slice());
                     }
+                    return result;
+                }, {});
+            }
 
-                    var isColor = prop.match(/color/i);
-                    var isCssProp = isColor || prop === 'opacity';
-
-                    var pos, bgPos, diff;
-                    var steps = properties[prop].slice();
-
-                    if (isCssProp) {
-                        css($el, prop, '');
-                    }
-
-                    if (steps.length < 2) {
-                        steps.unshift((prop === 'scale'
-                            ? 1
-                            : isCssProp
-                                ? css($el, prop)
-                                : 0) || 0);
-                    }
-
-                    var unit = getUnit(steps);
-
-                    if (isColor) {
-
-                        var ref = $el.style;
-                        var color = ref.color;
-                        steps = steps.map(function (step) { return parseColor($el, step); });
-                        $el.style.color = color;
-
-                    } else if (startsWith(prop, 'bg')) {
-
-                        var attr = prop === 'bgy' ? 'height' : 'width';
-                        steps = steps.map(function (step) { return toPx(step, attr, $el); });
-
-                        css($el, ("background-position-" + (prop[2])), '');
-                        bgPos = css($el, 'backgroundPosition').split(' ')[prop[2] === 'x' ? 0 : 1]; // IE 11 can't read background-position-[x|y]
-
-                        if (this$1$1.covers) {
+        },
 
-                            var min = Math.min.apply(Math, steps);
-                            var max = Math.max.apply(Math, steps);
-                            var down = steps.indexOf(min) < steps.indexOf(max);
+        methods: {
 
-                            diff = max - min;
+            reset: function() {
+                var this$1$1 = this;
 
-                            steps = steps.map(function (step) { return step - (down ? min : max); });
-                            pos = (down ? -diff : 0) + "px";
+                each(this.getCss(0), function (_, prop) { return css(this$1$1.$el, prop, ''); });
+            },
 
-                        } else {
+            getCss: function(percent) {
+                var this$1$1 = this;
 
-                            pos = bgPos;
+                return keys(this.props).reduce(function (css, prop) {
+                    this$1$1.props[prop](css, percent);
+                    return css;
+                }, {transform: '', filter: ''});
+            }
 
-                        }
+        }
 
-                    } else {
+    };
 
-                        steps = steps.map(toFloat);
+    function transformFn(prop, el, steps) {
 
-                    }
+        var unit = getUnit(steps) || {x: 'px', y: 'px', rotate: 'deg'}[prop] || '';
 
-                    if (prop === 'stroke') {
+        if (prop === 'x' || prop === 'y') {
+            prop = "translate" + (ucfirst(prop));
+        }
 
-                        if (!steps.some(function (step) { return step; })) {
-                            return props;
-                        }
+        steps = steps.map(toFloat);
 
-                        var length = getMaxPathLength($el);
-                        css($el, 'strokeDasharray', length);
+        if (steps.length === 1) {
+            steps.unshift(prop === 'scale' ? 1 : 0);
+        }
 
-                        if (unit === '%') {
-                            steps = steps.map(function (step) { return step * length / 100; });
-                        }
+        return function (css, percent) {
+            var value = getValue(steps, percent);
 
-                        steps = steps.reverse();
+            if (startsWith(prop, 'translate')) {
+                value = toFloat(value).toFixed(unit === 'px' ? 0 : 6);
+            }
 
-                        prop = 'strokeDashoffset';
-                    }
+            css.transform += " " + prop + "(" + value + unit + ")";
+        };
+    }
 
-                    props[prop] = {steps: steps, unit: unit, pos: pos, bgPos: bgPos, diff: diff};
+    function colorFn(prop, el, steps) {
 
-                    return props;
+        if (steps.length === 1) {
+            steps.unshift(getCssValue(el, prop, ''));
+        }
 
-                }, {});
+        steps = steps.map(function (step) { return parseColor(el, step); });
 
-            },
+        return function (css, percent) {
 
-            bgProps: function() {
-                var this$1$1 = this;
+            var ref = getStep(steps, percent);
+            var start = ref[0];
+            var end = ref[1];
+            var p = ref[2];
+            var value = start.map(function (value, i) {
+                value += p * (end[i] - value);
+                return i === 3 ? toFloat(value) : parseInt(value, 10);
+            }).join(',');
+            css[prop] = "rgba(" + value + ")";
+        };
+    }
 
-                return ['bgx', 'bgy'].filter(function (bg) { return bg in this$1$1.props; });
-            },
+    function parseColor(el, color) {
+        return getCssValue(el, 'color', color)
+            .split(/[(),]/g)
+            .slice(1, -1)
+            .concat(1)
+            .slice(0, 4)
+            .map(toFloat);
+    }
 
-            covers: function(_, $el) {
-                return covers($el);
-            }
+    function filterFn(prop, el, steps) {
 
-        },
+        if (steps.length === 1) {
+            steps.unshift(0);
+        }
 
-        disconnected: function() {
-            delete this._image;
-        },
+        var unit = getUnit(steps) || {blur: 'px', hue: 'deg'}[prop] || '%';
+        prop = {fopacity: 'opacity', hue: 'hue-rotate'}[prop] || prop;
+        steps = steps.map(toFloat);
 
-        update: {
+        return function (css, percent) {
+            var value = getValue(steps, percent);
+            css.filter += " " + prop + "(" + (value + unit) + ")";
+        };
+    }
 
-            read: function(data) {
-                var this$1$1 = this;
+    function cssPropFn(prop, el, steps) {
 
+        if (steps.length === 1) {
+            steps.unshift(getCssValue(el, prop, ''));
+        }
 
-                if (!this.matchMedia) {
-                    return;
-                }
+        steps = steps.map(toFloat);
 
-                if (!data.image && this.covers && this.bgProps.length) {
-                    var src = css(this.$el, 'backgroundImage').replace(/^none|url\(["']?(.+?)["']?\)$/, '$1');
+        return function (css, percent) {
+            css[prop] = getValue(steps, percent);
+        };
+    }
 
-                    if (src) {
-                        var img = new Image();
-                        img.src = src;
-                        data.image = img;
+    function strokeFn(prop, el, steps) {
 
-                        if (!img.naturalWidth) {
-                            img.onload = function () { return this$1$1.$update(); };
-                        }
-                    }
-
-                }
+        if (steps.length === 1) {
+            steps.unshift(0);
+        }
 
-                var image = data.image;
+        var unit = getUnit(steps);
+        steps = steps.map(toFloat);
 
-                if (!image || !image.naturalWidth) {
-                    return;
-                }
+        if (!steps.some(function (step) { return step; })) {
+            return noop;
+        }
 
-                var dimEl = {
-                    width: this.$el.offsetWidth,
-                    height: this.$el.offsetHeight
-                };
-                var dimImage = {
-                    width: image.naturalWidth,
-                    height: image.naturalHeight
-                };
+        var length = getMaxPathLength(el);
+        css(el, 'strokeDasharray', length);
 
-                var dim = Dimensions.cover(dimImage, dimEl);
+        if (unit === '%') {
+            steps = steps.map(function (step) { return step * length / 100; });
+        }
 
-                this.bgProps.forEach(function (prop) {
+        steps = steps.reverse();
 
-                    var ref = this$1$1.props[prop];
-                    var diff = ref.diff;
-                    var bgPos = ref.bgPos;
-                    var steps = ref.steps;
-                    var attr = prop === 'bgy' ? 'height' : 'width';
-                    var span = dim[attr] - dimEl[attr];
+        return function (css, percent) {
+            css.strokeDashoffset = getValue(steps, percent);
+        };
+    }
 
-                    if (span < diff) {
-                        dimEl[attr] = dim[attr] + diff - span;
-                    } else if (span > diff) {
+    function backgroundFn(prop, el, steps) {
 
-                        var posPercentage = dimEl[attr] / toPx(bgPos, attr, this$1$1.$el);
+        if (steps.length === 1) {
+            steps.unshift(0);
+        }
 
-                        if (posPercentage) {
-                            this$1$1.props[prop].steps = steps.map(function (step) { return step - (span - diff) / posPercentage; });
-                        }
-                    }
+        prop = prop.substr(-1);
+        var attr = prop === 'y' ? 'height' : 'width';
+        steps = steps.map(function (step) { return toPx(step, attr, el); });
 
-                    dim = Dimensions.cover(dimImage, dimEl);
-                });
+        css(el, ("background-position-" + prop), '');
+        var bgPos = css(el, 'backgroundPosition').split(' ')[prop === 'x' ? 0 : 1]; // IE 11 can't read background-position-[x|y]
 
-                data.dim = dim;
-            },
+        return getCssValue(el, 'backgroundSize', '') === 'cover'
+            ? backgroundCoverFn.call(this, prop, el, steps, bgPos, attr)
+            : setBackgroundPosFn(prop, steps, bgPos);
+    }
 
-            write: function(ref) {
-                var dim = ref.dim;
+    function backgroundCoverFn(prop, el, steps, bgPos, attr) {
 
+        var image = getBackgroundImage.call(this, el);
 
-                if (!this.matchMedia) {
-                    css(this.$el, {backgroundSize: '', backgroundRepeat: ''});
-                    return;
-                }
+        if (!image.naturalWidth) {
+            return noop;
+        }
 
-                dim && css(this.$el, {
-                    backgroundSize: ((dim.width) + "px " + (dim.height) + "px"),
-                    backgroundRepeat: 'no-repeat'
-                });
+        var min = Math.min.apply(Math, steps);
+        var max = Math.max.apply(Math, steps);
+        var down = steps.indexOf(min) < steps.indexOf(max);
 
-            },
+        var diff = max - min;
+        var pos = (down ? -diff : 0) - (down ? min : max);
 
-            events: ['resize']
+        var dimEl = {
+            width: el.offsetWidth,
+            height: el.offsetHeight
+        };
 
-        },
+        var dimImage = {
+            width: image.naturalWidth,
+            height: image.naturalHeight
+        };
 
-        methods: {
+        var baseDim = Dimensions.cover(dimImage, dimEl);
+        var span = baseDim[attr] - dimEl[attr];
 
-            reset: function() {
-                var this$1$1 = this;
+        if (span < diff) {
+            dimEl[attr] = baseDim[attr] + diff - span;
+        } else if (span > diff) {
 
-                each(this.getCss(0), function (_, prop) { return css(this$1$1.$el, prop, ''); });
-            },
+            var posPercentage = dimEl[attr] / toPx(bgPos, attr, el, true);
 
-            getCss: function(percent) {
+            if (posPercentage) {
+                pos -= (span - diff) / posPercentage;
+            }
+        }
 
-                var ref = this;
-                var props = ref.props;
-                return Object.keys(props).reduce(function (css, prop) {
-
-                    var ref = props[prop];
-                    var steps = ref.steps;
-                    var unit = ref.unit;
-                    var pos = ref.pos;
-                    var value = getValue(steps, percent);
-
-                    switch (prop) {
-
-                        // transforms
-                        case 'x':
-                        case 'y': {
-                            unit = unit || 'px';
-                            css.transform += " translate" + (ucfirst(prop)) + "(" + (toFloat(value).toFixed(unit === 'px' ? 0 : 2)) + unit + ")";
-                            break;
-                        }
-                        case 'rotate':
-                            unit = unit || 'deg';
-                            css.transform += " rotate(" + (value + unit) + ")";
-                            break;
-                        case 'scale':
-                            css.transform += " scale(" + value + ")";
-                            break;
+        var dim = Dimensions.cover(dimImage, dimEl);
 
-                        // bg image
-                        case 'bgy':
-                        case 'bgx':
-                            css[("background-position-" + (prop[2]))] = "calc(" + pos + " + " + value + "px)";
-                            break;
+        var fn = setBackgroundPosFn(prop, steps, (pos + "px"));
+        return function (css, percent) {
+            fn(css, percent);
+            css.backgroundSize = (dim.width) + "px " + (dim.height) + "px";
+            css.backgroundRepeat = 'no-repeat';
+        };
+    }
 
-                        // color
-                        case 'color':
-                        case 'backgroundColor':
-                        case 'borderColor': {
+    function setBackgroundPosFn(prop, steps, pos) {
+        return function (css, percent) {
+            css[("background-position-" + prop)] = "calc(" + pos + " + " + (getValue(steps, percent)) + "px)";
+        };
+    }
 
-                            var ref$1 = getStep(steps, percent);
-                            var start = ref$1[0];
-                            var end = ref$1[1];
-                            var p = ref$1[2];
+    function getBackgroundImage(el) {
+        var this$1$1 = this;
 
-                            css[prop] = "rgba(" + (start.map(function (value, i) {
-                                    value += p * (end[i] - value);
-                                    return i === 3 ? toFloat(value) : parseInt(value, 10);
-                                }).join(',')) + ")";
-                            break;
-                        }
-                        // CSS Filter
-                        case 'blur':
-                            unit = unit || 'px';
-                            css.filter += " blur(" + (value + unit) + ")";
-                            break;
-                        case 'hue':
-                            unit = unit || 'deg';
-                            css.filter += " hue-rotate(" + (value + unit) + ")";
-                            break;
-                        case 'fopacity':
-                            unit = unit || '%';
-                            css.filter += " opacity(" + (value + unit) + ")";
-                            break;
-                        case 'grayscale':
-                        case 'invert':
-                        case 'saturate':
-                        case 'sepia':
-                            unit = unit || '%';
-                            css.filter += " " + prop + "(" + (value + unit) + ")";
-                            break;
-                        default:
-                            css[prop] = value;
-                    }
+        var src = css(el, 'backgroundImage').replace(/^none|url\(["']?(.+?)["']?\)$/, '$1');
 
-                    return css;
+        var data = this._data;
 
-                }, {transform: '', filter: ''});
+        if (data[src]) {
+            return data[src];
+        }
 
+        if (src) {
+            var img = new Image();
+            img.src = src;
+            if (!img.naturalWidth) {
+                img.onload = function () { return this$1$1.$update(); };
             }
 
+            return data[src] = img;
         }
-
-    };
-
-    function parseColor(el, color) {
-        return css(css(el, 'color', color), 'color')
-            .split(/[(),]/g)
-            .slice(1, -1)
-            .concat(1)
-            .slice(0, 4)
-            .map(toFloat);
     }
 
     function getStep(steps, percent) {
         var count = steps.length - 1;
         var index = Math.min(Math.floor(count * percent), count - 1);
-        var step = steps.slice(index, index + 2);
-
-        step.push(percent === 1 ? 1 : percent % (1 / count) * count);
 
-        return step;
+        return steps
+            .slice(index, index + 2)
+            .concat(percent === 1 ? 1 : percent % (1 / count) * count);
     }
 
-    function getValue(steps, percent, digits) {
-        if ( digits === void 0 ) digits = 2;
-
+    function getValue(steps, percent) {
         var ref = getStep(steps, percent);
         var start = ref[0];
         var end = ref[1];
         var p = ref[2];
-        return (isNumber(start)
+        return isNumber(start)
             ? start + Math.abs(start - end) * p * (start < end ? 1 : -1)
-            : +end
-        ).toFixed(digits);
+            : +end;
     }
 
-    function getUnit(steps) {
-        return steps.reduce(function (unit, step) { return isString(step) && step.replace(/-|\d/g, '').trim() || unit; }, '');
+    function getUnit(steps, defaultUnit) {
+        return steps.reduce(function (unit, step) { return unit || isString(step) && step.replace(/[\d-]/g, '').trim(); }, '') || defaultUnit;
     }
 
-    function covers(el) {
-        var ref = el.style;
-        var backgroundSize = ref.backgroundSize;
-        var covers = css(css(el, 'backgroundSize', ''), 'backgroundSize') === 'cover';
-        el.style.backgroundSize = backgroundSize;
-        return covers;
+    function getCssValue(el, prop, value) {
+        var prev = el.style[prop];
+        var val = css(css(el, prop, value), prop);
+        el.style[prop] = prev;
+        return val;
+    }
+
+    function fillObject(keys, value) {
+        return keys.reduce(function (data, prop) {
+            data[prop] = value;
+            return data;
+        }, {});
     }
 
     var parallax = {
@@ -11057,14 +11017,18 @@
 
         props: {
             target: String,
-            viewport: Number,
-            easing: Number
+            viewport: Number, // Deprecated
+            easing: Number,
+            start: String,
+            end: String
         },
 
         data: {
             target: false,
             viewport: 1,
-            easing: 1
+            easing: 1,
+            start: 0,
+            end: 0
         },
 
         computed: {
@@ -11073,6 +11037,22 @@
                 var target = ref.target;
 
                 return getOffsetElement(target && query(target, $el) || $el);
+            },
+
+            start: function(ref) {
+                var start = ref.start;
+
+                return parseCalc(start, this.target);
+            },
+
+            end: function(ref) {
+                var end = ref.end;
+                var viewport = ref.viewport;
+
+                return parseCalc(
+                    end || (viewport = (1 - viewport) * 100) && (viewport + "vh+" + viewport + "%"),
+                    this.target
+                );
             }
 
         },
@@ -11092,11 +11072,11 @@
                 }
 
                 var prev = percent;
-                percent = ease(scrolledOver(this.target) / (this.viewport || 1), this.easing);
+                percent = ease(scrolledOver(this.target, this.start, this.end), this.easing);
 
                 return {
                     percent: percent,
-                    style: prev !== percent ? this.getCss(percent) : false
+                    style: prev === percent ? false : this.getCss(percent)
                 };
             },
 
@@ -11118,8 +11098,23 @@
 
     };
 
+    var calcRe = /-?\d+(?:\.\d+)?(?:v[wh]|%|px)?/g;
+    function parseCalc(calc, el) {
+        var match;
+        var result = 0;
+        calc = calc.toString().replace(/\s/g, '');
+        calcRe.lastIndex = 0;
+        while ((match = calcRe.exec(calc)) !== null) {
+            result += toPx(match[0], 'height', el, true);
+        }
+
+        return result;
+    }
+
     function ease(percent, easing) {
-        return clamp(percent * (1 - (easing - easing * percent)));
+        return easing >= 0
+            ? Math.pow(percent, easing + 1)
+            : 1 - Math.pow(1 - percent, -easing + 1);
     }
 
     // SVG elements do not inherit from HTMLElement
@@ -11128,7 +11123,7 @@
             ? 'offsetTop' in el
                 ? el
                 : getOffsetElement(parent(el))
-            : document.body;
+            : document.documentElement;
     }
 
     var SliderReactive = {