https://martinlogan.com/bundles/front/js/uikit/uikit.js

1/*! UIkit 3.0.0-beta.36 | http://www.getuikit.com | (c) 2014 - 2017 YOOtheme | MIT License */
2
3(function (global, factory) {
4	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
5	typeof define === 'function' && define.amd ? define('uikit', factory) :
6	(global.UIkit = factory());
7}(this, (function () { 'use strict';
8
9/* global setImmediate */
10/**
11 * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)
12 */
13
14var RESOLVED = 0;
15var REJECTED = 1;
16var PENDING = 2;
17
18var async = 'setImmediate' in window ? setImmediate : setTimeout;
19
20function Promise$1(executor) {
21
22    this.state = PENDING;
23    this.value = undefined;
24    this.deferred = [];
25
26    var promise = this;
27
28    try {
29        executor(function (x) {
30            promise.resolve(x);
31        }, function (r) {
32            promise.reject(r);
33        });
34    } catch (e) {
35        promise.reject(e);
36    }
37}
38
39Promise$1.reject = function (r) {
40    return new Promise$1(function (resolve, reject) {
41        reject(r);
42    });
43};
44
45Promise$1.resolve = function (x) {
46    return new Promise$1(function (resolve, reject) {
47        resolve(x);
48    });
49};
50
51Promise$1.all = function all(iterable) {
52    return new Promise$1(function (resolve, reject) {
53        var count = 0, result = [];
54
55        if (iterable.length === 0) {
56            resolve(result);
57        }
58
59        function resolver(i) {
60            return function (x) {
61                result[i] = x;
62                count += 1;
63
64                if (count === iterable.length) {
65                    resolve(result);
66                }
67            };
68        }
69
70        for (var i = 0; i < iterable.length; i += 1) {
71            Promise$1.resolve(iterable[i]).then(resolver(i), reject);
72        }
73    });
74};
75
76Promise$1.race = function race(iterable) {
77    return new Promise$1(function (resolve, reject) {
78        for (var i = 0; i < iterable.length; i += 1) {
79            Promise$1.resolve(iterable[i]).then(resolve, reject);
80        }
81    });
82};
83
84var p = Promise$1.prototype;
85
86p.resolve = function resolve(x) {
87    var promise = this;
88
89    if (promise.state === PENDING) {
90        if (x === promise) {
91            throw new TypeError('Promise settled with itself.');
92        }
93
94        var called = false;
95
96        try {
97            var then = x && x.then;
98
99            if (x !== null && isObject(x) && isFunction(then)) {
100                then.call(x, function (x) {
101                    if (!called) {
102                        promise.resolve(x);
103                    }
104                    called = true;
105
106                }, function (r) {
107                    if (!called) {
108                        promise.reject(r);
109                    }
110                    called = true;
111                });
112                return;
113            }
114        } catch (e) {
115            if (!called) {
116                promise.reject(e);
117            }
118            return;
119        }
120
121        promise.state = RESOLVED;
122        promise.value = x;
123        promise.notify();
124    }
125};
126
127p.reject = function reject(reason) {
128    var promise = this;
129
130    if (promise.state === PENDING) {
131        if (reason === promise) {
132            throw new TypeError('Promise settled with itself.');
133        }
134
135        promise.state = REJECTED;
136        promise.value = reason;
137        promise.notify();
138    }
139};
140
141p.notify = function notify() {
142    var this$1 = this;
143
144    async(function () {
145        if (this$1.state !== PENDING) {
146            while (this$1.deferred.length) {
147                var deferred = this$1.deferred.shift(),
148                    onResolved = deferred[0],
149                    onRejected = deferred[1],
150                    resolve = deferred[2],
151                    reject = deferred[3];
152
153                try {
154                    if (this$1.state === RESOLVED) {
155                        if (isFunction(onResolved)) {
156                            resolve(onResolved.call(undefined, this$1.value));
157                        } else {
158                            resolve(this$1.value);
159                        }
160                    } else if (this$1.state === REJECTED) {
161                        if (isFunction(onRejected)) {
162                            resolve(onRejected.call(undefined, this$1.value));
163                        } else {
164                            reject(this$1.value);
165                        }
166                    }
167                } catch (e) {
168                    reject(e);
169                }
170            }
171        }
172    });
173};
174
175p.then = function then(onResolved, onRejected) {
176    var this$1 = this;
177
178    return new Promise$1(function (resolve, reject) {

179        this$1.deferred.push([onResolved, onRejected, resolve, reject]);
180        this$1.notify();
181    });
182};
183
184p.catch = function (onRejected) {
185    return this.then(undefined, onRejected);
186};
187
188/* global DocumentTouch */
189var win = window;
190var doc = document;
191var docEl = doc.documentElement;
192
193var Observer = win.MutationObserver;
194var requestAnimationFrame$1 = win.requestAnimationFrame;
195
196var hasTouchEvents = 'ontouchstart' in win;
197var hasPointerEvents = win.PointerEvent;
198var hasTouch = 'ontouchstart' in win
199    || win.DocumentTouch && doc instanceof DocumentTouch
200    || navigator.pointerEnabled && navigator.maxTouchPoints; // IE >=11
201
202var pointerDown = !hasTouch ? 'mousedown' : ("mousedown " + (hasTouchEvents ? 'touchstart' : 'pointerdown'));
203var pointerMove = !hasTouch ? 'mousemove' : ("mousemove " + (hasTouchEvents ? 'touchmove' : 'pointermove'));
204var pointerUp = !hasTouch ? 'mouseup' : ("mouseup " + (hasTouchEvents ? 'touchend' : 'pointerup'));
205var pointerEnter = hasTouch && hasPointerEvents ? 'pointerenter' : 'mouseenter';
206var pointerLeave = hasTouch && hasPointerEvents ? 'pointerleave' : 'mouseleave';
207
208function getImage(src) {
209
210    return new Promise$1(function (resolve, reject) {
211        var img = new Image();
212
213        img.onerror = reject;
214        img.onload = function () { return resolve(img); };
215
216        img.src = src;
217    });
218
219}
220
221var supports = {};
222
223// IE 11
224(function () {
225
226    var list = doc.createElement('_').classList;
227    if (list) {
228        list.add('a', 'b');
229        list.toggle('c', false);
230        supports.Multiple = list.contains('b');
231        supports.Force = !list.contains('c');
232        supports.ClassList = true;
233    }
234    list = null;
235
236})();
237
238function attr(element, name, value) {
239
240    if (isObject(name)) {
241        for (var key in name) {
242            attr(element, key, name[key]);
243        }
244        return;
245    }
246
247    if (isUndefined(value)) {
248        element = toNode(element);
249        return element && element.getAttribute(name);
250    } else {
251        toNodes(element).forEach(function (element) {
252
253            if (isFunction(value)) {
254                value = value.call(element, attr(element, name));
255            }
256
257            if (value === null) {
258                removeAttr(element, name);
259            } else {
260                element.setAttribute(name, value);
261            }
262        });
263    }
264
265}
266
267function hasAttr(element, name) {
268    return toNodes(element).some(function (element) { return element.hasAttribute(name); });
269}
270
271function removeAttr(element, name) {
272    element = toNodes(element);
273    name.split(' ').forEach(function (name) { return element.forEach(function (element) { return element.removeAttribute(name); }
274        ); }
275    );
276}
277
278function filterAttr(element, attribute, pattern, replacement) {
279    attr(element, attribute, function (value) { return value ? value.replace(pattern, replacement) : value; });
280}
281
282function data(element, attribute) {
283    for (var i = 0, attrs = [attribute, ("data-" + attribute)]; i < attrs.length; i++) {
284        if (hasAttr(element, attrs[i])) {
285            return attr(element, attrs[i]);
286        }
287    }
288}
289
290function addClass(element) {
291    var args = [], len = arguments.length - 1;
292    while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
293
294    apply(element, args, 'add');
295}
296
297function removeClass(element) {
298    var args = [], len = arguments.length - 1;
299    while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
300
301    apply(element, args, 'remove');
302}
303
304function removeClasses(element, cls) {
305    filterAttr(element, 'class', new RegExp(("(^|\\s)" + cls + "(?!\\S)"), 'g'), '');
306}
307
308function replaceClass(element) {
309    var args = [], len = arguments.length - 1;
310    while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
311
312    args[0] && removeClass(element, args[0]);
313    args[1] && addClass(element, args[1]);
314}
315
316function hasClass(element, cls) {
317    return supports.ClassList && toNodes(element).some(function (element) { return element.classList.contains(cls); });
318}
319
320function toggleClass(element) {
321    var args = [], len = arguments.length - 1;
322    while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
323
324
325    if (!supports.ClassList || !args.length) {
326        return;
327    }
328
329    args = getArgs$1(args);
330
331    var force = !isString(args[args.length - 1]) ? args.pop() : undefined;
332

333    args = args.filter(Boolean);
334
335    toNodes(element).forEach(function (ref) {
336        var classList = ref.classList;
337
338        for (var i = 0; i < args.length; i++) {
339            supports.Force
340                ? classList.toggle(args[i], force)
341                : (classList[(!isUndefined(force) ? force : !classList.contains(args[i])) ? 'add' : 'remove'](args[i]));
342        }
343    });
344
345}
346
347function apply(element, args, fn) {
348    args = getArgs$1(args).filter(Boolean);
349
350    supports.ClassList && args.length && toNodes(element).forEach(function (ref) {
351        var classList = ref.classList;
352
353        supports.Multiple
354            ? classList[fn].apply(classList, args)
355            : args.forEach(function (cls) { return classList[fn](cls); });
356    });
357}
358
359function getArgs$1(args) {
360    return args.reduce(function (args, arg) { return args.concat.call(args, isString(arg) && includes(arg, ' ') ? arg.trim().split(' ') : arg); }
361        , []);
362}
363
364var cssNumber = {
365    'animation-iteration-count': true,
366    'column-count': true,
367    'fill-opacity': true,
368    'flex-grow': true,
369    'flex-shrink': true,
370    'font-weight': true,
371    'line-height': true,
372    'opacity': true,
373    'order': true,
374    'orphans': true,
375    'widows': true,
376    'z-index': true,
377    'zoom': true
378};
379
380function css(element, property, value) {
381
382    return toNodes(element).map(function (element) {
383
384        if (isString(property)) {
385
386            property = propName(property);
387
388            if (isUndefined(value)) {
389                return getStyle(element, property);
390            } else if (!value && value !== 0) {
391                element.style.removeProperty(property);
392            } else {
393                element.style[property] = isNumeric(value) && !cssNumber[property] ? (value + "px") : value;
394            }
395
396        } else if (isArray(property)) {
397
398            var styles = getStyles(element);
399
400            return property.reduce(function (props, property) {
401                props[property] = propName(styles[property]);
402                return props;
403            }, {});
404
405        } else if (isObject(property)) {
406            each(property, function (value, property) { return css(element, property, value); });
407        }
408
409        return element;
410
411    })[0];
412
413}
414
415function getStyles(element, pseudoElt) {
416    element = toNode(element);
417    return element.ownerDocument.defaultView.getComputedStyle(element, pseudoElt);
418}
419
420function getStyle(element, property, pseudoElt) {
421    return getStyles(element, pseudoElt)[property];
422}
423
424var vars$1 = {};
425
426function getCssVar(name) {
427
428    if (!(name in vars$1)) {
429
430        /* usage in css:  .var-name:before { content:"xyz" } */
431
432        var element = append(docEl, doc.createElement('div'));
433
434        addClass(element, ("var-" + name));
435
436        try {
437
438            vars$1[name] = getStyle(element, 'content', ':before').replace(/^["'](.*)["']$/, '$1');
439            vars$1[name] = JSON.parse(vars$1[name]);
440
441        } catch (e) {}
442
443        docEl.removeChild(element);
444
445    }
446
447    return vars$1[name];
448
449}
450
451var cssProps = {};
452
453function propName(name) {
454
455    var ret = cssProps[name];
456    if (!ret) {
457        ret = cssProps[name] = vendorPropName(name) || name;
458    }
459    return ret;
460}
461
462var cssPrefixes = ['webkit', 'moz', 'ms'];
463var style = doc.createElement('_').style;
464
465function vendorPropName(name) {
466
467    name = hyphenate(name);
468
469    if (name in style) {
470        return name;
471    }
472
473    var i = cssPrefixes.length, prefixedName;
474
475    while (i--) {
476        prefixedName = "-" + (cssPrefixes[i]) + "-" + name;
477        if (prefixedName in style) {
478            return prefixedName;
479        }
480    }
481}
482
483var dirs = {
484    width: ['x', 'left', 'right'],
485    height: ['y', 'top', 'bottom']
486};
487
488function positionAt(element, target, elAttach, targetAttach, elOffset, targetOffset, flip, boundary) {
489
490    elAttach = getPos(elAttach);
491    targetAttach = getPos(targetAttach);
492
493    var flipped = {element: elAttach, target: targetAttach};
494
495    if (!element || !target) {
496        return flipped;
497    }
498
499    var dim = getDimensions(element),
500        targetDim = getDimensions(target),
501        position = targetDim;
502
503    moveTo(position, elAttach, dim, -1);
504    moveTo(position, targetAttach, targetDim, 1);
505
506    elOffset = getOffsets(elOffset, dim.width, dim.height);
507    targetOffset = getOffsets(targetOffset, targetDim.width, targetDim.height);
508
509    elOffset['x'] += targetOffset['x'];
510    elOffset['y'] += targetOffset['y'];
511
512    position.left += elOffset['x'];
513    position.top += elOffset['y'];
514
515    boundary = getDimensions(boundary || getWindow(element));
516
517    if (flip) {
518        each(dirs, function (ref, prop) {
519            var dir = ref[0];
520            var align = ref[1];
521            var alignFlip = ref[2];
522
523
524            if (!(flip === true || includes(flip, dir))) {
525                return;
526            }
527
528            var elemOffset = elAttach[dir] === align
529                    ? -dim[prop]
530                    : elAttach[dir] === alignFlip
531                        ? dim[prop]
532                        : 0,
533                targetOffset = targetAttach[dir] === align
534                    ? targetDim[prop]
535                    : targetAttach[dir] === alignFlip
536                        ? -targetDim[prop]
537                        : 0;
538
539            if (position[align] < boundary[align] || position[align] + dim[prop] > boundary[alignFlip]) {
540
541                var centerOffset = dim[prop] / 2,
542                    centerTargetOffset = targetAttach[dir] === 'center' ? -targetDim[prop] / 2 : 0;
543
544                elAttach[dir] === 'center' && (
545                    apply(centerOffset, centerTargetOffset)
546                    || apply(-centerOffset, -centerTargetOffset)
547                ) || apply(elemOffset, targetOffset);
548
549            }
550
551            function apply(elemOffset, targetOffset) {
552
553                var newVal = position[align] + elemOffset + targetOffset - elOffset[dir] * 2;
554
555                if (newVal >= boundary[align] && newVal + dim[prop] <= boundary[alignFlip]) {
556                    position[align] = newVal;
557
558                    ['element', 'target'].forEach(function (el) {
559                        flipped[el][dir] = !elemOffset
560                            ? flipped[el][dir]
561                            : flipped[el][dir] === dirs[prop][1]
562                                ? dirs[prop][2]
563                                : dirs[prop][1];
564                    });
565
566                    return true;
567                }
568
569            }
570
571        });
572    }
573
574    offset(element, position);
575
576    return flipped;
577}
578
579function offset(element, coordinates) {
580
581    element = toNode(element);
582
583    if (coordinates) {
584
585        var currentOffset = offset(element),
586            pos = css(element, 'position');
587
588        ['left', 'top'].forEach(function (prop) {
589            if (prop in coordinates) {
590                var value = css(element, prop);
591                element.style[prop] = ((coordinates[prop] - currentOffset[prop])
592                    + toFloat(pos === 'absolute' && value === 'auto' ? position(element)[prop] : value)) + "px";
593            }
594        });
595
596        return;
597    }
598
599    return getDimensions(element);
600}
601
602function getDimensions(element) {
603
604    element = toNode(element);
605
606    var ref = getWindow(element);
607    var top = ref.pageYOffset;
608    var left = ref.pageXOffset;
609
610    if (isWindow(element)) {
611

612        var height = element.innerHeight,
613            width = element.innerWidth;
614
615        return {
616            top: top,
617            left: left,
618            height: height,
619            width: width,
620            bottom: top + height,
621            right: left + width,
622        };
623    }
624
625    var display = false;
626    if (!isVisible(element)) {
627        display = element.style.display;
628        element.style.display = 'block';
629    }
630
631    var rect = element.getBoundingClientRect();
632
633    if (display !== false) {
634        element.style.display = display;
635    }
636
637    return {
638        height: rect.height,
639        width: rect.width,
640        top: rect.top + top,
641        left: rect.left + left,
642        bottom: rect.bottom + top,
643        right: rect.right + left,
644    };
645}
646
647function position(element) {
648    element = toNode(element);
649
650    var parent = offsetParent(element),
651        parentOffset = parent === docEl$1(element) ? {top: 0, left: 0} : offset(parent);
652
653    return ['top', 'left'].reduce(function (props, prop) {
654        var propName = ucfirst(prop);
655        props[prop] -= parentOffset[prop]
656            + (toFloat(css(element, ("margin" + propName))) || 0)
657            + (toFloat(css(parent, ("border" + propName + "Width"))) || 0);
658        return props;
659    }, offset(element));
660}
661
662function offsetParent(element) {
663
664    var parent = toNode(element).offsetParent;
665
666    while (parent && css(parent, 'position') === 'static') {
667        parent = parent.offsetParent;
668    }
669
670    return parent || docEl$1(element);
671}
672
673var height = dimension('height');
674var width = dimension('width');
675
676function dimension(prop) {
677    var propName = ucfirst(prop);
678    return function (element, value) {
679
680        element = toNode(element);
681
682        if (isUndefined(value)) {
683
684            if (isWindow(element)) {
685                return element[("inner" + propName)];
686            }
687
688            if (isDocument(element)) {
689                var doc = element.documentElement;
690                return Math.max(doc.offsetHeight, doc.scrollHeight);
691            }
692
693            value = css(element, prop);
694            value = value === 'auto' ? element[("offset" + propName)] : toFloat(value) || 0;
695
696            return getContentSize(prop, element, value);
697
698        } else {
699
700            css(element, prop, !value && value !== 0
701                ? ''
702                : getContentSize(prop, element, value) + 'px'
703            );
704
705        }
706
707    };
708}
709
710function getContentSize(prop, element, value) {
711    return css(element, 'boxSizing') === 'border-box' ? dirs[prop].slice(1).map(ucfirst).reduce(function (value, prop) { return value
712            - toFloat(css(element, ("padding" + prop)))
713            - toFloat(css(element, ("border" + prop + "Width"))); }
714        , value) : value;
715}
716
717function getWindow(element) {
718    return isWindow(element) ? element : document$1(element).defaultView;
719}
720
721function moveTo(position, attach, dim, factor) {
722    each(dirs, function (ref, prop) {
723        var dir = ref[0];
724        var align = ref[1];
725        var alignFlip = ref[2];
726
727        if (attach[dir] === alignFlip) {
728            position[align] += dim[prop] * factor;
729        } else if (attach[dir] === 'center') {
730            position[align] += dim[prop] * factor / 2;
731        }
732    });
733}
734
735function getPos(pos) {
736
737    var x = /left|center|right/, y = /top|center|bottom/;
738
739    pos = (pos || '').split(' ');
740
741    if (pos.length === 1) {
742        pos = x.test(pos[0])
743            ? pos.concat(['center'])
744            : y.test(pos[0])
745                ? ['center'].concat(pos)
746                : ['center', 'center'];
747    }
748
749    return {
750        x: x.test(pos[0]) ? pos[0] : 'center',
751        y: y.test(pos[1]) ? pos[1] : 'center'
752    };
753}
754
755function getOffsets(offsets, width, height) {
756
757    var ref = (offsets || '').split(' ');
758    var x = ref[0];
759    var y = ref[1];
760
761    return {
762        x: x ? toFloat(x) * (endsWith(x, '%') ? width / 100 : 1) : 0,
763        y: y ? toFloat(y) * (endsWith(y, '%') ? height / 100 : 1) : 0
764    };
765}
766
767function flipPosition(pos) {
768    switch (pos) {
769        case 'left':
770            return 'right';
771        case 'right':
772            return 'left';
773        case 'top':
774            return 'bottom';
775        case 'bottom':
776            return 'top';
777        default:
778            return pos;
779    }
780}
781
782function document$1(element) {
783    return toNode(element).ownerDocument;
784}
785
786function docEl$1(element) {
787    return document$1(element).documentElement;
788}
789
790var isRtl = attr(docEl, 'dir') === 'rtl';
791
792function isReady() {
793    return doc.readyState === 'complete' || doc.readyState !== 'loading' && !docEl.doScroll;
794}
795
796function ready(fn) {
797
798    if (isReady()) {
799        fn();
800        return;
801    }
802
803    var handle = function () {
804            unbind1();
805            unbind2();
806            fn();
807        },
808        unbind1 = on(doc, 'DOMContentLoaded', handle),
809        unbind2 = on(win, 'load', handle);
810}
811
812function transition(element, props, duration, timing) {
813    if ( duration === void 0 ) duration = 400;
814    if ( timing === void 0 ) timing = 'linear';
815
816
817    return Promise$$1.all(toNodes(element).map(function (element) { return new Promise$$1(function (resolve, reject) {
818
819            for (var name in props) {
820                var value = css(element, name);
821                if (value === '') {
822                    css(element, name, value);
823                }
824            }
825
826            var timer = setTimeout(function () { return trigger(element, 'transitionend'); }, duration);
827
828            once(element, 'transitionend transitioncanceled', function (ref) {
829                var type = ref.type;
830
831                clearTimeout(timer);
832                removeClass(element, 'uk-transition');
833                css(element, 'transition', '');
834                type === 'transitioncanceled' ? reject() : resolve();
835            }, false, function (ref) {
836                var target = ref.target;
837
838                return element === target;
839            });
840
841            addClass(element, 'uk-transition');
842            css(element, assign({transition: ("all " + duration + "ms " + timing)}, props));
843
844        }); }
845    ));
846
847}
848
849var Transition = {
850
851    start: transition,
852
853    stop: function stop(element) {
854        trigger(element, 'transitionend');
855        return Promise$$1.resolve();
856    },
857
858    cancel: function cancel(element) {
859        trigger(element, 'transitioncanceled');
860    },
861
862    inProgress: function inProgress(element) {
863        return hasClass(element, 'uk-transition');
864    }
865
866};
867
868var animationPrefix = 'uk-animation-';
869var clsCancelAnimation = 'uk-cancel-animation';
870
871function animate(element, animation, duration, origin, out) {
872    var arguments$1 = arguments;
873    if ( duration === void 0 ) duration = 200;
874
875
876    return Promise$$1.all(toNodes(element).map(function (element) { return new Promise$$1(function (resolve, reject) {
877
878            if (hasClass(element, clsCancelAnimation)) {
879                requestAnimationFrame(function () { return Promise$$1.resolve().then(function () { return animate.apply(null, arguments$1).then(resolve, reject); }
880                    ); }
881                );
882                return;
883            }
884
885            var cls = animation + " " + animationPrefix + (out ? 'leave' : 'enter');
886
887            if (startsWith(animation, animationPrefix)) {
888
889                if (origin) {
890                    cls += " " + animationPrefix + origin;
891                }
892
893                if (out) {
894                    cls += " " + animationPrefix + "reverse";
895                }
896
897            }
898
899            reset();
900
901            once(element, 'animationend animationcancel', function (ref) {
902                var type = ref.type;
903
904
905                var hasReset = false;

906
907                if (type === 'animationcancel') {
908                    reject();
909                    reset();
910                } else {
911                    resolve();
912                    Promise$$1.resolve().then(function () {
913                        hasReset = true;
914                        reset();
915                    });
916                }
917
918                requestAnimationFrame(function () {
919                    if (!hasReset) {
920                        addClass(element, clsCancelAnimation);
921
922                        requestAnimationFrame(function () { return removeClass(element, clsCancelAnimation); });
923                    }
924                });
925
926            }, false, function (ref) {
927                var target = ref.target;
928
929                return element === target;
930            });
931
932            css(element, 'animationDuration', (duration + "ms"));
933            addClass(element, cls);
934
935            function reset() {
936                css(element, 'animationDuration', '');
937                removeClasses(element, (animationPrefix + "\\S*"));
938            }
939
940        }); }
941    ));
942
943}
944
945var inProgress = new RegExp((animationPrefix + "(enter|leave)"));
946var Animation = {
947
948    in: function in$1(element, animation, duration, origin) {
949        return animate(element, animation, duration, origin, false);
950    },
951
952    out: function out(element, animation, duration, origin) {
953        return animate(element, animation, duration, origin, true);
954    },
955
956    inProgress: function inProgress$1(element) {
957        return inProgress.test(attr(element, 'class'));
958    },
959
960    cancel: function cancel(element) {
961        trigger(element, 'animationcancel');
962    }
963
964};
965
966function isInView(element, top, left) {
967    if ( top === void 0 ) top = 0;
968    if ( left === void 0 ) left = 0;
969
970    return intersectRect(toNode(element).getBoundingClientRect(), {
971        top: top,
972        left: left,
973        bottom: top + height(win),
974        right: left + width(win)
975    });
976}
977
978function scrolledOver(element) {
979
980    element = toNode(element);
981
982    var elHeight = element.offsetHeight,
983        top = positionTop(element),
984        vp = height(win),
985        vh = vp + Math.min(0, top - vp),
986        diff = Math.max(0, vp - (height(doc) - (top + elHeight)));
987
988    return clamp(((vh + win.pageYOffset - top) / ((vh + (elHeight - (diff < vp ? diff : 0))) / 100)) / 100);
989}
990
991function positionTop(element) {
992    var top = 0;
993
994    do {
995
996        top += element.offsetTop;
997
998    } while (element = element.offsetParent);
999
1000    return top;
1001}
1002
1003function getIndex(i, elements, current, finite) {
1004    if ( current === void 0 ) current = 0;
1005    if ( finite === void 0 ) finite = false;
1006
1007
1008    elements = toNodes(elements);
1009
1010    var length = elements.length;
1011
1012    i = isNumeric(i)
1013        ? toNumber(i)
1014        : i === 'next'
1015            ? current + 1
1016            : i === 'previous'
1017                ? current - 1
1018                : index(elements, i);
1019
1020    if (finite) {
1021        return clamp(i, 0, length - 1);
1022    }
1023
1024    i %= length;
1025
1026    return i < 0 ? i + length : i;
1027}
1028
1029var voidElements = {
1030    area: true,
1031    base: true,
1032    br: true,
1033    col: true,
1034    embed: true,
1035    hr: true,
1036    img: true,
1037    input: true,
1038    keygen: true,
1039    link: true,
1040    menuitem: true,
1041    meta: true,
1042    param: true,
1043    source: true,
1044    track: true,
1045    wbr: true
1046};
1047function isVoidElement(element) {
1048    return voidElements[toNode(element).tagName.toLowerCase()];
1049}
1050
1051var Dimensions = {
1052
1053    ratio: function ratio(dimensions, prop, value) {
1054        var obj;
1055
1056
1057        var aProp = prop === 'width' ? 'height' : 'width';
1058
1059        return ( obj = {}, obj[aProp] = Math.round(value * dimensions[aProp] / dimensions[prop]), obj[prop] = value, obj);
1060    },
1061
1062    contain: function contain(dimensions, maxDimensions) {
1063        var this$1 = this;
1064
1065        dimensions = assign({}, dimensions);
1066
1067        each(dimensions, function (_, prop) { return dimensions = dimensions[prop] > maxDimensions[prop]
1068            ? this$1.ratio(dimensions, prop, maxDimensions[prop])
1069            : dimensions; }
1070        );
1071
1072        return dimensions;
1073    },
1074
1075    cover: function cover(dimensions, maxDimensions) {
1076        var this$1 = this;
1077
1078        dimensions = this.contain(dimensions, maxDimensions);
1079
1080        each(dimensions, function (_, prop) { return dimensions = dimensions[prop] < maxDimensions[prop]
1081            ? this$1.ratio(dimensions, prop, maxDimensions[prop])
1082            : dimensions; }
1083        );
1084
1085        return dimensions;
1086    }
1087
1088};
1089
1090function preventClick() {
1091
1092    var timer = setTimeout(function () { return trigger(doc, 'click'); }, 0);
1093
1094    once(doc, 'click', function (e) {
1095        e.preventDefault();
1096        e.stopImmediatePropagation();
1097
1098        clearTimeout(timer);
1099    }, true);
1100
1101}
1102
1103function isVisible(element) {
1104    return toNodes(element).some(function (element) { return element.offsetHeight; });
1105}
1106
1107var selInput = 'input,select,textarea,button';
1108function isInput(element) {
1109    return toNodes(element).some(function (element) { return matches(element, selInput); });
1110}
1111
1112function empty(element) {
1113    element = toNode(element);
1114    element.innerHTML = '';
1115    return element;
1116}
1117
1118function html(parent, html) {
1119    parent = toNode(parent);
1120    return isUndefined(html)
1121        ? parent.innerHTML
1122        : append(parent.hasChildNodes() ? empty(parent) : parent, html);
1123}
1124
1125function prepend(parent, element) {
1126
1127    parent = toNode(parent);
1128
1129    if (!parent.hasChildNodes()) {
1130        return append(parent, element);
1131    } else {

1132        return insertNodes(element, function (element) { return parent.insertBefore(element, parent.firstChild); });
1133    }
1134}
1135
1136function append(parent, element) {
1137    parent = toNode(parent);
1138    return insertNodes(element, function (element) { return parent.appendChild(element); });
1139}
1140
1141function before(ref, element) {
1142    ref = toNode(ref);
1143    return insertNodes(element, function (element) { return ref.parentNode.insertBefore(element, ref); });
1144}
1145
1146function after(ref, element) {
1147    ref = toNode(ref);
1148    return insertNodes(element, function (element) { return ref.nextSibling
1149        ? before(ref.nextSibling, element)
1150        : append(ref.parentNode, element); }
1151    );
1152}
1153
1154function insertNodes(element, fn) {
1155    element = isString(element) ? fragment(element) : element;
1156    return element
1157        ? 'length' in element
1158            ? toNodes(element).map(fn)
1159            : fn(element)
1160        : null;
1161}
1162
1163function remove(element) {
1164    toNodes(element).map(function (element) { return element.parentNode && element.parentNode.removeChild(element); });
1165}
1166
1167function wrapAll(element, structure) {
1168
1169    structure = toNode(before(element, structure));
1170
1171    while (structure.firstChild) {
1172        structure = structure.firstChild;
1173    }
1174
1175    append(structure, element);
1176
1177    return structure;
1178}
1179
1180function wrapInner(element, structure) {
1181    return toNodes(toNodes(element).map(function (element) { return element.hasChildNodes ? wrapAll(toNodes(element.childNodes), structure) : append(element, structure); }
1182    ));
1183}
1184
1185function unwrap(element) {
1186    toNodes(element)
1187        .map(function (element) { return element.parentNode; })
1188        .filter(function (value, index, self) { return self.indexOf(value) === index; })
1189        .forEach(function (parent) {
1190            before(parent, parent.childNodes);
1191            remove(parent);
1192        });
1193}
1194
1195var fragmentRE = /^\s*<(\w+|!)[^>]*>/;
1196var singleTagRE = /^<(\w+)\s*\/?>(?:<\/\1>)?$/;
1197
1198function fragment(html) {
1199
1200    var matches$$1;
1201
1202    if (matches$$1 = singleTagRE.exec(html)) {
1203        return doc.createElement(matches$$1[1]);
1204    }
1205
1206    var container = doc.createElement('div');
1207    if (fragmentRE.test(html)) {
1208        container.insertAdjacentHTML('beforeend', html.trim());
1209    } else {
1210        container.textContent = html;
1211    }
1212
1213    return container.childNodes.length > 1 ? toNodes(container.childNodes) : container.firstChild;
1214
1215}
1216
1217function index(element, ref) {
1218    return ref
1219        ? toNodes(element).indexOf(toNode(ref))
1220        : toNodes((element = toNode(element)) && element.parentNode.children).indexOf(element);
1221}
1222
1223var arrayProto = Array.prototype;
1224
1225function $(selector, context) {
1226    return !isString(selector)
1227        ? toNode(selector)
1228        : isHtml(selector)
1229            ? toNode(fragment(selector))
1230            : find(selector, context);
1231}
1232
1233function $$(selector, context) {
1234    return !isString(selector)
1235        ? toNodes(selector)
1236        : isHtml(selector)
1237            ? toNodes(fragment(selector))
1238            : findAll(selector, context);
1239}
1240
1241function isHtml(str) {
1242    return str[0] === '<' || str.match(/^\s*</);
1243}
1244
1245function query(selector, context) {
1246    return $(selector, isContextSelector(selector) ? context : doc);
1247}
1248
1249function queryAll(selector, context) {
1250    return $$(selector, isContextSelector(selector) ? context : doc);
1251}
1252
1253function find(selector, context) {
1254    return toNode(_query(selector, context, 'querySelector'));
1255}
1256
1257function findAll(selector, context) {
1258    return toNodes(_query(selector, context, 'querySelectorAll'));
1259}
1260
1261function _query(selector, context, queryFn) {
1262    if ( context === void 0 ) context = doc;
1263
1264
1265    if (!selector || !isString(selector)) {
1266        return null;
1267    }
1268
1269    selector = selector.replace(contextSanitizeRe, '$1 *');
1270
1271    var removes;
1272
1273    if (isContextSelector(selector)) {
1274
1275        removes = [];
1276
1277        selector = selector.split(',').map(function (selector, i) {
1278
1279            var ctx = context;
1280
1281            selector = selector.trim();
1282
1283            if (selector[0] === '!') {
1284
1285                var selectors = selector.substr(1).trim().split(' ');
1286                ctx = closest(context.parentNode, selectors[0]);
1287                selector = selectors.slice(1).join(' ');
1288
1289            }
1290
1291            if (!ctx) {
1292                return null;
1293            }
1294
1295            if (!ctx.id) {
1296                ctx.id = "uk-" + (Date.now()) + i;
1297                removes.push(function () { return removeAttr(ctx, 'id'); });
1298            }
1299
1300            return ("#" + (escape(ctx.id)) + " " + selector);
1301
1302        }

1302).filter(Boolean).join(',');
1303
1304        context = doc;
1305
1306    }
1307
1308    try {
1309
1310        return context[queryFn](selector);
1311
1312    } catch (e) {
1313
1314        return null;
1315
1316    } finally {
1317
1318        removes && removes.forEach(function (remove$$1) { return remove$$1(); });
1319
1320    }
1321
1322}
1323
1324function filter(element, selector) {
1325    return $$(element).filter(function (element) { return matches(element, selector); });
1326}
1327
1328function within(element, selector) {
1329    return !isString(selector)
1330        ? element === selector || toNode(selector).contains(toNode(element))
1331        : matches(element, selector) || closest(element, selector);
1332}
1333
1334var contextSelectorRe = /(^|,)\s*[!>+~]/;
1335var contextSanitizeRe = /([!>+~])(?=\s+[!>+~]|\s*$)/g;
1336
1337function isContextSelector(selector) {
1338    return isString(selector) && selector.match(contextSelectorRe);
1339}
1340
1341var elProto = Element.prototype;
1342var matchesFn = elProto.matches || elProto.msMatchesSelector;
1343
1344function matches(element, selector) {
1345    return toNodes(element).some(function (element) { return matchesFn.call(element, selector); });
1346}
1347
1348var closestFn = elProto.closest || function (selector) {
1349    var ancestor = this;
1350
1351    do {
1352
1353        if (matches(ancestor, selector)) {
1354            return ancestor;
1355        }
1356
1357        ancestor = ancestor.parentNode;
1358
1359    } while (ancestor && ancestor.nodeType === 1);
1360};
1361
1362function closest(element, selector) {
1363
1364    if (startsWith(selector, '>')) {
1365        selector = selector.slice(1);
1366    }
1367
1368    return isNode(element)
1369        ? element.parentNode && closestFn.call(element, selector)
1370        : toNodes(element).map(function (element) { return element.parentNode && closestFn.call(element, selector); }).filter(Boolean);
1371}
1372
1373function parents(element, selector) {
1374    var elements = [], parent = toNode(element).parentNode;
1375
1376    while (parent && parent.nodeType === 1) {
1377
1378        if (matches(parent, selector)) {
1379            elements.push(parent);
1380        }
1381
1382        parent = parent.parentNode;
1383    }
1384
1385    return elements;
1386}
1387
1388function isJQuery(obj) {
1389    return isObject(obj) && !!obj.jquery;
1390}
1391
1392function isNode(element) {
1393    return element instanceof Node || isObject(element) && element.nodeType === 1;
1394}
1395
1396function isNodeCollection(element) {
1397    return element instanceof NodeList || element instanceof HTMLCollection;
1398}
1399
1400function toNode(element) {
1401    return isNode(element) || isWindow(element) || isDocument(element)
1402        ? element
1403        : isNodeCollection(element) || isJQuery(element)
1404            ? element[0]
1405            : isArray(element)
1406                ? toNode(element[0])
1407                : null;
1408}
1409
1410function toNodes(element) {
1411    return isNode(element)
1412        ? [element]
1413        : isNodeCollection(element)
1414            ? arrayProto.slice.call(element)
1415            : isArray(element)

1416                ? element.map(toNode).filter(Boolean)
1417                : isJQuery(element)
1418                    ? element.toArray()
1419                    : [];
1420}
1421
1422var escapeFn = win.CSS && CSS.escape || function (css) { return css.replace(/([^\x7f-\uFFFF\w-])/g, function (match) { return ("\\" + match); }); };
1423function escape(css) {
1424    return isString(css) ? escapeFn.call(null, css) : '';
1425}
1426
1427function on() {
1428    var args = [], len = arguments.length;
1429    while ( len-- ) args[ len ] = arguments[ len ];
1430
1431
1432    var ref = getArgs(args);
1433    var target = ref[0];
1434    var type = ref[1];
1435    var selector = ref[2];
1436    var listener = ref[3];
1437    var useCapture = ref[4];
1438
1439    target = toEventTarget(target);
1440
1441    if (selector) {
1442        listener = delegate(target, selector, listener);
1443    }
1444
1445    if (listener.length > 1) {
1446        listener = detail(listener);
1447    }
1448
1449    type.split(' ').forEach(function (type) { return target && target.addEventListener(type, listener, useCapture); });
1450    return function () { return off(target, type, listener, useCapture); };
1451}
1452
1453function off(target, type, listener, useCapture) {
1454    if ( useCapture === void 0 ) useCapture = false;
1455
1456    target = toEventTarget(target);
1457    target && type.split(' ').forEach(function (type) { return target.removeEventListener(type, listener, useCapture); });
1458}
1459
1460function once() {
1461    var args = [], len = arguments.length;
1462    while ( len-- ) args[ len ] = arguments[ len ];
1463
1464
1465    var ref = getArgs(args);
1466    var element = ref[0];
1467    var type = ref[1];
1468    var selector = ref[2];
1469    var listener = ref[3];
1470    var useCapture = ref[4];
1471    var condition = ref[5];
1472    var off = on(element, type, selector, function (e) {
1473            var result = !condition || condition(e);
1474            if (result) {
1475                off();
1476                listener(e, result);
1477            }
1478        }, useCapture);
1479
1480    return off;
1481}
1482
1483function trigger(target, event, detail) {
1484    return toEventTargets(target).reduce(function (notCanceled, target) { return notCanceled && target.dispatchEvent(createEvent(event, true, true, detail)); }
1485        , true);
1486}
1487
1488function createEvent(e, bubbles, cancelable, detail) {
1489    if ( bubbles === void 0 ) bubbles = true;
1490    if ( cancelable === void 0 ) cancelable = false;
1491
1492    if (isString(e)) {
1493        var event = doc.createEvent('CustomEvent'); // IE 11
1494        event.initCustomEvent(e, bubbles, cancelable, detail);
1495        e = event;
1496    }
1497
1498    return e;
1499}
1500
1501function getArgs(args) {
1502
1503    if (isString(args[0])) {
1504        args[0] = $(args[0]);
1505    }
1506
1507    if (isFunction(args[2])) {
1508        args.splice(2, 0, false);
1509    }
1510    return args;
1511}
1512
1513function delegate(element, selector, listener) {
1514    var this$1 = this;
1515
1516    return function (e) {
1517
1518        var target = e.target,
1519            current = selector[0] === '>'
1520                ? $$(selector, element).reverse().filter(function (element) { return within(target, element); })[0]
1521                : closest(target, selector);
1522
1523        if (current) {
1524            e.delegate = element;
1525            e.current = current;
1526
1527            listener.call(this$1, e);
1528        }
1529    };
1530}
1531
1532function detail(listener) {
1533    return function (e) { return isArray(e.detail) ? listener.apply(listener, [e].concat(e.detail)) : listener(e); };
1534}
1535
1536function isEventTarget(target) {
1537    return 'EventTarget' in win
1538        ? target instanceof EventTarget
1539        : target && 'addEventListener' in target;
1540}
1541
1542function toEventTarget(target) {
1543    return isEventTarget(target) ? target : toNode(target);
1544}
1545
1546function toEventTargets(target) {
1547    return isEventTarget(target)
1548        ? [target]
1549        : isArray(target)
1550            ? target.map(toEventTarget).filter(Boolean)
1551            : toNodes(target);
1552}
1553
1554function bind(fn, context) {
1555    return function (a) {
1556        var l = arguments.length;
1557        return l ? l > 1 ? fn.apply(context, arguments) : fn.call(context, a) : fn.call(context);
1558    };
1559}
1560
1561var hasOwnProperty = Object.prototype.hasOwnProperty;
1562
1563function hasOwn(obj, key) {
1564    return hasOwnProperty.call(obj, key);
1565}
1566
1567var Promise$$1 = 'Promise' in window ? window.Promise : Promise$1;
1568
1569var Deferred = function Deferred() {
1570    var this$1 = this;
1571
1572    this.promise = new Promise$$1(function (resolve, reject) {
1573        this$1.reject = reject;
1574        this$1.resolve = resolve;
1575    });
1576};
1577
1578var classifyRe = /(?:^|[-_\/])(\w)/g;
1579
1580function classify(str) {
1581    return str.replace(classifyRe, function (_, c) { return c ? c.toUpperCase() : ''; });
1582}
1583
1584var hyphenateRe = /([a-z\d])([A-Z])/g;
1585
1586function hyphenate(str) {
1587    return str
1588        .replace(hyphenateRe, '$1-$2')
1589        .toLowerCase();
1590}
1591
1592var camelizeRE = /-(\w)/g;
1593
1594function camelize(str) {
1595    return str.replace(camelizeRE, toUpper);
1596}
1597
1598function toUpper(_, c) {
1599    return c ? c.toUpperCase() : '';
1600}
1601
1602function ucfirst(str) {
1603    return str.length ? toUpper(null, str.charAt(0)) + str.slice(1) : '';
1604}
1605
1606var strPrototype = String.prototype;
1607var startsWithFn = strPrototype.startsWith || function (search) { return this.lastIndexOf(search, 0) === 0; };
1608
1609function startsWith(str, search) {
1610    return startsWithFn.call(str, search);
1611}
1612
1613var endsWithFn = strPrototype.endsWith || function (search) { return this.substr(-1 * search.length) === search; };
1614
1615function endsWith(str, search) {
1616    return endsWithFn.call(str, search);
1617}
1618
1619var includesFn = function (search) { return ~this.indexOf(search); };
1620var includesStr = strPrototype.includes || includesFn;
1621var includesArray = Array.prototype.includes || includesFn;
1622
1623function includes(obj, search) {
1624    return obj && (isString(obj) ? includesStr : includesArray).call(obj, search);
1625}
1626
1627var isArray = Array.isArray;
1628
1629function isFunction(obj) {
1630    return typeof obj === 'function';
1631}
1632
1633function isObject(obj) {
1634    return obj !== null && typeof obj === 'object';
1635}
1636
1637function isPlainObject(obj) {
1638    return isObject(obj) && Object.getPrototypeOf(obj) === Object.prototype;
1639}
1640
1641function isWindow(obj) {
1642    return isObject(obj) && obj === obj.window;
1643}
1644
1645function isDocument(obj) {
1646    return isObject(obj) && obj.nodeType === 9;
1647}
1648
1649function isBoolean(value) {
1650    return typeof value === 'boolean';
1651}
1652
1653function isString(value) {
1654    return typeof value === 'string';
1655}
1656
1657function isNumber(value) {
1658    return typeof value === 'number';
1659}
1660
1661function isNumeric(value) {
1662    return isNumber(value) || isString(value) && !isNaN(value - parseFloat(value));
1663}
1664
1665function isUndefined(value) {
1666    return value === void 0;
1667}
1668
1669function toBoolean(value) {
1670    return isBoolean(value)
1671        ? value
1672        : value === 'true' || value === '1' || value === ''
1673            ? true
1674            : value === 'false' || value === '0'
1675                ? false
1676                : value;
1677}
1678
1679function toNumber(value) {
1680    var number = Number(value);
1681    return !isNaN(number) ? number : false;

1682}
1683
1684function toFloat(value) {
1685    return parseFloat(value) || 0;
1686}
1687
1688function toList(value) {
1689    return isArray(value)
1690        ? value
1691        : isString(value)
1692            ? value.split(/,(?![^(]*\))/).map(function (value) { return isNumeric(value)
1693                ? toNumber(value)
1694                : toBoolean(value.trim()); })
1695            : [value];
1696}
1697
1698var vars = {};
1699
1700function toMedia(value) {
1701
1702    if (isString(value)) {
1703        if (value[0] === '@') {
1704            var name = "media-" + (value.substr(1));
1705            value = vars[name] || (vars[name] = toFloat(getCssVar(name)));
1706        } else if (isNaN(value)) {
1707            return value;
1708        }
1709    }
1710
1711    return value && !isNaN(value) ? ("(min-width: " + value + "px)") : false;
1712}
1713
1714function coerce(type, value, context) {
1715
1716    if (type === Boolean) {
1717        return toBoolean(value);
1718    } else if (type === Number) {
1719        return toNumber(value);
1720    } else if (type === 'query') {
1721        return query(value, context);
1722    } else if (type === 'list') {
1723        return toList(value);
1724    } else if (type === 'media') {
1725        return toMedia(value);
1726    }
1727
1728    return type ? type(value) : value;
1729}
1730
1731function toMs(time) {
1732    return !time
1733        ? 0
1734        : endsWith(time, 'ms')
1735            ? toFloat(time)
1736            : toFloat(time) * 1000;
1737}
1738
1739function swap(value, a, b) {
1740    return value.replace(new RegExp((a + "|" + b), 'mg'), function (match) {
1741        return match === a ? b : a;
1742    });
1743}
1744
1745var assign = Object.assign || function (target) {
1746    var args = [], len = arguments.length - 1;
1747    while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
1748
1749    target = Object(target);
1750    for (var i = 0; i < args.length; i++) {
1751        var source = args[i];
1752        if (source !== null) {
1753            for (var key in source) {
1754                if (hasOwn(source, key)) {
1755                    target[key] = source[key];
1756                }
1757            }
1758        }
1759    }
1760    return target;
1761};
1762
1763function each(obj, cb) {
1764    for (var key in obj) {
1765        if (cb.call(obj[key], obj[key], key) === false) {
1766            break;
1767        }
1768    }
1769}
1770
1771function clamp(number, min, max) {
1772    if ( min === void 0 ) min = 0;
1773    if ( max === void 0 ) max = 1;
1774
1775    return Math.min(Math.max(number, min), max);
1776}
1777
1778function noop() {}
1779
1780function intersectRect(r1, r2) {
1781    return r1.left <= r2.right &&
1782        r2.left <= r1.right &&
1783        r1.top <= r2.bottom &&
1784        r2.top <= r1.bottom;
1785}
1786
1787function pointInRect(point, rect) {
1788    return intersectRect({top: point.y, bottom: point.y, left: point.x, right: point.x}, rect);
1789}
1790
1791function ajax(url, options) {
1792    return new Promise$$1(function (resolve, reject) {
1793
1794        var env = assign({
1795            data: null,
1796            method: 'GET',
1797            headers: {},
1798            xhr: new XMLHttpRequest(),
1799            beforeSend: noop,
1800            responseType: ''
1801        }, options);
1802
1803        var xhr = env.xhr;
1804
1805        env.beforeSend(env);
1806
1807        for (var prop in env) {
1808            if (prop in xhr) {
1809                try {
1810
1811                    xhr[prop] = env[prop];
1812
1813                } catch (e) {}
1814            }
1815        }
1816
1817        xhr.open(env.method.toUpperCase(), url);
1818
1819        for (var header in env.headers) {
1820            xhr.setRequestHeader(header, env.headers[header]);
1821        }
1822
1823        on(xhr, 'load', function () {
1824
1825            if (xhr.status === 0 || xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) {
1826                resolve(xhr);
1827            } else {
1828                reject(assign(Error(xhr.statusText), {
1829                    xhr: xhr,
1830                    status: xhr.status
1831                }));
1832            }
1833
1834        });
1835
1836        on(xhr, 'error', function () { return reject(assign(Error('Network Error'), {xhr: xhr})); });
1837        on(xhr, 'timeout', function () { return reject(assign(Error('Network Timeout'), {xhr: xhr})); });
1838
1839        xhr.send(env.data);
1840    });
1841}
1842
1843/*
1844    Based on:
1845    Copyright (c) 2016 Wilson Page [email protected]
1846    https://github.com/wilsonpage/fastdom
1847*/
1848
1849var fastdom = {
1850
1851    reads: [],
1852    writes: [],
1853
1854    read: function read(task) {
1855        this.reads.push(task);
1856        scheduleFlush();
1857        return task;
1858    },
1859
1860    write: function write(task) {
1861        this.writes.push(task);
1862        scheduleFlush();
1863        return task;
1864    },
1865
1866    clear: function clear(task) {
1867        return remove$1(this.reads, task) || remove$1(this.writes, task);
1868    },
1869
1870    flush: function flush() {
1871
1872        runTasks(this.reads);
1873        runTasks(this.writes.splice(0, this.writes.length));
1874
1875        this.scheduled = false;

1876
1877        if (this.reads.length || this.writes.length) {
1878            scheduleFlush();
1879        }
1880
1881    }
1882
1883};
1884
1885function scheduleFlush() {
1886    if (!fastdom.scheduled) {
1887        fastdom.scheduled = true;
1888        requestAnimationFrame$1(fastdom.flush.bind(fastdom));
1889    }
1890}
1891
1892function runTasks(tasks) {
1893    var task;
1894    while (task = tasks.shift()) {
1895        task();
1896    }
1897}
1898
1899function remove$1(array, item) {
1900    var index = array.indexOf(item);
1901    return !!~index && !!array.splice(index, 1);
1902}
1903
1904function MouseTracker() {}
1905
1906MouseTracker.prototype = {
1907
1908    positions: [],
1909    position: null,
1910
1911    init: function init() {
1912        var this$1 = this;
1913
1914
1915        this.positions = [];
1916        this.position = null;
1917
1918        var ticking = false;
1919        this.unbind = on(doc, 'mousemove', function (e) {
1920
1921            if (ticking) {
1922                return;
1923            }
1924
1925            setTimeout(function () {
1926
1927                var time = Date.now(), length = this$1.positions.length;
1928                if (length && (time - this$1.positions[length - 1].time > 100)) {
1929                    this$1.positions.splice(0, length);
1930                }
1931
1932                this$1.positions.push({time: time, x: e.pageX, y: e.pageY});
1933
1934                if (this$1.positions.length > 5) {
1935                    this$1.positions.shift();
1936                }
1937
1938                ticking = false;
1939            }, 5);
1940
1941            ticking = true;
1942        });
1943
1944    },
1945
1946    cancel: function cancel() {
1947        if (this.unbind) {
1948            this.unbind();
1949        }
1950    },
1951
1952    movesTo: function movesTo(target) {
1953
1954        if (this.positions.length < 2) {
1955            return false;
1956        }
1957
1958        var p = offset(target),
1959            position$$1 = this.positions[this.positions.length - 1],
1960            prevPos = this.positions[0];
1961
1962        if (p.left <= position$$1.x && position$$1.x <= p.right && p.top <= position$$1.y && position$$1.y <= p.bottom) {
1963            return false;
1964        }
1965
1966        var points = [
1967            [{x: p.left, y: p.top}, {x: p.right, y: p.bottom}],
1968            [{x: p.right, y: p.top}, {x: p.left, y: p.bottom}]
1969        ];
1970
1971        if (p.right <= position$$1.x) {
1972
1973        } else if (p.left >= position$$1.x) {
1974            points[0].reverse();
1975            points[1].reverse();
1976        } else if (p.bottom <= position$$1.y) {
1977            points[0].reverse();
1978        } else if (p.top >= position$$1.y) {
1979            points[1].reverse();
1980        }
1981
1982        return !!points.reduce(function (result, point) {
1983            return result + (slope(prevPos, point[0]) < slope(position$$1, point[0]) && slope(prevPos, point[1]) > slope(position$$1, point[1]));
1984        }, 0);
1985    }
1986
1987};
1988
1989function slope(a, b) {
1990    return (b.y - a.y) / (b.x - a.x);
1991}
1992
1993var strats = {};
1994
1995// concat strategy
1996strats.args =
1997strats.created =
1998strats.events =
1999strats.init =
2000strats.ready =
2001strats.connected =
2002strats.disconnected =
2003strats.destroy = function (parentVal, childVal) {
2004
2005    parentVal = parentVal && !isArray(parentVal) ? [parentVal] : parentVal;
2006
2007    return childVal
2008        ? parentVal
2009            ? parentVal.concat(childVal)
2010            : isArray(childVal)
2011                ? childVal
2012                : [childVal]
2013        : parentVal;
2014};
2015
2016// update strategy
2017strats.update = function (parentVal, childVal) {
2018    return strats.args(parentVal, isFunction(childVal) ? {read: childVal} : childVal);
2019};
2020
2021// property strategy
2022strats.props = function (parentVal, childVal) {
2023
2024    if (isArray(childVal)) {
2025        childVal = childVal.reduce(function (value, key) {
2026            value[key] = String;
2027            return value;
2028        }, {});
2029    }
2030
2031    return strats.methods(parentVal, childVal);
2032};
2033
2034// extend strategy
2035strats.computed =
2036strats.defaults =
2037strats.methods = function (parentVal, childVal) {
2038    return childVal
2039        ? parentVal
2040            ? assign({}, parentVal, childVal)
2041            : childVal
2042        : parentVal;
2043};
2044
2045// default strategy
2046var defaultStrat = function (parentVal, childVal) {
2047    return isUndefined(childVal) ? parentVal : childVal;
2048};
2049
2050function mergeOptions(parent, child) {
2051
2052    var options = {}, key;
2053
2054    if (child.mixins) {
2055        for (var i = 0, l = child.mixins.length; i < l; i++) {
2056            parent = mergeOptions(parent, child.mixins[i]);
2057        }
2058    }
2059
2060    for (key in parent) {

2061        mergeKey(key);
2062    }
2063
2064    for (key in child) {
2065        if (!hasOwn(parent, key)) {
2066            mergeKey(key);
2067        }
2068    }
2069
2070    function mergeKey(key) {
2071        options[key] = (strats[key] || defaultStrat)(parent[key], child[key]);
2072    }
2073
2074    return options;
2075}
2076
2077var id = 0;
2078
2079var Player = function Player(el) {
2080    this.id = ++id;
2081    this.el = toNode(el);
2082};
2083
2084Player.prototype.isVideo = function isVideo () {
2085    return this.isYoutube() || this.isVimeo() || this.isHTML5();
2086};
2087
2088Player.prototype.isHTML5 = function isHTML5 () {
2089    return this.el.tagName === 'VIDEO';
2090};
2091
2092Player.prototype.isIFrame = function isIFrame () {
2093    return this.el.tagName === 'IFRAME';
2094};
2095
2096Player.prototype.isYoutube = function isYoutube () {
2097    return this.isIFrame() && !!this.el.src.match(/\/\/.*?youtube\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/);
2098};
2099
2100Player.prototype.isVimeo = function isVimeo () {
2101    return this.isIFrame() && !!this.el.src.match(/vimeo\.com\/video\/.*/);
2102};
2103
2104Player.prototype.enableApi = function enableApi () {
2105        var this$1 = this;
2106
2107
2108    if (this.ready) {
2109        return this.ready;
2110    }
2111
2112    var youtube = this.isYoutube(), vimeo = this.isVimeo(), poller;
2113
2114    if (youtube || vimeo) {
2115
2116        return this.ready = new Promise$1(function (resolve) {
2117
2118            once(this$1.el, 'load', function () {
2119                if (youtube) {
2120                    var listener = function () { return post(this$1.el, {event: 'listening', id: this$1.id}); };
2121                    poller = setInterval(listener, 100);
2122                    listener();
2123                }
2124            });
2125
2126            listen(function (data$$1) { return youtube && data$$1.id === this$1.id && data$$1.event === 'onReady' || vimeo && Number(data$$1.player_id) === this$1.id; })
2127                .then(function () {
2128                    resolve();
2129                    poller && clearInterval(poller);
2130                });
2131
2132            attr(this$1.el, 'src', ("" + (this$1.el.src) + (includes(this$1.el.src, '?') ? '&' : '?') + (youtube ? 'enablejsapi=1' : ("api=1&player_id=" + id))));
2133
2134        });
2135
2136    }
2137
2138    return Promise$1.resolve();
2139
2140};
2141
2142Player.prototype.play = function play () {
2143        var this$1 = this;
2144
2145
2146    if (!this.isVideo()) {
2147        return;
2148    }
2149
2150    if (this.isIFrame()) {
2151        this.enableApi().then(function () { return post(this$1.el, {func: 'playVideo', method: 'play'}); });
2152    } else if (this.isHTML5()) {
2153        try {
2154            this.el.play();
2155        } catch (e) {}
2156    }
2157};
2158
2159Player.prototype.pause = function pause () {
2160        var this$1 = this;
2161
2162
2163    if (!this.isVideo()) {
2164        return;
2165    }
2166
2167    if (this.isIFrame()) {
2168        this.enableApi().then(function () { return post(this$1.el, {func: 'pauseVideo', method: 'pause'}); });
2169    } else if (this.isHTML5()) {
2170        this.el.pause();
2171    }
2172};
2173
2174Player.prototype.mute = function mute () {
2175        var this$1 = this;
2176
2177
2178    if (!this.isVideo()) {
2179        return;
2180    }
2181
2182    if (this.isIFrame()) {
2183        this.enableApi().then(function () { return post(this$1.el, {func: 'mute', method: 'setVolume', value: 0}); });
2184    } else if (this.isHTML5()) {
2185        this.el.muted = true;
2186        attr(this.el, 'muted', '');
2187    }
2188
2189};
2190
2191function post(el, cmd) {
2192    try {
2193        el.contentWindow.postMessage(JSON.stringify(assign({event: 'command'}, cmd)), '*');
2194    } catch (e) {}
2195}
2196
2197function listen(cb) {
2198
2199    return new Promise$1(function (resolve) {
2200
2201        once(win, 'message', function (_, data$$1) { return resolve(data$$1); }, false, function (ref) {
2202            var data$$1 = ref.data;
2203
2204
2205            if (!data$$1 || !isString(data$$1)) {
2206                return;
2207            }
2208
2209            try {
2210                data$$1 = JSON.parse(data$$1);
2211            } catch (e) {
2212                return;
2213            }
2214
2215            return data$$1 && cb(data$$1);
2216
2217        });
2218
2219    });
2220
2221}
2222
2223/*
2224    Based on:
2225    Copyright (c) 2010-2016 Thomas Fuchs
2226    http://zeptojs.com/
2227*/
2228var touch = {};
2229var clickTimeout;
2230var swipeTimeout;
2231var tapTimeout;
2232var clicked;
2233
2234function swipeDirection(ref) {
2235    var x1 = ref.x1;
2236    var x2 = ref.x2;
2237    var y1 = ref.y1;
2238    var y2 = ref.y2;
2239
2240    return Math.abs(x1 - x2) >= Math.abs(y1 - y2) ? (x1 - x2 > 0 ? 'Left' : 'Right') : (y1 - y2 > 0 ? 'Up' : 'Down');
2241}
2242
2243function cancelAll() {
2244    clickTimeout && clearTimeout(clickTimeout);
2245    swipeTimeout && clearTimeout(swipeTimeout);
2246    tapTimeout && clearTimeout(tapTimeout);
2247    clickTimeout = swipeTimeout = tapTimeout = null;
2248    touch = {};
2249}
2250
2251ready(function () {
2252
2253    on(doc, 'click', function () { return clicked = true; }, true);
2254
2255    on(doc, pointerDown, function (e) {
2256
2257        var target = e.target;
2258        var ref = getPos$1(e);
2259        var x = ref.x;
2260        var y = ref.y;
2261        var now = Date.now();
2262
2263        touch.el = 'tagName' in target ? target : target.parentNode;
2264
2265        clickTimeout && clearTimeout(clickTimeout);
2266
2267        touch.x1 = x;
2268        touch.y1 = y;
2269
2270        if (touch.last && now - touch.last <= 250) {
2271            touch = {};
2272        }
2273
2274        touch.last = now;
2275
2276        clicked = e.button > 0;
2277
2278    });
2279
2280    on(doc, pointerMove, function (e) {
2281
2282        var ref = getPos$1(e);
2283        var x = ref.x;
2284        var y = ref.y;
2285
2286        touch.x2 = x;

2287        touch.y2 = y;
2288    });
2289
2290    on(doc, pointerUp, function (ref) {
2291        var type = ref.type;
2292        var target = ref.target;
2293
2294
2295        // swipe
2296        if (touch.x2 && Math.abs(touch.x1 - touch.x2) > 30 || touch.y2 && Math.abs(touch.y1 - touch.y2) > 30) {
2297
2298            swipeTimeout = setTimeout(function () {
2299                if (touch.el) {
2300                    trigger(touch.el, 'swipe');
2301                    trigger(touch.el, ("swipe" + (swipeDirection(touch))));
2302                }
2303                touch = {};
2304            });
2305
2306        // normal tap
2307        } else if ('last' in touch) {
2308
2309            tapTimeout = setTimeout(function () { return touch.el && trigger(touch.el, 'tap'); });
2310
2311            // trigger single click after 350ms of inactivity
2312            if (touch.el && type !== 'mouseup' && within(target, touch.el)) {
2313                clickTimeout = setTimeout(function () {
2314                    clickTimeout = null;
2315                    if (touch.el && !clicked) {
2316                        trigger(touch.el, 'click');
2317                    }
2318                    touch = {};
2319                }, 350);
2320            }
2321
2322        } else {
2323            touch = {};
2324        }
2325    });
2326
2327    on(doc, 'touchcancel', cancelAll);
2328    on(win, 'scroll', cancelAll);
2329});
2330
2331var touching = false;
2332on(doc, 'touchstart', function () { return touching = true; }, true);
2333on(doc, 'click', function () {touching = false;});
2334on(doc, 'touchcancel', function () { return touching = false; }, true);
2335
2336function isTouch(e) {
2337    return touching || e.pointerType === 'touch';
2338}
2339
2340function getPos$1(e) {
2341    var touches = e.touches;
2342    var changedTouches = e.changedTouches;
2343    
2344    var ref = touches && touches[0] || changedTouches && changedTouches[0] || e;
2345    var x = ref.pageX;
2346    var y = ref.pageY;
2347    return {x: x, y: y};
2348}
2349
2350
2351
2352var util = Object.freeze({
2353	bind: bind,
2354	hasOwn: hasOwn,
2355	Promise: Promise$$1,
2356	Deferred: Deferred,
2357	classify: classify,
2358	hyphenate: hyphenate,
2359	camelize: camelize,
2360	ucfirst: ucfirst,
2361	startsWith: startsWith,
2362	endsWith: endsWith,
2363	includes: includes,
2364	isArray: isArray,
2365	isFunction: isFunction,
2366	isObject: isObject,
2367	isPlainObject: isPlainObject,
2368	isWindow: isWindow,
2369	isDocument: isDocument,
2370	isBoolean: isBoolean,
2371	isString: isString,
2372	isNumber: isNumber,
2373	isNumeric: isNumeric,
2374	isUndefined: isUndefined,
2375	toBoolean: toBoolean,
2376	toNumber: toNumber,
2377	toFloat: toFloat,
2378	toList: toList,
2379	toMedia: toMedia,
2380	coerce: coerce,
2381	toMs: toMs,
2382	swap: swap,
2383	assign: assign,
2384	each: each,
2385	clamp: clamp,
2386	noop: noop,
2387	intersectRect: intersectRect,
2388	pointInRect: pointInRect,
2389	ajax: ajax,
2390	$: $,
2391	$$: $$,
2392	query: query,
2393	queryAll: queryAll,
2394	filter: filter,
2395	within: within,
2396	matches: matches,
2397	closest: closest,
2398	parents: parents,
2399	isJQuery: isJQuery,
2400	toNode: toNode,
2401	toNodes: toNodes,
2402	escape: escape,
2403	attr: attr,
2404	hasAttr: hasAttr,
2405	removeAttr: removeAttr,
2406	filterAttr: filterAttr,
2407	data: data,
2408	isRtl: isRtl,
2409	isReady: isReady,
2410	ready: ready,
2411	transition: transition,
2412	Transition: Transition,
2413	animate: animate,
2414	Animation: Animation,
2415	isInView: isInView,
2416	scrolledOver: scrolledOver,
2417	getIndex: getIndex,
2418	isVoidElement: isVoidElement,
2419	Dimensions: Dimensions,
2420	preventClick: preventClick,
2421	isVisible: isVisible,
2422	selInput: selInput,
2423	isInput: isInput,
2424	empty: empty,
2425	html: html,
2426	prepend: prepend,
2427	append: append,
2428	before: before,
2429	after: after,
2430	remove: remove,
2431	wrapAll: wrapAll,
2432	wrapInner: wrapInner,
2433	unwrap: unwrap,
2434	fragment: fragment,
2435	index: index,
2436	css: css,
2437	getStyles: getStyles,
2438	getStyle: getStyle,
2439	getCssVar: getCssVar,
2440	addClass: addClass,
2441	removeClass: removeClass,
2442	removeClasses: removeClasses,
2443	replaceClass: replaceClass,
2444	hasClass: hasClass,
2445	toggleClass: toggleClass,
2446	win: win,
2447	doc: doc,
2448	docEl: docEl,
2449	Observer: Observer,
2450	requestAnimationFrame: requestAnimationFrame$1,
2451	hasTouch: hasTouch,
2452	pointerDown: pointerDown,
2453	pointerMove: pointerMove,
2454	pointerUp: pointerUp,
2455	pointerEnter: pointerEnter,
2456	pointerLeave: pointerLeave,
2457	getImage: getImage,
2458	supports: supports,
2459	on: on,
2460	off: off,
2461	once: once,
2462	trigger: trigger,
2463	createEvent: createEvent,
2464	toEventTargets: toEventTargets,
2465	fastdom: fastdom,
2466	MouseTracker: MouseTracker,
2467	mergeOptions: mergeOptions,
2468	Player: Player,
2469	positionAt: positionAt,
2470	offset: offset,
2471	position: position,
2472	height: height,
2473	width: width,
2474	flipPosition: flipPosition,
2475	isTouch: isTouch,
2476	getPos: getPos$1
2477});
2478
2479function componentAPI (UIkit) {
2480
2481    var DATA = UIkit.data;
2482
2483    UIkit.components = {};
2484
2485    UIkit.component = function (id, options) {
2486
2487        var name = camelize(id);
2488
2489        if (isPlainObject(options)) {
2490            options.name = name;

2491            options = UIkit.extend(options);
2492        } else if (isUndefined(options)) {
2493            return UIkit.components[name];
2494        } else {
2495            options.options.name = name;
2496        }
2497
2498        UIkit.components[name] = options;
2499
2500        UIkit[name] = function (element, data) {
2501            var i = arguments.length, argsArray = Array(i);
2502            while ( i-- ) argsArray[i] = arguments[i];
2503
2504
2505            if (isPlainObject(element)) {
2506                return new UIkit.components[name]({data: element});
2507            }
2508
2509            if (UIkit.components[name].options.functional) {
2510                return new UIkit.components[name]({data: [].concat( argsArray )});
2511            }
2512
2513            return element && element.nodeType ? init(element) : $$(element).map(init)[0];
2514
2515            function init(element) {
2516
2517                var cmp = UIkit.getComponent(element, name);
2518
2519                if (cmp) {
2520                    cmp.$reset(data);
2521                }
2522
2523                return cmp || new UIkit.components[name]({el: element, data: data || {}});
2524            }
2525
2526        };
2527
2528        if (UIkit._initialized && !options.options.functional) {
2529            fastdom.read(function () { return UIkit[name](("[uk-" + id + "],[data-uk-" + id + "]")); });
2530        }
2531
2532        return UIkit.components[name];
2533    };
2534
2535    UIkit.getComponents = function (element) { return element && (element = isJQuery(element) ? element[0] : element) && element[DATA] || {}; };
2536    UIkit.getComponent = function (element, name) { return UIkit.getComponents(element)[name]; };
2537
2538    UIkit.connect = function (node) {
2539
2540        var name;
2541
2542        if (node[DATA]) {
2543            for (name in node[DATA]) {
2544                node[DATA][name]._callConnected();
2545            }
2546        }
2547
2548        for (var i = 0; i < node.attributes.length; i++) {
2549
2550            name = getComponentName(node.attributes[i].name);
2551
2552            if (name && name in UIkit.components) {
2553                UIkit[name](node);
2554            }
2555
2556        }
2557
2558    };
2559
2560    UIkit.disconnect = function (node) {
2561        for (var name in node[DATA]) {
2562            node[DATA][name]._callDisconnected();
2563        }
2564    };
2565
2566}
2567
2568function getComponentName(attribute) {
2569    return startsWith(attribute, 'uk-') || startsWith(attribute, 'data-uk-')
2570        ? camelize(attribute.replace('data-uk-', '').replace('uk-', ''))
2571        : false;
2572}
2573
2574function boot (UIkit) {
2575
2576    var connect = UIkit.connect;
2577    var disconnect = UIkit.disconnect;
2578
2579    if (!Observer) {
2580        return;
2581    }
2582
2583    if (doc.body) {
2584
2585        init();
2586
2587    } else {
2588
2589        (new Observer(function () {
2590
2591            if (doc.body) {
2592                this.disconnect();
2593                init();
2594            }
2595
2596        })).observe(docEl, {childList: true, subtree: true});
2597
2598    }
2599
2600    function init() {
2601
2602        apply(doc.body, connect);
2603
2604        fastdom.flush();
2605
2606        (new Observer(function (mutations) { return mutations.forEach(applyMutation); })).observe(docEl, {
2607            childList: true,
2608            subtree: true,
2609            characterData: true,
2610            attributes: true
2611        });
2612
2613        UIkit._initialized = true;
2614    }
2615
2616    function applyMutation(mutation) {
2617
2618        var target = mutation.target;
2619        var type = mutation.type;
2620
2621        var update = type !== 'attributes'
2622            ? applyChildList(mutation)
2623            : applyAttribute(mutation);
2624
2625        update && UIkit.update(createEvent('update', true, false, {mutation: true}), target, true);
2626
2627    }
2628
2629    function applyAttribute(ref) {
2630        var target = ref.target;
2631        var attributeName = ref.attributeName;
2632
2633
2634        if (attributeName === 'href') {
2635            return true;
2636        }
2637
2638        var name = getComponentName(attributeName);
2639
2640        if (!name || !(name in UIkit.components)) {
2641            return;
2642        }
2643
2644        if (hasAttr(target, attributeName)) {
2645            UIkit[name](target);
2646            return true;
2647        }
2648
2649        var component = UIkit.getComponent(target, name);
2650
2651        if (component) {
2652            component.$destroy();
2653            return true;
2654        }
2655
2656    }
2657
2658    function applyChildList(ref) {
2659        var addedNodes = ref.addedNodes;
2660        var removedNodes = ref.removedNodes;
2661
2662
2663        var i;
2664
2665        for (i = 0; i < addedNodes.length; i++) {
2666            apply(addedNodes[i], connect);
2667        }
2668
2669        for (i = 0; i < removedNodes.length; i++) {
2670            apply(removedNodes[i], disconnect);
2671        }
2672
2673        return true;
2674    }
2675    function apply(node, fn) {
2676
2677        if (node.nodeType !== 1 || hasAttr(node, 'uk-no-boot')) {
2678            return;
2679        }
2680
2681        fn(node);
2682        node = node.firstElementChild;
2683        while (node) {
2684            var next = node.nextElementSibling;
2685            apply(node, fn);
2686            node = next;
2687        }
2688    }
2689
2690}
2691
2692function globalAPI (UIkit) {
2693
2694    var DATA = UIkit.data;
2695
2696    UIkit.use = function (plugin) {
2697
2698        if (plugin.installed) {
2699            return;
2700        }
2701
2702        plugin.call(null, this);
2703        plugin.installed = true;
2704
2705        return this;
2706    };
2707
2708    UIkit.mixin = function (mixin, component) {
2709        component = (isString(component) ? UIkit.components[component] : component) || this;
2710        mixin = mergeOptions({}, mixin);
2711        mixin.mixins = component.options.mixins;
2712        delete component.options.mixins;
2713        component.options = mergeOptions(mixin, component.options);
2714    };
2715
2716    UIkit.extend = function (options) {
2717
2718        options = options || {};
2719
2720        var Super = this;
2721        var Sub = function UIkitComponent (options) {
2722            this._init(options);
2723        };
2724
2725        Sub.prototype = Object.create(Super.prototype);
2726        Sub.prototype.constructor = Sub;
2727        Sub.options = mergeOptions(Super.options, options);
2728
2729        Sub['super'] = Super;
2730        Sub.extend = Super.extend;
2731
2732        return Sub;
2733    };
2734
2735    UIkit.update = function (e, element, parents) {
2736        if ( parents === void 0 ) parents = false;