https://www.hanau.de/mam/assets/js/uikit.js

1/*! UIkit 3.20.8 | https://www.getuikit.com | (c) 2014 - 2024 YOOtheme | MIT License */
2
3(function (global, factory) {
4    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
5    typeof define === 'function' && define.amd ? define('uikit', factory) :
6    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.UIkit = factory());
7})(this, (function () { 'use strict';
8
9    const { hasOwnProperty, toString } = Object.prototype;
10    function hasOwn(obj, key) {
11      return hasOwnProperty.call(obj, key);
12    }
13    const hyphenateRe = /\B([A-Z])/g;
14    const hyphenate = memoize((str) => str.replace(hyphenateRe, "-$1").toLowerCase());
15    const camelizeRe = /-(\w)/g;
16    const camelize = memoize(
17      (str) => (str.charAt(0).toLowerCase() + str.slice(1)).replace(camelizeRe, (_, c) => c.toUpperCase())
18    );
19    const ucfirst = memoize((str) => str.charAt(0).toUpperCase() + str.slice(1));
20    function startsWith(str, search) {
21      var _a;
22      return (_a = str == null ? void 0 : str.startsWith) == null ? void 0 : _a.call(str, search);
23    }
24    function endsWith(str, search) {
25      var _a;
26      return (_a = str == null ? void 0 : str.endsWith) == null ? void 0 : _a.call(str, search);
27    }
28    function includes(obj, search) {
29      var _a;
30      return (_a = obj == null ? void 0 : obj.includes) == null ? void 0 : _a.call(obj, search);
31    }
32    function findIndex(array, predicate) {
33      var _a;
34      return (_a = array == null ? void 0 : array.findIndex) == null ? void 0 : _a.call(array, predicate);
35    }
36    const { isArray, from: toArray } = Array;
37    const { assign } = Object;
38    function isFunction(obj) {
39      return typeof obj === "function";
40    }
41    function isObject(obj) {
42      return obj !== null && typeof obj === "object";
43    }
44    function isPlainObject(obj) {
45      return toString.call(obj) === "[object Object]";
46    }
47    function isWindow(obj) {
48      return isObject(obj) && obj === obj.window;
49    }
50    function isDocument(obj) {
51      return nodeType(obj) === 9;
52    }
53    function isNode(obj) {
54      return nodeType(obj) >= 1;
55    }
56    function isElement(obj) {
57      return nodeType(obj) === 1;
58    }
59    function nodeType(obj) {
60      return !isWindow(obj) && isObject(obj) && obj.nodeType;
61    }
62    function isBoolean(value) {
63      return typeof value === "boolean";
64    }
65    function isString(value) {
66      return typeof value === "string";
67    }
68    function isNumber(value) {
69      return typeof value === "number";
70    }
71    function isNumeric(value) {
72      return isNumber(value) || isString(value) && !isNaN(value - parseFloat(value));
73    }
74    function isEmpty(obj) {
75      return !(isArray(obj) ? obj.length : isObject(obj) ? Object.keys(obj).length : false);
76    }
77    function isUndefined(value) {
78      return value === void 0;
79    }
80    function toBoolean(value) {
81      return isBoolean(value) ? value : value === "true" || value === "1" || value === "" ? true : value === "false" || value === "0" ? false : value;
82    }
83    function toNumber(value) {
84      const number = Number(value);
85      return isNaN(number) ? false : number;
86    }
87    function toFloat(value) {
88      return parseFloat(value) || 0;
89    }
90    function toNode(element) {
91      return element && toNodes(element)[0];
92    }
93    function toNodes(element) {
94      return isNode(element) ? [element] : Array.from(element || []).filter(isNode);
95    }
96    function toWindow(element) {
97      if (isWindow(element)) {
98        return element;
99      }
100      element = toNode(element);
101      const document = isDocument(element) ? element : element == null ? void 0 : element.ownerDocument;
102      return (document == null ? void 0 : document.defaultView) || window;
103    }
104    function isEqual(value, other) {
105      return value === other || isObject(value) && isObject(other) && Object.keys(value).length === Object.keys(other).length && each(value, (val, key) => val === other[key]);
106    }
107    function swap(value, a, b) {
108      return value.replace(new RegExp(`${a}|${b}`, "g"), (match) => match === a ? b : a);
109    }
110    function last(array) {
111      return array[array.length - 1];
112    }
113    function each(obj, cb) {
114      for (const key in obj) {
115        if (false === cb(obj[key], key)) {
116          return false;
117        }
118      }
119      return true;
120    }
121    function sortBy(array, prop) {
122      return array.slice().sort(
123        ({ [prop]: propA = 0 }, { [prop]: propB = 0 }) => propA > propB ? 1 : propB > propA ? -1 : 0
124      );
125    }
126    function sumBy(array, iteratee) {
127      return array.reduce(
128        (sum, item) => sum + toFloat(isFunction(iteratee) ? iteratee(item) : item[iteratee]),
129        0
130      );
131    }
132    function uniqueBy(array, prop) {
133      const seen = /* @__PURE__ */ new Set();
134      return array.filter(({ [prop]: check }) => seen.has(check) ? false : seen.add(check));
135    }
136    function pick(obj, props) {
137      return props.reduce((res, prop) => ({ ...res, [prop]: obj[prop] }), {});
138    }
139    function clamp(number, min = 0, max = 1) {
140      return Math.min(Math.max(toNumber(number) || 0, min), max);
141    }
142    function noop() {
143    }
144    function intersectRect(...rects) {
145      return [
146        ["bottom", "top"],
147        ["right", "left"]
148      ].every(
149        ([minProp, maxProp]) => Math.min(...rects.map(({ [minProp]: min }) => min)) - Math.max(...rects.map(({ [maxProp]: max }) => max)) > 0
150      );
151    }
152    function pointInRect(point, rect) {
153      return point.x <= rect.right && point.x >= rect.left && point.y <= rect.bottom && point.y >= rect.top;
154    }
155    function ratio(dimensions, prop, value) {
156      const aProp = prop === "width" ? "height" : "width";
157      return {
158        [aProp]: dimensions[prop] ? Math.round(value * dimensions[aProp] / dimensions[prop]) : dimensions[aProp],
159        [prop]: value
160      };
161    }
162    function contain(dimensions, maxDimensions) {
163      dimensions = { ...dimensions };
164      for (const prop in dimensions) {
165        dimensions = dimensions[prop] > maxDimensions[prop] ? ratio(dimensions, prop, maxDimensions[prop]) : dimensions;
166      }
167      return dimensions;
168    }
169    function cover$1(dimensions, maxDimensions) {
170      dimensions = contain(dimensions, maxDimensions);
171      for (const prop in dimensions) {
172        dimensions = dimensions[prop] < maxDimensions[prop] ? ratio(dimensions, prop, maxDimensions[prop]) : dimensions;
173      }
174      return dimensions;
175    }
176    const Dimensions = { ratio, contain, cover: cover$1 };
177    function getIndex(i, elements, current = 0, finite = false) {
178      elements = toNodes(elements);
179      const { length } = elements;
180      if (!length) {
181        return -1;
182      }
183      i = isNumeric(i) ? toNumber(i) : i === "next" ? current + 1 : i === "previous" ? current - 1 : i === "last" ? length - 1 : elements.indexOf(toNode(i));
184      if (finite) {
185        return clamp(i, 0, length - 1);
186      }
187      i %= length;
188      return i < 0 ? i + length : i;
189    }
190    function memoize(fn) {
191      const cache = /* @__PURE__ */ Object.create(null);
192      return (key, ...args) => cache[key] || (cache[key] = fn(key, ...args));
193    }
194
195    function attr(element, name, value) {
196      var _a;
197      if (isObject(name)) {
198        for (const key in name) {
199          attr(element, key, name[key]);
200        }
201        return;
202      }
203      if (isUndefined(value)) {
204        return (_a = toNode(element)) == null ? void 0 : _a.getAttribute(name);
205      } else {
206        for (const el of toNodes(element)) {
207          if (isFunction(value)) {
208            value = value.call(el, attr(el, name));
209          }
210          if (value === null) {
211            removeAttr(el, name);
212          } else {
213            el.setAttribute(name, value);
214          }
215        }
216      }
217    }
218    function hasAttr(element, name) {
219      return toNodes(element).some((element2) => element2.hasAttribute(name));
220    }
221    function removeAttr(element, name) {
222      toNodes(element).forEach((element2) => element2.removeAttribute(name));
223    }
224    function data(element, attribute) {
225      for (const name of [attribute, `data-${attribute}`]) {
226        if (hasAttr(element, name)) {
227          return attr(element, name);
228        }
229      }
230    }
231
232    function addClass(element, ...classes) {
233      for (const node of toNodes(element)) {
234        const add = toClasses(classes).filter((cls) => !hasClass(node, cls));
235        if (add.length) {
236          node.classList.add(...add);
237        }
238      }
239    }
240    function removeClass(element, ...classes) {
241      for (const node of toNodes(element)) {
242        const remove = toClasses(classes).filter((cls) => hasClass(node, cls));
243        if (remove.length) {
244          node.classList.remove(...remove);
245        }
246      }
247    }
248    function removeClasses(element, clsRegex) {
249      clsRegex = new RegExp(clsRegex);
250      for (const node of toNodes(element)) {
251        node.classList.remove(...toArray(node.classList).filter((cls) => cls.match(clsRegex)));
252      }
253    }
254    function replaceClass(element, oldClass, newClass) {
255      newClass = toClasses(newClass);
256      oldClass = toClasses(oldClass).filter((cls) => !includes(newClass, cls));
257      removeClass(element, oldClass);
258      addClass(element, newClass);
259    }
260    function hasClass(element, cls) {
261      [cls] = toClasses(cls);
262      return toNodes(element).some((node) => node.classList.contains(cls));
263    }
264    function toggleClass(element, cls, force) {
265      const classes = toClasses(cls);
266      if (!isUndefined(force)) {
267        force = !!force;
268      }
269      for (const node of toNodes(element)) {
270        for (const cls2 of classes) {
271          node.classList.toggle(cls2, force);
272        }
273      }
274    }
275    function toClasses(str) {
276      return str ? isArray(str) ? str.map(toClasses).flat() : String(str).split(" ").filter(Boolean) : [];
277    }
278
279    const inBrowser = typeof window !== "undefined";
280    const isRtl = inBrowser && document.dir === "rtl";
281    const hasTouch = inBrowser && "ontouchstart" in window;
282    const hasPointerEvents = inBrowser && window.PointerEvent;
283    const pointerDown$1 = hasPointerEvents ? "pointerdown" : hasTouch ? "touchstart" : "mousedown";
284    const pointerMove$1 = hasPointerEvents ? "pointermove" : hasTouch ? "touchmove" : "mousemove";
285    const pointerUp$1 = hasPointerEvents ? "pointerup" : hasTouch ? "touchend" : "mouseup";
286    const pointerEnter = hasPointerEvents ? "pointerenter" : hasTouch ? "" : "mouseenter";
287    const pointerLeave = hasPointerEvents ? "pointerleave" : hasTouch ? "" : "mouseleave";
288    const pointerCancel = hasPointerEvents ? "pointercancel" : "touchcancel";
289
290    const voidElements = {
291      area: true,
292      base: true,
293      br: true,
294      col: true,
295      embed: true,
296      hr: true,
297      img: true,
298      input: true,
299      keygen: true,
300      link: true,
301      meta: true,
302      param: true,
303      source: true,
304      track: true,
305      wbr: true
306    };
307    function isVoidElement(element) {
308      return toNodes(element).some((element2) => voidElements[element2.tagName.toLowerCase()]);
309    }
310    const isVisibleFn = inBrowser && Element.prototype.checkVisibility || function() {
311      return this.offsetWidth || this.offsetHeight || this.getClientRects().length;
312    };
313    function isVisible(element) {
314      return toNodes(element).some((element2) => isVisibleFn.call(element2));
315    }
316    const selInput = "input,select,textarea,button";
317    function isInput(element) {
318      return toNodes(element).some((element2) => matches(element2, selInput));
319    }
320    const selFocusable = `${selInput},a[href],[tabindex]`;
321    function isFocusable(element) {
322      return matches(element, selFocusable);
323    }
324    function parent(element) {
325      var _a;
326      return (_a = toNode(element)) == null ? void 0 : _a.parentElement;
327    }
328    function filter$1(element, selector) {
329      return toNodes(element).filter((element2) => matches(element2, selector));
330    }
331    function matches(element, selector) {
332      return toNodes(element).some((element2) => element2.matches(selector));
333    }
334    function parents(element, selector) {
335      const elements = [];
336      while (element = parent(element)) {
337        if (!selector || matches(element, selector)) {
338          elements.push(element);
339        }
340      }
341      return elements;
342    }
343    function children(element, selector) {
344      element = toNode(element);
345      const children2 = element ? toArray(element.children) : [];
346      return selector ? filter$1(children2, selector) : children2;
347    }
348    function index(element, ref) {
349      return ref ? toNodes(element).indexOf(toNode(ref)) : children(parent

528        e = new CustomEvent(e, { bubbles, cancelable, detail: detail2 });
529      }
530      return e;
531    }
532    function getArgs(args) {
533      args[0] = toEventTargets(args[0]);
534      if (isString(args[1])) {
535        args[1] = args[1].split(" ");
536      }
537      if (isFunction(args[2])) {
538        args.splice(2, 0, false);
539      }
540      return args;
541    }
542    function delegate(selector, listener) {
543      return (e) => {
544        const current = selector[0] === ">" ? findAll(selector, e.currentTarget).reverse().find((element) => element.contains(e.target)) : e.target.closest(selector);
545        if (current) {
546          e.current = current;
547          listener.call(this, e);
548          delete e.current;
549        }
550      };
551    }
552    function detail(listener) {
553      return (e) => isArray(e.detail) ? listener(e, ...e.detail) : listener(e);
554    }
555    function selfFilter(listener) {
556      return function(e) {
557        if (e.target === e.currentTarget || e.target === e.current) {
558          return listener.call(null, e);
559        }
560      };
561    }
562    function isEventTarget(target) {
563      return target && "addEventListener" in target;
564    }
565    function toEventTarget(target) {
566      return isEventTarget(target) ? target : toNode(target);
567    }
568    function toEventTargets(target) {
569      return isArray(target) ? target.map(toEventTarget).filter(Boolean) : isString(target) ? findAll(target) : isEventTarget(target) ? [target] : toNodes(target);
570    }
571    function isTouch(e) {
572      return e.pointerType === "touch" || !!e.touches;
573    }
574    function getEventPos(e) {
575      var _a, _b;
576      const { clientX: x, clientY: y } = ((_a = e.touches) == null ? void 0 : _a[0]) || ((_b = e.changedTouches) == null ? void 0 : _b[0]) || e;
577      return { x, y };
578    }
579
580    const cssNumber = {
581      "animation-iteration-count": true,
582      "column-count": true,
583      "fill-opacity": true,
584      "flex-grow": true,
585      "flex-shrink": true,
586      "font-weight": true,
587      "line-height": true,
588      opacity: true,
589      order: true,
590      orphans: true,
591      "stroke-dasharray": true,
592      "stroke-dashoffset": true,
593      widows: true,
594      "z-index": true,
595      zoom: true
596    };
597    function css(element, property, value, priority) {
598      const elements = toNodes(element);
599      for (const element2 of elements) {
600        if (isString(property)) {
601          property = propName(property);
602          if (isUndefined(value)) {
603            return getComputedStyle(element2).getPropertyValue(property);
604          } else {
605            element2.style.setProperty(
606              property,
607              isNumeric(value) && !cssNumber[property] ? `${value}px` : value || isNumber(value) ? value : "",
608              priority
609            );
610          }
611        } else if (isArray(property)) {
612          const props = {};
613          for (const prop of property) {
614            props[prop] = css(element2, prop);
615          }
616          return props;
617        } else if (isObject(property)) {
618          for (const prop in property) {
619            css(element2, prop, property[prop], value);
620          }
621        }
622      }
623      return elements[0];
624    }
625    const propName = memoize((name) => {
626      if (startsWith(name, "--")) {
627        return name;
628      }
629      name = hyphenate(name);
630      const { style } = document.documentElement;
631      if (name in style) {
632        return name;
633      }
634      for (const prefix of ["webkit", "moz"]) {
635        const prefixedName = `-${prefix}-${name}`;
636        if (prefixedName in style) {
637          return prefixedName;
638        }
639      }
640    });
641
642    const clsTransition = "uk-transition";
643    const transitionEnd = "transitionend";
644    const transitionCanceled = "transitioncanceled";
645    function transition$1(element, props, duration = 400, timing = "linear") {
646      duration = Math.round(duration);
647      return Promise.all(
648        toNodes(element).map(
649          (element2) => new Promise((resolve, reject) => {
650            for (const name in props) {
651              const value = css(element2, name);
652              if (value === "") {
653                css(element2, name, value);
654              }
655            }
656            const timer = setTimeout(() => trigger(element2, transitionEnd), duration);
657            once(
658              element2,
659              [transitionEnd, transitionCanceled],
660              ({ type }) => {
661                clearTimeout(timer);
662                removeClass(element2, clsTransition);
663                css(element2, {
664                  transitionProperty: "",
665                  transitionDuration: "",
666                  transitionTimingFunction: ""
667                });
668                type === transitionCanceled ? reject() : resolve(element2);
669              },
670              { self: true }
671            );
672            addClass(element2, clsTransition);
673            css(element2, {
674              transitionProperty: Object.keys(props).map(propName).join(","),
675              transitionDuration: `${duration}ms`,
676              transitionTimingFunction: timing,
677              ...props
678            });
679          })
680        )
681      );
682    }
683    const Transition = {
684      start: transition$1,
685      async stop(element) {
686        trigger(element, transitionEnd);
687        await Promise.resolve();
688      },
689      async cancel(element) {
690        trigger(element, transitionCanceled);
691        await Promise.resolve();
692      },
693      inProgress(element) {
694        return hasClass(element, clsTransition);
695      }
696    };
697    const animationPrefix = "uk-animation-";
698    const animationEnd = "animationend";
699    const animationCanceled = "animationcanceled";
700    function animate$2(element, animation, duration = 200, origin, out) {
701      return Promise.all(
702        toNodes(element).map(
703          (element2) => new Promise((resolve, reject) => {
704            trigger(element2, animationCanceled);
705            const timer = setTimeout(() => trigger(element2, animationEnd), duration);
706            once(
707              element2,
708              [animationEnd, animationCanceled],
709              ({ type }) => {
710                clearTimeout(timer);
711                type === animationCanceled ? reject() : resolve(element2);
712                css(element2, "animationDuration", "");
713                removeClasses(element2, `${animationPrefix}\\S*`);
714              },
715              { self: true }
716            );
717            css(element2, "animationDuration", `${duration}ms`);
718            addClass(element2, animation, animationPrefix + (out ? "leave" : "enter"));
719            if (startsWith(animation, animationPrefix)) {
720              origin && addClass(element2, `uk-transform-origin-${origin}`);
721              out && addClass(element2, `${animationPrefix}reverse`);
722            }
723          })
724        )
725      );
726    }
727    const inProgressRe = new RegExp(`${animationPrefix}(enter|leave)`);
728    const Animation = {
729      in: animate$2,
730      out(element, animation, duration, origin) {
731        return animate$2(element, animation, duration, origin, true);
732      },
733      inProgress(element) {
734        return inProgressRe.test(attr(element, "class"));
735      },
736      cancel(element) {
737        trigger(element, animationCanceled);
738      }
739    };
740
741    function ready(fn) {
742      if (document.readyState !== "loading") {
743        fn();
744        return;
745      }
746      once(document, "DOMContentLoaded", fn);
747    }
748    function isTag(element, ...tagNames) {
749      return tagNames.some((tagName) => {
750        var _a;
751        return ((_a = element == null ? void 0 : element.tagName) == null ? void 0 : _a.toLowerCase()) === tagName.toLowerCase();
752      });
753    }
754    function empty(element) {
755      element = $(element);
756      element.innerHTML = "";
757      return element;
758    }
759    function html(parent2, html2) {
760      return isUndefined(html2) ? $(parent2).innerHTML : append(empty(parent2), html2);
761    }
762    const prepend = applyFn("prepend");
763    const append = applyFn("append");
764    const before = applyFn("before");
765    const after = applyFn("after");
766    function applyFn(fn) {
767      return function(ref, element) {
768        var _a;
769        const nodes = toNodes(isString(element) ? fragment(element) : element);

770        (_a = $(ref)) == null ? void 0 : _a[fn](...nodes);
771        return unwrapSingle(nodes);
772      };
773    }
774    function remove$1(element) {
775      toNodes(element).forEach((element2) => element2.remove());
776    }
777    function wrapAll(element, structure) {
778      structure = toNode(before(element, structure));
779      while (structure.firstElementChild) {
780        structure = structure.firstElementChild;
781      }
782      append(structure, element);
783      return structure;
784    }
785    function wrapInner(element, structure) {
786      return toNodes(
787        toNodes(element).map(
788          (element2) => element2.hasChildNodes() ? wrapAll(toArray(element2.childNodes), structure) : append(element2, structure)
789        )
790      );
791    }
792    function unwrap(element) {
793      toNodes(element).map(parent).filter((value, index, self) => self.indexOf(value) === index).forEach((parent2) => parent2.replaceWith(...parent2.childNodes));
794    }
795    const singleTagRe = /^<(\w+)\s*\/?>(?:<\/\1>)?$/;
796    function fragment(html2) {
797      const matches = singleTagRe.exec(html2);
798      if (matches) {
799        return document.createElement(matches[1]);
800      }
801      const container = document.createElement("template");
802      container.innerHTML = html2.trim();
803      return unwrapSingle(container.content.childNodes);
804    }
805    function unwrapSingle(nodes) {
806      return nodes.length > 1 ? nodes : nodes[0];
807    }
808    function apply(node, fn) {
809      if (!isElement(node)) {
810        return;
811      }
812      fn(node);
813      node = node.firstElementChild;
814      while (node) {
815        const next = node.nextElementSibling;
816        apply(node, fn);
817        node = next;
818      }
819    }
820    function $(selector, context) {
821      return isHtml(selector) ? toNode(fragment(selector)) : find(selector, context);
822    }
823    function $$(selector, context) {
824      return isHtml(selector) ? toNodes(fragment(selector)) : findAll(selector, context);
825    }
826    function isHtml(str) {
827      return isString(str) && startsWith(str.trim(), "<");
828    }
829
830    const dirs$1 = {
831      width: ["left", "right"],
832      height: ["top", "bottom"]
833    };
834    function dimensions$1(element) {
835      const rect = isElement(element) ? toNode(element).getBoundingClientRect() : { height: height(element), width: width(element), top: 0, left: 0 };
836      return {
837        height: rect.height,
838        width: rect.width,
839        top: rect.top,
840        left: rect.left,
841        bottom: rect.top + rect.height,
842        right: rect.left + rect.width
843      };
844    }
845    function offset(element, coordinates) {
846      if (coordinates) {
847        css(element, { left: 0, top: 0 });
848      }
849      const currentOffset = dimensions$1(element);
850      if (element) {
851        const { scrollY, scrollX } = toWindow(element);
852        const offsetBy = { height: scrollY, width: scrollX };
853        for (const dir in dirs$1) {
854          for (const prop of dirs$1[dir]) {
855            currentOffset[prop] += offsetBy[dir];
856          }
857        }
858      }
859      if (!coordinates) {
860        return currentOffset;
861      }
862      for (const prop of ["left", "top"]) {
863        css(element, prop, coordinates[prop] - currentOffset[prop]);
864      }
865    }
866    function position(element) {
867      let { top, left } = offset(element);
868      const {
869        ownerDocument: { body, documentElement },
870        offsetParent
871      } = toNode(element);
872      let parent = offsetParent || documentElement;
873      while (parent && (parent === body || parent === documentElement) && css(parent, "position") === "static") {
874        parent = parent.parentNode;
875      }
876      if (isElement(parent)) {
877        const parentOffset = offset(parent);
878        top -= parentOffset.top + toFloat(css(parent, "borderTopWidth"));
879        left -= parentOffset.left + toFloat(css(parent, "borderLeftWidth"));
880      }
881      return {
882        top: top - toFloat(css(element, "marginTop")),
883        left: left - toFloat(css(element, "marginLeft"))
884      };
885    }
886    function offsetPosition(element) {
887      element = toNode(element);
888      const offset2 = [element.offsetTop, element.offsetLeft];
889      while (element = element.offsetParent) {
890        offset2[0] += element.offsetTop + toFloat(css(element, `borderTopWidth`));
891        offset2[1] += element.offsetLeft + toFloat(css(element, `borderLeftWidth`));
892        if (css(element, "position") === "fixed") {
893          const win = toWindow(element);
894          offset2[0] += win.scrollY;
895          offset2[1] += win.scrollX;
896          return offset2;
897        }
898      }
899      return offset2;
900    }
901    const height = dimension("height");
902    const width = dimension("width");
903    function dimension(prop) {
904      const propName = ucfirst(prop);
905      return (element, value) => {
906        if (isUndefined(value)) {
907          if (isWindow(element)) {
908            return element[`inner${propName}`];
909          }
910          if (isDocument(element)) {
911            const doc = element.documentElement;
912            return Math.max(doc[`offset${propName}`], doc[`scroll${propName}`]);
913          }
914          element = toNode(element);
915          value = css(element, prop);
916          value = value === "auto" ? element[`offset${propName}`] : toFloat(value) || 0;
917          return value - boxModelAdjust(element, prop);
918        } else {
919          return css(
920            element,
921            prop,
922            !value && value !== 0 ? "" : +value + boxModelAdjust(element, prop) + "px"
923          );
924        }
925      };
926    }
927    function boxModelAdjust(element, prop, sizing = "border-box") {
928      return css(element, "boxSizing") === sizing ? sumBy(
929        dirs$1[prop].map(ucfirst),
930        (prop2) => toFloat(css(element, `padding${prop2}`)) + toFloat(css(element, `border${prop2}Width`))
931      ) : 0;
932    }
933    function flipPosition(pos) {
934      for (const dir in dirs$1) {
935        for (const i in dirs$1[dir]) {
936          if (dirs$1[dir][i] === pos) {
937            return dirs$1[dir][1 - i];
938          }
939        }
940      }
941      return pos;
942    }
943    function toPx(value, property = "width", element = window, offsetDim = false) {
944      if (!isString(value)) {
945        return toFloat(value);
946      }
947      return sumBy(parseCalc(value), (value2) => {
948        const unit = parseUnit(value2);
949        return unit ? percent(
950          unit === "vh" ? getViewportHeight() : unit === "vw" ? width(toWindow(element)) : offsetDim ? element[`offset${ucfirst(property)}`] : dimensions$1(element)[property],
951          value2
952        ) : value2;
953      });
954    }
955    const calcRe = /-?\d+(?:\.\d+)?(?:v[wh]|%|px)?/g;
956    const parseCalc = memoize((calc) => calc.toString().replace(/\s/g, "").match(calcRe) || []);
957    const unitRe$1 = /(?:v[hw]|%)$/;
958    const parseUnit = memoize((str) => (str.match(unitRe$1) || [])[0]);
959    function percent(base, value) {
960      return base * toFloat(value) / 100;
961    }
962    let vh;
963    let vhEl;
964    function getViewportHeight() {
965      if (vh) {
966        return vh;
967      }
968      if (!vhEl) {
969        vhEl = $("<div>");
970        css(vhEl, {
971          height: "100vh",
972          position: "fixed"
973        });
974        on(window, "resize", () => vh = null);
975      }
976      append(document.body, vhEl);
977      vh = vhEl.clientHeight;
978      remove$1(vhEl);
979      return vh;
980    }
981
982    const fastdom = {
983      reads: [],
984      writes: [],
985      read(task) {
986        this.reads.push(task);
987        scheduleFlush();
988        return task;
989      },
990      write(task) {
991        this.writes.push(task);
992        scheduleFlush();
993        return task;
994      },
995      clear(task) {
996        remove(this.reads, task);
997        remove(this.writes, task);
998      },
999      flush
1000    };
1001    function flush() {
1002      runTasks(fastdom.reads);
1003      runTasks(fastdom.writes.splice(0));
1004      fastdom.scheduled = false;
1005      if (fastdom.reads.length || fastdom.writes.length) {
1006        scheduleFlush();
1007      }
1008    }
1009    function scheduleFlush() {
1010      if (!fastdom.scheduled) {
1011        fastdom.scheduled = true;
1012        queueMicrotask(flush);
1013      }
1014    }
1015    function runTasks(tasks) {
1016      let task;
1017      while (task = tasks.shift()) {
1018        try {
1019          task();
1020        } catch (e) {
1021          console.error(e);
1022        }
1023      }
1024    }
1025    function remove(array, item) {
1026      const index = array.indexOf(item);
1027      return ~index && array.splice(index, 1);
1028    }
1029
1030    class MouseTracker {
1031      init() {
1032        this.positions = [];
1033        let position;
1034        this.unbind = on(document, "mousemove", (e) => position = getEventPos(e));
1035        this.interval = setInterval(() => {
1036          if (!position) {
1037            return;
1038          }
1039          this.positions.push(position);
1040          if (this.positions.length > 5) {
1041            this.positions.shift();
1042          }
1043        }, 50);
1044      }
1045      cancel() {
1046        var _a;
1047        (_a = this.unbind) == null ? void 0 : _a.call(this);
1048        clearInterval(this.interval);
1049      }
1050      movesTo(target) {
1051        if (!this.positions || this.positions.length < 2) {
1052          return false;
1053        }
1054        const p = dimensions$1(target);
1055        const { left, right, top, bottom } = p;
1056        const [prevPosition] = this.positions;
1057        const position = last(this.positions);
1058        const path = [prevPosition, position];
1059        if (pointInRect(position, p)) {
1060          return false;
1061        }
1062        const diagonals = [
1063          [
1064            { x: left, y: top },
1065            { x: right, y: bottom }
1066          ],
1067          [
1068            { x: left, y: bottom },
1069            { x: right, y: top }
1070          ]
1071        ];
1072        return diagonals.some((diagonal) => {
1073          const intersection = intersect(path, diagonal);
1074          return intersection && pointInRect(intersection, p);
1075        });
1076      }
1077    }
1078    function intersect([{ x: x1, y: y1 }, { x: x2, y: y2 }], [{ x: x3, y: y3 }, { x: x4, y: y4 }]) {
1079      const denominator = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
1080      if (denominator === 0) {
1081        return false;
1082      }
1083      const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator;
1084      if (ua < 0) {
1085        return false;

1086      }
1087      return { x: x1 + ua * (x2 - x1), y: y1 + ua * (y2 - y1) };
1088    }
1089
1090    function observeIntersection(targets, cb, options = {}, { intersecting = true } = {}) {
1091      const observer = new IntersectionObserver(
1092        intersecting ? (entries, observer2) => {
1093          if (entries.some((entry) => entry.isIntersecting)) {
1094            cb(entries, observer2);
1095          }
1096        } : cb,
1097        options
1098      );
1099      for (const el of toNodes(targets)) {
1100        observer.observe(el);
1101      }
1102      return observer;
1103    }
1104    const hasResizeObserver = inBrowser && window.ResizeObserver;
1105    function observeResize(targets, cb, options = { box: "border-box" }) {
1106      if (hasResizeObserver) {
1107        return observe$1(ResizeObserver, targets, cb, options);
1108      }
1109      const off = [on(window, "load resize", cb), on(document, "loadedmetadata load", cb, true)];
1110      return { disconnect: () => off.map((cb2) => cb2()) };
1111    }
1112    function observeViewportResize(cb) {
1113      return { disconnect: on([window, window.visualViewport], "resize", cb) };
1114    }
1115    function observeMutation(targets, cb, options) {
1116      return observe$1(MutationObserver, targets, cb, options);
1117    }
1118    function observe$1(Observer, targets, cb, options) {
1119      const observer = new Observer(cb);
1120      for (const el of toNodes(targets)) {
1121        observer.observe(el, options);
1122      }
1123      return observer;
1124    }
1125
1126    function play(el) {
1127      if (isIFrame(el)) {
1128        call(el, { func: "playVideo", method: "play" });
1129      }
1130      if (isHTML5(el)) {
1131        el.play();
1132      }
1133    }
1134    function pause(el) {
1135      if (isIFrame(el)) {
1136        call(el, { func: "pauseVideo", method: "pause" });
1137      }
1138      if (isHTML5(el)) {
1139        el.pause();
1140      }
1141    }
1142    function mute(el) {
1143      if (isIFrame(el)) {
1144        call(el, { func: "mute", method: "setVolume", value: 0 });
1145      }
1146      if (isHTML5(el)) {
1147        el.muted = true;
1148      }
1149    }
1150    function isVideo(el) {
1151      return isHTML5(el) || isIFrame(el);
1152    }
1153    function isHTML5(el) {
1154      return isTag(el, "video");
1155    }
1156    function isIFrame(el) {
1157      return isTag(el, "iframe") && (isYoutube(el) || isVimeo(el));
1158    }
1159    function isYoutube(el) {
1160      return !!el.src.match(
1161        /\/\/.*?youtube(-nocookie)?\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/
1162      );
1163    }
1164    function isVimeo(el) {
1165      return !!el.src.match(/vimeo\.com\/video\/.*/);
1166    }
1167    async function call(el, cmd) {
1168      await enableApi(el);
1169      post(el, cmd);
1170    }
1171    function post(el, cmd) {
1172      el.contentWindow.postMessage(JSON.stringify({ event: "command", ...cmd }), "*");
1173    }
1174    const stateKey = "_ukPlayer";
1175    let counter = 0;
1176    function enableApi(el) {
1177      if (el[stateKey]) {
1178        return el[stateKey];
1179      }
1180      const youtube = isYoutube(el);
1181      const vimeo = isVimeo(el);
1182      const id = ++counter;
1183      let poller;
1184      return el[stateKey] = new Promise((resolve) => {
1185        youtube && once(el, "load", () => {
1186          const listener = () => post(el, { event: "listening", id });
1187          poller = setInterval(listener, 100);
1188          listener();
1189        });
1190        once(window, "message", resolve, false, ({ data }) => {
1191          try {
1192            data = JSON.parse(data);
1193            return youtube && (data == null ? void 0 : data.id) === id && data.event === "onReady" || vimeo && Number(data == null ? void 0 : data.player_id) === id;
1194          } catch (e) {
1195          }
1196        });
1197        el.src = `${el.src}${includes(el.src, "?") ? "&" : "?"}${youtube ? "enablejsapi=1" : `api=1&player_id=${id}`}`;
1198      }).then(() => clearInterval(poller));
1199    }
1200
1201    function isInView(element, offsetTop = 0, offsetLeft = 0) {
1202      if (!isVisible(element)) {
1203        return false;
1204      }
1205      return intersectRect(
1206        ...overflowParents(element).map((parent2) => {
1207          const { top, left, bottom, right } = offsetViewport(parent2);
1208          return {
1209            top: top - offsetTop,
1210            left: left - offsetLeft,
1211            bottom: bottom + offsetTop,
1212            right: right + offsetLeft
1213          };
1214        }).concat(offset(element))
1215      );
1216    }
1217    function scrollIntoView(element, { offset: offsetBy = 0 } = {}) {
1218      const parents2 = isVisible(element) ? scrollParents(element, false, ["hidden"]) : [];
1219      return parents2.reduce(
1220        (fn, scrollElement, i) => {
1221          const { scrollTop, scrollHeight, offsetHeight } = scrollElement;
1222          const viewport = offsetViewport(scrollElement);
1223          const maxScroll = scrollHeight - viewport.height;
1224          const { height: elHeight, top: elTop } = parents2[i - 1] ? offsetViewport(parents2[i - 1]) : offset(element);
1225          let top = Math.ceil(elTop - viewport.top - offsetBy + scrollTop);
1226          if (offsetBy > 0 && offsetHeight < elHeight + offsetBy) {
1227            top += offsetBy;
1228          } else {
1229            offsetBy = 0;
1230          }
1231          if (top > maxScroll) {
1232            offsetBy -= top - maxScroll;
1233            top = maxScroll;
1234          } else if (top < 0) {
1235            offsetBy -= top;
1236            top = 0;
1237          }
1238          return () => scrollTo(scrollElement, top - scrollTop, element, maxScroll).then(fn);
1239        },
1240        () => Promise.resolve()
1241      )();
1242      function scrollTo(element2, top, targetEl, maxScroll) {
1243        return new Promise((resolve) => {
1244          const scroll = element2.scrollTop;
1245          const duration = getDuration(Math.abs(top));
1246          const start = Date.now();
1247          const isScrollingElement = scrollingElement(element2) === element2;
1248          const targetTop = offset(targetEl).top + (isScrollingElement ? 0 : scroll);
1249          let prev = 0;
1250          let frames = 15;
1251          (function step() {
1252            const percent = ease(clamp((Date.now() - start) / duration));
1253            let diff = 0;
1254            if (parents2[0] === element2 && scroll + top < maxScroll) {
1255              diff = offset(targetEl).top + (isScrollingElement ? 0 : element2.scrollTop) - targetTop;
1256              const coverEl = getCoveringElement(targetEl);
1257              diff -= coverEl ? offset(coverEl).height : 0;
1258            }
1259            element2.scrollTop = scroll + (top + diff) * percent;
1260            if (percent === 1 && (prev === diff || !frames--)) {
1261              resolve();
1262            } else {
1263              prev = diff;
1264              requestAnimationFrame(step);
1265            }
1266          })();
1267        });
1268      }
1269      function getDuration(dist) {
1270        return 40 * Math.pow(dist, 0.375);
1271      }
1272      function ease(k) {
1273        return 0.5 * (1 - Math.cos(Math.PI * k));
1274      }
1275    }
1276    function scrolledOver(element, startOffset = 0, endOffset = 0) {
1277      if (!isVisible(element)) {
1278        return 0;
1279      }
1280      const scrollElement = scrollParent(element, true);
1281      const { scrollHeight, scrollTop } = scrollElement;

1282      const { height: viewportHeight } = offsetViewport(scrollElement);
1283      const maxScroll = scrollHeight - viewportHeight;
1284      const elementOffsetTop = offsetPosition(element)[0] - offsetPosition(scrollElement)[0];
1285      const start = Math.max(0, elementOffsetTop - viewportHeight + startOffset);
1286      const end = Math.min(maxScroll, elementOffsetTop + element.offsetHeight - endOffset);
1287      return start < end ? clamp((scrollTop - start) / (end - start)) : 1;
1288    }
1289    function scrollParents(element, scrollable = false, props = []) {
1290      const scrollEl = scrollingElement(element);
1291      let ancestors = parents(element).reverse();
1292      ancestors = ancestors.slice(ancestors.indexOf(scrollEl) + 1);
1293      const fixedIndex = findIndex(ancestors, (el) => css(el, "position") === "fixed");
1294      if (~fixedIndex) {
1295        ancestors = ancestors.slice(fixedIndex);
1296      }
1297      return [scrollEl].concat(
1298        ancestors.filter(
1299          (parent2) => css(parent2, "overflow").split(" ").some((prop) => includes(["auto", "scroll", ...props], prop)) && (!scrollable || parent2.scrollHeight > offsetViewport(parent2).height)
1300        )
1301      ).reverse();
1302    }
1303    function scrollParent(...args) {
1304      return scrollParents(...args)[0];
1305    }
1306    function overflowParents(element) {
1307      return scrollParents(element, false, ["hidden", "clip"]);
1308    }
1309    function offsetViewport(scrollElement) {
1310      const window = toWindow(scrollElement);
1311      let viewportElement = scrollElement === scrollingElement(scrollElement) ? window : scrollElement;
1312      if (isWindow(viewportElement) && window.visualViewport) {
1313        let { height, width, scale, pageTop: top, pageLeft: left } = window.visualViewport;
1314        height = Math.round(height * scale);
1315        width = Math.round(width * scale);
1316        return { height, width, top, left, bottom: top + height, right: left + width };
1317      }
1318      let rect = offset(viewportElement);
1319      if (css(viewportElement, "display") === "inline") {
1320        return rect;
1321      }
1322      for (let [prop, dir, start, end] of [
1323        ["width", "x", "left", "right"],
1324        ["height", "y", "top", "bottom"]
1325      ]) {
1326        if (isWindow(viewportElement)) {
1327          viewportElement = scrollElement.ownerDocument;
1328        } else {
1329          rect[start] += toFloat(css(viewportElement, `border-${start}-width`));
1330        }
1331        const subpixel = rect[prop] % 1;
1332        rect[prop] = rect[dir] = viewportElement[`client${ucfirst(prop)}`] - (subpixel ? subpixel < 0.5 ? -subpixel : 1 - subpixel : 0);
1333        rect[end] = rect[prop] + rect[start];
1334      }
1335      return rect;
1336    }
1337    function getCoveringElement(target) {
1338      const { left, width, top } = dimensions$1(target);
1339      for (const topPosition of [0, top]) {
1340        const coverEl = target.ownerDocument.elementsFromPoint(left + width / 2, topPosition).find(
1341          (el) => !el.contains(target) && // If e.g. Offcanvas is not yet closed
1342          !hasClass(el, "uk-togglable-leave") && (hasPosition(el, "fixed") && zIndex(
1343            parents(target).reverse().find(
1344              (parent2) => !parent2.contains(el) && !hasPosition(parent2, "static")
1345            )
1346          ) < zIndex(el) || hasPosition(el, "sticky") && parent(el).contains(target))
1347        );
1348        if (coverEl) {
1349          return coverEl;
1350        }
1351      }
1352    }
1353    function zIndex(element) {
1354      return toFloat(css(element, "zIndex"));
1355    }
1356    function hasPosition(element, position) {
1357      return css(element, "position") === position;
1358    }
1359    function scrollingElement(element) {
1360      return toWindow(element).document.scrollingElement;
1361    }
1362
1363    const dirs = [
1364      ["width", "x", "left", "right"],
1365      ["height", "y", "top", "bottom"]
1366    ];
1367    function positionAt(element, target, options) {
1368      options = {
1369        attach: {
1370          element: ["left", "top"],
1371          target: ["left", "top"],
1372          ...options.attach
1373        },
1374        offset: [0, 0],
1375        placement: [],
1376        ...options
1377      };
1378      if (!isArray(target)) {
1379        target = [target, target];
1380      }
1381      offset(element, getPosition(element, target, options));
1382    }
1383    function getPosition(element, target, options) {
1384      const position = attachTo(element, target, options);
1385      const { boundary, viewportOffset = 0, placement } = options;
1386      let offsetPosition = position;
1387      for (const [i, [prop, , start, end]] of Object.entries(dirs)) {
1388        const viewport = getViewport$2(element, target[i], viewportOffset, boundary, i);
1389        if (isWithin(position, viewport, i)) {
1390          continue;
1391        }
1392        let offsetBy = 0;
1393        if (placement[i] === "flip") {
1394          const attach = options.attach.target[i];
1395          if (attach === end && position[end] <= viewport[end] || attach === start && position[start] >= viewport[start]) {
1396            continue;
1397          }
1398          offsetBy = flip(element, target, options, i)[start] - position[start];
1399          const scrollArea = getScrollArea(element, target[i], viewportOffset, i);
1400          if (!isWithin(applyOffset(position, offsetBy, i), scrollArea, i)) {
1401            if (isWithin(position, scrollArea, i)) {
1402              continue;
1403            }
1404            if (options.recursion) {
1405              return false;
1406            }
1407            const newPos = flipAxis(element, target, options);
1408            if (newPos && isWithin(newPos, scrollArea, 1 - i)) {
1409              return newPos;
1410            }
1411            continue;
1412          }
1413        } else if (placement[i] === "shift") {
1414          const targetDim = offset(target[i]);
1415          const { offset: elOffset } = options;
1416          offsetBy = clamp(
1417            clamp(position[start], viewport[start], viewport[end] - position[prop]),
1418            targetDim[start] - position[prop] + elOffset[i],
1419            targetDim[end] - elOffset[i]
1420          ) - position[start];
1421        }
1422        offsetPosition = applyOffset(offsetPosition, offsetBy, i);
1423      }
1424      return offsetPosition;
1425    }
1426    function attachTo(element, target, options) {
1427      let { attach, offset: offsetBy } = {
1428        attach: {
1429          element: ["left", "top"],
1430          target: ["left", "top"],
1431          ...options.attach
1432        },
1433        offset: [0, 0],
1434        ...options
1435      };
1436      let elOffset = offset(element);
1437      for (const [i, [prop, , start, end]] of Object.entries(dirs)) {
1438        const targetOffset = attach.target[i] === attach.element[i] ? offsetViewport(target[i]) : offset(target[i]);
1439        elOffset = applyOffset(
1440          elOffset,
1441          targetOffset[start] - elOffset[start] + moveBy(attach.target[i], end, targetOffset[prop]) - moveBy(attach.element[i], end, elOffset[prop]) + +offsetBy[i],
1442          i
1443        );
1444      }
1445      return elOffset;
1446    }
1447    function applyOffset(position, offset2, i) {
1448      const [, dir, start, end] = dirs[i];
1449      const newPos = { ...position };
1450      newPos[start] = position[dir] = position[start] + offset2;
1451      newPos[end] += offset2;
1452      return newPos;
1453    }
1454    function moveBy(attach, end, dim) {
1455      return attach === "center" ? dim / 2 : attach === end ? dim : 0;
1456    }
1457    function getViewport$2(element, target, viewportOffset, boundary, i) {
1458      let viewport = getIntersectionArea(...commonScrollParents(element, target).map(offsetViewport));
1459      if (viewportOffset) {
1460        viewport[dirs[i][2]] += viewportOffset;
1461        viewport[dirs[i][3]] -= viewportOffset;
1462      }
1463      if (boundary) {
1464        viewport = getIntersectionArea(
1465          viewport,
1466          offset(isArray(boundary) ? boundary[i] : boundary)
1467        );
1468      }
1469      return viewport;
1470    }
1471    function getScrollArea(element, target, viewportOffset, i) {
1472      const [prop, axis, start, end] = dirs[i];
1473      const [scrollElement] = commonScrollParents(element, target);
1474      const viewport = offsetViewport(scrollElement);
1475      if (["auto", "scroll"].includes(css(scrollElement, `overflow-${axis}`))) {
1476        viewport[start] -= scrollElement[`scroll${ucfirst(start)}`];
1477        viewport[end] = viewport[start] + scrollElement[`scroll${ucfirst(prop)}`];
1478      }
1479      viewport[start] += viewportOffset;
1480      viewport[end] -= viewportOffset;
1481      return viewport;
1482    }
1483    function commonScrollParents(element, target) {
1484      return overflowParents(target).filter((parent) => parent.contains(element));
1485    }
1486    function getIntersectionArea(...rects) {
1487      let area = {};
1488      for (const rect of rects) {
1489        for (const [, , start, end] of dirs) {
1490          area[start] = Math.max(area[start] || 0, rect[start]);
1491          area[end] = Math.min(...[area[end], rect[end]].filter(Boolean));
1492        }
1493      }
1494      return area;
1495    }
1496    function isWithin(positionA, positionB, i) {
1497      const [, , start, end] = dirs[i];
1498      return positionA[start] >= positionB[start] && positionA[end] <= positionB[end];
1499    }
1500    function flip(element, target, { offset: offset2, attach }, i) {
1501      return attachTo(element, target, {
1502        attach: {
1503          element: flipAttach(attach.element, i),
1504          target: flipAttach(attach.target, i)
1505        },
1506        offset: flipOffset(offset2, i)
1507      });
1508    }
1509    function flipAxis(element, target, options) {
1510      return getPosition(element, target, {
1511        ...options,
1512        attach: {
1513          element: options.attach.element.map(flipAttachAxis).reverse(),
1514          target: options.attach.target.map(flipAttachAxis).reverse()
1515        },
1516        offset: options.offset.reverse(),
1517        placement: options.placement.reverse(),
1518        recursion: true
1519      });
1520    }
1521    function flipAttach(attach, i) {
1522      const newAttach = [...attach];
1523      const index = dirs[i].indexOf(attach[i]);
1524      if (~index) {
1525        newAttach[i] = dirs[i][1 - index % 2 + 2];
1526      }
1527      return newAttach;
1528    }
1529    function flipAttachAxis(prop) {
1530      for (let i = 0; i < dirs.length; i++) {
1531        const index = dirs[i].indexOf(prop);
1532        if (~index) {
1533          return dirs[1 - i][index % 2 + 2];
1534        }
1535      }
1536    }
1537    function flipOffset(offset2, i) {
1538      offset2 = [...offset2];
1539      offset2[i] *= -1;
1540      return offset2;
1541    }
1542
1543    var util = /*#__PURE__*/Object.freeze({
1544        __proto__: null,
1545        $: $,
1546        $$: $$,
1547        Animation: Animation,
1548        Dimensions: Dimensions,
1549        MouseTracker: MouseTracker,
1550        Transition: Transition,
1551        addClass: addClass,
1552        after: after,
1553        append: append,
1554        apply: apply,
1555        assign: assign,
1556        attr: attr,
1557        before: before,
1558        boxModelAdjust: boxModelAdjust,
1559        camelize: camelize,
1560        children: children,
1561        clamp: clamp,
1562        createEvent: createEvent,
1563        css: css,
1564        data: data,
1565        dimensions: dimensions$1,
1566        each: each,
1567        empty: empty,
1568        endsWith: endsWith,
1569        escape: escape,
1570        fastdom: fastdom,
1571        filter: filter$1,
1572        find: find,
1573        findAll: findAll,
1574        findIndex: findIndex,
1575        flipPosition: flipPosition,
1576        fragment: fragment,
1577        getCoveringElement: getCoveringElement,
1578        getEventPos: getEventPos,
1579        getIndex: getIndex,
1580        getTargetedElement: getTargetedElement,
1581        hasAttr: hasAttr,
1582        hasClass: hasClass,
1583        hasOwn: hasOwn,
1584        hasTouch: hasTouch,
1585        height: height,
1586        html: html,
1587        hyphenate: hyphenate,
1588        inBrowser: inBrowser,
1589        includes: includes,
1590        index: index,
1591        intersectRect: intersectRect,
1592        isArray: isArray,
1593        isBoolean: isBoolean,
1594        isDocument: isDocument,
1595        isElement: isElement,
1596        isEmpty: isEmpty,
1597        isEqual: isEqual,
1598        isFocusable: isFocusable,
1599        isFunction: isFunction,
1600        isInView: isInView,

1762              digits.forEach((digit, i) => el.children[i].textContent = digit);
1763            }
1764          }
1765        }
1766      }
1767    };
1768    function getTimeSpan(date) {
1769      const total = Math.max(0, date - Date.now()) / 1e3;
1770      return {
1771        total,
1772        seconds: total % 60,
1773        minutes: total / 60 % 60,
1774        hours: total / 60 / 60 % 24,
1775        days: total / 60 / 60 / 24
1776      };
1777    }
1778
1779    const strats = {};
1780    strats.events = strats.watch = strats.observe = strats.created = strats.beforeConnect = strats.connected = strats.beforeDisconnect = strats.disconnected = strats.destroy = concatStrat;
1781    strats.args = function(parentVal, childVal) {
1782      return childVal !== false && concatStrat(childVal || parentVal);
1783    };
1784    strats.update = function(parentVal, childVal) {
1785      return sortBy(
1786        concatStrat(parentVal, isFunction(childVal) ? { read: childVal } : childVal),
1787        "order"
1788      );
1789    };
1790    strats.props = function(parentVal, childVal) {
1791      if (isArray(childVal)) {
1792        const value = {};
1793        for (const key of childVal) {
1794          value[key] = String;
1795        }
1796        childVal = value;
1797      }
1798      return strats.methods(parentVal, childVal);
1799    };
1800    strats.computed = strats.methods = function(parentVal, childVal) {
1801      return childVal ? parentVal ? { ...parentVal, ...childVal } : childVal : parentVal;
1802    };
1803    strats.i18n = strats.data = function(parentVal, childVal, vm) {
1804      if (!vm) {
1805        if (!childVal) {
1806          return parentVal;
1807        }
1808        if (!parentVal) {
1809          return childVal;
1810        }
1811        return function(vm2) {
1812          return mergeFnData(parentVal, childVal, vm2);
1813        };
1814      }
1815      return mergeFnData(parentVal, childVal, vm);
1816    };
1817    function mergeFnData(parentVal, childVal, vm) {
1818      return strats.computed(
1819        isFunction(parentVal) ? parentVal.call(vm, vm) : parentVal,
1820        isFunction(childVal) ? childVal.call(vm, vm) : childVal
1821      );
1822    }
1823    function concatStrat(parentVal, childVal) {
1824      parentVal = parentVal && !isArray(parentVal) ? [parentVal] : parentVal;
1825      return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal;
1826    }
1827    function defaultStrat(parentVal, childVal) {
1828      return isUndefined(childVal) ? parentVal : childVal;
1829    }
1830    function mergeOptions(parent, child, vm) {
1831      const options = {};
1832      if (isFunction(child)) {
1833        child = child.options;
1834      }
1835      if (child.extends) {
1836        parent = mergeOptions(parent, child.extends, vm);
1837      }
1838      if (child.mixins) {
1839        for (const mixin of child.mixins) {
1840          parent = mergeOptions(parent, mixin, vm);
1841        }
1842      }
1843      for (const key in parent) {
1844        mergeKey(key);
1845      }
1846      for (const key in child) {
1847        if (!hasOwn(parent, key)) {
1848          mergeKey(key);
1849        }
1850      }
1851      function mergeKey(key) {
1852        options[key] = (strats[key] || defaultStrat)(parent[key], child[key], vm);
1853      }
1854      return options;
1855    }
1856    function parseOptions(options, args = []) {
1857      try {
1858        return options ? startsWith(options, "{") ? JSON.parse(options) : args.length && !includes(options, ":") ? { [args[0]]: options } : options.split(";").reduce((options2, option) => {
1859          const [key, value] = option.split(/:(.*)/);
1860          if (key && !isUndefined(value)) {
1861            options2[key.trim()] = value.trim();
1862          }
1863          return options2;
1864        }, {}) : {};
1865      } catch (e) {
1866        return {};
1867      }
1868    }
1869    function coerce$1(type, value) {
1870      if (type === Boolean) {
1871        return toBoolean(value);
1872      } else if (type === Number) {
1873        return toNumber(value);
1874      } else if (type === "list") {
1875        return toList(value);
1876      } else if (type === Object && isString(value)) {
1877        return parseOptions(value);
1878      }
1879      return type ? type(value) : value;
1880    }
1881    const listRe = /,(?![^(]*\))/;
1882    function toList(value) {
1883      return isArray(value) ? value : isString(value) ? value.split(listRe).map((value2) => isNumeric(value2) ? toNumber(value2) : toBoolean(value2.trim())) : [value];
1884    }
1885
1886    function initUpdates(instance) {
1887      instance._data = {};
1888      instance._updates = [...instance.$options.update || []];
1889    }
1890    function prependUpdate(instance, update) {
1891      instance._updates.unshift(update);
1892    }
1893    function clearUpdateData(instance) {
1894      delete instance._data;
1895    }
1896    function callUpdate(instance, e = "update") {
1897      if (!instance._connected) {
1898        return;
1899      }
1900      if (!instance._updates.length) {
1901        return;
1902      }
1903      if (!instance._queued) {
1904        instance._queued = /* @__PURE__ */ new Set();
1905        fastdom.read(() => {
1906          if (instance._connected) {
1907            runUpdates(instance, instance._queued);
1908          }
1909          delete instance._queued;
1910        });
1911      }
1912      instance._queued.add(e.type || e);
1913    }
1914    function runUpdates(instance, types) {
1915      for (const { read, write, events = [] } of instance._updates) {
1916        if (!types.has("update") && !events.some((type) => types.has(type))) {
1917          continue;
1918        }
1919        let result;
1920        if (read) {
1921          result = read.call(instance, instance._data, types);
1922          if (result && isPlainObject(result)) {
1923            assign(instance._data, result);
1924          }
1925        }
1926        if (write && result !== false) {
1927          fastdom.write(() => {
1928            if (instance._connected) {
1929              write.call(instance, instance._data, types);
1930            }
1931          });
1932        }
1933      }
1934    }
1935
1936    function resize(options) {
1937      return observe(observeResize, options, "resize");
1938    }
1939    function intersection(options) {
1940      return observe(observeIntersection, options);
1941    }
1942    function mutation(options) {
1943      return observe(observeMutation, options);
1944    }
1945    function lazyload(options = {}) {
1946      return intersection({
1947        handler: function(entries, observer) {
1948          const { targets = this.$el, preload = 5 } = options;
1949          for (const el of toNodes(isFunction(targets) ? targets(this) : targets)) {
1950            $$('[loading="lazy"]', el).slice(0, preload - 1).forEach((el2) => removeAttr(el2, "loading"));
1951          }
1952          for (const el of entries.filter(({ isIntersecting }) => isIntersecting).map(({ target }) => target)) {
1953            observer.unobserve(el);
1954          }
1955        },
1956        ...options
1957      });
1958    }
1959    function viewport(options) {
1960      return observe((target, handler) => observeViewportResize(handler), options, "resize");
1961    }
1962    function scroll$1(options) {
1963      return observe(
1964        (target, handler) => ({
1965          disconnect: on(toScrollTargets(target), "scroll", handler, { passive: true })
1966        }),
1967        options,
1968        "scroll"
1969      );
1970    }
1971    function swipe(options) {
1972      return {
1973        observe(target, handler) {
1974          return {
1975            observe: noop,
1976            unobserve: noop,
1977            disconnect: on(target, pointerDown$1, handler, { passive: true })
1978          };
1979        },
1980        handler(e) {
1981          if (!isTouch(e)) {
1982            return;
1983          }
1984          const pos = getEventPos(e);
1985          const target = "tagName" in e.target ? e.target : parent(e.target);
1986          once(document, `${pointerUp$1} ${pointerCancel} scroll`, (e2) => {
1987            const { x, y } = getEventPos(e2);
1988            if (e2.type !== "scroll" && target && x && Math.abs(pos.x - x) > 100 || y && Math.abs(pos.y - y) > 100) {
1989              setTimeout(() => {
1990                trigger(target, "swipe");
1991                trigger(target, `swipe${swipeDirection(pos.x, pos.y, x, y)}`);
1992              });
1993            }
1994          });
1995        },
1996        ...options
1997      };
1998    }
1999    function observe(observe2, options, emit) {
2000      return {
2001        observe: observe2,
2002        handler() {
2003          callUpdate(this, emit);
2004        },
2005        ...options
2006      };
2007    }
2008    function swipeDirection(x1, y1, x2, y2) {
2009      return Math.abs(x1 - x2) >= Math.abs(y1 - y2) ? x1 - x2 > 0 ? "Left" : "Right" : y1 - y2 > 0 ? "Up" : "Down";
2010    }
2011    function toScrollTargets(elements) {
2012      return toNodes(elements).map((node) => {
2013        const { ownerDocument } = node;
2014        const parent2 = scrollParent(node, true);
2015        return parent2 === ownerDocument.scrollingElement ? ownerDocument : parent2;
2016      });
2017    }
2018
2019    var Margin = {
2020      props: {
2021        margin: String,
2022        firstColumn: Boolean
2023      },
2024      data: {
2025        margin: "uk-margin-small-top",
2026        firstColumn: "uk-first-column"
2027      },
2028      observe: [
2029        mutation({
2030          options: {
2031            childList: true
2032          }
2033        }),
2034        mutation({
2035          options: {
2036            attributes: true,
2037            attributeFilter: ["style"]
2038          },
2039          target: ({ $el }) => [$el, ...children($el)]
2040        }),
2041        resize({
2042          target: ({ $el }) => [$el, ...children($el)]
2043        })
2044      ],
2045      update: {
2046        read() {
2047          return {
2048            rows: getRows(children(this.$el))
2049          };
2050        },
2051        write({ rows }) {
2052          for (const row of rows) {
2053            for (const el of row) {
2054              toggleClass(el, this.margin, rows[0] !== row);
2055              toggleClass(el, this.firstColumn, row[isRtl ? row.length - 1 : 0] === el);
2056            }
2057          }
2058        },
2059        events: ["resize"]
2060      }
2061    };
2062    function getRows(elements) {
2063      const sorted = [[]];
2064      const withOffset = elements.some(
2065        (el, i) => i && elements[i - 1].offsetParent !== el.offsetParent
2066      );
2067      for (const el of elements) {
2068        if (!isVisible(el)) {
2069          continue;
2070        }
2071        const offset = getOffset(el, withOffset);
2072        for (let i = sorted.length - 1; i >= 0; i--) {
2073          const current = sorted[i];
2074          if (!current[0]) {
2075            current.push(el);
2076            break;
2077          }
2078          const offsetCurrent = getOffset(current[0], withOffset);
2079          if (offset.top >= offsetCurrent.bottom - 1 && offset.top !== offsetCurrent.top) {
2080            sorted.push([el]);
2081            break;
2082          }
2083          if (offset.bottom - 1 > offsetCurrent.top || offset.top === offsetCurrent.top) {
2084            let j = current.length - 1;
2085            for (; j >= 0; j--) {
2086              const offsetCurrent2 = getOffset(current[j], withOffset);
2087              if (offset.left >= offsetCurrent2.left) {
2088                break;
2089              }
2090            }
2091            current.splice(j + 1, 0, el);
2092            break;
2093          }
2094          if (i === 0) {
2095            sorted.unshift([el]);
2096            break;
2097          }
2098        }
2099      }
2100      return sorted;
2101    }
2102    function getOffset(element, offset = false) {
2103      let { offsetTop, offsetLeft, offsetHeight, offsetWidth } = element;
2104      if (offset) {
2105        [offsetTop, offsetLeft] = offsetPosition(element);
2106      }
2107      return {
2108        top: offsetTop,
2109        left: offsetLeft,
2110        bottom: offsetTop + offsetHeight,
2111        right: offsetLeft + offsetWidth
2112      };
2113    }
2114
2115    async function slide(action, target, duration) {
2116      await awaitFrame();
2117      let nodes = children(target);
2118      const currentProps = nodes.map((el) => getProps$1(el, true));
2119      const targetProps = { ...css(target, ["height", "padding"]), display: "block" };
2120      const targets = nodes.concat(target);
2121      await Promise.all(targets.map(Transition.cancel));
2122      css(targets, "transitionProperty", "none");
2123      await action();
2124      nodes = nodes.concat(children(target).filter((el) => !includes(nodes, el)));
2125      await Promise.resolve();
2126      css(targets, "transitionProperty", "");
2127      const targetStyle = attr(target, "style");
2128      const targetPropsTo = css(target, ["height", "padding"]);
2129      const [propsTo, propsFrom] = getTransitionProps(target, nodes, currentProps);
2130      const attrsTo = nodes.map((el) => ({ style: attr(el, "style") }));

2304    const keyMap = {
2305      TAB: 9,
2306      ESC: 27,
2307      SPACE: 32,
2308      END: 35,
2309      HOME: 36,
2310      LEFT: 37,
2311      UP: 38,
2312      RIGHT: 39,
2313      DOWN: 40
2314    };
2315
2316    var filter = {
2317      mixins: [Animate],
2318      args: "target",
2319      props: {
2320        target: String,
2321        selActive: Boolean
2322      },
2323      data: {
2324        target: "",
2325        selActive: false,
2326        attrItem: "uk-filter-control",
2327        cls: "uk-active",
2328        duration: 250
2329      },
2330      computed: {
2331        children: ({ target }, $el) => $$(`${target} > *`, $el),
2332        toggles: ({ attrItem }, $el) => $$(`[${attrItem}],[data-${attrItem}]`, $el)
2333      },
2334      watch: {
2335        toggles(toggles) {
2336          this.updateState();
2337          const actives = $$(this.selActive, this.$el);
2338          for (const toggle of toggles) {
2339            if (this.selActive !== false) {
2340              toggleClass(toggle, this.cls, includes(actives, toggle));
2341            }
2342            const button = findButton(toggle);
2343            if (isTag(button, "a")) {
2344              attr(button, "role", "button");
2345            }
2346          }
2347        },
2348        children(list, prev) {
2349          if (prev) {
2350            this.updateState();
2351          }
2352        }
2353      },
2354      events: {
2355        name: "click keydown",
2356        delegate() {
2357          return `[${this.attrItem}],[data-${this.attrItem}]`;
2358        },
2359        handler(e) {
2360          if (e.type === "keydown" && e.keyCode !== keyMap.SPACE) {
2361            return;
2362          }
2363          if (e.target.closest("a,button")) {
2364            e.preventDefault();
2365            this.apply(e.current);
2366          }
2367        }
2368      },
2369      methods: {
2370        apply(el) {
2371          const prevState = this.getState();
2372          const newState = mergeState(el, this.attrItem, this.getState());
2373          if (!isEqualState(prevState, newState)) {
2374            this.setState(newState);
2375          }
2376        },
2377        getState() {
2378          return this.toggles.filter((item) => hasClass(item, this.cls)).reduce((state, el) => mergeState(el, this.attrItem, state), {
2379            filter: { "": "" },
2380            sort: []
2381          });
2382        },
2383        async setState(state, animate = true) {
2384          state = { filter: { "": "" }, sort: [], ...state };
2385          trigger(this.$el, "beforeFilter", [this, state]);
2386          for (const toggle of this.toggles) {
2387            toggleClass(toggle, this.cls, matchFilter(toggle, this.attrItem, state));
2388          }
2389          await Promise.all(
2390            $$(this.target, this.$el).map((target) => {
2391              const filterFn = () => applyState(state, target, children(target));
2392              return animate ? this.animate(filterFn, target) : filterFn();
2393            })
2394          );
2395          trigger(this.$el, "afterFilter", [this]);
2396        },
2397        updateState() {
2398          fastdom.write(() => this.setState(this.getState(), false));
2399        }
2400      }
2401    };
2402    function getFilter(el, attr2) {
2403      return parseOptions(data(el, attr2), ["filter"]);
2404    }
2405    function isEqualState(stateA, stateB) {
2406      return ["filter", "sort"].every((prop) => isEqual(stateA[prop], stateB[prop]));
2407    }
2408    function applyState(state, target, children) {
2409      const selector = getSelector(state);
2410      for (const el of children) {
2411        css(el, "display", selector && !matches(el, selector) ? "none" : "");
2412      }
2413      const [sort, order] = state.sort;
2414      if (sort) {
2415        const sorted = sortItems(children, sort, order);
2416        if (!isEqual(sorted, children)) {
2417          append(target, sorted);
2418        }
2419      }
2420    }
2421    function mergeState(el, attr2, state) {
2422      const { filter, group, sort, order = "asc" } = getFilter(el, attr2);
2423      if (filter || isUndefined(sort)) {
2424        if (group) {
2425          if (filter) {
2426            delete state.filter[""];
2427            state.filter[group] = filter;
2428          } else {
2429            delete state.filter[group];
2430            if (isEmpty(state.filter) || "" in state.filter) {
2431              state.filter = { "": filter || "" };
2432            }
2433          }
2434        } else {
2435          state.filter = { "": filter || "" };
2436        }
2437      }
2438      if (!isUndefined(sort)) {
2439        state.sort = [sort, order];
2440      }
2441      return state;
2442    }
2443    function matchFilter(el, attr2, { filter: stateFilter = { "": "" }, sort: [stateSort, stateOrder] }) {
2444      const { filter = "", group = "", sort, order = "asc" } = getFilter(el, attr2);
2445      return isUndefined(sort) ? group in stateFilter && filter === stateFilter[group] || !filter && group && !(group in stateFilter) && !stateFilter[""] : stateSort === sort && stateOrder === order;
2446    }
2447    function getSelector({ filter }) {
2448      let selector = "";
2449      each(filter, (value) => selector += value || "");
2450      return selector;
2451    }
2452    function sortItems(nodes, sort, order) {
2453      return [...nodes].sort(
2454        (a, b) => data(a, sort).localeCompare(data(b, sort), void 0, { numeric: true }) * (order === "asc" || -1)
2455      );
2456    }
2457    function findButton(el) {
2458      return $("a,button", el) || el;
2459    }
2460
2461    let prevented;
2462    function preventBackgroundScroll(el) {
2463      const off = on(el, "touchstart", (e) => {
2464        if (e.targetTouches.length !== 1 || matches(e.target, 'input[type="range"')) {
2465          return;
2466        }
2467        let prev = getEventPos(e).y;
2468        const offMove = on(
2469          el,
2470          "touchmove",
2471          (e2) => {
2472            const pos = getEventPos(e2).y;
2473            if (pos === prev) {
2474              return;
2475            }
2476            prev = pos;
2477            if (!scrollParents(e2.target).some((scrollParent) => {
2478              if (!el.contains(scrollParent)) {
2479                return false;
2480              }
2481              let { scrollHeight, clientHeight } = scrollParent;
2482              return clientHeight < scrollHeight;
2483            })) {
2484              e2.preventDefault();
2485            }
2486          },
2487          { passive: false }
2488        );
2489        once(el, "scroll touchend touchcanel", offMove, { capture: true });
2490      });
2491      if (prevented) {
2492        return off;
2493      }
2494      prevented = true;
2495      const { scrollingElement } = document;
2496      css(scrollingElement, {
2497        overflowY: CSS.supports("overflow", "clip") ? "clip" : "hidden",
2498        touchAction: "none",
2499        paddingRight: width(window) - scrollingElement.clientWidth || ""
2500      });
2501      return () => {
2502        prevented = false;
2503        off();
2504        css(scrollingElement, { overflowY: "", touchAction: "", paddingRight: "" });
2505      };
2506    }
2507
2508    var Container = {
2509      props: {
2510        container: Boolean
2511      },
2512      data: {
2513        container: true
2514      },
2515      computed: {
2516        container({ container }) {
2517          return container === true && this.$container || container && $(container);
2518        }
2519      }
2520    };
2521
2522    var Togglable = {
2523      props: {
2524        cls: Boolean,
2525        animation: "list",
2526        duration: Number,
2527        velocity: Number,
2528        origin: String,
2529        transition: String
2530      },
2531      data: {
2532        cls: false,
2533        animation: [false],
2534        duration: 200,
2535        velocity: 0.2,
2536        origin: false,
2537        transition: "ease",
2538        clsEnter: "uk-togglable-enter",
2539        clsLeave: "uk-togglable-leave"
2540      },
2541      computed: {
2542        hasAnimation: ({ animation }) => !!animation[0],
2543        hasTransition: ({ animation }) => ["slide", "reveal"].some((transition) => startsWith(animation[0], transition))
2544      },
2545      methods: {
2546        async toggleElement(targets, toggle, animate) {
2547          try {
2548            await Promise.all(
2549              toNodes(targets).map((el) => {
2550                const show = isBoolean(toggle) ? toggle : !this.isToggled(el);
2551                if (!trigger(el, `before${show ? "show" : "hide"}`, [this])) {
2552                  return Promise.reject();
2553                }
2554                const promise = (isFunction(animate) ? animate : animate === false || !this.hasAnimation ? toggleInstant : this.hasTransition ? toggleTransition : toggleAnimation)(el, show, this);
2555                const cls = show ? this.clsEnter : this.clsLeave;
2556                addClass(el, cls);
2557                trigger(el, show ? "show" : "hide", [this]);
2558                const done = () => {
2559                  removeClass(el, cls);
2560                  trigger(el, show ? "shown" : "hidden", [this]);
2561                };
2562                return promise ? promise.then(done, () => {
2563                  removeClass(el, cls);
2564                  return Promise.reject();
2565                }) : done();
2566              })
2567            );
2568            return true;
2569          } catch (e) {
2570            return false;
2571          }
2572        },
2573        isToggled(el = this.$el) {
2574          el = toNode(el);
2575          return hasClass(el, this.clsEnter) ? true : hasClass(el, this.clsLeave) ? false : this.cls ? hasClass(el, this.cls.split(" ")[0]) : isVisible(el);
2576        },
2577        _toggle(el, toggled) {
2578          if (!el) {
2579            return;
2580          }
2581          toggled = Boolean(toggled);
2582          let changed;
2583          if (this.cls) {
2584            changed = includes(this.cls, " ") || toggled !== hasClass(el, this.cls);
2585            changed && toggleClass(el, this.cls, includes(this.cls, " ") ? void 0 : toggled);
2586          } else {
2587            changed = toggled === el.hidden;
2588            changed && (el.hidden = !toggled);
2589          }
2590          $$("[autofocus]", el).some((el2) => isVisible(el2) ? el2.focus() || true : el2.blur());
2591          if (changed) {
2592            trigger(el, "toggled", [toggled, this]);
2593          }
2594        }
2595      }
2596    };
2597    function toggleInstant(el, show, { _toggle }) {
2598      Animation.cancel(el);
2599      Transition.cancel(el);
2600      return _toggle(el, show);
2601    }
2602    async function toggleTransition(el, show, { animation, duration, velocity, transition, _toggle }) {
2603      var _a;
2604      const [mode = "reveal", startProp = "top"] = ((_a = animation[0]) == null ? void 0 : _a.split("-")) || [];
2605      const dirs = [
2606        ["left", "right"],
2607        ["top", "bottom"]
2608      ];
2609      const dir = dirs[includes(dirs[0], startProp) ? 0 : 1];
2610      const end = dir[1] === startProp;
2611      const props = ["width", "height"];
2612      const dimProp = props[dirs.indexOf(dir)];
2613      const marginProp = `margin-${dir[0]}`;
2614      const marginStartProp = `margin-${startProp}`;
2615      let currentDim = dimensions$1(el)[dimProp];
2616      const inProgress = Transition.inProgress(el);
2617      await Transition.cancel(el);
2618      if (show) {
2619        _toggle(el, true);
2620      }
2621      const prevProps = Object.fromEntries(
2622        [
2623          "padding",
2624          "border",
2625          "width",
2626          "height",
2627          "minWidth",
2628          "minHeight",
2629          "overflowY",
2630          "overflowX",
2631          marginProp,
2632          marginStartProp
2633        ].map((key) => [key, el.style[key]])
2634      );
2635      const dim = dimensions$1(el);
2636      const currentMargin = toFloat(css(el, marginProp));
2637      const marginStart = toFloat(css(el, marginStartProp));
2638      const endDim = dim[dimProp] + marginStart;
2639      if (!inProgress && !show) {
2640        currentDim += marginStart;
2641      }
2642      const [wrapper] = wrapInner(el, "<div>");
2643      css(wrapper, {
2644        boxSizing: "border-box",

2645        height: dim.height,
2646        width: dim.width,
2647        ...css(el, [
2648          "overflow",
2649          "padding",
2650          "borderTop",
2651          "borderRight",
2652          "borderBottom",
2653          "borderLeft",
2654          "borderImage",
2655          marginStartProp
2656        ])
2657      });
2658      css(el, {
2659        padding: 0,
2660        border: 0,
2661        minWidth: 0,
2662        minHeight: 0,
2663        [marginStartProp]: 0,
2664        width: dim.width,
2665        height: dim.height,
2666        overflow: "hidden",
2667        [dimProp]: currentDim
2668      });
2669      const percent = currentDim / endDim;
2670      duration = (velocity * endDim + duration) * (show ? 1 - percent : percent);
2671      const endProps = { [dimProp]: show ? endDim : 0 };
2672      if (end) {
2673        css(el, marginProp, endDim - currentDim + currentMargin);
2674        endProps[marginProp] = show ? currentMargin : endDim + currentMargin;
2675      }
2676      if (!end ^ mode === "reveal") {
2677        css(wrapper, marginProp, -endDim + currentDim);
2678        Transition.start(wrapper, { [marginProp]: show ? 0 : -endDim }, duration, transition);
2679      }
2680      try {
2681        await Transition.start(el, endProps, duration, transition);
2682      } finally {
2683        css(el, prevProps);
2684        unwrap(wrapper.firstChild);
2685        if (!show) {
2686          _toggle(el, false);
2687        }
2688      }
2689    }
2690    function toggleAnimation(el, show, cmp) {
2691      const { animation, duration, _toggle } = cmp;
2692      if (show) {
2693        _toggle(el, true);
2694        return Animation.in(el, animation[0], duration, cmp.origin);
2695      }
2696      return Animation.out(el, animation[1] || animation[0], duration, cmp.origin).then(
2697        () => _toggle(el, false)
2698      );
2699    }
2700
2701    const active$1 = [];
2702    var Modal = {
2703      mixins: [Class, Container, Togglable],
2704      props: {
2705        selPanel: String,
2706        selClose: String,
2707        escClose: Boolean,
2708        bgClose: Boolean,
2709        stack: Boolean,
2710        role: String
2711      },
2712      data: {
2713        cls: "uk-open",
2714        escClose: true,
2715        bgClose: true,
2716        overlay: true,
2717        stack: false,
2718        role: "dialog"
2719      },
2720      computed: {
2721        panel: ({ selPanel }, $el) => $(selPanel, $el),
2722        transitionElement() {
2723          return this.panel;
2724        },
2725        bgClose({ bgClose }) {
2726          return bgClose && this.panel;
2727        }
2728      },
2729      connected() {
2730        attr(this.panel || this.$el, "role", this.role);
2731        if (this.overlay) {
2732          attr(this.panel || this.$el, "aria-modal", true);
2733        }
2734      },
2735      beforeDisconnect() {
2736        if (includes(active$1, this)) {
2737          this.toggleElement(this.$el, false, false);
2738        }
2739      },
2740      events: [
2741        {
2742          name: "click",
2743          delegate() {
2744            return `${this.selClose},a[href*="#"]`;
2745          },
2746          handler(e) {
2747            const { current, defaultPrevented } = e;
2748            const { hash } = current;
2749            if (!defaultPrevented && hash && isSameSiteAnchor(current) && !this.$el.contains($(hash))) {
2750              this.hide();
2751            } else if (matches(current, this.selClose)) {
2752              e.preventDefault();
2753              this.hide();
2754            }
2755          }
2756        },
2757        {
2758          name: "toggle",
2759          self: true,
2760          handler(e) {
2761            if (e.defaultPrevented) {
2762              return;
2763            }
2764            e.preventDefault();
2765            if (this.isToggled() === includes(active$1, this)) {
2766              this.toggle();
2767            }
2768          }
2769        },
2770        {
2771          name: "beforeshow",
2772          self: true,
2773          handler(e) {
2774            if (includes(active$1, this)) {
2775              return false;
2776            }
2777            if (!this.stack && active$1.length) {
2778              Promise.all(active$1.map((modal) => modal.hide())).then(this.show);
2779              e.preventDefault();
2780            } else {
2781              active$1.push(this);
2782            }
2783          }
2784        },
2785        {
2786          name: "show",
2787          self: true,
2788          handler() {
2789            if (this.stack) {