{% block title %}Beacon{% endblock %}

"); + css(vhEl, { + height: "100vh", + position: "fixed" + }); + on(window, "resize", () => vh = null); + } + append(document.body, vhEl); + vh = vhEl.clientHeight; + remove$1(vhEl); + return vh; + } + + const fastdom = { read, write, clear, flush }; + const reads = []; + const writes = []; + function read(task) { + reads.push(task); + scheduleFlush(); + return task; + } + function write(task) { + writes.push(task); + scheduleFlush(); + return task; + } + function clear(task) { + remove(reads, task); + remove(writes, task); + } + let scheduled = false; + function flush() { + runTasks(reads); + runTasks(writes.splice(0)); + scheduled = false; + if (reads.length || writes.length) { + scheduleFlush(); + } + } + function scheduleFlush() { + if (!scheduled) { + scheduled = true; + queueMicrotask(flush); + } + } + function runTasks(tasks) { + let task; + while (task = tasks.shift()) { + try { + task(); + } catch (e) { + console.error(e); + } + } + } + function remove(array, item) { + const index = array.indexOf(item); + return ~index && array.splice(index, 1); + } + + class MouseTracker { + init() { + this.positions = []; + let position; + this.unbind = on(document, "mousemove", (e) => position = getEventPos(e)); + this.interval = setInterval(() => { + if (!position) { + return; + } + this.positions.push(position); + if (this.positions.length > 5) { + this.positions.shift(); + } + }, 50); + } + cancel() { + var _a; + (_a = this.unbind) == null ? void 0 : _a.call(this); + clearInterval(this.interval); + } + movesTo(target) { + if (!this.positions || this.positions.length < 2) { + return false; + } + const p = dimensions$1(target); + const { left, right, top, bottom } = p; + const [prevPosition] = this.positions; + const position = last(this.positions); + const path = [prevPosition, position]; + if (pointInRect(position, p)) { + return false; + } + const diagonals = [ + [ + { x: left, y: top }, + { x: right, y: bottom } + ], + [ + { x: left, y: bottom }, + { x: right, y: top } + ] + ]; + return diagonals.some((diagonal) => { + const intersection = intersect(path, diagonal); + return intersection && pointInRect(intersection, p); + }); + } + } + function intersect([{ x: x1, y: y1 }, { x: x2, y: y2 }], [{ x: x3, y: y3 }, { x: x4, y: y4 }]) { + const denominator = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1); + if (denominator === 0) { + return false; + } + const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator; + if (ua < 0) { + return false; + } + return { x: x1 + ua * (x2 - x1), y: y1 + ua * (y2 - y1) }; + } + + function observeIntersection(targets, cb, options = {}, { intersecting = true } = {}) { + const observer = new IntersectionObserver( + intersecting ? (entries, observer2) => { + if (entries.some((entry) => entry.isIntersecting)) { + cb(entries, observer2); + } + } : cb, + options + ); + for (const el of toNodes(targets)) { + observer.observe(el); + } + return observer; + } + const hasResizeObserver = inBrowser && window.ResizeObserver; + function observeResize(targets, cb, options = { box: "border-box" }) { + if (hasResizeObserver) { + return observe$1(ResizeObserver, targets, cb, options); + } + const off = [on(window, "load resize", cb), on(document, "loadedmetadata load", cb, true)]; + return { disconnect: () => off.map((cb2) => cb2()) }; + } + function observeViewportResize(cb) { + return { disconnect: on([window, window.visualViewport], "resize", cb) }; + } + function observeMutation(targets, cb, options) { + return observe$1(MutationObserver, targets, cb, options); + } + function observe$1(Observer, targets, cb, options) { + const observer = new Observer(cb); + for (const el of toNodes(targets)) { + observer.observe(el, options); + } + return observer; + } + + function play(el) { + if (isIFrame(el)) { + call(el, { func: "playVideo", method: "play" }); + } + if (isHTML5(el)) { + el.play().catch(noop); + } + } + function pause(el) { + if (isIFrame(el)) { + call(el, { func: "pauseVideo", method: "pause" }); + } + if (isHTML5(el)) { + el.pause(); + } + } + function mute(el) { + if (isIFrame(el)) { + call(el, { func: "mute", method: "setVolume", value: 0 }); + } + if (isHTML5(el)) { + el.muted = true; + } + } + function isHTML5(el) { + return isTag(el, "video"); + } + function isIFrame(el) { + return isTag(el, "iframe") && (isYoutube(el) || isVimeo(el)); + } + function isYoutube(el) { + return !!el.src.match( + /\/\/.*?youtube(-nocookie)?\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/ + ); + } + function isVimeo(el) { + return !!el.src.match(/vimeo\.com\/video\/.*/); + } + async function call(el, cmd) { + await enableApi(el); + post(el, cmd); + } + function post(el, cmd) { + el.contentWindow.postMessage(JSON.stringify({ event: "command", ...cmd }), "*"); + } + const stateKey = "_ukPlayer"; + let counter = 0; + function enableApi(el) { + if (el[stateKey]) { + return el[stateKey]; + } + const youtube = isYoutube(el); + const vimeo = isVimeo(el); + const id = ++counter; + let poller; + return el[stateKey] = new Promise((resolve) => { + youtube && once(el, "load", () => { + const listener = () => post(el, { event: "listening", id }); + poller = setInterval(listener, 100); + listener(); + }); + once(window, "message", resolve, false, ({ data }) => { + try { + data = JSON.parse(data); + return youtube && (data == null ? void 0 : data.id) === id && data.event === "onReady" || vimeo && Number(data == null ? void 0 : data.player_id) === id; + } catch (e) { + } + }); + el.src = `${el.src}${includes(el.src, "?") ? "&" : "?"}${youtube ? "enablejsapi=1" : `api=1&player_id=${id}`}`; + }).then(() => clearInterval(poller)); + } + + function isInView(element, offsetTop = 0, offsetLeft = 0) { + if (!isVisible(element)) { + return false; + } + return intersectRect( + ...overflowParents(element).map((parent2) => { + const { top, left, bottom, right } = offsetViewport(parent2); + return { + top: top - offsetTop, + left: left - offsetLeft, + bottom: bottom + offsetTop, + right: right + offsetLeft + }; + }).concat(offset(element)) + ); + } + function scrollIntoView(element, { offset: offsetBy = 0 } = {}) { + const parents2 = isVisible(element) ? scrollParents(element, false, ["hidden"]) : []; + return parents2.reduce( + (fn, scrollElement, i) => { + const { scrollTop, scrollHeight, offsetHeight } = scrollElement; + const viewport = offsetViewport(scrollElement); + const maxScroll = scrollHeight - viewport.height; + const { height: elHeight, top: elTop } = parents2[i - 1] ? offsetViewport(parents2[i - 1]) : offset(element); + let top = Math.ceil(elTop - viewport.top - offsetBy + scrollTop); + if (offsetBy > 0 && offsetHeight < elHeight + offsetBy) { + top += offsetBy; + } else { + offsetBy = 0; + } + if (top > maxScroll) { + offsetBy -= top - maxScroll; + top = maxScroll; + } else if (top < 0) { + offsetBy -= top; + top = 0; + } + return () => scrollTo(scrollElement, top - scrollTop, element, maxScroll).then(fn); + }, + () => Promise.resolve() + )(); + function scrollTo(element2, top, targetEl, maxScroll) { + return new Promise((resolve) => { + const scroll = element2.scrollTop; + const duration = getDuration(Math.abs(top)); + const start = Date.now(); + const isScrollingElement = scrollingElement(element2) === element2; + const targetTop = offset(targetEl).top + (isScrollingElement ? 0 : scroll); + let prev = 0; + let frames = 15; + (function step() { + const percent = ease(clamp((Date.now() - start) / duration)); + let diff = 0; + if (parents2[0] === element2 && scroll + top < maxScroll) { + diff = offset(targetEl).top + (isScrollingElement ? 0 : element2.scrollTop) - targetTop - dimensions$1(getCoveringElement(targetEl)).height; + } + if (css(element2, "scrollBehavior") !== "auto") { + css(element2, "scrollBehavior", "auto"); + } + element2.scrollTop = scroll + (top + diff) * percent; + css(element2, "scrollBehavior", ""); + if (percent === 1 && (prev === diff || !frames--)) { + resolve(); + } else { + prev = diff; + requestAnimationFrame(step); + } + })(); + }); + } + function getDuration(dist) { + return 40 * Math.pow(dist, 0.375); + } + function ease(k) { + return 0.5 * (1 - Math.cos(Math.PI * k)); + } + } + function scrolledOver(element, startOffset = 0, endOffset = 0) { + if (!isVisible(element)) { + return 0; + } + const scrollElement = scrollParent(element, true); + const { scrollHeight, scrollTop } = scrollElement; + const { height: viewportHeight } = offsetViewport(scrollElement); + const maxScroll = scrollHeight - viewportHeight; + const elementOffsetTop = offsetPosition(element)[0] - offsetPosition(scrollElement)[0]; + const start = Math.max(0, elementOffsetTop - viewportHeight + startOffset); + const end = Math.min(maxScroll, elementOffsetTop + element.offsetHeight - endOffset); + return start < end ? clamp((scrollTop - start) / (end - start)) : 1; + } + function scrollParents(element, scrollable = false, props = []) { + const scrollEl = scrollingElement(element); + let ancestors = parents(element).reverse(); + ancestors = ancestors.slice(ancestors.indexOf(scrollEl) + 1); + const fixedIndex = findIndex(ancestors, (el) => css(el, "position") === "fixed"); + if (~fixedIndex) { + ancestors = ancestors.slice(fixedIndex); + } + return [scrollEl].concat( + ancestors.filter( + (parent2) => css(parent2, "overflow").split(" ").some((prop) => includes(["auto", "scroll", ...props], prop)) && (!scrollable || parent2.scrollHeight > offsetViewport(parent2).height) + ) + ).reverse(); + } + function scrollParent(...args) { + return scrollParents(...args)[0]; + } + function overflowParents(element) { + return scrollParents(element, false, ["hidden", "clip"]); + } + function offsetViewport(scrollElement) { + const window = toWindow(scrollElement); + const documentScrollingElement = scrollingElement(scrollElement); + const useWindow = !isNode(scrollElement) || scrollElement.contains(documentScrollingElement); + if (useWindow && window.visualViewport) { + let { height, width, scale, pageTop: top, pageLeft: left } = window.visualViewport; + height = Math.round(height * scale); + width = Math.round(width * scale); + return { height, width, top, left, bottom: top + height, right: left + width }; + } + let rect = offset(useWindow ? window : scrollElement); + if (css(scrollElement, "display") === "inline") { + return rect; + } + const { body, documentElement } = window.document; + const viewportElement = useWindow ? documentScrollingElement === documentElement || // In quirks mode the scrolling element is body, even though the viewport is html + documentScrollingElement.clientHeight < body.clientHeight ? documentScrollingElement : body : scrollElement; + for (let [prop, dir, start, end] of [ + ["width", "x", "left", "right"], + ["height", "y", "top", "bottom"] + ]) { + const subpixel = rect[prop] % 1; + rect[start] += toFloat(css(viewportElement, `border-${start}-width`)); + rect[prop] = rect[dir] = viewportElement[`client${ucfirst(prop)}`] - (subpixel ? subpixel < 0.5 ? -subpixel : 1 - subpixel : 0); + rect[end] = rect[prop] + rect[start]; + } + return rect; + } + function getCoveringElement(target) { + const { left, width, top } = dimensions$1(target); + for (const position of top ? [0, top] : [0]) { + let coverEl; + for (const el of toWindow(target).document.elementsFromPoint(left + width / 2, position)) { + if (!el.contains(target) && // If e.g. Offcanvas is not yet closed + !hasClass(el, "uk-togglable-leave") && (hasPosition(el, "fixed") && zIndex( + parents(target).reverse().find( + (parent2) => !parent2.contains(el) && !hasPosition(parent2, "static") + ) + ) < zIndex(el) || hasPosition(el, "sticky") && parent(el).contains(target)) && (!coverEl || dimensions$1(coverEl).height < dimensions$1(el).height)) { + coverEl = el; + } + } + if (coverEl) { + return coverEl; + } + } + } + function zIndex(element) { + return toFloat(css(element, "zIndex")); + } + function hasPosition(element, position) { + return css(element, "position") === position; + } + function scrollingElement(element) { + return toWindow(element).document.scrollingElement; + } + + const dirs = [ + ["width", "x", "left", "right"], + ["height", "y", "top", "bottom"] + ]; + function positionAt(element, target, options) { + options = { + attach: { + element: ["left", "top"], + target: ["left", "top"], + ...options.attach + }, + offset: [0, 0], + placement: [], + ...options + }; + if (!isArray(target)) { + target = [target, target]; + } + offset(element, getPosition(element, target, options)); + } + function getPosition(element, target, options) { + const position = attachTo(element, target, options); + const { boundary, viewportOffset = 0, placement } = options; + let offsetPosition = position; + for (const [i, [prop, , start, end]] of Object.entries(dirs)) { + const viewport = getViewport$2(element, target[i], viewportOffset, boundary, i); + if (isWithin(position, viewport, i)) { + continue; + } + let offsetBy = 0; + if (placement[i] === "flip") { + const attach = options.attach.target[i]; + if (attach === end && position[end] <= viewport[end] || attach === start && position[start] >= viewport[start]) { + continue; + } + offsetBy = flip(element, target, options, i)[start] - position[start]; + const scrollArea = getScrollArea(element, target[i], viewportOffset, i); + if (!isWithin(applyOffset(position, offsetBy, i), scrollArea, i)) { + if (isWithin(position, scrollArea, i)) { + continue; + } + if (options.recursion) { + return false; + } + const newPos = flipAxis(element, target, options); + if (newPos && isWithin(newPos, scrollArea, 1 - i)) { + return newPos; + } + continue; + } + } else if (placement[i] === "shift") { + const targetDim = offset(target[i]); + const { offset: elOffset } = options; + offsetBy = clamp( + clamp(position[start], viewport[start], viewport[end] - position[prop]), + targetDim[start] - position[prop] + elOffset[i], + targetDim[end] - elOffset[i] + ) - position[start]; + } + offsetPosition = applyOffset(offsetPosition, offsetBy, i); + } + return offsetPosition; + } + function attachTo(element, target, options) { + let { attach, offset: offsetBy } = { + attach: { + element: ["left", "top"], + target: ["left", "top"], + ...options.attach + }, + offset: [0, 0], + ...options + }; + let elOffset = offset(element); + for (const [i, [prop, , start, end]] of Object.entries(dirs)) { + const targetOffset = attach.target[i] === attach.element[i] ? offsetViewport(target[i]) : offset(target[i]); + elOffset = applyOffset( + elOffset, + targetOffset[start] - elOffset[start] + moveBy(attach.target[i], end, targetOffset[prop]) - moveBy(attach.element[i], end, elOffset[prop]) + +offsetBy[i], + i + ); + } + return elOffset; + } + function applyOffset(position, offset2, i) { + const [, dir, start, end] = dirs[i]; + const newPos = { ...position }; + newPos[start] = position[dir] = position[start] + offset2; + newPos[end] += offset2; + return newPos; + } + function moveBy(attach, end, dim) { + return attach === "center" ? dim / 2 : attach === end ? dim : 0; + } + function getViewport$2(element, target, viewportOffset, boundary, i) { + let viewport = getIntersectionArea(...commonScrollParents(element, target).map(offsetViewport)); + if (viewportOffset) { + viewport[dirs[i][2]] += viewportOffset; + viewport[dirs[i][3]] -= viewportOffset; + } + if (boundary) { + viewport = getIntersectionArea( + viewport, + offset(isArray(boundary) ? boundary[i] : boundary) + ); + } + return viewport; + } + function getScrollArea(element, target, viewportOffset, i) { + const [prop, axis, start, end] = dirs[i]; + const [scrollElement] = commonScrollParents(element, target); + const viewport = offsetViewport(scrollElement); + if (["auto", "scroll"].includes(css(scrollElement, `overflow-${axis}`))) { + viewport[start] -= scrollElement[`scroll${ucfirst(start)}`]; + viewport[end] = viewport[start] + scrollElement[`scroll${ucfirst(prop)}`]; + } + viewport[start] += viewportOffset; + viewport[end] -= viewportOffset; + return viewport; + } + function commonScrollParents(element, target) { + return overflowParents(target).filter((parent) => parent.contains(element)); + } + function getIntersectionArea(...rects) { + let area = {}; + for (const rect of rects) { + for (const [, , start, end] of dirs) { + area[start] = Math.max(area[start] || 0, rect[start]); + area[end] = Math.min(...[area[end], rect[end]].filter(Boolean)); + } + } + return area; + } + function isWithin(positionA, positionB, i) { + const [, , start, end] = dirs[i]; + return positionA[start] >= positionB[start] && positionA[end] <= positionB[end]; + } + function flip(element, target, { offset: offset2, attach }, i) { + return attachTo(element, target, { + attach: { + element: flipAttach(attach.element, i), + target: flipAttach(attach.target, i) + }, + offset: flipOffset(offset2, i) + }); + } + function flipAxis(element, target, options) { + return getPosition(element, target, { + ...options, + attach: { + element: options.attach.element.map(flipAttachAxis).reverse(), + target: options.attach.target.map(flipAttachAxis).reverse() + }, + offset: options.offset.reverse(), + placement: options.placement.reverse(), + recursion: true + }); + } + function flipAttach(attach, i) { + const newAttach = [...attach]; + const index = dirs[i].indexOf(attach[i]); + if (~index) { + newAttach[i] = dirs[i][1 - index % 2 + 2]; + } + return newAttach; + } + function flipAttachAxis(prop) { + for (let i = 0; i < dirs.length; i++) { + const index = dirs[i].indexOf(prop); + if (~index) { + return dirs[1 - i][index % 2 + 2]; + } + } + } + function flipOffset(offset2, i) { + offset2 = [...offset2]; + offset2[i] *= -1; + return offset2; + } + + var util = /*#__PURE__*/Object.freeze({ + __proto__: null, + $: $, + $$: $$, + Animation: Animation, + Dimensions: Dimensions, + MouseTracker: MouseTracker, + Transition: Transition, + addClass: addClass, + after: after, + append: append, + apply: apply, + assign: assign, + attr: attr, + before: before, + boxModelAdjust: boxModelAdjust, + camelize: camelize, + children: children, + clamp: clamp, + createEvent: createEvent, + css: css, + data: data, + dimensions: dimensions$1, + each: each, + empty: empty, + endsWith: endsWith, + escape: escape, + fastdom: fastdom, + filter: filter$1, + find: find, + findAll: findAll, + findIndex: findIndex, + flipPosition: flipPosition, + fragment: fragment, + getCoveringElement: getCoveringElement, + getEventPos: getEventPos, + getIndex: getIndex, + getTargetedElement: getTargetedElement, + hasAttr: hasAttr, + hasClass: hasClass, + hasOwn: hasOwn, + hasTouch: hasTouch, + height: height, + html: html, + hyphenate: hyphenate, + inBrowser: inBrowser, + includes: includes, + index: index, + intersectRect: intersectRect, + isArray: isArray, + isBoolean: isBoolean, + isDocument: isDocument, + isElement: isElement, + isEmpty: isEmpty, + isEqual: isEqual, + isFocusable: isFocusable, + isFunction: isFunction, + isInView: isInView, + isInput: isInput, + isNode: isNode, + isNumber: isNumber, + isNumeric: isNumeric, + isObject: isObject, + isPlainObject: isPlainObject, + isRtl: isRtl, + isSameSiteAnchor: isSameSiteAnchor, + isString: isString, + isTag: isTag, + isTouch: isTouch, + isUndefined: isUndefined, + isVisible: isVisible, + isVoidElement: isVoidElement, + isWindow: isWindow, + last: last, + matches: matches, + memoize: memoize, + mute: mute, + noop: noop, + observeIntersection: observeIntersection, + observeMutation: observeMutation, + observeResize: observeResize, + observeViewportResize: observeViewportResize, + off: off, + offset: offset, + offsetPosition: offsetPosition, + offsetViewport: offsetViewport, + on: on, + once: once, + overflowParents: overflowParents, + parent: parent, + parents: parents, + pause: pause, + pick: pick, + play: play, + pointInRect: pointInRect, + pointerCancel: pointerCancel, + pointerDown: pointerDown$1, + pointerEnter: pointerEnter, + pointerLeave: pointerLeave, + pointerMove: pointerMove$1, + pointerUp: pointerUp$1, + position: position, + positionAt: positionAt, + prepend: prepend, + propName: propName, + query: query, + queryAll: queryAll, + ready: ready, + remove: remove$1, + removeAttr: removeAttr, + removeClass: removeClass, + replaceClass: replaceClass, + resetProps: resetProps, + scrollIntoView: scrollIntoView, + scrollParent: scrollParent, + scrollParents: scrollParents, + scrolledOver: scrolledOver, + selFocusable: selFocusable, + selInput: selInput, + sortBy: sortBy, + startsWith: startsWith, + sumBy: sumBy, + swap: swap, + toArray: toArray, + toBoolean: toBoolean, + toEventTargets: toEventTargets, + toFloat: toFloat, + toNode: toNode, + toNodes: toNodes, + toNumber: toNumber, + toPx: toPx, + toWindow: toWindow, + toggleClass: toggleClass, + trigger: trigger, + ucfirst: ucfirst, + uniqueBy: uniqueBy, + unwrap: unwrap, + width: width, + wrapAll: wrapAll, + wrapInner: wrapInner + }); + + var Class = { + connected() { + addClass(this.$el, this.$options.id); + } + }; + + const units = ["days", "hours", "minutes", "seconds"]; + var countdown = { + mixins: [Class], + props: { + date: String, + clsWrapper: String, + role: String, + reload: Boolean + }, + data: { + date: "", + clsWrapper: ".uk-countdown-%unit%", + role: "timer", + reload: false + }, + connected() { + this.$el.role = this.role; + this.date = toFloat(Date.parse(this.$props.date)); + this.started = this.end = false; + this.start(); + }, + disconnected() { + this.stop(); + }, + events: { + name: "visibilitychange", + el: () => document, + handler() { + if (document.hidden) { + this.stop(); + } else { + this.start(); + } + } + }, + methods: { + start() { + this.stop(); + this.update(); + }, + stop() { + if (this.timer) { + clearInterval(this.timer); + trigger(this.$el, "countdownstop"); + this.timer = null; + } + }, + update() { + const timespan = getTimeSpan(this.date); + if (!timespan.total) { + this.stop(); + if (!this.end) { + trigger(this.$el, "countdownend"); + this.end = true; + if (this.reload && this.started) { + window.location.reload(); + } + } + } else if (!this.timer) { + this.started = true; + this.timer = setInterval(this.update, 1e3); + trigger(this.$el, "countdownstart"); + } + for (const unit of units) { + const el = $(this.clsWrapper.replace("%unit%", unit), this.$el); + if (!el) { + continue; + } + let digits = Math.trunc(timespan[unit]).toString().padStart(2, "0"); + if (el.textContent !== digits) { + digits = digits.split(""); + if (digits.length !== el.children.length) { + html(el, digits.map(() => "").join("")); + } + digits.forEach((digit, i) => el.children[i].textContent = digit); + } + } + } + } + }; + function getTimeSpan(date) { + const total = Math.max(0, date - Date.now()) / 1e3; + return { + total, + seconds: total % 60, + minutes: total / 60 % 60, + hours: total / 60 / 60 % 24, + days: total / 60 / 60 / 24 + }; + } + + const strats = {}; + strats.events = strats.watch = strats.observe = strats.created = strats.beforeConnect = strats.connected = strats.beforeDisconnect = strats.disconnected = strats.destroy = concatStrat; + strats.args = function(parentVal, childVal) { + return childVal !== false && concatStrat(childVal || parentVal); + }; + strats.update = function(parentVal, childVal) { + return sortBy( + concatStrat(parentVal, isFunction(childVal) ? { read: childVal } : childVal), + "order" + ); + }; + strats.props = function(parentVal, childVal) { + if (isArray(childVal)) { + const value = {}; + for (const key of childVal) { + value[key] = String; + } + childVal = value; + } + return strats.methods(parentVal, childVal); + }; + strats.computed = strats.methods = function(parentVal, childVal) { + return childVal ? parentVal ? { ...parentVal, ...childVal } : childVal : parentVal; + }; + strats.i18n = strats.data = function(parentVal, childVal, vm) { + if (!vm) { + if (!childVal) { + return parentVal; + } + if (!parentVal) { + return childVal; + } + return function(vm2) { + return mergeFnData(parentVal, childVal, vm2); + }; + } + 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 + ); + } + function concatStrat(parentVal, childVal) { + parentVal = parentVal && !isArray(parentVal) ? [parentVal] : parentVal; + return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal; + } + function defaultStrat(parentVal, childVal) { + return isUndefined(childVal) ? parentVal : childVal; + } + function mergeOptions(parent, child, vm) { + const options = {}; + if (isFunction(child)) { + child = child.options; + } + if (child.extends) { + parent = mergeOptions(parent, child.extends, vm); + } + if (child.mixins) { + for (const mixin of child.mixins) { + parent = mergeOptions(parent, mixin, vm); + } + } + for (const key in parent) { + mergeKey(key); + } + for (const key in child) { + if (!hasOwn(parent, key)) { + mergeKey(key); + } + } + function mergeKey(key) { + options[key] = (strats[key] || defaultStrat)(parent[key], child[key], vm); + } + return options; + } + function parseOptions(options, args = []) { + try { + return options ? startsWith(options, "{") ? JSON.parse(options) : args.length && !includes(options, ":") ? { [args[0]]: options } : options.split(";").reduce((options2, option) => { + const [key, value] = option.split(/:(.*)/); + if (key && !isUndefined(value)) { + options2[key.trim()] = value.trim(); + } + return options2; + }, {}) : {}; + } catch (e) { + return {}; + } + } + function coerce$1(type, value) { + if (type === Boolean) { + return toBoolean(value); + } else if (type === Number) { + return toNumber(value); + } else if (type === "list") { + return toList(value); + } else if (type === Object && isString(value)) { + return parseOptions(value); + } + return type ? type(value) : value; + } + const listRe = /,(?![^(]*\))/; + function toList(value) { + return isArray(value) ? value : isString(value) ? value.split(listRe).map((value2) => isNumeric(value2) ? toNumber(value2) : toBoolean(value2.trim())) : [value]; + } + + function initUpdates(instance) { + instance._data = {}; + instance._updates = [...instance.$options.update || []]; + instance._disconnect.push(() => instance._updates = instance._data = null); + } + function prependUpdate(instance, update) { + instance._updates.unshift(update); + } + function callUpdate(instance, e = "update") { + if (!instance._connected) { + return; + } + if (!instance._updates.length) { + return; + } + if (!instance._queued) { + instance._queued = /* @__PURE__ */ new Set(); + fastdom.read(() => { + if (instance._connected) { + runUpdates(instance, instance._queued); + } + instance._queued = null; + }); + } + instance._queued.add(e.type || e); + } + function runUpdates(instance, types) { + for (const { read, write, events = [] } of instance._updates) { + if (!types.has("update") && !events.some((type) => types.has(type))) { + continue; + } + let result; + if (read) { + result = read.call(instance, instance._data, types); + if (result && isPlainObject(result)) { + assign(instance._data, result); + } + } + if (write && result !== false) { + fastdom.write(() => { + if (instance._connected) { + write.call(instance, instance._data, types); + } + }); + } + } + } + + function resize(options) { + return observe(observeResize, options, "resize"); + } + function intersection(options) { + return observe(observeIntersection, options); + } + function mutation(options) { + return observe(observeMutation, options); + } + function lazyload(options = {}) { + return intersection({ + handler: function(entries, observer) { + const { targets = this.$el, preload = 5 } = options; + for (const el of toNodes(isFunction(targets) ? targets(this) : targets)) { + $$('[loading="lazy"]', el).slice(0, preload - 1).forEach((el2) => removeAttr(el2, "loading")); + } + for (const el of entries.filter(({ isIntersecting }) => isIntersecting).map(({ target }) => target)) { + observer.unobserve(el); + } + }, + ...options + }); + } + function viewport(options) { + return observe((target, handler) => observeViewportResize(handler), options, "resize"); + } + function scroll$1(options) { + return observe( + (target, handler) => ({ + disconnect: on(toScrollTargets(target), "scroll", handler, { passive: true }) + }), + options, + "scroll" + ); + } + function swipe(options) { + return { + observe(target, handler) { + return { + observe: noop, + unobserve: noop, + disconnect: on(target, pointerDown$1, handler, { passive: true }) + }; + }, + handler(e) { + if (!isTouch(e)) { + return; + } + const pos = getEventPos(e); + const target = "tagName" in e.target ? e.target : parent(e.target); + once(document, `${pointerUp$1} ${pointerCancel} scroll`, (e2) => { + const { x, y } = getEventPos(e2); + if (e2.type !== "scroll" && target && x && Math.abs(pos.x - x) > 100 || y && Math.abs(pos.y - y) > 100) { + setTimeout(() => { + trigger(target, "swipe"); + trigger(target, `swipe${swipeDirection(pos.x, pos.y, x, y)}`); + }); + } + }); + }, + ...options + }; + } + function observe(observe2, options, emit) { + return { + observe: observe2, + handler() { + callUpdate(this, emit); + }, + ...options + }; + } + 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 toScrollTargets(elements) { + return toNodes(elements).map((node) => { + const { ownerDocument } = node; + const parent2 = scrollParent(node, true); + return parent2 === ownerDocument.scrollingElement ? ownerDocument : parent2; + }); + } + + var Margin = { + props: { + margin: String, + firstColumn: Boolean + }, + data: { + margin: "uk-margin-small-top", + firstColumn: "uk-first-column" + }, + observe: [ + mutation({ + options: { + childList: true + } + }), + mutation({ + options: { + attributes: true, + attributeFilter: ["style"] + } + }), + resize({ + handler(mutations) { + for (const { + borderBoxSize: [{ inlineSize, blockSize }] + } of mutations) { + if (inlineSize || blockSize) { + this.$emit("resize"); + return; + } + } + }, + target: ({ $el }) => [$el, ...children($el)] + }) + ], + update: { + read() { + return { + rows: getRows(children(this.$el)) + }; + }, + write({ rows }) { + for (const row of rows) { + for (const el of row) { + toggleClass(el, this.margin, rows[0] !== row); + toggleClass(el, this.firstColumn, row[isRtl ? row.length - 1 : 0] === el); + } + } + }, + events: ["resize"] + } + }; + function getRows(elements) { + const sorted = [[]]; + const withOffset = elements.some( + (el, i) => i && elements[i - 1].offsetParent !== el.offsetParent + ); + for (const el of elements) { + if (!isVisible(el)) { + continue; + } + const offset = getOffset(el, withOffset); + for (let i = sorted.length - 1; i >= 0; i--) { + const current = sorted[i]; + if (!current[0]) { + current.push(el); + break; + } + const offsetCurrent = getOffset(current[0], withOffset); + if (offset.top >= offsetCurrent.bottom - 1 && offset.top !== offsetCurrent.top) { + sorted.push([el]); + break; + } + if (offset.bottom - 1 > offsetCurrent.top || offset.top === offsetCurrent.top) { + let j = current.length - 1; + for (; j >= 0; j--) { + const offsetCurrent2 = getOffset(current[j], withOffset); + if (offset.left >= offsetCurrent2.left) { + break; + } + } + current.splice(j + 1, 0, el); + break; + } + if (i === 0) { + sorted.unshift([el]); + break; + } + } + } + return sorted; + } + function getOffset(element, offset = false) { + let { offsetTop, offsetLeft, offsetHeight, offsetWidth } = element; + if (offset) { + [offsetTop, offsetLeft] = offsetPosition(element); + } + return { + top: offsetTop, + left: offsetLeft, + bottom: offsetTop + offsetHeight, + right: offsetLeft + offsetWidth + }; + } + + const clsLeave = "uk-transition-leave"; + const clsEnter = "uk-transition-enter"; + function fade(action, target, duration, stagger = 0) { + const index = transitionIndex(target, true); + const propsIn = { opacity: 1 }; + const propsOut = { opacity: 0 }; + const isCurrentIndex = () => index === transitionIndex(target); + const wrapIndexFn = (fn) => () => isCurrentIndex() ? fn() : Promise.reject(); + const leaveFn = wrapIndexFn(async () => { + addClass(target, clsLeave); + await (stagger ? Promise.all( + getTransitionNodes(target).map(async (child, i) => { + await awaitTimeout(i * stagger); + return Transition.start(child, propsOut, duration / 2, "ease"); + }) + ) : Transition.start(target, propsOut, duration / 2, "ease")); + removeClass(target, clsLeave); + }); + const enterFn = wrapIndexFn(async () => { + const oldHeight = height(target); + addClass(target, clsEnter); + action(); + css(stagger ? children(target) : target, propsOut); + height(target, oldHeight); + await awaitTimeout(); + height(target, ""); + const newHeight = height(target); + css(target, "alignContent", "flex-start"); + height(target, oldHeight); + let transitions = []; + let targetDuration = duration / 2; + if (stagger) { + const nodes = getTransitionNodes(target); + css(children(target), propsOut); + transitions = nodes.map(async (child, i) => { + await awaitTimeout(i * stagger); + await Transition.start(child, propsIn, duration / 2, "ease"); + if (isCurrentIndex()) { + resetProps(child, propsIn); + } + }); + targetDuration += nodes.length * stagger; + } + if (!stagger || oldHeight !== newHeight) { + const targetProps = { height: newHeight, ...stagger ? {} : propsIn }; + transitions.push(Transition.start(target, targetProps, targetDuration, "ease")); + } + await Promise.all(transitions); + removeClass(target, clsEnter); + if (isCurrentIndex()) { + resetProps(target, { height: "", alignContent: "", ...propsIn }); + delete target.dataset.transition; + } + }); + return hasClass(target, clsLeave) ? waitTransitionend(target).then(enterFn) : hasClass(target, clsEnter) ? waitTransitionend(target).then(leaveFn).then(enterFn) : leaveFn().then(enterFn); + } + function transitionIndex(target, next) { + if (next) { + target.dataset.transition = 1 + transitionIndex(target); + } + return toNumber(target.dataset.transition) || 0; + } + function waitTransitionend(target) { + return Promise.all( + children(target).filter(Transition.inProgress).map( + (el) => new Promise((resolve) => once(el, "transitionend transitioncanceled", resolve)) + ) + ); + } + function getTransitionNodes(target) { + return getRows(children(target)).flat().filter(isVisible); + } + function awaitTimeout(timeout) { + return new Promise((resolve) => setTimeout(resolve, timeout)); + } + + async function slide(action, target, duration) { + await awaitFrame(); + let nodes = children(target); + const currentProps = nodes.map((el) => getProps$1(el, true)); + const targetProps = { ...css(target, ["height", "padding"]), display: "block" }; + const targets = nodes.concat(target); + await Promise.all(targets.map(Transition.cancel)); + css(targets, "transitionProperty", "none"); + await action(); + nodes = nodes.concat(children(target).filter((el) => !includes(nodes, el))); + await Promise.resolve(); + css(targets, "transitionProperty", ""); + const targetStyle = attr(target, "style"); + const targetPropsTo = css(target, ["height", "padding"]); + const [propsTo, propsFrom] = getTransitionProps(target, nodes, currentProps); + const attrsTo = nodes.map((el) => ({ style: attr(el, "style") })); + nodes.forEach((el, i) => propsFrom[i] && css(el, propsFrom[i])); + css(target, targetProps); + trigger(target, "scroll"); + await awaitFrame(); + const transitions = nodes.map((el, i) => parent(el) === target && Transition.start(el, propsTo[i], duration, "ease")).concat(Transition.start(target, targetPropsTo, duration, "ease")); + try { + await Promise.all(transitions); + nodes.forEach((el, i) => { + attr(el, attrsTo[i]); + if (parent(el) === target) { + css(el, "display", propsTo[i].opacity === 0 ? "none" : ""); + } + }); + attr(target, "style", targetStyle); + } catch (e) { + attr(nodes, "style", ""); + resetProps(target, targetProps); + } + } + function getProps$1(el, opacity) { + const zIndex = css(el, "zIndex"); + return isVisible(el) ? { + display: "", + opacity: opacity ? css(el, "opacity") : "0", + pointerEvents: "none", + position: "absolute", + zIndex: zIndex === "auto" ? index(el) : zIndex, + ...getPositionWithMargin(el) + } : false; + } + function getTransitionProps(target, nodes, currentProps) { + const propsTo = nodes.map( + (el, i) => parent(el) && i in currentProps ? currentProps[i] ? isVisible(el) ? getPositionWithMargin(el) : { opacity: 0 } : { opacity: isVisible(el) ? 1 : 0 } : false + ); + const propsFrom = propsTo.map((props, i) => { + const from = parent(nodes[i]) === target && (currentProps[i] || getProps$1(nodes[i])); + if (!from) { + return false; + } + if (!props) { + delete from.opacity; + } else if (!("opacity" in props)) { + const { opacity } = from; + if (opacity % 1) { + props.opacity = 1; + } else { + delete from.opacity; + } + } + return from; + }); + return [propsTo, propsFrom]; + } + function getPositionWithMargin(el) { + const { height, width } = dimensions$1(el); + return { + height, + width, + transform: "", + ...position(el), + ...css(el, ["marginTop", "marginLeft"]) + }; + } + function awaitFrame() { + return new Promise((resolve) => requestAnimationFrame(resolve)); + } + + var Animate = { + props: { + duration: Number, + animation: Boolean + }, + data: { + duration: 150, + animation: "slide" + }, + methods: { + animate(action, target = this.$el) { + const name = this.animation; + const animationFn = name === "fade" ? fade : name === "delayed-fade" ? (...args) => fade(...args, 40) : name ? slide : () => { + action(); + return Promise.resolve(); + }; + return animationFn(action, target, this.duration).catch(noop); + } + } + }; + + function maybeDefaultPreventClick(e) { + if (e.target.closest('a[href="#"],a[href=""]')) { + e.preventDefault(); + } + } + + const keyMap = { + TAB: 9, + ESC: 27, + SPACE: 32, + END: 35, + HOME: 36, + LEFT: 37, + UP: 38, + RIGHT: 39, + DOWN: 40 + }; + + var filter = { + mixins: [Animate], + args: "target", + props: { + target: String, + selActive: Boolean + }, + data: { + target: "", + selActive: false, + attrItem: "uk-filter-control", + cls: "uk-active", + duration: 250 + }, + computed: { + children: ({ target }, $el) => $$(`${target} > *`, $el), + toggles: ({ attrItem }, $el) => $$(`[${attrItem}],[data-${attrItem}]`, $el) + }, + watch: { + toggles(toggles) { + this.updateState(); + const actives = $$(this.selActive, this.$el); + for (const toggle of toggles) { + if (this.selActive !== false) { + toggleClass(toggle, this.cls, includes(actives, toggle)); + } + const button = findButton(toggle); + if (isTag(button, "a")) { + button.role = "button"; + } + } + }, + children(list, prev) { + if (prev) { + this.updateState(); + } + } + }, + events: { + name: "click keydown", + delegate: ({ attrItem }) => `[${attrItem}],[data-${attrItem}]`, + handler(e) { + if (e.type === "keydown" && e.keyCode !== keyMap.SPACE) { + return; + } + if (e.target.closest("a,button")) { + maybeDefaultPreventClick(e); + this.apply(e.current); + } + } + }, + methods: { + apply(el) { + const prevState = this.getState(); + const newState = mergeState(el, this.attrItem, this.getState()); + if (!isEqualState(prevState, newState)) { + this.setState(newState); + } + }, + getState() { + return this.toggles.filter((item) => hasClass(item, this.cls)).reduce((state, el) => mergeState(el, this.attrItem, state), { + filter: { "": "" }, + sort: [] + }); + }, + async setState(state, animate = true) { + state = { filter: { "": "" }, sort: [], ...state }; + trigger(this.$el, "beforeFilter", [this, state]); + for (const toggle of this.toggles) { + toggleClass(toggle, this.cls, matchFilter(toggle, this.attrItem, state)); + } + await Promise.all( + $$(this.target, this.$el).map((target) => { + const filterFn = () => applyState(state, target, children(target)); + return animate ? this.animate(filterFn, target) : filterFn(); + }) + ); + trigger(this.$el, "afterFilter", [this]); + }, + updateState() { + fastdom.write(() => this.setState(this.getState(), false)); + } + } + }; + function getFilter(el, attr) { + return parseOptions(data(el, attr), ["filter"]); + } + function isEqualState(stateA, stateB) { + return ["filter", "sort"].every((prop) => isEqual(stateA[prop], stateB[prop])); + } + function applyState(state, target, children) { + for (const el of children) { + css( + el, + "display", + Object.values(state.filter).every((selector) => !selector || matches(el, selector)) ? "" : "none" + ); + } + const [sort, order] = state.sort; + if (sort) { + const sorted = sortItems(children, sort, order); + if (!isEqual(sorted, children)) { + append(target, sorted); + } + } + } + function mergeState(el, attr, state) { + const { filter, group, sort, order = "asc" } = getFilter(el, attr); + if (filter || isUndefined(sort)) { + if (group) { + if (filter) { + delete state.filter[""]; + state.filter[group] = filter; + } else { + delete state.filter[group]; + if (isEmpty(state.filter) || "" in state.filter) { + state.filter = { "": filter || "" }; + } + } + } else { + state.filter = { "": filter || "" }; + } + } + if (!isUndefined(sort)) { + state.sort = [sort, order]; + } + return state; + } + function matchFilter(el, attr, { filter: stateFilter = { "": "" }, sort: [stateSort, stateOrder] }) { + const { filter = "", group = "", sort, order = "asc" } = getFilter(el, attr); + return isUndefined(sort) ? group in stateFilter && filter === stateFilter[group] || !filter && group && !(group in stateFilter) && !stateFilter[""] : stateSort === sort && stateOrder === order; + } + function sortItems(nodes, sort, order) { + return [...nodes].sort( + (a, b) => data(a, sort).localeCompare(data(b, sort), void 0, { numeric: true }) * (order === "asc" || -1) + ); + } + function findButton(el) { + return $("a,button", el) || el; + } + + var img = { + args: "dataSrc", + props: { + dataSrc: String, + sources: String, + margin: String, + target: String, + loading: String + }, + data: { + dataSrc: "", + sources: false, + margin: "50%", + target: false, + loading: "lazy" + }, + connected() { + if (this.loading !== "lazy") { + this.load(); + } else if (isImg(this.$el)) { + this.$el.loading = "lazy"; + setSrcAttrs(this.$el); + } + }, + disconnected() { + if (this.img) { + this.img.onload = ""; + } + delete this.img; + }, + observe: intersection({ + handler(entries, observer) { + this.load(); + observer.disconnect(); + }, + options: ({ margin }) => ({ rootMargin: margin }), + filter: ({ loading }) => loading === "lazy", + target: ({ $el, $props }) => $props.target ? [$el, ...queryAll($props.target, $el)] : $el + }), + methods: { + load() { + if (this.img) { + return this.img; + } + const image = isImg(this.$el) ? this.$el : getImageFromElement(this.$el, this.dataSrc, this.sources); + removeAttr(image, "loading"); + setSrcAttrs(this.$el, image.currentSrc); + return this.img = image; + } + } + }; + function setSrcAttrs(el, src) { + if (isImg(el)) { + const parentNode = parent(el); + const elements = isTag(parentNode, "picture") ? children(parentNode) : [el]; + elements.forEach((el2) => setSourceProps(el2, el2)); + } else if (src) { + const change = !includes(el.style.backgroundImage, src); + if (change) { + css(el, "backgroundImage", `url(${escape(src)})`); + trigger(el, createEvent("load", false)); + } + } + } + const srcProps = ["data-src", "data-srcset", "sizes"]; + function setSourceProps(sourceEl, targetEl) { + for (const prop of srcProps) { + const value = data(sourceEl, prop); + if (value) { + attr(targetEl, prop.replace(/data-/g, ""), value); + } + } + } + function getImageFromElement(el, src, sources) { + const img = new Image(); + wrapInPicture(img, sources); + setSourceProps(el, img); + img.onload = () => setSrcAttrs(el, img.currentSrc); + img.src = src; + return img; + } + function wrapInPicture(img, sources) { + sources = parseSources(sources); + if (sources.length) { + const picture = fragment("

Beacon

Server List:

TODO la transition stylée où on plonge dans la balise

Players

Worlds

RAM - Heap

RAM - Non-Heap

CPU Usage

RAM - Non-Heap

TODO la transition stylée où on plonge dans la balise

{{ label }}

{{ component }} - {{ label }}

RAM - Heap

RAM - Non-Heap

CPU Usage

{{ key }}

Players

Worlds

Players

Worlds

Players

Worlds

Players

Logs

Disk R/W speeds

Terminal

Versions

Versions