vuikit/dist/vuikit.js

A responsive Vue UI library for web site interfaces based on UIkit

/**
 * Vuikit 0.8.10
 * (c) 2018 Miljan Aleksic
 * @license MIT
**/

/* Substantial part of the code is adapted from UIkit,
  Copyright (c) 2013-2018 YOOtheme GmbH, getuikit.com */

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global.Vuikit = factory());
}(this, (function () { 'use strict';

var ref = Object.prototype;
var hasOwnProperty = ref.hasOwnProperty;
function hasOwn (obj, key) {
  return hasOwnProperty.call(obj, key)
}
var hyphenateRe = /([a-z\d])([A-Z])/g;
function hyphenate (str) {
  return str
    .replace(hyphenateRe, '$1-$2')
    .toLowerCase()
}
function toUpper (_, c) {
  return c ? c.toUpperCase() : ''
}
function ucfirst (str) {
  return str.length ? toUpper(null, str.charAt(0)) + str.slice(1) : ''
}
var strPrototype = String.prototype;
var startsWithFn = strPrototype.startsWith || function (search) { return this.lastIndexOf(search, 0) === 0 };
function startsWith (str, search) {
  return startsWithFn.call(str, search)
}
var endsWithFn = strPrototype.endsWith || function (search) { return this.substr(-search.length) === search };
function endsWith (str, search) {
  return endsWithFn.call(str, search)
}
var includesFn = function (search) { return ~this.indexOf(search) };
var includesStr = strPrototype.includes || includesFn;
var includesArray = Array.prototype.includes || includesFn;
function includes (obj, search) {
  return obj && (isString(obj) ? includesStr : includesArray).call(obj, search)
}
var isArray = Array.isArray;
function isFunction (obj) {
  return typeof obj === 'function'
}
function isObject (obj) {
  return obj !== null && typeof obj === 'object'
}
function isPlainObject (obj) {
  return isObject(obj) && Object.getPrototypeOf(obj) === Object.prototype
}
function isWindow (obj) {
  return isObject(obj) && obj === obj.window
}
function isDocument (obj) {
  return isObject(obj) && obj.nodeType === 9
}
function isJQuery (obj) {
  return isObject(obj) && !!obj.jquery
}
function isNode (element) {
  return typeof Node !== 'undefined' && element instanceof Node || isObject(element) && element.nodeType === 1
}
function isNodeCollection (element) {
  return typeof NodeList !== 'undefined' && element instanceof NodeList ||
    typeof HTMLCollection !== 'undefined' && element instanceof HTMLCollection
}
function isString (value) {
  return typeof value === 'string'
}
function isNumber (value) {
  return typeof value === 'number'
}
function isNumeric (value) {
  return isNumber(value) || isString(value) && !isNaN(value - parseFloat(value))
}
function isUndefined (value) {
  return value === void 0
}
function toFloat (value) {
  return parseFloat(value) || 0
}
function toNode (element) {
  return isNode(element) || isWindow(element) || isDocument(element)
    ? element
    : isNodeCollection(element) || isJQuery(element)
      ? element[0]
      : isArray(element)
        ? toNode(element[0])
        : null
}
var arrayProto = Array.prototype;
function toNodes (element) {
  return isNode(element)
    ? [element]
    : isNodeCollection(element)
      ? arrayProto.slice.call(element)
      : isArray(element)
        ? element.map(toNode).filter(Boolean)
        : isJQuery(element)
          ? element.toArray()
          : []
}
var assign = Object.assign || function (target) {
  var args = [], len = arguments.length - 1;
  while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
  target = Object(target);
  for (var i = 0; i < args.length; i++) {
    var source = args[i];
    if (source !== null) {
      for (var key in source) {
        if (hasOwn(source, key)) {
          target[key] = source[key];
        }
      }
    }
  }
  return target
};
function each (obj, cb) {
  for (var key in obj) {
    if (cb.call(obj[key], obj[key], key) === false) {
      break
    }
  }
}
function clamp (number, min, max) {
  if ( min === void 0 ) min = 0;
  if ( max === void 0 ) max = 1;
  return Math.min(Math.max(number, min), max)
}
function noop () {}
function intersectRect (r1, r2) {
  return r1.left <= r2.right &&
        r2.left <= r1.right &&
        r1.top <= r2.bottom &&
        r2.top <= r1.bottom
}

function attr (element, name, value) {
  if (isObject(name)) {
    for (var key in name) {
      attr(element, key, name[key]);
    }
    return
  }
  if (isUndefined(value)) {
    element = toNode(element);
    return element && element.getAttribute(name)
  } else {
    toNodes(element).forEach(function (element) {
      if (isFunction(value)) {
        value = value.call(element, attr(element, name));
      }
      if (value === null) {
        removeAttr(element, name);
      } else {
        element.setAttribute(name, value);
      }
    });
  }
}
function hasAttr (element, name) {
  return toNodes(element).some(function (element) { return element.hasAttribute(name); })
}
function removeAttr (element, name) {
  element = toNodes(element);
  name.split(' ').forEach(function (name) { return element.forEach(function (element) { return element.removeAttribute(name); }
    ); }
  );
}
function filterAttr (element, attribute, pattern, replacement) {
  attr(element, attribute, function (value) { return value ? value.replace(pattern, replacement) : value; });
}
function data (element, attribute) {
  for (var i = 0, attrs = [attribute, ("data-" + attribute)]; i < attrs.length; i++) {
    if (hasAttr(element, attrs[i])) {
      return attr(element, attrs[i])
    }
  }
}

function query (selector, context) {
  return toNode(selector) || find(selector, isContextSelector(selector) ? context : document)
}
function find (selector, context) {
  return toNode(_query(selector, context, 'querySelector'))
}
function findAll (selector, context) {
  return toNodes(_query(selector, context, 'querySelectorAll'))
}
function _query (selector, context, queryFn) {
  if ( context === void 0 ) context = document;
  if (!selector || !isString(selector)) {
    return null
  }
  selector = selector.replace(contextSanitizeRe, '$1 *');
  var removes;
  if (isContextSelector(selector)) {
    removes = [];
    selector = selector.split(',').map(function (selector, i) {
      var ctx = context;
      selector = selector.trim();
      if (selector[0] === '!') {
        var selectors = selector.substr(1).trim().split(' ');
        ctx = closest(context.parentNode, selectors[0]);
        selector = selectors.slice(1).join(' ');
      }
      if (!ctx) {
        return null
      }
      if (!ctx.id) {
        ctx.id = "uk-" + (Date.now()) + i;
        removes.push(function () { return removeAttr(ctx, 'id'); });
      }
      return ("#" + (escape(ctx.id)) + " " + selector)
    }).filter(Boolean).join(',');
    context = document;
  }
  try {
    return context[queryFn](selector)
  } catch (e) {
    return null
  } finally {
    removes && removes.forEach(function (remove) { return remove(); });
  }
}
var contextSelectorRe = /(^|,)\s*[!>+~]/;
var contextSanitizeRe = /([!>+~])(?=\s+[!>+~]|\s*$)/g;
function isContextSelector (selector) {
  return isString(selector) && selector.match(contextSelectorRe)
}
function matches (element, selector) {
  var elProto = window.Element.prototype;
  var matchesFn = elProto.matches || elProto.webkitMatchesSelector || elProto.msMatchesSelector;
  return toNodes(element).some(function (element) { return matchesFn.call(element, selector); })
}
function closest (element, selector) {
  var elProto = window.Element.prototype;
  var closestFn = elProto.closest || function (selector) {
    var ancestor = this;
    do {
      if (matches(ancestor, selector)) {
        return ancestor
      }
      ancestor = ancestor.parentNode;
    } while (ancestor && ancestor.nodeType === 1)
  };
  if (startsWith(selector, '>')) {
    selector = selector.slice(1);
  }
  return isNode(element)
    ? element.parentNode && closestFn.call(element, selector)
    : toNodes(element).map(function (element) { return element.parentNode && closestFn.call(element, selector); }).filter(Boolean)
}
function escape (css) {
  var escapeFn = window.CSS && CSS.escape || function (css) { return css.replace(/([^\x7f-\uFFFF\w-])/g, function (match) { return ("\\" + match); }) };
  return isString(css) ? escapeFn.call(null, css) : ''
}

function isVisible (element) {
  return toNodes(element).some(function (element) { return element.offsetHeight || element.getBoundingClientRect().height; })
}
function filter (element, selector) {
  return toNodes(element).filter(function (element) { return matches(element, selector); })
}
function within (element, selector) {
  return !isString(selector)
    ? element === selector || (isDocument(selector)
      ? selector.documentElement
      : toNode(selector)).contains(toNode(element))
    : matches(element, selector) || closest(element, selector)
}

function on () {
  var args = [], len = arguments.length;
  while ( len-- ) args[ len ] = arguments[ len ];
  var ref = getArgs(args);
  var target = ref[0];
  var type = ref[1];
  var selector = ref[2];
  var listener = ref[3];
  var useCapture = ref[4];
  target = toEventTarget(target);
  if (selector) {
    listener = delegate(target, selector, listener);
  }
  if (listener.length > 1) {
    listener = detail(listener);
  }
  type.split(' ').forEach(function (type) { return target && target.addEventListener(type, listener, useCapture); });
  return function () { return off(target, type, listener, useCapture); }
}
function off (target, type, listener, useCapture) {
  if ( useCapture === void 0 ) useCapture = false;
  target = toEventTarget(target);
  target && type.split(' ').forEach(function (type) { return target.removeEventListener(type, listener, useCapture); });
}
function once () {
  var args = [], len = arguments.length;
  while ( len-- ) args[ len ] = arguments[ len ];
  var ref = getArgs(args);
  var element = ref[0];
  var type = ref[1];
  var selector = ref[2];
  var listener = ref[3];
  var useCapture = ref[4];
  var condition = ref[5];
  var off = on(element, type, selector, function (e) {
    var result = !condition || condition(e);
    if (result) {
      off();
      listener(e, result);
    }
  }, useCapture);
  return off
}
function trigger (target, event, detail) {
  return toEventTargets(target).reduce(function (notCanceled, target) { return notCanceled && target.dispatchEvent(createEvent(event, true, true, detail)); }
    , true)
}
function createEvent (e, bubbles, cancelable, detail) {
  if ( bubbles === void 0 ) bubbles = true;
  if ( cancelable === void 0 ) cancelable = false;
  if (isString(e)) {
    var event = document.createEvent('CustomEvent');
    event.initCustomEvent(e, bubbles, cancelable, detail);
    e = event;
  }
  return e
}
function getArgs (args) {
  if (isString(args[0])) {
    args[0] = find(args[0]);
  }
  if (isFunction(args[2])) {
    args.splice(2, 0, false);
  }
  return args
}
function delegate (element, selector, listener) {
  var this$1 = this;
  return function (e) {
    var target = e.target;
    var current = selector[0] === '>'
      ? findAll(selector, element).reverse().filter(function (element) { return within(target, element); })[0]
      : closest(target, selector);
    if (current) {
      e.delegate = element;
      e.current = current;
      listener.call(this$1, e);
    }
  }
}
function detail (listener) {
  return function (e) { return isArray(e.detail) ? listener.apply(listener, [e].concat(e.detail)) : listener(e); }
}
function isEventTarget (target) {
  return typeof window !== 'undefined' && 'EventTarget' in window
    ? target instanceof window.EventTarget
    : target && 'addEventListener' in target
}
function toEventTarget (target) {
  return isEventTarget(target) ? target : toNode(target)
}
function toEventTargets (target) {
  return isEventTarget(target)
    ? [target]
    : isArray(target)
      ? target.map(toEventTarget).filter(Boolean)
      : toNodes(target)
}

var doc = typeof document !== 'undefined' && document;
function isReady () {
  return doc && (document.readyState === 'complete' || document.readyState !== 'loading' && !document.documentElement.doScroll)
}
function ready (fn) {
  if (!doc) {
    return
  }
  if (isReady()) {
    fn();
    return
  }
  var handle = function () {
    unbind1();
    unbind2();
    fn();
  };
  var unbind1 = on(document, 'DOMContentLoaded', handle);
  var unbind2 = on(window, 'load', handle);
}
function append (parent, element) {
  parent = toNode(parent);
  return insertNodes(element, function (element) { return parent.appendChild(element); })
}
function before (ref, element) {
  ref = toNode(ref);
  return insertNodes(element, function (element) { return ref.parentNode.insertBefore(element, ref); })
}
function after (ref, element) {
  ref = toNode(ref);
  return insertNodes(element, function (element) { return ref.nextSibling
    ? before(ref.nextSibling, element)
    : append(ref.parentNode, element); }
  )
}
function insertNodes (element, fn) {
  element = isString(element) ? fragment(element) : element;
  return element
    ? 'length' in element
      ? toNodes(element).map(fn)
      : fn(element)
    : null
}
function remove (element) {
  toNodes(element).map(function (element) { return element.parentNode && element.parentNode.removeChild(element); });
}
var fragmentRE = /^\s*<(\w+|!)[^>]*>/;
var singleTagRE = /^<(\w+)\s*\/?>(?:<\/\1>)?$/;
function fragment (html) {
  var matches = singleTagRE.exec(html);
  if (matches) {
    return document.createElement(matches[1])
  }
  var container = document.createElement('div');
  if (fragmentRE.test(html)) {
    container.insertAdjacentHTML('beforeend', html.trim());
  } else {
    container.textContent = html;
  }
  return container.childNodes.length > 1 ? toNodes(container.childNodes) : container.firstChild
}

function addClass (element) {
  var args = [], len = arguments.length - 1;
  while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
  apply$1(element, args, 'add');
}
function removeClass (element) {
  var args = [], len = arguments.length - 1;
  while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
  apply$1(element, args, 'remove');
}
function removeClasses (element, cls) {
  filterAttr(element, 'class', new RegExp(("(^|\\s)" + cls + "(?!\\S)"), 'g'), '');
}
function replaceClass (element) {
  var args = [], len = arguments.length - 1;
  while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
  args[0] && removeClass(element, args[0]);
  args[1] && addClass(element, args[1]);
}
function hasClass (element, cls) {
  return toNodes(element).some(function (element) { return element.classList.contains(cls); })
}
function toggleClass (element) {
  var args = [], len = arguments.length - 1;
  while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
  if (!args.length) {
    return
  }
  args = getArgs$1(args);
  var force = !isString(args[args.length - 1]) ? args.pop() : [];
  args = args.filter(Boolean);
  toNodes(element).forEach(function (ref) {
    var classList = ref.classList;
    for (var i = 0; i < args.length; i++) {
      supports.Force
        ? classList.toggle.apply(classList, [args[i]].concat(force))
        : (classList[(!isUndefined(force) ? force : !classList.contains(args[i])) ? 'add' : 'remove'](args[i]));
    }
  });
}
function apply$1 (element, args, fn) {
  args = getArgs$1(args).filter(Boolean);
  args.length && toNodes(element).forEach(function (ref) {
    var classList = ref.classList;
    supports.Multiple
      ? classList[fn].apply(classList, args)
      : args.forEach(function (cls) { return classList[fn](cls); });
  });
}
function getArgs$1 (args) {
  return args.reduce(function (args, arg) { return args.concat.call(args, isString(arg) && includes(arg, ' ') ? arg.trim().split(' ') : arg); }
    , [])
}
var supports = {};
(function () {
  if (typeof document !== 'undefined' && document.createElement('_').classList) {
    var list = document.createElement('_').classList;
    list.add('a', 'b');
    list.toggle('c', false);
    supports.Multiple = list.contains('b');
    supports.Force = !list.contains('c');
    list = null;
  }
})();

var cssNumber = {
  'animation-iteration-count': true,
  'column-count': true,
  'fill-opacity': true,
  'flex-grow': true,
  'flex-shrink': true,
  'font-weight': true,
  'line-height': true,
  'opacity': true,
  'order': true,
  'orphans': true,
  'widows': true,
  'z-index': true,
  'zoom': true
};
function css (element, property, value) {
  return toNodes(element).map(function (element) {
    if (isString(property)) {
      property = propName(property);
      if (isUndefined(value)) {
        return getStyle(element, property)
      } else if (!value && value !== 0) {
        element.style.removeProperty(property);
      } else {
        element.style[property] = isNumeric(value) && !cssNumber[property] ? (value + "px") : value;
      }
    } else if (isArray(property)) {
      var styles = getStyles(element);
      return property.reduce(function (props, property) {
        props[property] = styles[propName(property)];
        return props
      }, {})
    } else if (isObject(property)) {
      each(property, function (value, property) { return css(element, property, value); });
    }
    return element
  })[0]
}
function getStyles (element, pseudoElt) {
  element = toNode(element);
  return element.ownerDocument.defaultView.getComputedStyle(element, pseudoElt)
}
function getStyle (element, property, pseudoElt) {
  return getStyles(element, pseudoElt)[property]
}
var vars = {};
function getCssVar (name) {
  if (!(name in vars)) {
    var element = append(document.documentElement, document.createElement('div'));
    addClass(element, ("var-" + name));
    try {
      vars[name] = getStyle(element, 'content', ':before').replace(/^["'](.*)["']$/, '$1');
      vars[name] = JSON.parse(vars[name]);
    } catch (e) {}
    document.documentElement.removeChild(element);
  }
  return vars[name]
}
var cssProps = {};
function propName (name) {
  var ret = cssProps[name];
  if (!ret) {
    ret = cssProps[name] = vendorPropName(name) || name;
  }
  return ret
}
var cssPrefixes = ['webkit', 'moz', 'ms'];
function vendorPropName (name) {
  var ref = document.createElement('_');
  var style = ref.style;
  name = hyphenate(name);
  if (name in style) {
    return name
  }
  var i = cssPrefixes.length, prefixedName;
  while (i--) {
    prefixedName = "-" + (cssPrefixes[i]) + "-" + name;
    if (prefixedName in style) {
      return prefixedName
    }
  }
}

function toMedia (value) {
  if (isString(value)) {
    if (value[0] === '@') {
      var name = "media-" + (value.substr(1));
      value = toFloat(getCssVar(name));
    } else if (isNaN(value)) {
      return value
    }
  }
  return value && !isNaN(value) ? ("(min-width: " + value + "px)") : false
}
function get (obj, path, defVal) {
  var result = isObject(obj) && isString(path)
    ? _get(obj, path)
    : undefined;
  return result === undefined
    ? defVal
    : result
}
function _get (obj, path) {
  return path.split('.').reduce(function (acc, val) { return acc && acc[val]; }, obj)
}
function range (start, stop, step) {
  if ( step === void 0 ) step = 1;
  if (typeof stop === 'undefined') {
    stop = start;
    start = 0;
  }
  return Array.from(new Array(Math.floor((stop - start) / step)), function (x, i) { return start + (i * step); })
}

function findParent (instance) {
  return findParents(instance).pop()
}
function findParents (instance) {
  var parents = [];
  var name = instance.$options.name;
  var parent = instance.$parent;
  while (parent) {
    if (parent.$options.name === name) {
      parents.unshift(parent);
    }
    parent = parent.$parent;
  }
  return parents
}
function apply$2 (instance, fn) {
  if (!instance || !instance._isVue) {
    return
  }
  fn(instance);
  instance.$children.forEach(function (child) { return apply$2(child, fn); });
}
function filterOutTextNodes (nodes) {
  return nodes.filter(function (n) { return n.tag || isAsyncPlaceholder(n); })
}
function isAsyncPlaceholder (node) {
  return node.isComment && node.asyncFactory
}
function mergeData () {
  var arguments$1 = arguments;
  for(var e,a,s={},t=arguments.length;t--;){ for(var r=0,c=Object.keys(arguments[t]);r<c.length;r++){ switch(e=c[r]){case"class":case"style":case"directives":Array.isArray(s[e])||(s[e]=[]), s[e]=s[e].concat(arguments$1[t][e]);break;case"staticClass":if(!arguments$1[t][e]){ break; }void 0===s[e]&&(s[e]=""), s[e]&&(s[e]+=" "), s[e]+=arguments$1[t][e].trim();break;case"on":case"nativeOn":s[e]||(s[e]={});for(var o=0,n=Object.keys(arguments[t][e]);o<n.length;o++){ a=n[o], s[e][a]?s[e][a]=[].concat(s[e][a],arguments$1[t][e][a]):s[e][a]=arguments$1[t][e][a]; }break;case"attrs":case"props":case"domProps":case"scopedSlots":case"staticStyle":case"hook":case"transition":s[e]||(s[e]={}), s[e]=__assign({},arguments$1[t][e],s[e]);break;case"slot":case"key":case"ref":case"tag":case"show":case"keepAlive":default:s[e]||(s[e]=arguments$1[t][e]);} } }return s}var __assign=Object.assign||function(e){
  var arguments$1 = arguments;
for(var a,s=1,t=arguments.length;s<t;s++){a=arguments$1[s];for(var r in a){ Object.prototype.hasOwnProperty.call(a,r)&&(e[r]=a[r]); }}return e
};

var ElementBreadcrumb = {
  functional: true,
  render: function (h, ref) {
    var props = ref.props;
    var data = ref.data;
    var children = ref.children;
    return h('ul', mergeData(data, {
      class: 'uk-breadcrumb'
    }), children)
  }
}

var ElementBreadcrumbItem = {
  functional: true,
  props: {
    href: String,
    target: String,
    disabled: {
      type: Boolean,
      default: false
    }
  },
  render: function (h, ref) {
    var props = ref.props;
    var data = ref.data;
    var children = ref.children;
    var disabled = props.disabled;
    var href = props.href;
    var target = props.target;
    return h('li', mergeData(data, {
      class: {
        'uk-disabled': disabled
      }
    }), [
      (isUndefined(href) || disabled)
        ? h('span', children)
        : h('a', { attrs: { href: href, target: target } }, children)
    ])
  }
}

var breadcrumb = {
  name: 'VkBreadcrumb',
  functional: true,
  props: ElementBreadcrumb.props,
  render: ElementBreadcrumb.render
}

var breadcrumb_Item = {
  name: 'VkBreadcrumbItem',
  functional: true,
  props: ElementBreadcrumbItem.props,
  render: ElementBreadcrumbItem.render
}

var props = {
  active: {
    type: Boolean,
    default: false
  },
  size: {
    type: String,
    validator: function (val) { return !val || /^(small|large)$/.test(val); }
  },
  type: {
    type: String,
    validator: function (val) { return !val || /^(primary|secondary|danger|text|link)$/.test(val); }
  }
};
var def = function (ref) {
  var obj;
  var type = ref.type;
  var active = ref.active;
  var size = ref.size;
  return ({
  class: ['uk-button', ("uk-button-" + (type || 'default')), ( obj = {
    'uk-active': active
  }, obj[("uk-button-" + size)] = size, obj)]
});
};

var ElementButton = {
  functional: true,
  props: assign({}, props, {
    htmlType: {
      type: String,
      default: 'button'
    }
  }),
  render: function render (h, ref) {
    var props$$1 = ref.props;
    var data = ref.data;
    var children = ref.children;
    var htmlType = props$$1.htmlType;
    return h('button', mergeData(data, def(props$$1), {
      attrs: {
        type: htmlType
      }
    }), children)
  }
}

var ElementButtonLink = {
  functional: true,
  props: props,
  render: function render (h, ref) {
    var props$$1 = ref.props;
    var data = ref.data;
    var children = ref.children;
    return h('a', mergeData(data, def(props$$1)), children)
  }
}

var ElementButtonGroup = {
  functional: true,
  render: function render (h, ref) {
    var data = ref.data;
    var children = ref.children;
    return h('div', mergeData(data, {
      class: 'uk-button-group'
    }), children)
  }
}

var button = {
  name: 'VkButton',
  functional: true,
  props: ElementButton.props,
  render: ElementButton.render
}

var buttonLink = {
  name: 'VkButtonLink',
  functional: true,
  props: ElementButtonLink.props,
  render: ElementButtonLink.render
}

var buttonGroup = {
  name: 'VkButtonGroup',
  functional: true,
  props: ElementButtonGroup.props,
  render: ElementButtonGroup.render
}

var ElementCard = {
  functional: true,
  props: {
    type: {
      type: String,
      default: 'default',
      validator: function (val) { return /^(default|primary|secondary|blank)$/.test(val); }
    },
    padding: {
      type: String,
      validator: function (val) { return !val || /^(small|large)$/.test(val); }
    },
    hover: {
      type: Boolean,
      default: false
    }
  },
  render: function render (h, ref) {
    var obj;
    var props = ref.props;
    var data = ref.data;
    var slots = ref.slots;
    var type = props.type;
    var padding = props.padding;
    var hover = props.hover;
    var _slots = slots();
    var body = _slots.body;
    if (!body || !body.length) {
      _slots.body = _slots.default;
      delete _slots.default;
    }
    return h('div', mergeData(data, {
      class: ['uk-card', ( obj = {
        'uk-card-hover': hover
      }, obj[("uk-card-" + type)] = type, obj[("uk-card-" + padding)] = padding, obj)]
    }), [
      _slots.default && _slots.default,
      _slots['media-top'] && h('div', { class: 'uk-card-media-top' }, _slots['media-top']),
      _slots.badge && h('div', { class: 'uk-card-badge' }, _slots.badge),
      _slots.header && h('div', { class: 'uk-card-header' }, _slots.header),
      _slots['media'] && h('div', { class: 'uk-card-media' }, _slots['media']),
      _slots.body && h('div', { class: 'uk-card-body' }, _slots.body),
      _slots.footer && h('div', { class: 'uk-card-footer' }, _slots.footer),
      _slots['media-bottom'] && h('div', { class: 'uk-card-media-bottom' }, _slots['media-bottom'])
    ])
  }
}

var ElementCardTitle = {
  functional: true,
  props: {
    tag: {
      type: String,
      default: 'h3'
    }
  },
  render: function render (h, ref) {
    var props = ref.props;
    var data = ref.data;
    var children = ref.children;
    return h(props.tag, mergeData(data, {
      class: 'uk-card-title'
    }), children)
  }
}

var card = {
  name: 'VkCard',
  functional: true,
  props: ElementCard.props,
  render: ElementCard.render
}

var card_Title = {
  name: 'VkCardTitle',
  functional: true,
  props: ElementCardTitle.props,
  render: ElementCardTitle.render
}

var VkRoot = {
  inserted: function inserted (el, binding, vnode) {
    vnode.context.$nextTick(function () {
      vnode.context.$root.$el.appendChild(el);
    });
  }
}

function noop$1 () {}
var warn = noop$1;
var tip = noop$1;
{
  var hasConsole = typeof console !== 'undefined';
  var classifyRE = /(?:^|[-_])(\w)/g;
  var classify = function (str) { return str
    .replace(classifyRE, function (c) { return c.toUpperCase(); })
    .replace(/[-_]/g, ''); };
  warn = function (msg, vm) {
    if (hasConsole) {
      console.error("[Vuikit warn]: " + msg + (
        vm ? generateComponentTrace(vm) : ''
      ));
    }
  };
  tip = function (msg, vm) {
    if (hasConsole) {
      console.warn("[Vuikit tip]: " + msg + (
        vm ? generateComponentTrace(vm) : ''
      ));
    }
  };
  var formatComponentName = function (vm, includeFile) {
    if (vm.$root === vm) {
      return '<Root>'
    }
    var name = typeof vm === 'string'
      ? vm
      : typeof vm === 'function' && vm.options
        ? vm.options.name
        : vm._isVue
          ? vm.$options.name || vm.$options._componentTag
          : vm.name;
    var file = vm._isVue && vm.$options.__file;
    if (!name && file) {
      var match = file.match(/([^/\\]+)\.vue$/);
      name = match && match[1];
    }
    return (
      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
      (file && includeFile !== false ? (" at " + file) : '')
    )
  };
  var repeat = function (str, n) {
    var res = '';
    while (n) {
      if (n % 2 === 1) { res += str; }
      if (n > 1) { str += str; }
      n >>= 1;
    }
    return res
  };
  var generateComponentTrace = function (vm) {
    if (vm._isVue && vm.$parent) {
      var tree = [];
      var currentRecursiveSequence = 0;
      while (vm) {
        if (tree.length > 0) {
          var last = tree[tree.length - 1];
          if (last.constructor === vm.constructor) {
            currentRecursiveSequence++;
            vm = vm.$parent;
            continue
          } else if (currentRecursiveSequence > 0) {
            tree[tree.length - 1] = [last, currentRecursiveSequence];
            currentRecursiveSequence = 0;
          }
        }
        tree.push(vm);
        vm = vm.$parent;
      }
      return '\n\nfound in\n\n' + tree
        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
            : formatComponentName(vm))); })
        .join('\n')
    } else {
      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
    }
  };
}

var dirs = {
  width: ['x', 'left', 'right'],
  height: ['y', 'top', 'bottom']
};
function positionAt (element, target, elAttach, targetAttach, elOffset, targetOffset, flip, boundary) {
  elAttach = getPos(elAttach);
  targetAttach = getPos(targetAttach);
  var flipped = {element: elAttach, target: targetAttach};
  if (!element || !target) {
    return flipped
  }
  var dim = getDimensions(element);
  var targetDim = getDimensions(target);
  var position = targetDim;
  moveTo(position, elAttach, dim, -1);
  moveTo(position, targetAttach, targetDim, 1);
  elOffset = getOffsets(elOffset, dim.width, dim.height);
  targetOffset = getOffsets(targetOffset, targetDim.width, targetDim.height);
  elOffset['x'] += targetOffset['x'];
  elOffset['y'] += targetOffset['y'];
  position.left += elOffset['x'];
  position.top += elOffset['y'];
  boundary = getDimensions(boundary || window$1(element));
  if (flip) {
    each(dirs, function (ref, prop) {
      var dir = ref[0];
      var align = ref[1];
      var alignFlip = ref[2];
      if (!(flip === true || includes(flip, dir))) {
        return
      }
      var elemOffset = elAttach[dir] === align
        ? -dim[prop]
        : elAttach[dir] === alignFlip
          ? dim[prop]
          : 0;
      var targetOffset = targetAttach[dir] === align
        ? targetDim[prop]
        : targetAttach[dir] === alignFlip
          ? -targetDim[prop]
          : 0;
      if (position[align] < boundary[align] || position[align] + dim[prop] > boundary[alignFlip]) {
        var centerOffset = dim[prop] / 2;
        var centerTargetOffset = targetAttach[dir] === 'center' ? -targetDim[prop] / 2 : 0;
        elAttach[dir] === 'center' && (
          apply(centerOffset, centerTargetOffset) ||
                    apply(-centerOffset, -centerTargetOffset)
        ) || apply(elemOffset, targetOffset);
      }
      function apply (elemOffset, targetOffset) {
        var newVal = position[align] + elemOffset + targetOffset - elOffset[dir] * 2;
        if (newVal >= boundary[align] && newVal + dim[prop] <= boundary[alignFlip]) {
          position[align] = newVal;
          ['element', 'target'].forEach(function (el) {
            flipped[el][dir] = !elemOffset
              ? flipped[el][dir]
              : flipped[el][dir] === dirs[prop][1]
                ? dirs[prop][2]
                : dirs[prop][1];
          });
          return true
        }
      }
    });
  }
  offset(element, position);
  return flipped
}
function offset (element, coordinates) {
  element = toNode(element);
  if (coordinates) {
    var currentOffset = offset(element);
    var pos = css(element, 'position');
    ['left', 'top'].forEach(function (prop) {
      if (prop in coordinates) {
        var value = css(element, prop);
        element.style[prop] = ((coordinates[prop] - currentOffset[prop]) +
                toFloat(pos === 'absolute' && value === 'auto' ? position(element)[prop] : value)) + "px";
      }
    });
    return
  }
  return getDimensions(element)
}
function getDimensions (element) {
  element = toNode(element);
  var ref = window$1(element);
  var top = ref.pageYOffset;
  var left = ref.pageXOffset;
  if (isWindow(element)) {
    var height = element.innerHeight;
    var width = element.innerWidth;
    return {
      top: top,
      left: left,
      height: height,
      width: width,
      bottom: top + height,
      right: left + width
    }
  }
  var display = false;
  if (!isVisible(element)) {
    display = element.style.display;
    element.style.display = 'block';
  }
  var rect = element.getBoundingClientRect();
  if (display !== false) {
    element.style.display = display;
  }
  return {
    height: rect.height,
    width: rect.width,
    top: rect.top + top,
    left: rect.left + left,
    bottom: rect.bottom + top,
    right: rect.right + left
  }
}
function position (element) {
  element = toNode(element);
  var parent = offsetParent(element);
  var parentOffset = parent === docEl(element) ? {top: 0, left: 0} : offset(parent);
  var ref = ['top', 'left'].reduce(function (props, prop) {
    var propName$$1 = ucfirst(prop);
    props[prop] -= parentOffset[prop] +
            (toFloat(css(element, ("margin" + propName$$1))) || 0) +
            (toFloat(css(parent, ("border" + propName$$1 + "Width"))) || 0);
    return props
  }, offset(element));
  var top = ref.top;
  var left = ref.left;
  return {top: top, left: left}
}
function offsetParent (element) {
  var parent = toNode(element).offsetParent;
  while (parent && css(parent, 'position') === 'static') {
    parent = parent.offsetParent;
  }
  return parent || docEl(element)
}
var height = dimension('height');
var width = dimension('width');
function dimension (prop) {
  var propName$$1 = ucfirst(prop);
  return function (element, value) {
    element = toNode(element);
    if (isUndefined(value)) {
      if (isWindow(element)) {
        return element[("inner" + propName$$1)]
      }
      if (isDocument(element)) {
        var doc = element.documentElement;
        return Math.max(doc[("offset" + propName$$1)], doc[("scroll" + propName$$1)])
      }
      value = css(element, prop);
      value = value === 'auto' ? element[("offset" + propName$$1)] : toFloat(value) || 0;
      return getContentSize(prop, element, value)
    } else {
      css(element, prop, !value && value !== 0
        ? ''
        : getContentSize(prop, element, value) + 'px'
      );
    }
  }
}
function getContentSize (prop, element, value) {
  return css(element, 'boxSizing') === 'border-box' ? dirs[prop].slice(1).map(ucfirst).reduce(function (value, prop) { return value -
        toFloat(css(element, ("padding" + prop))) -
        toFloat(css(element, ("border" + prop + "Width"))); }
    , value) : value
}
function moveTo (position, attach, dim, factor) {
  each(dirs, function (ref, prop) {
    var dir = ref[0];
    var align = ref[1];
    var alignFlip = ref[2];
    if (attach[dir] === alignFlip) {
      position[align] += dim[prop] * factor;
    } else if (attach[dir] === 'center') {
      position[align] += dim[prop] * factor / 2;
    }
  });
}
function getPos (pos) {
  var x = /left|center|right/;
  var y = /top|center|bottom/;
  pos = (pos || '').split(' ');
  if (pos.length === 1) {
    pos = x.test(pos[0])
      ? pos.concat(['center'])
      : y.test(pos[0])
        ? ['center'].concat(pos)
        : ['center', 'center'];
  }
  return {
    x: x.test(pos[0]) ? pos[0] : 'center',
    y: y.test(pos[1]) ? pos[1] : 'center'
  }
}
function getOffsets (offsets, width, height) {
  var ref = (offsets || '').split(' ');
  var x = ref[0];
  var y = ref[1];
  return {
    x: x ? toFloat(x) * (endsWith(x, '%') ? width / 100 : 1) : 0,
    y: y ? toFloat(y) * (endsWith(y, '%') ? height / 100 : 1) : 0
  }
}
function flipPosition (pos) {
  switch (pos) {
    case 'left':
      return 'right'
    case 'right':
      return 'left'
    case 'top':
      return 'bottom'
    case 'bottom':
      return 'top'
    default:
      return pos
  }
}
function isInView (element, top, left) {
  if ( top === void 0 ) top = 0;
  if ( left === void 0 ) left = 0;
  element = toNode(element);
  var win = window$1(element);
  return intersectRect(element.getBoundingClientRect(), {
    top: top,
    left: left,
    bottom: top + height(win),
    right: left + width(win)
  })
}
function window$1 (element) {
  return isWindow(element) ? element : document$1(element).defaultView
}
function document$1 (element) {
  return toNode(element).ownerDocument
}
function docEl (element) {
  return document$1(element).documentElement
}

var BEFORE_POSITION = 'v-vk-position:before';
var AFTER_POSITION = 'v-vk-position:after';

var Directive = {
  inserted: function inserted (el, binding, vnode) {
    var ctx = getContext(el, binding, vnode);
    if (ctx) {
      position$1(ctx);
    }
  },
  componentUpdated: function componentUpdated (el, binding, vnode) {
    var ctx = getContext(el, binding, vnode);
    if (ctx) {
      position$1(ctx);
    }
  }
}
function position$1 (ctx) {
  var el = ctx.el;
  var props = ctx.props;
  var vnode = ctx.vnode;
  var target = props.target;
  var position$$1 = props.position;
  var offset$$1 = props.offset;
  var boundary = props.boundary;
  var flip = props.flip;
  var mainClass = props.mainClass;
  if ("development" !== 'production' && !position$$1.match(/^((top|bottom)-(left|center|right))|((left|right)-(top|center|bottom))$/)) {
    warn(("v-position -> '" + position$$1 + "' -> no valid position"), vnode);
  }
  if ("development" !== 'production' && (!target || !target.tagName)) {
    warn("v-position -> no valid target", vnode);
  }
  var ref = position$$1.split('-');
  var dir = ref[0];
  var align = ref[1];
  trigger(el, BEFORE_POSITION);
  var classesRx = new RegExp((mainClass + "-(top|bottom|left|right)(-[a-z]+)?"));
  el.className = el.className.replace(classesRx, '');
  css(el, { top: '', left: '' });
  var axis = getPositionAxis(position$$1);
  var elAttach = axis === 'x'
    ? ((flipPosition(dir)) + " " + align)
    : (align + " " + (flipPosition(dir)));
  var targetAttach = axis === 'x'
    ? (dir + " " + align)
    : (align + " " + dir);
  var elOffset = axis === 'x'
    ? ("" + (dir === 'left' ? -1 * offset$$1 : offset$$1))
    : (" " + (dir === 'top' ? -1 * offset$$1 : offset$$1));
  var targetOffset = null;
  var ref$1 = positionAt(
    el,
    target,
    elAttach,
    targetAttach,
    elOffset,
    targetOffset,
    flip,
    boundary
  ).target;
  var x = ref$1.x;
  var y = ref$1.y;
  dir = axis === 'x' ? x : y;
  align = axis === 'x' ? y : x;
  toggleClass(el, (mainClass + "-" + dir + "-" + align), offset$$1 === false);
  trigger(el, AFTER_POSITION);
}
function getOptions (ctx) {
  var vnode = ctx.vnode;
  var ref = ctx.binding;
  var value = ref.value;
  if ("development" !== 'production' && (isUndefined(value) || !isObject(value))) {
    warn('v-position -> configuration is missing or is not an Object', vnode.context);
  }
  var options = assign({
    target: null,
    position: 'top-center',
    boundary: window,
    flip: true,
    offset: false,
    mainClass: ''
  }, value);
  return options
}
function getContext (el, binding, vnode) {
  var ctx = { el: el, binding: binding, vnode: vnode };
  ctx.props = getOptions(ctx);
  if (!ctx.props) {
    binding.def.unbind(el, binding);
    return
  }
  return ctx
}
function getPositionAxis (position$$1) {
  var ref = position$$1.split('-');
  var dir = ref[0];
  return dir === 'top' || dir === 'bottom'
    ? 'y'
    : 'x'
}

var EventsMixin = {
  methods: {
    on: function on$1 () {
      var args = [], len = arguments.length;
      while ( len-- ) args[ len ] = arguments[ len ];
      this._vk_events_off.push(on.apply(void 0, args));
    },
    off: function off$1 () {
      var args = [], len = arguments.length;
      while ( len-- ) args[ len ] = arguments[ len ];
      off.apply(void 0, args);
    }
  },
  created: function created () {
    this._vk_events_off = [];
  },
  beforeDestroy: function beforeDestroy () {
    this._vk_events_off.forEach(function (off$$1) { return off$$1(); });
  }
}

function $ (selector, context) {
  return !isString(selector)
    ? toNode(selector)
    : isHtml(selector)
      ? toNode(fragment(selector))
      : find(selector, context)
}
function $$ (selector, context) {
  return !isString(selector)
    ? toNodes(selector)
    : isHtml(selector)
      ? toNodes(fragment(selector))
      : findAll(selector, context)
}
function isHtml (str) {
  return str[0] === '<' || str.match(/^\s*</)
}

function MouseTracker () {}
MouseTracker.prototype = {
  positions: [],
  position: null,
  init: function init () {
    var this$1 = this;
    this.positions = [];
    this.position = null;
    var ticking = false;
    this.unbind = on(document, 'mousemove', function (e) {
      if (ticking) {
        return
      }
      setTimeout(function () {
        var time = Date.now();
        var ref = this$1.positions;
        var length = ref.length;
        if (length && (time - this$1.positions[length - 1].time > 100)) {
          this$1.positions.splice(0, length);
        }
        this$1.positions.push({time: time, x: e.pageX, y: e.pageY});
        if (this$1.positions.length > 5) {
          this$1.positions.shift();
        }
        ticking = false;
      }, 5);
      ticking = true;
    });
  },
  cancel: function cancel () {
    if (this.unbind) {
      this.unbind();
    }
  },
  movesTo: function movesTo (target) {
    if (this.positions.length < 2) {
      return false
    }
    var p = offset(target);
    var position$$1 = this.positions[this.positions.length - 1];
    var ref = this.positions;
    var prevPos = ref[0];
    if (p.left <= position$$1.x && position$$1.x <= p.right && p.top <= position$$1.y && position$$1.y <= p.bottom) {
      return false
    }
    var points = [
      [{x: p.left, y: p.top}, {x: p.right, y: p.bottom}],
      [{x: p.right, y: p.top}, {x: p.left, y: p.bottom}]
    ];
    if (p.right <= position$$1.x) {
    } else if (p.left >= position$$1.x) {
      points[0].reverse();
      points[1].reverse();
    } else if (p.bottom <= position$$1.y) {
      points[0].reverse();
    } else if (p.top >= position$$1.y) {
      points[1].reverse();
    }
    return !!points.reduce(function (result, point) {
      return result + (slope(prevPos, point[0]) < slope(position$$1, point[0]) && slope(prevPos, point[1]) > slope(position$$1, point[1]))
    }, 0)
  }
};
function slope (a, b) {
  return (b.y - a.y) / (b.x - a.x)
}

var doc$1 = typeof document !== 'undefined' && document;
var win$1 = typeof window !== 'undefined' && window;
var nav = typeof navigator !== 'undefined' && navigator;
var isRtl = doc$1 && attr(document.documentElement, 'dir') === 'rtl';
var hasTouchEvents = win$1 && 'ontouchstart' in window;
var hasPointerEvents = win$1 && window.PointerEvent;
var hasTouch = hasTouchEvents ||
  (win$1 && window.DocumentTouch) && (doc$1 && document instanceof window.DocumentTouch) ||
  nav && navigator.maxTouchPoints;
var pointerDown = !hasTouch ? 'mousedown' : ("mousedown " + (hasTouchEvents ? 'touchstart' : 'pointerdown'));
var pointerMove = !hasTouch ? 'mousemove' : ("mousemove " + (hasTouchEvents ? 'touchmove' : 'pointermove'));
var pointerUp = !hasTouch ? 'mouseup' : ("mouseup " + (hasTouchEvents ? 'touchend' : 'pointerup'));
var pointerEnter = hasTouch && hasPointerEvents ? 'pointerenter' : 'mouseenter';
var pointerLeave = hasTouch && hasPointerEvents ? 'pointerleave' : 'mouseleave';

var props$1 = {
  target: {},
  boundary: {},
  boundaryAlign: {
    type: Boolean,
    default: false
  },
  flip: {
    type: [String, Boolean],
    default: true
  },
  position: {
    type: String,
    default: ("bottom-" + (isRtl ? 'right' : 'left')),
    validator: function (pos) { return /^(top|bottom)-(left|right|center|justify)$/.test(pos) ||
      /^(left|right)-(top|bottom|center|justify)$/.test(pos); }
  },
  offset: {
    type: [Boolean, Number],
    default: false
  },
  animation: {
    type: String,
    default: 'fade'
  },
  duration: {
    type: Number,
    default: 200
  },
  mode: {
    type: String,
    default: 'click hover'
  },
  delayShow: {
    type: Number,
    default: 0
  },
  delayHide: {
    type: Number,
    default: 800
  },
  mainClass: {
    type: String,
    default: 'uk-drop'
  }
}

var ElementDrop = {
  functional: true,
  props: {
    show: {
      type: Boolean,
      default: false
    }
  },
  render: function render (h, ref) {
    var children = ref.children;
    var data = ref.data;
    var props = ref.props;
    var show = props.show;
    return h('div', mergeData(data, {
      class: {
        'uk-open': show
      },
      style: {
        display: show ? 'block' : null
      }
    }), children)
  }
}

var win$2 = typeof window !== 'undefined' && window;
var Promise = win$2 && 'Promise' in window ? window.Promise : PromiseFn;
var RESOLVED = 0;
var REJECTED = 1;
var PENDING = 2;
var async = win$2 && 'setImmediate' in window ? setImmediate : setTimeout;
function PromiseFn (executor) {
  this.state = PENDING;
  this.value = undefined;
  this.deferred = [];
  var promise = this;
  try {
    executor(
      function (x) {
        promise.resolve(x);
      },
      function (r) {
        promise.reject(r);
      }
    );
  } catch (e) {
    promise.reject(e);
  }
}
PromiseFn.reject = function (r) {
  return new PromiseFn(function (resolve, reject) {
    reject(r);
  })
};
PromiseFn.resolve = function (x) {
  return new PromiseFn(function (resolve, reject) {
    resolve(x);
  })
};
PromiseFn.all = function all (iterable) {
  return new PromiseFn(function (resolve, reject) {
    var result = [];
    var count = 0;
    if (iterable.length === 0) {
      resolve(result);
    }
    function resolver (i) {
      return function (x) {
        result[i] = x;
        count += 1;
        if (count === iterable.length) {
          resolve(result);
        }
      }
    }
    for (var i = 0; i < iterable.length; i += 1) {
      PromiseFn.resolve(iterable[i]).then(resolver(i), reject);
    }
  })
};
PromiseFn.race = function race (iterable) {
  return new PromiseFn(function (resolve, reject) {
    for (var i = 0; i < iterable.length; i += 1) {
      PromiseFn.resolve(iterable[i]).then(resolve, reject);
    }
  })
};
var p = PromiseFn.prototype;
p.resolve = function resolve (x) {
  var promise = this;
  if (promise.state === PENDING) {
    if (x === promise) {
      throw new TypeError('Promise settled with itself.')
    }
    var called = false;
    try {
      var then = x && x.then;
      if (x !== null && isObject(x) && isFunction(then)) {
        then.call(
          x,
          function (x) {
            if (!called) {
              promise.resolve(x);
            }
            called = true;
          },
          function (r) {
            if (!called) {
              promise.reject(r);
            }
            called = true;
          }
        );
        return
      }
    } catch (e) {
      if (!called) {
        promise.reject(e);
      }
      return
    }
    promise.state = RESOLVED;
    promise.value = x;
    promise.notify();
  }
};
p.reject = function reject (reason) {
  var promise = this;
  if (promise.state === PENDING) {
    if (reason === promise) {
      throw new TypeError('Promise settled with itself.')
    }
    promise.state = REJECTED;
    promise.value = reason;
    promise.notify();
  }
};
p.notify = function notify () {
  var this$1 = this;
  async(function () {
    if (this$1.state !== PENDING) {
      while (this$1.deferred.length) {
        var ref = this$1.deferred.shift();
        var onResolved = ref[0];
        var onRejected = ref[1];
        var resolve = ref[2];
        var reject = ref[3];
        try {
          if (this$1.state === RESOLVED) {
            if (isFunction(onResolved)) {
              resolve(onResolved.call(undefined, this$1.value));
            } else {
              resolve(this$1.value);
            }
          } else if (this$1.state === REJECTED) {
            if (isFunction(onRejected)) {
              resolve(onRejected.call(undefined, this$1.value));
            } else {
              reject(this$1.value);
            }
          }
        } catch (e) {
          reject(e);
        }
      }
    }
  });
};
p.then = function then (onResolved, onRejected) {
  var this$1 = this;
  return new PromiseFn(function (resolve, reject) {
    this$1.deferred.push([onResolved, onRejected, resolve, reject]);
    this$1.notify();
  })
};
p.catch = function (onRejected) {
  return this.then(undefined, onRejected)
};

function transition (element, props, duration, timing) {
  if ( duration === void 0 ) duration = 400;
  if ( timing === void 0 ) timing = 'linear';
  return Promise.all(toNodes(element).map(function (element) { return new Promise(function (resolve, reject) {
      for (var name in props) {
        var value = css(element, name);
        if (value === '') {
          css(element, name, value);
        }
      }
      var timer = setTimeout(function () { return trigger(element, 'transitionend'); }, duration);
      once(element, 'transitionend transitioncanceled', function (ref) {
        var type = ref.type;
        clearTimeout(timer);
        removeClass(element, 'uk-transition');
        css(element, {
          'transition-property': '',
          'transition-duration': '',
          'transition-timing-function': ''
        });
        type === 'transitioncanceled' ? reject() : resolve();
      }, false, function (ref) {
        var target = ref.target;
        return element === target;
      });
      addClass(element, 'uk-transition');
      css(element, assign({
        'transition-property': Object.keys(props).map(propName).join(','),
        'transition-duration': (duration + "ms"),
        'transition-timing-function': timing
      }, props