uikit
Version:
UIkit is a lightweight and modular front-end framework for developing fast and powerful web interfaces.
1,719 lines (1,295 loc) • 341 kB
JavaScript
/*! UIkit 3.2.1 | http://www.getuikit.com | (c) 2014 - 2019 YOOtheme | MIT License */
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define('uikit', factory) :
(global = global || self, global.UIkit = factory());
}(this, function () { 'use strict';
var objPrototype = Object.prototype;
var hasOwnProperty = objPrototype.hasOwnProperty;
function hasOwn(obj, key) {
return hasOwnProperty.call(obj, key);
}
var hyphenateCache = {};
var hyphenateRe = /([a-z\d])([A-Z])/g;
function hyphenate(str) {
if (!(str in hyphenateCache)) {
hyphenateCache[str] = str
.replace(hyphenateRe, '$1-$2')
.toLowerCase();
}
return hyphenateCache[str];
}
var camelizeRe = /-(\w)/g;
function camelize(str) {
return str.replace(camelizeRe, toUpper);
}
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 arrPrototype = Array.prototype;
var includesFn = function (search, i) { return ~this.indexOf(search, i); };
var includesStr = strPrototype.includes || includesFn;
var includesArray = arrPrototype.includes || includesFn;
function includes(obj, search) {
return obj && (isString(obj) ? includesStr : includesArray).call(obj, search);
}
var findIndexFn = arrPrototype.findIndex || function (predicate) {
var arguments$1 = arguments;
for (var i = 0; i < this.length; i++) {
if (predicate.call(arguments$1[1], this[i], i, this)) {
return i;
}
}
return -1;
};
function findIndex(array, predicate) {
return findIndexFn.call(array, predicate);
}
var isArray = Array.isArray;
function isFunction(obj) {
return typeof obj === 'function';
}
function isObject(obj) {
return obj !== null && typeof obj === 'object';
}
var toString = objPrototype.toString;
function isPlainObject(obj) {
return toString.call(obj) === '[object Object]';
}
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(obj) {
return obj instanceof Node || isObject(obj) && obj.nodeType >= 1;
}
function isNodeCollection(obj) {
return toString.call(obj).match(/^\[object (NodeList|HTMLCollection)\]$/);
}
function isBoolean(value) {
return typeof value === 'boolean';
}
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 isEmpty(obj) {
return !(isArray(obj)
? obj.length
: isObject(obj)
? Object.keys(obj).length
: false
);
}
function isUndefined(value) {
return value === void 0;
}
function toBoolean(value) {
return isBoolean(value)
? value
: value === 'true' || value === '1' || value === ''
? true
: value === 'false' || value === '0'
? false
: value;
}
function toNumber(value) {
var number = Number(value);
return !isNaN(number) ? number : false;
}
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;
}
function toNodes(element) {
return isNode(element)
? [element]
: isNodeCollection(element)
? arrPrototype.slice.call(element)
: isArray(element)
? element.map(toNode).filter(Boolean)
: isJQuery(element)
? element.toArray()
: [];
}
function toList(value) {
return isArray(value)
? value
: isString(value)
? value.split(/,(?![^(]*\))/).map(function (value) { return isNumeric(value)
? toNumber(value)
: toBoolean(value.trim()); })
: [value];
}
function toMs(time) {
return !time
? 0
: endsWith(time, 'ms')
? toFloat(time)
: toFloat(time) * 1000;
}
function isEqual(value, other) {
return value === other
|| isObject(value)
&& isObject(other)
&& Object.keys(value).length === Object.keys(other).length
&& each(value, function (val, key) { return val === other[key]; });
}
function swap(value, a, b) {
return value.replace(new RegExp((a + "|" + b), 'mg'), function (match) {
return match === a ? b : a;
});
}
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 last(array) {
return array[array.length - 1];
}
function each(obj, cb) {
for (var key in obj) {
if (false === cb(obj[key], key)) {
return false;
}
}
return true;
}
function sortBy(array, prop) {
return array.sort(function (ref, ref$1) {
var propA = ref[prop]; if ( propA === void 0 ) propA = 0;
var propB = ref$1[prop]; if ( propB === void 0 ) propB = 0;
return propA > propB
? 1
: propB > propA
? -1
: 0;
}
);
}
function uniqueBy(array, prop) {
var seen = new Set();
return array.filter(function (ref) {
var check = ref[prop];
return seen.has(check)
? false
: seen.add(check) || true;
} // IE 11 does not return the Set object
);
}
function clamp(number, min, max) {
if ( min === void 0 ) min = 0;
if ( max === void 0 ) max = 1;
return Math.min(Math.max(toNumber(number) || 0, min), max);
}
function noop() {}
function intersectRect(r1, r2) {
return r1.left < r2.right &&
r1.right > r2.left &&
r1.top < r2.bottom &&
r1.bottom > r2.top;
}
function pointInRect(point, rect) {
return point.x <= rect.right &&
point.x >= rect.left &&
point.y <= rect.bottom &&
point.y >= rect.top;
}
var Dimensions = {
ratio: function(dimensions, prop, value) {
var obj;
var aProp = prop === 'width' ? 'height' : 'width';
return ( obj = {}, obj[aProp] = dimensions[prop] ? Math.round(value * dimensions[aProp] / dimensions[prop]) : dimensions[aProp], obj[prop] = value, obj );
},
contain: function(dimensions, maxDimensions) {
var this$1 = this;
dimensions = assign({}, dimensions);
each(dimensions, function (_, prop) { return dimensions = dimensions[prop] > maxDimensions[prop]
? this$1.ratio(dimensions, prop, maxDimensions[prop])
: dimensions; }
);
return dimensions;
},
cover: function(dimensions, maxDimensions) {
var this$1 = this;
dimensions = this.contain(dimensions, maxDimensions);
each(dimensions, function (_, prop) { return dimensions = dimensions[prop] < maxDimensions[prop]
? this$1.ratio(dimensions, prop, maxDimensions[prop])
: dimensions; }
);
return dimensions;
}
};
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.hasAttribute(name) && element.removeAttribute(name); }
); }
);
}
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]);
}
}
}
/* global DocumentTouch */
var isIE = /msie|trident/i.test(window.navigator.userAgent);
var isRtl = attr(document.documentElement, 'dir') === 'rtl';
var hasTouchEvents = 'ontouchstart' in window;
var hasPointerEvents = window.PointerEvent;
var hasTouch = hasTouchEvents
|| window.DocumentTouch && document instanceof DocumentTouch
|| navigator.maxTouchPoints; // IE >=11
var pointerDown = hasPointerEvents ? 'pointerdown' : hasTouchEvents ? 'touchstart' : 'mousedown';
var pointerMove = hasPointerEvents ? 'pointermove' : hasTouchEvents ? 'touchmove' : 'mousemove';
var pointerUp = hasPointerEvents ? 'pointerup' : hasTouchEvents ? 'touchend' : 'mouseup';
var pointerEnter = hasPointerEvents ? 'pointerenter' : hasTouchEvents ? '' : 'mouseenter';
var pointerLeave = hasPointerEvents ? 'pointerleave' : hasTouchEvents ? '' : 'mouseleave';
var pointerCancel = hasPointerEvents ? 'pointercancel' : 'touchcancel';
function query(selector, context) {
return toNode(selector) || find(selector, getContext(selector, context));
}
function queryAll(selector, context) {
var nodes = toNodes(selector);
return nodes.length && nodes || findAll(selector, getContext(selector, context));
}
function getContext(selector, context) {
if ( context === void 0 ) context = document;
return isContextSelector(selector) || isDocument(context)
? context
: context.ownerDocument;
}
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 = splitSelector(selector).map(function (selector, i) {
var ctx = context;
if (selector[0] === '!') {
var selectors = selector.substr(1).trim().split(' ');
ctx = closest(context.parentNode, selectors[0]);
selector = selectors.slice(1).join(' ').trim();
}
if (selector[0] === '-') {
var selectors$1 = selector.substr(1).trim().split(' ');
var prev = (ctx || context).previousElementSibling;
ctx = matches(prev, selector.substr(1)) ? prev : null;
selector = selectors$1.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);
}
var selectorRe = /.*?[^\\](?:,|$)/g;
function splitSelector(selector) {
return selector.match(selectorRe).map(function (selector) { return selector.replace(/,$/, '').trim(); });
}
var elProto = Element.prototype;
var matchesFn = elProto.matches || elProto.webkitMatchesSelector || elProto.msMatchesSelector;
function matches(element, selector) {
return toNodes(element).some(function (element) { return matchesFn.call(element, selector); });
}
var closestFn = elProto.closest || function (selector) {
var ancestor = this;
do {
if (matches(ancestor, selector)) {
return ancestor;
}
ancestor = ancestor.parentNode;
} while (ancestor && ancestor.nodeType === 1);
};
function closest(element, selector) {
if (startsWith(selector, '>')) {
selector = selector.slice(1);
}
return isNode(element)
? closestFn.call(element, selector)
: toNodes(element).map(function (element) { return closest(element, selector); }).filter(Boolean);
}
function parents(element, selector) {
var elements = [];
element = toNode(element);
while ((element = element.parentNode) && element.nodeType === 1) {
if (matches(element, selector)) {
elements.push(element);
}
}
return elements;
}
var escapeFn = window.CSS && CSS.escape || function (css) { return css.replace(/([^\x7f-\uFFFF\w-])/g, function (match) { return ("\\" + match); }); };
function escape(css) {
return isString(css) ? escapeFn.call(null, css) : '';
}
var voidElements = {
area: true,
base: true,
br: true,
col: true,
embed: true,
hr: true,
img: true,
input: true,
keygen: true,
link: true,
menuitem: true,
meta: true,
param: true,
source: true,
track: true,
wbr: true
};
function isVoidElement(element) {
return toNodes(element).some(function (element) { return voidElements[element.tagName.toLowerCase()]; });
}
function isVisible(element) {
return toNodes(element).some(function (element) { return element.offsetWidth || element.offsetHeight || element.getClientRects().length; });
}
var selInput = 'input,select,textarea,button';
function isInput(element) {
return toNodes(element).some(function (element) { return matches(element, selInput); });
}
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)) // IE 11 document does not implement contains
: matches(element, selector) || closest(element, selector);
}
function on() {
var args = [], len = arguments.length;
while ( len-- ) args[ len ] = arguments[ len ];
var ref = getArgs(args);
var targets = ref[0];
var type = ref[1];
var selector = ref[2];
var listener = ref[3];
var useCapture = ref[4];
targets = toEventTargets(targets);
if (listener.length > 1) {
listener = detail(listener);
}
if (selector) {
listener = delegate(targets, selector, listener);
}
if (useCapture && useCapture.self) {
listener = selfFilter(listener);
}
useCapture = useCaptureFilter(useCapture);
type.split(' ').forEach(function (type) { return targets.forEach(function (target) { return target.addEventListener(type, listener, useCapture); }
); }
);
return function () { return off(targets, type, listener, useCapture); };
}
function off(targets, type, listener, useCapture) {
if ( useCapture === void 0 ) useCapture = false;
useCapture = useCaptureFilter(useCapture);
targets = toEventTargets(targets);
type.split(' ').forEach(function (type) { return targets.forEach(function (target) { 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(targets, event, detail) {
return toEventTargets(targets).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'); // IE 11
event.initCustomEvent(e, bubbles, cancelable, detail);
e = event;
}
return e;
}
function getArgs(args) {
if (isFunction(args[2])) {
args.splice(2, 0, false);
}
return args;
}
function delegate(delegates, selector, listener) {
var this$1 = this;
return function (e) {
delegates.forEach(function (delegate) {
var current = selector[0] === '>'
? findAll(selector, delegate).reverse().filter(function (element) { return within(e.target, element); })[0]
: closest(e.target, selector);
if (current) {
e.delegate = delegate;
e.current = current;
listener.call(this$1, e);
}
});
};
}
function detail(listener) {
return function (e) { return isArray(e.detail) ? listener.apply(void 0, [e].concat(e.detail)) : listener(e); };
}
function selfFilter(listener) {
return function (e) {
if (e.target === e.currentTarget || e.target === e.current) {
return listener.call(null, e);
}
};
}
function useCaptureFilter(options) {
return options && isIE && !isBoolean(options)
? !!options.capture
: options;
}
function isEventTarget(target) {
return target && 'addEventListener' in target;
}
function toEventTarget(target) {
return isEventTarget(target) ? target : toNode(target);
}
function toEventTargets(target) {
return isArray(target)
? target.map(toEventTarget).filter(Boolean)
: isString(target)
? findAll(target)
: isEventTarget(target)
? [target]
: toNodes(target);
}
function isTouch(e) {
return e.pointerType === 'touch' || !!e.touches;
}
function getEventPos(e, prop) {
if ( prop === void 0 ) prop = 'client';
var touches = e.touches;
var changedTouches = e.changedTouches;
var ref = touches && touches[0] || changedTouches && changedTouches[0] || e;
var x = ref[(prop + "X")];
var y = ref[(prop + "Y")];
return {x: x, y: y};
}
/* global setImmediate */
var Promise = 'Promise' in window ? window.Promise : PromiseFn;
var Deferred = function() {
var this$1 = this;
this.promise = new Promise(function (resolve, reject) {
this$1.reject = reject;
this$1.resolve = resolve;
});
};
/**
* Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)
*/
var RESOLVED = 0;
var REJECTED = 1;
var PENDING = 2;
var async = '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 ajax(url, options) {
return new Promise(function (resolve, reject) {
var env = assign({
data: null,
method: 'GET',
headers: {},
xhr: new XMLHttpRequest(),
beforeSend: noop,
responseType: ''
}, options);
env.beforeSend(env);
var xhr = env.xhr;
for (var prop in env) {
if (prop in xhr) {
try {
xhr[prop] = env[prop];
} catch (e) {}
}
}
xhr.open(env.method.toUpperCase(), url);
for (var header in env.headers) {
xhr.setRequestHeader(header, env.headers[header]);
}
on(xhr, 'load', function () {
if (xhr.status === 0 || xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) {
resolve(xhr);
} else {
reject(assign(Error(xhr.statusText), {
xhr: xhr,
status: xhr.status
}));
}
});
on(xhr, 'error', function () { return reject(assign(Error('Network Error'), {xhr: xhr})); });
on(xhr, 'timeout', function () { return reject(assign(Error('Network Timeout'), {xhr: xhr})); });
xhr.send(env.data);
});
}
function getImage(src, srcset, sizes) {
return new Promise(function (resolve, reject) {
var img = new Image();
img.onerror = reject;
img.onload = function () { return resolve(img); };
sizes && (img.sizes = sizes);
srcset && (img.srcset = srcset);
img.src = src;
});
}
function ready(fn) {
if (document.readyState !== 'loading') {
fn();
return;
}
var unbind = on(document, 'DOMContentLoaded', function () {
unbind();
fn();
});
}
function index(element, ref) {
return ref
? toNodes(element).indexOf(toNode(ref))
: toNodes((element = toNode(element)) && element.parentNode.children).indexOf(element);
}
function getIndex(i, elements, current, finite) {
if ( current === void 0 ) current = 0;
if ( finite === void 0 ) finite = false;
elements = toNodes(elements);
var length = elements.length;
i = isNumeric(i)
? toNumber(i)
: i === 'next'
? current + 1
: i === 'previous'
? current - 1
: index(elements, i);
if (finite) {
return clamp(i, 0, length - 1);
}
i %= length;
return i < 0 ? i + length : i;
}
function empty(element) {
element = $(element);
element.innerHTML = '';
return element;
}
function html(parent, html) {
parent = $(parent);
return isUndefined(html)
? parent.innerHTML
: append(parent.hasChildNodes() ? empty(parent) : parent, html);
}
function prepend(parent, element) {
parent = $(parent);
if (!parent.hasChildNodes()) {
return append(parent, element);
} else {
return insertNodes(element, function (element) { return parent.insertBefore(element, parent.firstChild); });
}
}
function append(parent, element) {
parent = $(parent);
return insertNodes(element, function (element) { return parent.appendChild(element); });
}
function before(ref, element) {
ref = $(ref);
return insertNodes(element, function (element) { return ref.parentNode.insertBefore(element, ref); });
}
function after(ref, element) {
ref = $(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); });
}
function wrapAll(element, structure) {
structure = toNode(before(element, structure));
while (structure.firstChild) {
structure = structure.firstChild;
}
append(structure, element);
return structure;
}
function wrapInner(element, structure) {
return toNodes(toNodes(element).map(function (element) { return element.hasChildNodes ? wrapAll(toNodes(element.childNodes), structure) : append(element, structure); }
));
}
function unwrap(element) {
toNodes(element)
.map(function (element) { return element.parentNode; })
.filter(function (value, index, self) { return self.indexOf(value) === index; })
.forEach(function (parent) {
before(parent, parent.childNodes);
remove(parent);
});
}
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 apply(node, fn) {
if (!node || node.nodeType !== 1) {
return;
}
fn(node);
node = node.firstElementChild;
while (node) {
apply(node, fn);
node = node.nextElementSibling;
}
}
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 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) {
attr(element, 'class', function (value) { return (value || '').replace(new RegExp(("\\b" + cls + "\\b"), '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 cls && toNodes(element).some(function (element) { return element.classList.contains(cls.split(' ')[0]); });
}
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(last(args)) ? args.pop() : []; // in iOS 9.3 force === undefined evaluates to false
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); }
, []);
}
// IE 11
var supports = {
get Multiple() {
return this.get('_multiple');
},
get Force() {
return this.get('_force');
},
get: function(key) {
if (!hasOwn(this, key)) {
var ref = document.createElement('_');
var classList = ref.classList;
classList.add('a', 'b');
classList.toggle('c', false);
this._multiple = classList.contains('b');
this._force = !classList.contains('c');
}
return this[key];
}
};
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,
'stroke-dasharray': true,
'stroke-dashoffset': 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 && !isNumber(value)) {
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) {
var docEl = document.documentElement;
if (!isIE) {
return getStyles(docEl).getPropertyValue(("--uk-" + name));
}
if (!(name in vars)) {
/* usage in css: .uk-name:before { content:"xyz" } */
var element = append(docEl, document.createElement('div'));
addClass(element, ("uk-" + name));
vars[name] = getStyle(element, 'content', ':before').replace(/^["'](.*)["']$/, '$1');
remove(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) {
name = hyphenate(name);
var ref = document.documentElement;
var style = ref.style;
if (name in style) {
return name;
}
var i = cssPrefixes.length, prefixedName;
while (i--) {
prefixedName = "-" + (cssPrefixes[i]) + "-" + name;
if (prefixedName in style) {
return prefixedName;
}
}
}
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();
}, {self: true});
addClass(element, 'uk-transition');
css(element, assign({
'transition-property': Object.keys(props).map(propName).join(','),
'transition-duration': (duration + "ms"),
'transition-timing-function': timing
}, props));
}); }
));
}
var Transition = {
start: transition,
stop: function(element) {
trigger(element, 'transitionend');
return Promise.resolve();
},
cancel: function(element) {
trigger(element, 'transitioncanceled');
},
inProgress: function(element) {
return hasClass(element, 'uk-transition');
}
};
var animationPrefix = 'uk-animation-';
var clsCancelAnimation = 'uk-cancel-animation';
function animate(element, animation, duration, origin, out) {
var arguments$1 = arguments;
if ( duration === void 0 ) duration = 200;
return Promise.all(toNodes(element).map(function (element) { return new Promise(function (resolve, reject) {
if (hasClass(element, clsCancelAnimation)) {
requestAnimationFrame(function () { return Promise.resolve().then(function () { return animate.apply(void 0, arguments$1).then(resolve, reject); }
); }
);
return;
}
var cls = animation + " " + animationPrefix + (out ? 'leave' : 'enter');
if (startsWith(animation, animationPrefix)) {
if (origin) {
cls += " uk-transform-origin-" + origin;
}
if (out) {
cls += " " + animationPrefix + "reverse";
}
}
reset();
once(element, 'animationend animationcancel', function (ref) {
var type = ref.type;
var hasReset = false;
if (type === 'animationcancel') {
reject();
reset();
} else {
resolve();
Promise.resolve().then(function () {
hasReset = true;
reset();
});
}
requestAnimationFrame(function () {
if (!hasReset) {
addClass(element, clsCancelAnimation);
requestAnimationFrame(function () { return removeClass(element, clsCancelAnimation); });
}
});
}, {self: true});
css(element, 'animationDuration', (duration + "ms"));
addClass(element, cls);
function reset() {
css(element, 'animationDuration', '');
removeClasses(element, (animationPrefix + "\\S*"));
}
}); }
));
}
var inProgress = new RegExp((animationPrefix + "(enter|leave)"));
var Animation = {
in: function(element, animation, duration, origin) {
return animate(element, animation, duration, origin, false);
},
out: function(element, animation, duration, origin) {
return animate(element, animation, duration, origin, true);
},
inProgress: function(element) {
return inProgress.test(attr(element, 'class'));
},
cancel: function(element) {
trigger(element, 'animationcancel');
}
};
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'];
if (flip) {
var boundaries = [getDimensions(getWindow(element))];
if (boundary) {
boundaries.unshift(getDimensions(boundary));
}
each(dirs, function (ref, prop) {
var dir = ref[0];
var align = ref[1];
var alignFlip = ref[2];
if (!(flip === true || includes(flip, dir))) {
return;
}
boundaries.some(function (boundary) {
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;
return 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);
css(element, prop, coordinates[prop] - currentOffset[prop]
+ toFloat(pos === 'absolute' && value === 'auto'
? position(element)[prop]