uikit 3.11.2-dev.31cd2ba38 → 3.11.2-dev.4274bc35b

package/dist/js/components/filter.js

@@ -1,4 +1,4 @@
-/*! UIkit 3.11.2-dev.31cd2ba38 | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
+/*! UIkit 3.11.2-dev.4274bc35b | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
 
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('uikit-util')) :
@@ -7,589 +7,558 @@
 })(this, (function (uikitUtil) { 'use strict';
 
     function getRows(items) {
-        return sortBy(items, 'top', 'bottom');
+      return sortBy(items, 'top', 'bottom');
     }
 
     function sortBy(items, startProp, endProp) {
+      const sorted = [[]];
 
-        var sorted = [[]];
-
-        for (var i = 0; i < items.length; i++) {
-
-            var el = items[i];
-
-            if (!uikitUtil.isVisible(el)) {
-                continue;
-            }
-
-            var dim = getOffset(el);
-
-            for (var j = sorted.length - 1; j >= 0; j--) {
-
-                var current = sorted[j];
-
-                if (!current[0]) {
-                    current.push(el);
-                    break;
-                }
+      for (const el of items) {
+        if (!uikitUtil.isVisible(el)) {
+          continue;
+        }
 
-                var startDim = (void 0);
-                if (current[0].offsetParent === el.offsetParent) {
-                    startDim = getOffset(current[0]);
-                } else {
-                    dim = getOffset(el, true);
-                    startDim = getOffset(current[0], true);
-                }
+        let dim = getOffset(el);
+
+        for (let i = sorted.length - 1; i >= 0; i--) {
+          const current = sorted[i];
+
+          if (!current[0]) {
+            current.push(el);
+            break;
+          }
+
+          let startDim;
+          if (current[0].offsetParent === el.offsetParent) {
+            startDim = getOffset(current[0]);
+          } else {
+            dim = getOffset(el, true);
+            startDim = getOffset(current[0], true);
+          }
+
+          if (dim[startProp] >= startDim[endProp] - 1 && dim[startProp] !== startDim[startProp]) {
+            sorted.push([el]);
+            break;
+          }
+
+          if (dim[endProp] - 1 > startDim[startProp] || dim[startProp] === startDim[startProp]) {
+            current.push(el);
+            break;
+          }
+
+          if (i === 0) {
+            sorted.unshift([el]);
+            break;
+          }
+        }
+      }
 
-                if (dim[startProp] >= startDim[endProp] - 1 && dim[startProp] !== startDim[startProp]) {
-                    sorted.push([el]);
-                    break;
-                }
+      return sorted;
+    }
 
-                if (dim[endProp] - 1 > startDim[startProp] || dim[startProp] === startDim[startProp]) {
-                    current.push(el);
-                    break;
-                }
+    function getOffset(element, offset) {if (offset === void 0) {offset = false;}
+      let { offsetTop, offsetLeft, offsetHeight, offsetWidth } = element;
 
-                if (j === 0) {
-                    sorted.unshift([el]);
-                    break;
-                }
+      if (offset) {
+        [offsetTop, offsetLeft] = uikitUtil.offsetPosition(element);
+      }
 
-            }
+      return {
+        top: offsetTop,
+        left: offsetLeft,
+        bottom: offsetTop + offsetHeight,
+        right: offsetLeft + offsetWidth };
 
-        }
-
-        return sorted;
     }
 
-    function getOffset(element, offset) {
-        var assign;
+    const clsLeave = 'uk-transition-leave';
+    const clsEnter = 'uk-transition-enter';
 
-        if ( offset === void 0 ) offset = false;
+    function fade(action, target, duration, stagger) {if (stagger === void 0) {stagger = 0;}
+      const index = transitionIndex(target, true);
+      const propsIn = { opacity: 1 };
+      const propsOut = { opacity: 0 };
 
-        var offsetTop = element.offsetTop;
-        var offsetLeft = element.offsetLeft;
-        var offsetHeight = element.offsetHeight;
-        var offsetWidth = element.offsetWidth;
+      const wrapIndexFn = (fn) => () => index === transitionIndex(target) ? fn() : Promise.reject();
 
-        if (offset) {
-            (assign = uikitUtil.offsetPosition(element), offsetTop = assign[0], offsetLeft = assign[1]);
-        }
+      const leaveFn = wrapIndexFn(() => {
+        uikitUtil.addClass(target, clsLeave);
 
-        return {
-            top: offsetTop,
-            left: offsetLeft,
-            bottom: offsetTop + offsetHeight,
-            right: offsetLeft + offsetWidth
-        };
-    }
+        return Promise.all(
+        getTransitionNodes(target).map(
+        (child, i) =>
+        new Promise((resolve) =>
+        setTimeout(
+        () =>
+        uikitUtil.Transition.start(child, propsOut, duration / 2, 'ease').then(
+        resolve),
 
-    var clsLeave = 'uk-transition-leave';
-    var clsEnter = 'uk-transition-enter';
+        i * stagger)))).
 
-    function fade(action, target, duration, stagger) {
-        if ( stagger === void 0 ) stagger = 0;
 
 
-        var index = transitionIndex(target, true);
-        var propsIn = {opacity: 1};
-        var propsOut = {opacity: 0};
+        then(() => uikitUtil.removeClass(target, clsLeave));
+      });
 
-        var wrapIndexFn = function (fn) { return function () { return index === transitionIndex(target) ? fn() : uikitUtil.Promise.reject(); }; };
+      const enterFn = wrapIndexFn(() => {
+        const oldHeight = uikitUtil.height(target);
 
-        var leaveFn = wrapIndexFn(function () {
+        uikitUtil.addClass(target, clsEnter);
+        action();
 
-            uikitUtil.addClass(target, clsLeave);
+        uikitUtil.css(uikitUtil.children(target), { opacity: 0 });
 
-            return uikitUtil.Promise.all(getTransitionNodes(target).map(function (child, i) { return new uikitUtil.Promise(function (resolve) { return setTimeout(function () { return uikitUtil.Transition.start(child, propsOut, duration / 2, 'ease').then(resolve); }, i * stagger); }
-                ); }
-            )).then(function () { return uikitUtil.removeClass(target, clsLeave); });
+        // Ensure UIkit updates have propagated
+        return new Promise((resolve) =>
+        requestAnimationFrame(() => {
+          const nodes = uikitUtil.children(target);
+          const newHeight = uikitUtil.height(target);
 
-        });
+          // Ensure Grid cells do not stretch when height is applied
+          uikitUtil.css(target, 'alignContent', 'flex-start');
+          uikitUtil.height(target, oldHeight);
 
-        var enterFn = wrapIndexFn(function () {
+          const transitionNodes = getTransitionNodes(target);
+          uikitUtil.css(nodes, propsOut);
 
-            var oldHeight = uikitUtil.height(target);
+          const transitions = transitionNodes.map(
+          (child, i) =>
+          new Promise((resolve) =>
+          setTimeout(
+          () =>
+          uikitUtil.Transition.start(child, propsIn, duration / 2, 'ease').then(
+          resolve),
 
-            uikitUtil.addClass(target, clsEnter);
-            action();
+          i * stagger)));
 
-            uikitUtil.css(uikitUtil.children(target), {opacity: 0});
 
-            // Ensure UIkit updates have propagated
-            return new uikitUtil.Promise(function (resolve) { return requestAnimationFrame(function () {
 
-                    var nodes = uikitUtil.children(target);
-                    var newHeight = uikitUtil.height(target);
 
-                    // Ensure Grid cells do not stretch when height is applied
-                    uikitUtil.css(target, 'alignContent', 'flex-start');
-                    uikitUtil.height(target, oldHeight);
+          if (oldHeight !== newHeight) {
+            transitions.push(
+            uikitUtil.Transition.start(
+            target,
+            { height: newHeight },
+            duration / 2 + transitionNodes.length * stagger,
+            'ease'));
 
-                    var transitionNodes = getTransitionNodes(target);
-                    uikitUtil.css(nodes, propsOut);
 
-                    var transitions = transitionNodes.map(function (child, i) { return new uikitUtil.Promise(function (resolve) { return setTimeout(function () { return uikitUtil.Transition.start(child, propsIn, duration / 2, 'ease').then(resolve); }, i * stagger); }
-                        ); }
-                    );
+          }
 
-                    if (oldHeight !== newHeight) {
-                        transitions.push(uikitUtil.Transition.start(target, {height: newHeight}, duration / 2 + transitionNodes.length * stagger, 'ease'));
-                    }
+          Promise.all(transitions).then(() => {
+            uikitUtil.removeClass(target, clsEnter);
+            if (index === transitionIndex(target)) {
+              uikitUtil.css(target, { height: '', alignContent: '' });
+              uikitUtil.css(nodes, { opacity: '' });
+              delete target.dataset.transition;
+            }
+            resolve();
+          });
+        }));
 
-                    uikitUtil.Promise.all(transitions).then(function () {
-                        uikitUtil.removeClass(target, clsEnter);
-                        if (index === transitionIndex(target)) {
-                            uikitUtil.css(target, {height: '', alignContent: ''});
-                            uikitUtil.css(nodes, {opacity: ''});
-                            delete target.dataset.transition;
-                        }
-                        resolve();
-                    });
-                }); }
-            );
-        });
+      });
 
-        return uikitUtil.hasClass(target, clsLeave)
-            ? waitTransitionend(target).then(enterFn)
-            : uikitUtil.hasClass(target, clsEnter)
-                ? waitTransitionend(target).then(leaveFn).then(enterFn)
-                : leaveFn().then(enterFn);
+      return uikitUtil.hasClass(target, clsLeave) ?
+      waitTransitionend(target).then(enterFn) :
+      uikitUtil.hasClass(target, clsEnter) ?
+      waitTransitionend(target).then(leaveFn).then(enterFn) :
+      leaveFn().then(enterFn);
     }
 
     function transitionIndex(target, next) {
-        if (next) {
-            target.dataset.transition = 1 + transitionIndex(target);
-        }
+      if (next) {
+        target.dataset.transition = 1 + transitionIndex(target);
+      }
 
-        return uikitUtil.toNumber(target.dataset.transition) || 0;
+      return uikitUtil.toNumber(target.dataset.transition) || 0;
     }
 
     function waitTransitionend(target) {
-        return uikitUtil.Promise.all(uikitUtil.children(target).filter(uikitUtil.Transition.inProgress).map(function (el) { return new uikitUtil.Promise(function (resolve) { return uikitUtil.once(el, 'transitionend transitioncanceled', resolve); }); }
-        ));
-    }
+      return Promise.all(
+      uikitUtil.children(target).
+      filter(uikitUtil.Transition.inProgress).
+      map(
+      (el) =>
+      new Promise((resolve) => uikitUtil.once(el, 'transitionend transitioncanceled', resolve))));
 
-    function getTransitionNodes(target) {
-        return getRows(uikitUtil.children(target)).reduce(function (nodes, row) { return nodes.concat(uikitUtil.sortBy(row.filter(function (el) { return uikitUtil.isInView(el); }), 'offsetLeft')); }, []);
-    }
 
-    function slide (action, target, duration) {
-
-        return new uikitUtil.Promise(function (resolve) { return requestAnimationFrame(function () {
-
-                var nodes = uikitUtil.children(target);
-
-                // Get current state
-                var currentProps = nodes.map(function (el) { return getProps(el, true); });
-                var targetProps = uikitUtil.css(target, ['height', 'padding']);
-
-                // Cancel previous animations
-                uikitUtil.Transition.cancel(target);
-                nodes.forEach(uikitUtil.Transition.cancel);
-                reset(target);
-
-                // Adding, sorting, removing nodes
-                action();
-
-                // Find new nodes
-                nodes = nodes.concat(uikitUtil.children(target).filter(function (el) { return !uikitUtil.includes(nodes, el); }));
-
-                // Wait for update to propagate
-                uikitUtil.Promise.resolve().then(function () {
-
-                    // Force update
-                    uikitUtil.fastdom.flush();
+    }
 
-                    // Get new state
-                    var targetPropsTo = uikitUtil.css(target, ['height', 'padding']);
-                    var ref = getTransitionProps(target, nodes, currentProps);
-                    var propsTo = ref[0];
-                    var propsFrom = ref[1];
+    function getTransitionNodes(target) {
+      return getRows(uikitUtil.children(target)).reduce(
+      (nodes, row) =>
+      nodes.concat(
+      uikitUtil.sortBy(
+      row.filter((el) => uikitUtil.isInView(el)),
+      'offsetLeft')),
 
-                    // Reset to previous state
-                    nodes.forEach(function (el, i) { return propsFrom[i] && uikitUtil.css(el, propsFrom[i]); });
-                    uikitUtil.css(target, uikitUtil.assign({display: 'block'}, targetProps));
 
-                    // Start transitions on next frame
-                    requestAnimationFrame(function () {
+      []);
 
-                        var transitions = nodes.map(function (el, i) { return uikitUtil.parent(el) === target && uikitUtil.Transition.start(el, propsTo[i], duration, 'ease'); }
-                            ).concat(uikitUtil.Transition.start(target, targetPropsTo, duration, 'ease'));
+    }
 
-                        uikitUtil.Promise.all(transitions).then(function () {
-                            nodes.forEach(function (el, i) { return uikitUtil.parent(el) === target && uikitUtil.css(el, 'display', propsTo[i].opacity === 0 ? 'none' : ''); });
-                            reset(target);
-                        }, uikitUtil.noop).then(resolve);
+    function slide (action, target, duration) {
+      return new Promise((resolve) =>
+      requestAnimationFrame(() => {
+        let nodes = uikitUtil.children(target);
+
+        // Get current state
+        const currentProps = nodes.map((el) => getProps(el, true));
+        const targetProps = uikitUtil.css(target, ['height', 'padding']);
+
+        // Cancel previous animations
+        uikitUtil.Transition.cancel(target);
+        nodes.forEach(uikitUtil.Transition.cancel);
+        reset(target);
+
+        // Adding, sorting, removing nodes
+        action();
+
+        // Find new nodes
+        nodes = nodes.concat(uikitUtil.children(target).filter((el) => !uikitUtil.includes(nodes, el)));
+
+        // Wait for update to propagate
+        Promise.resolve().then(() => {
+          // Force update
+          uikitUtil.fastdom.flush();
+
+          // Get new state
+          const targetPropsTo = uikitUtil.css(target, ['height', 'padding']);
+          const [propsTo, propsFrom] = getTransitionProps(target, nodes, currentProps);
+
+          // Reset to previous state
+          nodes.forEach((el, i) => propsFrom[i] && uikitUtil.css(el, propsFrom[i]));
+          uikitUtil.css(target, { display: 'block', ...targetProps });
+
+          // Start transitions on next frame
+          requestAnimationFrame(() => {
+            const transitions = nodes.
+            map(
+            (el, i) =>
+            uikitUtil.parent(el) === target &&
+            uikitUtil.Transition.start(el, propsTo[i], duration, 'ease')).
+
+            concat(uikitUtil.Transition.start(target, targetPropsTo, duration, 'ease'));
+
+            Promise.all(transitions).
+            then(() => {
+              nodes.forEach(
+              (el, i) =>
+              uikitUtil.parent(el) === target &&
+              uikitUtil.css(el, 'display', propsTo[i].opacity === 0 ? 'none' : ''));
+
+              reset(target);
+            }, uikitUtil.noop).
+            then(resolve);
+          });
+        });
+      }));
 
-                    });
-                });
-            }); });
     }
 
     function getProps(el, opacity) {
-
-        var zIndex = uikitUtil.css(el, 'zIndex');
-
-        return uikitUtil.isVisible(el)
-            ? uikitUtil.assign({
-                display: '',
-                opacity: opacity ? uikitUtil.css(el, 'opacity') : '0',
-                pointerEvents: 'none',
-                position: 'absolute',
-                zIndex: zIndex === 'auto' ? uikitUtil.index(el) : zIndex
-            }, getPositionWithMargin(el))
-            : false;
+      const zIndex = uikitUtil.css(el, 'zIndex');
+
+      return uikitUtil.isVisible(el) ?
+      {
+        display: '',
+        opacity: opacity ? uikitUtil.css(el, 'opacity') : '0',
+        pointerEvents: 'none',
+        position: 'absolute',
+        zIndex: zIndex === 'auto' ? uikitUtil.index(el) : zIndex,
+        ...getPositionWithMargin(el) } :
+
+      false;
     }
 
     function getTransitionProps(target, nodes, currentProps) {
+      const propsTo = nodes.map((el, i) =>
+      uikitUtil.parent(el) && i in currentProps ?
+      currentProps[i] ?
+      uikitUtil.isVisible(el) ?
+      getPositionWithMargin(el) :
+      { opacity: 0 } :
+      { opacity: uikitUtil.isVisible(el) ? 1 : 0 } :
+      false);
 
-        var propsTo = nodes.map(function (el, i) { return uikitUtil.parent(el) && i in currentProps
-                ? currentProps[i]
-                ? uikitUtil.isVisible(el)
-                    ? getPositionWithMargin(el)
-                    : {opacity: 0}
-                : {opacity: uikitUtil.isVisible(el) ? 1 : 0}
-                : false; });
-
-        var propsFrom = propsTo.map(function (props, i) {
 
-            var from = uikitUtil.parent(nodes[i]) === target && (currentProps[i] || getProps(nodes[i]));
+      const propsFrom = propsTo.map((props, i) => {
+        const from = uikitUtil.parent(nodes[i]) === target && (currentProps[i] || getProps(nodes[i]));
 
-            if (!from) {
-                return false;
-            }
+        if (!from) {
+          return false;
+        }
 
-            if (!props) {
-                delete from.opacity;
-            } else if (!('opacity' in props)) {
-                var opacity = from.opacity;
+        if (!props) {
+          delete from.opacity;
+        } else if (!('opacity' in props)) {
+          const { opacity } = from;
 
-                if (opacity % 1) {
-                    props.opacity = 1;
-                } else {
-                    delete from.opacity;
-                }
-            }
+          if (opacity % 1) {
+            props.opacity = 1;
+          } else {
+            delete from.opacity;
+          }
+        }
 
-            return from;
-        });
+        return from;
+      });
 
-        return [propsTo, propsFrom];
+      return [propsTo, propsFrom];
     }
 
     function reset(el) {
-        uikitUtil.css(el.children, {
-            height: '',
-            left: '',
-            opacity: '',
-            pointerEvents: '',
-            position: '',
-            top: '',
-            marginTop: '',
-            marginLeft: '',
-            transform: '',
-            width: '',
-            zIndex: ''
-        });
-        uikitUtil.css(el, {height: '', display: '', padding: ''});
+      uikitUtil.css(el.children, {
+        height: '',
+        left: '',
+        opacity: '',
+        pointerEvents: '',
+        position: '',
+        top: '',
+        marginTop: '',
+        marginLeft: '',
+        transform: '',
+        width: '',
+        zIndex: '' });
+
+      uikitUtil.css(el, { height: '', display: '', padding: '' });
     }
 
     function getPositionWithMargin(el) {
-        var ref = uikitUtil.offset(el);
-        var height = ref.height;
-        var width = ref.width;
-        var ref$1 = uikitUtil.position(el);
-        var top = ref$1.top;
-        var left = ref$1.left;
-        var ref$2 = uikitUtil.css(el, ['marginTop', 'marginLeft']);
-        var marginLeft = ref$2.marginLeft;
-        var marginTop = ref$2.marginTop;
-
-        return {top: top, left: left, height: height, width: width, marginLeft: marginLeft, marginTop: marginTop, transform: ''};
+      const { height, width } = uikitUtil.offset(el);
+      const { top, left } = uikitUtil.position(el);
+      const { marginLeft, marginTop } = uikitUtil.css(el, ['marginTop', 'marginLeft']);
+
+      return { top, left, height, width, marginLeft, marginTop, transform: '' };
     }
 
     var Animate = {
+      props: {
+        duration: Number,
+        animation: Boolean },
+
+
+      data: {
+        duration: 150,
+        animation: 'slide' },
+
+
+      methods: {
+        animate(action, target) {if (target === void 0) {target = this.$el;}
+          const name = this.animation;
+          const animationFn =
+          name === 'fade' ?
+          fade :
+          name === 'delayed-fade' ?
+          function () {for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {args[_key] = arguments[_key];}return fade(...args, 40);} :
+          name ?
+          slide :
+          () => {
+            action();
+            return Promise.resolve();
+          };
 
-        props: {
-            duration: Number,
-            animation: Boolean
-        },
-
-        data: {
-            duration: 150,
-            animation: 'slide'
-        },
-
-        methods: {
-
-            animate: function(action, target) {
-                var this$1$1 = this;
-                if ( target === void 0 ) target = this.$el;
-
-
-                var name = this.animation;
-                var animationFn = name === 'fade'
-                    ? fade
-                    : name === 'delayed-fade'
-                        ? function () {
-                            var args = [], len = arguments.length;
-                            while ( len-- ) args[ len ] = arguments[ len ];
-
-                            return fade.apply(void 0, args.concat( [40] ));
-                }
-                        : name
-                            ? slide
-                            : function () {
-                                action();
-                                return uikitUtil.Promise.resolve();
-                            };
-
-                return animationFn(action, target, this.duration)
-                    .then(function () { return this$1$1.$update(target, 'resize'); }, uikitUtil.noop);
-            }
+          return animationFn(action, target, this.duration).then(
+          () => this.$update(target, 'resize'),
+          uikitUtil.noop);
 
-        }
-    };
+        } } };
 
     var Component = {
+      mixins: [Animate],
 
-        mixins: [Animate],
-
-        args: 'target',
-
-        props: {
-            target: Boolean,
-            selActive: Boolean
-        },
-
-        data: {
-            target: null,
-            selActive: false,
-            attrItem: 'uk-filter-control',
-            cls: 'uk-active',
-            duration: 250
-        },
-
-        computed: {
-
-            toggles: {
-
-                get: function(ref, $el) {
-                    var attrItem = ref.attrItem;
-
-                    return uikitUtil.$$(("[" + attrItem + "],[data-" + attrItem + "]"), $el);
-                },
-
-                watch: function() {
-                    var this$1$1 = this;
-
-
-                    this.updateState();
-
-                    if (this.selActive !== false) {
-                        var actives = uikitUtil.$$(this.selActive, this.$el);
-                        this.toggles.forEach(function (el) { return uikitUtil.toggleClass(el, this$1$1.cls, uikitUtil.includes(actives, el)); });
-                    }
-
-                },
-
-                immediate: true
+      args: 'target',
 
-            },
+      props: {
+        target: Boolean,
+        selActive: Boolean },
 
-            children: {
 
-                get: function(ref, $el) {
-                    var target = ref.target;
+      data: {
+        target: null,
+        selActive: false,
+        attrItem: 'uk-filter-control',
+        cls: 'uk-active',
+        duration: 250 },
 
-                    return uikitUtil.$$((target + " > *"), $el);
-                },
 
-                watch: function(list, old) {
-                    if (old && !isEqualList(list, old)) {
-                        this.updateState();
-                    }
-                },
+      computed: {
+        toggles: {
+          get(_ref, $el) {let { attrItem } = _ref;
+            return uikitUtil.$$("[" + attrItem + "],[data-" + attrItem + "]", $el);
+          },
 
-                immediate: true
+          watch() {
+            this.updateState();
 
+            if (this.selActive !== false) {
+              const actives = uikitUtil.$$(this.selActive, this.$el);
+              this.toggles.forEach((el) => uikitUtil.toggleClass(el, this.cls, uikitUtil.includes(actives, el)));
             }
+          },
 
-        },
-
-        events: [
-
-            {
+          immediate: true },
 
-                name: 'click',
 
-                delegate: function() {
-                    return ("[" + (this.attrItem) + "],[data-" + (this.attrItem) + "]");
-                },
+        children: {
+          get(_ref2, $el) {let { target } = _ref2;
+            return uikitUtil.$$(target + " > *", $el);
+          },
 
-                handler: function(e) {
+          watch(list, old) {
+            if (old && !isEqualList(list, old)) {
+              this.updateState();
+            }
+          },
 
-                    e.preventDefault();
-                    this.apply(e.current);
+          immediate: true } },
 
-                }
 
-            }
 
-        ],
+      events: [
+      {
+        name: 'click',
 
-        methods: {
+        delegate() {
+          return "[" + this.attrItem + "],[data-" + this.attrItem + "]";
+        },
 
-            apply: function(el) {
-                var prevState = this.getState();
-                var newState = mergeState(el, this.attrItem, this.getState());
+        handler(e) {
+          e.preventDefault();
+          this.apply(e.current);
+        } }],
 
-                if (!isEqualState(prevState, newState)) {
-                    this.setState(newState);
-                }
-            },
 
-            getState: function() {
-                var this$1$1 = this;
 
-                return this.toggles
-                    .filter(function (item) { return uikitUtil.hasClass(item, this$1$1.cls); })
-                    .reduce(function (state, el) { return mergeState(el, this$1$1.attrItem, state); }, {filter: {'': ''}, sort: []});
-            },
+      methods: {
+        apply(el) {
+          const prevState = this.getState();
+          const newState = mergeState(el, this.attrItem, this.getState());
 
-            setState: function(state, animate) {
-                var this$1$1 = this;
-                if ( animate === void 0 ) animate = true;
+          if (!isEqualState(prevState, newState)) {
+            this.setState(newState);
+          }
+        },
 
+        getState() {
+          return this.toggles.
+          filter((item) => uikitUtil.hasClass(item, this.cls)).
+          reduce((state, el) => mergeState(el, this.attrItem, state), {
+            filter: { '': '' },
+            sort: [] });
 
-                state = uikitUtil.assign({filter: {'': ''}, sort: []}, state);
+        },
 
-                uikitUtil.trigger(this.$el, 'beforeFilter', [this, state]);
+        setState(state, animate) {if (animate === void 0) {animate = true;}
+          state = { filter: { '': '' }, sort: [], ...state };
 
-                this.toggles.forEach(function (el) { return uikitUtil.toggleClass(el, this$1$1.cls, !!matchFilter(el, this$1$1.attrItem, state)); });
+          uikitUtil.trigger(this.$el, 'beforeFilter', [this, state]);
 
-                uikitUtil.Promise.all(uikitUtil.$$(this.target, this.$el).map(function (target) {
-                    var filterFn = function () {
-                        applyState(state, target, uikitUtil.children(target));
-                        this$1$1.$update(this$1$1.$el);
-                    };
-                    return animate ? this$1$1.animate(filterFn, target) : filterFn();
-                })).then(function () { return uikitUtil.trigger(this$1$1.$el, 'afterFilter', [this$1$1]); });
+          this.toggles.forEach((el) =>
+          uikitUtil.toggleClass(el, this.cls, !!matchFilter(el, this.attrItem, state)));
 
-            },
 
-            updateState: function() {
-                var this$1$1 = this;
+          Promise.all(
+          uikitUtil.$$(this.target, this.$el).map((target) => {
+            const filterFn = () => {
+              applyState(state, target, uikitUtil.children(target));
+              this.$update(this.$el);
+            };
+            return animate ? this.animate(filterFn, target) : filterFn();
+          })).
+          then(() => uikitUtil.trigger(this.$el, 'afterFilter', [this]));
+        },
 
-                uikitUtil.fastdom.write(function () { return this$1$1.setState(this$1$1.getState(), false); });
-            }
+        updateState() {
+          uikitUtil.fastdom.write(() => this.setState(this.getState(), false));
+        } } };
 
-        }
 
-    };
 
     function getFilter(el, attr) {
-        return uikitUtil.parseOptions(uikitUtil.data(el, attr), ['filter']);
+      return uikitUtil.parseOptions(uikitUtil.data(el, attr), ['filter']);
     }
 
     function isEqualState(stateA, stateB) {
-        return ['filter', 'sort'].every(function (prop) { return uikitUtil.isEqual(stateA[prop], stateB[prop]); });
+      return ['filter', 'sort'].every((prop) => uikitUtil.isEqual(stateA[prop], stateB[prop]));
     }
 
     function applyState(state, target, children) {
-        var selector = getSelector(state);
+      const selector = getSelector(state);
 
-        children.forEach(function (el) { return uikitUtil.css(el, 'display', selector && !uikitUtil.matches(el, selector) ? 'none' : ''); });
+      children.forEach((el) => uikitUtil.css(el, 'display', selector && !uikitUtil.matches(el, selector) ? 'none' : ''));
 
-        var ref = state.sort;
-        var sort = ref[0];
-        var order = ref[1];
+      const [sort, order] = state.sort;
 
-        if (sort) {
-            var sorted = sortItems(children, sort, order);
-            if (!uikitUtil.isEqual(sorted, children)) {
-                uikitUtil.append(target, sorted);
-            }
+      if (sort) {
+        const sorted = sortItems(children, sort, order);
+        if (!uikitUtil.isEqual(sorted, children)) {
+          uikitUtil.append(target, sorted);
         }
+      }
     }
 
     function mergeState(el, attr, state) {
-
-        var filterBy = getFilter(el, attr);
-        var filter = filterBy.filter;
-        var group = filterBy.group;
-        var sort = filterBy.sort;
-        var order = filterBy.order; if ( order === void 0 ) order = 'asc';
-
-        if (filter || uikitUtil.isUndefined(sort)) {
-
-            if (group) {
-
-                if (filter) {
-                    delete state.filter[''];
-                    state.filter[group] = filter;
-                } else {
-                    delete state.filter[group];
-
-                    if (uikitUtil.isEmpty(state.filter) || '' in state.filter) {
-                        state.filter = {'': filter || ''};
-                    }
-
-                }
-
-            } else {
-                state.filter = {'': filter || ''};
+      const filterBy = getFilter(el, attr);
+      const { filter, group, sort, order = 'asc' } = filterBy;
+
+      if (filter || uikitUtil.isUndefined(sort)) {
+        if (group) {
+          if (filter) {
+            delete state.filter[''];
+            state.filter[group] = filter;
+          } else {
+            delete state.filter[group];
+
+            if (uikitUtil.isEmpty(state.filter) || '' in state.filter) {
+              state.filter = { '': filter || '' };
             }
-
+          }
+        } else {
+          state.filter = { '': filter || '' };
         }
+      }
 
-        if (!uikitUtil.isUndefined(sort)) {
-            state.sort = [sort, order];
-        }
+      if (!uikitUtil.isUndefined(sort)) {
+        state.sort = [sort, order];
+      }
 
-        return state;
+      return state;
     }
 
-    function matchFilter(el, attr, ref) {
-        var stateFilter = ref.filter; if ( stateFilter === void 0 ) stateFilter = {'': ''};
-        var ref_sort = ref.sort;
-        var stateSort = ref_sort[0];
-        var stateOrder = ref_sort[1];
+    function matchFilter(
+    el,
+    attr, _ref3)
 
+    {let { filter: stateFilter = { '': '' }, sort: [stateSort, stateOrder] } = _ref3;
+      const { filter = '', group = '', sort, order = 'asc' } = getFilter(el, attr);
 
-        var ref$1 = getFilter(el, attr);
-        var filter = ref$1.filter; if ( filter === void 0 ) filter = '';
-        var group = ref$1.group; if ( group === void 0 ) group = '';
-        var sort = ref$1.sort;
-        var order = ref$1.order; if ( order === void 0 ) order = 'asc';
-
-        return uikitUtil.isUndefined(sort)
-            ? group in stateFilter && filter === stateFilter[group]
-                || !filter && group && !(group in stateFilter) && !stateFilter['']
-            : stateSort === sort && stateOrder === order;
+      return uikitUtil.isUndefined(sort) ?
+      group in stateFilter && filter === stateFilter[group] ||
+      !filter && group && !(group in stateFilter) && !stateFilter[''] :
+      stateSort === sort && stateOrder === order;
     }
 
     function isEqualList(listA, listB) {
-        return listA.length === listB.length
-            && listA.every(function (el) { return ~listB.indexOf(el); });
+      return listA.length === listB.length && listA.every((el) => ~listB.indexOf(el));
     }
 
-    function getSelector(ref) {
-        var filter = ref.filter;
-
-        var selector = '';
-        uikitUtil.each(filter, function (value) { return selector += value || ''; });
-        return selector;
+    function getSelector(_ref4) {let { filter } = _ref4;
+      let selector = '';
+      uikitUtil.each(filter, (value) => selector += value || '');
+      return selector;
     }
 
     function sortItems(nodes, sort, order) {
-        return uikitUtil.assign([], nodes).sort(function (a, b) { return uikitUtil.data(a, sort).localeCompare(uikitUtil.data(b, sort), undefined, {numeric: true}) * (order === 'asc' || -1); });
+      return [...nodes].sort(
+      (a, b) =>
+      uikitUtil.data(a, sort).localeCompare(uikitUtil.data(b, sort), undefined, { numeric: true }) * (
+      order === 'asc' || -1));
+
     }
 
     if (typeof window !== 'undefined' && window.UIkit) {
-        window.UIkit.component('filter', Component);
+      window.UIkit.component('filter', Component);
     }
 
     return Component;