@geolid/ui-kit
Version:
Geolid UI Kit
1,863 lines (1,391 loc) • 1.28 MB
JavaScript
/*! Geolid UIkit 0.0.3 */
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define('uikit', factory) :
(global.UIkit = factory());
}(this, (function () { 'use strict';
var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var uikit = createCommonjsModule(function (module, exports) {
/*! UIkit 3.0.0-beta.38 | http://www.getuikit.com | (c) 2014 - 2017 YOOtheme | MIT License */
(function (global, factory) {
module.exports = factory();
}(commonjsGlobal, (function () { var RESOLVED = 0;
var REJECTED = 1;
var PENDING = 2;
var async = 'setImmediate' in window ? setImmediate : setTimeout;
function Promise$1(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);
}
}
Promise$1.reject = function (r) {
return new Promise$1(function (resolve, reject) {
reject(r);
});
};
Promise$1.resolve = function (x) {
return new Promise$1(function (resolve, reject) {
resolve(x);
});
};
Promise$1.all = function all(iterable) {
return new Promise$1(function (resolve, reject) {
var count = 0, result = [];
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) {
Promise$1.resolve(iterable[i]).then(resolver(i), reject);
}
});
};
Promise$1.race = function race(iterable) {
return new Promise$1(function (resolve, reject) {
for (var i = 0; i < iterable.length; i += 1) {
Promise$1.resolve(iterable[i]).then(resolve, reject);
}
});
};
var p = Promise$1.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 deferred = this$1.deferred.shift(),
onResolved = deferred[0],
onRejected = deferred[1],
resolve = deferred[2],
reject = deferred[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 Promise$1(function (resolve, reject) {
this$1.deferred.push([onResolved, onRejected, resolve, reject]);
this$1.notify();
});
};
p.catch = function (onRejected) {
return this.then(undefined, onRejected);
};
/* global DocumentTouch */
var win = window;
var doc = document;
var docEl = doc.documentElement;
var Observer = win.MutationObserver;
var requestAnimationFrame$1 = win.requestAnimationFrame;
var hasTouchEvents = 'ontouchstart' in win;
var hasPointerEvents = win.PointerEvent;
var hasTouch = 'ontouchstart' in win
|| win.DocumentTouch && doc instanceof DocumentTouch
|| navigator.pointerEnabled && navigator.maxTouchPoints; // IE >=11
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';
function getImage(src) {
return new Promise$1(function (resolve, reject) {
var img = new Image();
img.onerror = reject;
img.onload = function () { return resolve(img); };
img.src = src;
});
}
var supports = {};
// IE 11
(function () {
var list = doc.createElement('_').classList;
if (list) {
list.add('a', 'b');
list.toggle('c', false);
supports.Multiple = list.contains('b');
supports.Force = !list.contains('c');
supports.ClassList = true;
}
list = null;
})();
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 addClass(element) {
var args = [], len = arguments.length - 1;
while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
apply(element, args, 'add');
}
function removeClass(element) {
var args = [], len = arguments.length - 1;
while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
apply(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 supports.ClassList && 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 (!supports.ClassList || !args.length) {
return;
}
args = getArgs$1(args);
var force = !isString(args[args.length - 1]) ? args.pop() : undefined;
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(args[i], force)
: (classList[(!isUndefined(force) ? force : !classList.contains(args[i])) ? 'add' : 'remove'](args[i]));
}
});
}
function apply(element, args, fn) {
args = getArgs$1(args).filter(Boolean);
supports.ClassList && 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 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$1 = {};
function getCssVar(name) {
if (!(name in vars$1)) {
/* usage in css: .var-name:before { content:"xyz" } */
var element = append(docEl, doc.createElement('div'));
addClass(element, ("var-" + name));
try {
vars$1[name] = getStyle(element, 'content', ':before').replace(/^["'](.*)["']$/, '$1');
vars$1[name] = JSON.parse(vars$1[name]);
} catch (e) {}
docEl.removeChild(element);
}
return vars$1[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'];
var style = doc.createElement('_').style;
function vendorPropName(name) {
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;
}
}
}
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),
targetDim = getDimensions(target),
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 || getWindow(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,
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,
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),
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 = getWindow(element);
var top = ref.pageYOffset;
var left = ref.pageXOffset;
if (isWindow(element)) {
var height = element.innerHeight,
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),
parentOffset = parent === docEl$1(element) ? {top: 0, left: 0} : offset(parent);
return ['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));
}
function offsetParent(element) {
var parent = toNode(element).offsetParent;
while (parent && css(parent, 'position') === 'static') {
parent = parent.offsetParent;
}
return parent || docEl$1(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.offsetHeight, doc.scrollHeight);
}
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 getWindow(element) {
return isWindow(element) ? element : document$1(element).defaultView;
}
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/, 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 document$1(element) {
return toNode(element).ownerDocument;
}
function docEl$1(element) {
return document$1(element).documentElement;
}
var isRtl = attr(docEl, 'dir') === 'rtl';
function isReady() {
return doc.readyState === 'complete' || doc.readyState !== 'loading' && !docEl.doScroll;
}
function ready(fn) {
if (isReady()) {
fn();
return;
}
var handle = function () {
unbind1();
unbind2();
fn();
},
unbind1 = on(doc, 'DOMContentLoaded', handle),
unbind2 = on(win, 'load', handle);
}
function transition(element, props, duration, timing) {
if ( duration === void 0 ) duration = 400;
if ( timing === void 0 ) timing = 'linear';
return Promise$$1.all(toNodes(element).map(function (element) { return new Promise$$1(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));
}); }
));
}
var Transition = {
start: transition,
stop: function stop(element) {
trigger(element, 'transitionend');
return Promise$$1.resolve();
},
cancel: function cancel(element) {
trigger(element, 'transitioncanceled');
},
inProgress: function inProgress(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$$1.all(toNodes(element).map(function (element) { return new Promise$$1(function (resolve, reject) {
if (hasClass(element, clsCancelAnimation)) {
requestAnimationFrame(function () { return Promise$$1.resolve().then(function () { return animate.apply(null, 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$$1.resolve().then(function () {
hasReset = true;
reset();
});
}
requestAnimationFrame(function () {
if (!hasReset) {
addClass(element, clsCancelAnimation);
requestAnimationFrame(function () { return removeClass(element, clsCancelAnimation); });
}
});
}, false, function (ref) {
var target = ref.target;
return element === target;
});
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 in$1(element, animation, duration, origin) {
return animate(element, animation, duration, origin, false);
},
out: function out(element, animation, duration, origin) {
return animate(element, animation, duration, origin, true);
},
inProgress: function inProgress$1(element) {
return inProgress.test(attr(element, 'class'));
},
cancel: function cancel(element) {
trigger(element, 'animationcancel');
}
};
function isInView(element, top, left) {
if ( top === void 0 ) top = 0;
if ( left === void 0 ) left = 0;
return intersectRect(toNode(element).getBoundingClientRect(), {
top: top,
left: left,
bottom: top + height(win),
right: left + width(win)
});
}
function scrolledOver(element) {
element = toNode(element);
var elHeight = element.offsetHeight,
top = positionTop(element),
vp = height(win),
vh = vp + Math.min(0, top - vp),
diff = Math.max(0, vp - (height(doc) - (top + elHeight)));
return clamp(((vh + win.pageYOffset - top) / ((vh + (elHeight - (diff < vp ? diff : 0))) / 100)) / 100);
}
function positionTop(element) {
var top = 0;
do {
top += element.offsetTop;
} while (element = element.offsetParent);
return top;
}
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;
}
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 voidElements[toNode(element).tagName.toLowerCase()];
}
var Dimensions = {
ratio: function ratio(dimensions, prop, value) {
var obj;
var aProp = prop === 'width' ? 'height' : 'width';
return ( obj = {}, obj[aProp] = Math.round(value * dimensions[aProp] / dimensions[prop]), obj[prop] = value, obj);
},
contain: function contain(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 cover(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 preventClick() {
var timer = setTimeout(function () { return trigger(doc, 'click'); }, 0);
once(doc, 'click', function (e) {
e.preventDefault();
e.stopImmediatePropagation();
clearTimeout(timer);
}, true);
}
function isVisible(element) {
return toNodes(element).some(function (element) { return element.offsetHeight; });
}
var selInput = 'input,select,textarea,button';
function isInput(element) {
return toNodes(element).some(function (element) { return matches(element, selInput); });
}
function empty(element) {
element = toNode(element);
element.innerHTML = '';
return element;
}
function html(parent, html) {
parent = toNode(parent);
return isUndefined(html)
? parent.innerHTML
: append(parent.hasChildNodes() ? empty(parent) : parent, html);
}
function prepend(parent, element) {
parent = toNode(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 = 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); });
}
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$$1;
if (matches$$1 = singleTagRE.exec(html)) {
return doc.createElement(matches$$1[1]);
}
var container = doc.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 index(element, ref) {
return ref
? toNodes(element).indexOf(toNode(ref))
: toNodes((element = toNode(element)) && element.parentNode.children).indexOf(element);
}
var arrayProto = Array.prototype;
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 query(selector, context) {
return $(selector, isContextSelector(selector) ? context : doc);
}
function queryAll(selector, context) {
return $$(selector, isContextSelector(selector) ? context : doc);
}
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 = doc;
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 = doc;
}
try {
return context[queryFn](selector);
} catch (e) {
return null;
} finally {
removes && removes.forEach(function (remove$$1) { return remove$$1(); });
}
}
function filter(element, selector) {
return $$(element).filter(function (element) { return matches(element, selector); });
}
function within(element, selector) {
return !isString(selector)
? element === selector || toNode(selector).contains(toNode(element))
: matches(element, selector) || closest(element, selector);
}
var contextSelectorRe = /(^|,)\s*[!>+~]/;
var contextSanitizeRe = /([!>+~])(?=\s+[!>+~]|\s*$)/g;
function isContextSelector(selector) {
return isString(selector) && selector.match(contextSelectorRe);
}
var elProto = Element.prototype;
var matchesFn = elProto.matches || 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)
? element.parentNode && closestFn.call(element, selector)
: toNodes(element).map(function (element) { return element.parentNode && closestFn.call(element, selector); }).filter(Boolean);
}
function parents(element, selector) {
var elements = [], parent = toNode(element).parentNode;
while (parent && parent.nodeType === 1) {
if (matches(parent, selector)) {
elements.push(parent);
}
parent = parent.parentNode;
}
return elements;
}
function isJQuery(obj) {
return isObject(obj) && !!obj.jquery;
}
function isNode(element) {
return element instanceof Node || isObject(element) && element.nodeType === 1;
}
function isNodeCollection(element) {
return element instanceof NodeList || element instanceof HTMLCollection;
}
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)
? arrayProto.slice.call(element)
: isArray(element)
? element.map(toNode).filter(Boolean)
: isJQuery(element)
? element.toArray()
: [];
}
var escapeFn = win.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) : '';
}
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 = doc.createEvent('CustomEvent'); // IE 11
event.initCustomEvent(e, bubbles, cancelable, detail);
e = event;
}
return e;
}
function getArgs(args) {
if (isString(args[0])) {
args[0] = $(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,
current = selector[0] === '>'
? $$(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 'EventTarget' in win
? target instanceof 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);
}
function bind(fn, context) {
return function (a) {
var l = arguments.length;
return l ? l > 1 ? fn.apply(context, arguments) : fn.call(context, a) : fn.call(context);
};
}
var hasOwnProperty = Object.prototype.hasOwnProperty;
function hasOwn(obj, key) {
return hasOwnProperty.call(obj, key);
}
var Promise$$1 = 'Promise' in window ? window.Promise : Promise$1;
var Deferred = function Deferred() {
var this$1 = this;
this.promise = new Promise$$1(function (resolve, reject) {
this$1.reject = reject;
this$1.resolve = resolve;
});
};
var classifyRe = /(?:^|[-_\/])(\w)/g;
function classify(str) {
return str.replace(classifyRe, function (_, c) { return c ? c.toUpperCase() : ''; });
}
var hyphenateRe = /([a-z\d])([A-Z])/g;
function hyphenate(str) {
return str
.replace(hyphenateRe, '$1-$2')
.toLowerCase();
}
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 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 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 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 toList(value) {
return isArray(value)
? value
: isString(value)
? value.split(/,(?![^(]*\))/).map(function (value) { return isNumeric(value)
? toNumber(value)
: toBoolean(value.trim()); })
: [value];
}
var vars = {};
function toMedia(value) {
if (isString(value)) {
if (value[0] === '@') {
var name = "media-" + (value.substr(1));
value = vars[name] || (vars[name] = toFloat(getCssVar(name)));
} else if (isNaN(value)) {
return value;
}
}
return value && !isNaN(value) ? ("(min-width: " + value + "px)") : false;
}
function coerce(type, value, context) {
if (type === Boolean) {
return toBoolean(value);
} else if (type === Number) {
return toNumber(value);
} else if (type === 'query') {
return query(value, context);
} else if (type === 'list') {
return toList(value);
} else if (type === 'media') {
return toMedia(value);
}
return type ? type(value) : value;
}
function toMs(time) {
return !time
? 0
: endsWith(time, 'ms')
? toFloat(time)
: toFloat(time) * 1000;
}
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 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 pointInRect(point, rect) {
return intersectRect({top: point.y, bottom: point.y, left: point.x, right: point.x}, rect);
}
function ajax(url, options) {
return new Promise$$1(function (resolve, reject) {
var env = assign({
data: null,
method: 'GET',
headers: {},
xhr: new XMLHttpRequest(),
beforeSend: noop,
responseType: ''
}, options);
var xhr = env.xhr;
env.beforeSend(env);
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);
});
}
/*
Based on:
Copyright (c) 2016 Wilson Page