https://mountaincabinsutah.com/wp-content/plugins/homerunner/assets/vendor/uikit/js/uikit.js?ver=2.6.7

1/*! hkUIkit 3.21.16 | 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.hkUIkit = 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 addClass(element, ...classes) {
196      for (const node of toNodes(element)) {
197        const add = toClasses(classes).filter((cls) => !hasClass(node, cls));
198        if (add.length) {
199          node.classList.add(...add);
200        }
201      }
202    }
203    function removeClass(element, ...classes) {
204      for (const node of toNodes(element)) {
205        const remove = toClasses(classes).filter((cls) => hasClass(node, cls));
206        if (remove.length) {
207          node.classList.remove(...remove);
208        }
209      }
210    }
211    function replaceClass(element, oldClass, newClass) {
212      newClass = toClasses(newClass);
213      oldClass = toClasses(oldClass).filter((cls) => !includes(newClass, cls));
214      removeClass(element, oldClass);
215      addClass(element, newClass);
216    }
217    function hasClass(element, cls) {
218      [cls] = toClasses(cls);
219      return toNodes(element).some((node) => node.classList.contains(cls));
220    }
221    function toggleClass(element, cls, force) {
222      const classes = toClasses(cls);
223      if (!isUndefined(force)) {
224        force = !!force;
225      }
226      for (const node of toNodes(element)) {
227        for (const cls2 of classes) {
228          node.classList.toggle(cls2, force);
229        }
230      }
231    }
232    function toClasses(str) {
233      return str ? isArray(str) ? str.map(toClasses).flat() : String(str).split(" ").filter(Boolean) : [];
234    }
235
236    function attr(element, name, value) {
237      var _a;
238      if (isObject(name)) {
239        for (const key in name) {
240          attr(element, key, name[key]);
241        }
242        return;
243      }
244      if (isUndefined(value)) {
245        return (_a = toNode(element)) == null ? void 0 : _a.getAttribute(name);
246      } else {
247        for (const el of toNodes(element)) {
248          if (isFunction(value)) {
249            value = value.call(el, attr(el, name));
250          }
251          if (value === null) {
252            removeAttr(el, name);
253          } else {
254            el.setAttribute(name, value);
255          }
256        }
257      }
258    }
259    function hasAttr(element, name) {
260      return toNodes(element).some((element2) => element2.hasAttribute(name));
261    }
262    function removeAttr(element, name) {
263      toNodes(element).forEach((element2) => element2.removeAttribute(name));
264    }
265    function data(element, attribute) {
266      for (const name of [attribute, `data-${attribute}`]) {
267        if (hasAttr(element, name)) {
268          return attr(element, name);
269        }
270      }
271    }
272
273    const inBrowser = typeof window !== "undefined";
274    const isRtl = inBrowser && document.dir === "rtl";
275    const hasTouch = inBrowser && "ontouchstart" in window;
276    const hasPointerEvents = inBrowser && window.PointerEvent;
277    const pointerDown$1 = hasPointerEvents ? "pointerdown" : hasTouch ? "touchstart" : "mousedown";
278    const pointerMove$1 = hasPointerEvents ? "pointermove" : hasTouch ? "touchmove" : "mousemove";
279    const pointerUp$1 = hasPointerEvents ? "pointerup" : hasTouch ? "touchend" : "mouseup";
280    const pointerEnter = hasPointerEvents ? "pointerenter" : hasTouch ? "" : "mouseenter";
281    const pointerLeave = hasPointerEvents ? "pointerleave" : hasTouch ? "" : "mouseleave";
282    const pointerCancel = hasPointerEvents ? "pointercancel" : "touchcancel";
283
284    const voidElements = {
285      area: true,
286      base: true,
287      br: true,
288      col: true,
289      embed: true,
290      hr: true,
291      img: true,
292      input: true,
293      keygen: true,
294      link: true,
295      meta: true,
296      param: true,
297      source: true,
298      track: true,
299      wbr: true
300    };
301    function isVoidElement(element) {
302      return toNodes(element).some((element2) => voidElements[element2.tagName.toLowerCase()]);
303    }
304    const isVisibleFn = inBrowser && Element.prototype.checkVisibility || function() {
305      return this.offsetWidth || this.offsetHeight || this.getClientRects().length;
306    };
307    function isVisible(element) {
308      return toNodes(element).some((element2) => isVisibleFn.call(element2));
309    }
310    const selInput = "input,select,textarea,button";
311    function isInput(element) {
312      return toNodes(element).some((element2) => matches(element2, selInput));
313    }
314    const selFocusable = `${selInput},a[href],[tabindex]`;
315    function isFocusable(element) {
316      return matches(element, selFocusable);
317    }
318    function parent(element) {
319      var _a;
320      return (_a = toNode(element)) == null ? void 0 : _a.parentElement;
321    }
322    function filter$1(element, selector) {
323      return toNodes(element).filter((element2) => matches(element2, selector));
324    }
325    function matches(element, selector) {
326      return toNodes(element).some((element2) => element2.matches(selector));
327    }
328    function parents(element, selector) {
329      const elements = [];
330      while (element = parent(element)) {
331        if (!selector || matches(element, selector)) {
332          elements.push(element);
333        }
334      }
335      return elements;
336    }
337    function children(element, selector) {
338      element = toNode(element);
339      const children2 = element ? toArray(element.children) : [];
340      return selector ? filter$1(children2, selector) : children2;
341    }
342    function index(element, ref) {
343      return ref ? toNodes(element).indexOf(toNode(ref)) : children(parent(element)).indexOf(element);
344    }
345    function isSameSiteAnchor(el) {
346      el = toNode(el);
347      return el && ["origin", "pathname", "search"].every((part) => el[part] === location[part]);
348    }
349    function getTargetedElement(el) {
350      if (isSameSiteAnchor(el)) {
351        const { hash, ownerDocument } = toNode(el);
352        const id = decodeURIComponent(hash).slice(1);
353        return id ? ownerDocument.getElementById(id) || ownerDocument.getElementsByName(id)[0] : ownerDocument.documentElement;
354      }
355    }
356
357    function query(selector, context) {
358      return find(selector, getContext(selector, context));
359    }
360    function queryAll(selector, context) {
361      return findAll(selector, getContext(selector, context));
362    }
363    function find(selector, context) {
364      return toNode(_query(selector, toNode(context), "querySelector"));
365    }
366    function findAll(selector, context) {
367      return toNodes(_query(selector, toNode(context), "querySelectorAll"));
368    }
369    function getContext(selector, context = document) {
370      return isDocument(context) || parseSelector(selector).isContextSelector ? context : context.ownerDocument;
371    }
372    const addStarRe = /([!>+~-])(?=\s+[!>+~-]|\s*$)/g;
373    const splitSelectorRe = /(\([^)]*\)|[^,])+/g;
374    const parseSelector = memoize((selector) => {
375      let isContextSelector = false;
376      if (!selector || !isString(selector)) {
377        return {};
378      }
379      const selectors = [];
380      for (let sel of selector.match(splitSelectorRe)) {
381        sel = sel.trim().replace(addStarRe, "$1 *");
382        isContextSelector || (isContextSelector = ["!", "+", "~", "-", ">"].includes(sel[0]));
383        selectors.push(sel);
384      }
385      return {
386        selector: selectors.join(","),
387        selectors,
388        isContextSelector
389      };
390    });
391    const positionRe = /(\([^)]*\)|\S)*/;
392    const parsePositionSelector = memoize((selector) => {
393      selector = selector.slice(1).trim();
394      const [position] = selector.match(positionRe);
395      return [position, selector.slice(position.length + 1)];
396    });
397    function _query(selector, context = document, queryFn) {
398      const parsed = parseSelector(selector);
399      if (!parsed.isContextSelector) {
400        return parsed.selector ? _doQuery(context, queryFn, parsed.selector) : selector;
401      }
402      selector = "";
403      const isSingle = parsed.selectors.length === 1;
404      for (let sel of parsed.selectors) {
405        let positionSel;
406        let ctx = context;
407        if (sel[0] === "!") {
408          [positionSel, sel] = parsePositionSelector(sel);
409          ctx = context.parentElement.closest(positionSel);
410          if (!sel && isSingle) {
411            return ctx;
412          }
413        }
414        if (ctx && sel[0] === "-") {
415          [positionSel, sel] = parsePositionSelector(sel);
416          ctx = ctx.previousElementSibling;
417          ctx = matches(ctx, positionSel) ? ctx : null;
418          if (!sel && isSingle) {
419            return ctx;
420          }
421        }
422        if (!ctx) {
423          continue;
424        }
425        if (isSingle) {
426          if (sel[0] === "~" || sel[0] === "+") {
427            sel = `:scope > :nth-child(${index(ctx) + 1}) ${sel}`;
428            ctx = ctx.parentElement;
429          } else if (sel[0] === ">") {
430            sel = `:scope ${sel}`;
431          }
432          return _doQuery(ctx, queryFn, sel);
433        }
434        selector += `${selector ? "," : ""}${domPath(ctx)} ${sel}`;
435      }
436      if (!isDocument(context)) {
437        context = context.ownerDocument;
438      }
439      return _doQuery(context, queryFn, selector);
440    }
441    function _doQuery(context, queryFn, selector) {
442      try {
443        return context[queryFn](selector);
444      } catch (e) {
445        return null;
446      }
447    }
448    function domPath(element) {
449      const names = [];
450      while (element.parentNode) {
451        const id = attr(element, "id");
452        if (id) {
453          names.unshift(`#${escape(id)}`);
454          break;
455        } else {
456          let { tagName } = element;
457          if (tagName !== "HTML") {
458            tagName += `:nth-child(${index(element) + 1})`;
459          }
460          names.unshift(tagName);
461          element = element.parentNode;
462        }
463      }
464      return names.join(" > ");
465    }
466    function escape(css) {
467      return isString(css) ? CSS.escape(css) : "";
468    }
469
470    function on(...args) {
471      let [targets, types, selector, listener, useCapture = false] = getArgs(args);
472      if (listener.length > 1) {
473        listener = detail(listener);
474      }
475      if (useCapture == null ? void 0 : useCapture.self) {
476        listener = selfFilter(listener);
477      }
478      if (selector) {
479        listener = delegate(selector, listener);
480      }
481      for (const type of types) {
482        for (const target of targets) {
483          target.addEventListener(type, listener, useCapture);
484        }
485      }
486      return () => off(targets, types, listener, useCapture);
487    }
488    function off(...args) {
489      let [targets, types, , listener, useCapture = false] = getArgs(args);
490      for (const type of types) {
491        for (const target of targets) {
492          target.removeEventListener(type, listener, useCapture);
493        }
494      }
495    }
496    function once(...args) {
497      const [element, types, selector, listener, useCapture = false, condition] = getArgs(args);
498      const off2 = on(
499        element,
500        types,
501        selector,
502        (e) => {
503          const result = !condition || condition(e);
504          if (result) {
505            off2();
506            listener(e, result);
507          }
508        },
509        useCapture
510      );
511      return off2;
512    }
513    function trigger(targets, event, detail2) {
514      return toEventTargets(targets).every(
515        (target) => target.dispatchEvent(createEvent(event, true, true, detail2))
516      );
517    }
518    function createEvent(e, bubbles = true, cancelable = false, detail2) {
519      if (isString(e)) {

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

765        (_a = $(ref)) == null ? void 0 : _a[fn](...nodes);
766        return unwrapSingle(nodes);
767      };
768    }
769    function remove$1(element) {
770      toNodes(element).forEach((element2) => element2.remove());
771    }
772    function wrapAll(element, structure) {
773      structure = toNode(before(element, structure));
774      while (structure.firstElementChild) {
775        structure = structure.firstElementChild;
776      }
777      append(structure, element);
778      return structure;
779    }
780    function wrapInner(element, structure) {
781      return toNodes(
782        toNodes(element).map(
783          (element2) => element2.hasChildNodes() ? wrapAll(toArray(element2.childNodes), structure) : append(element2, structure)
784        )
785      );
786    }
787    function unwrap(element) {
788      toNodes(element).map(parent).filter((value, index, self) => self.indexOf(value) === index).forEach((parent2) => parent2.replaceWith(...parent2.childNodes));
789    }
790    const singleTagRe = /^<(\w+)\s*\/?>(?:<\/\1>)?$/;
791    function fragment(html2) {
792      const matches = singleTagRe.exec(html2);
793      if (matches) {
794        return document.createElement(matches[1]);
795      }
796      const container = document.createElement("template");
797      container.innerHTML = html2.trim();
798      return unwrapSingle(container.content.childNodes);
799    }
800    function unwrapSingle(nodes) {
801      return nodes.length > 1 ? nodes : nodes[0];
802    }
803    function apply(node, fn) {
804      if (!isElement(node)) {
805        return;
806      }
807      fn(node);
808      node = node.firstElementChild;
809      while (node) {
810        apply(node, fn);
811        node = node.nextElementSibling;
812      }
813    }
814    function $(selector, context) {
815      return isHtml(selector) ? toNode(fragment(selector)) : find(selector, context);
816    }
817    function $$(selector, context) {
818      return isHtml(selector) ? toNodes(fragment(selector)) : findAll(selector, context);
819    }
820    function isHtml(str) {
821      return isString(str) && startsWith(str.trim(), "<");
822    }
823
824    const dirs$1 = {
825      width: ["left", "right"],
826      height: ["top", "bottom"]
827    };
828    function dimensions$1(element) {
829      const rect = isElement(element) ? toNode(element).getBoundingClientRect() : { height: height(element), width: width(element), top: 0, left: 0 };
830      return {
831        height: rect.height,
832        width: rect.width,
833        top: rect.top,
834        left: rect.left,
835        bottom: rect.top + rect.height,
836        right: rect.left + rect.width
837      };
838    }
839    function offset(element, coordinates) {
840      if (coordinates) {
841        css(element, { left: 0, top: 0 });
842      }
843      const currentOffset = dimensions$1(element);
844      if (element) {
845        const { scrollY, scrollX } = toWindow(element);
846        const offsetBy = { height: scrollY, width: scrollX };
847        for (const dir in dirs$1) {
848          for (const prop of dirs$1[dir]) {
849            currentOffset[prop] += offsetBy[dir];
850          }
851        }
852      }
853      if (!coordinates) {
854        return currentOffset;
855      }
856      for (const prop of ["left", "top"]) {
857        css(element, prop, coordinates[prop] - currentOffset[prop]);
858      }
859    }
860    function position(element) {
861      let { top, left } = offset(element);
862      const {
863        ownerDocument: { body, documentElement },
864        offsetParent
865      } = toNode(element);
866      let parent = offsetParent || documentElement;
867      while (parent && (parent === body || parent === documentElement) && css(parent, "position") === "static") {
868        parent = parent.parentNode;
869      }
870      if (isElement(parent)) {
871        const parentOffset = offset(parent);
872        top -= parentOffset.top + toFloat(css(parent, "borderTopWidth"));
873        left -= parentOffset.left + toFloat(css(parent, "borderLeftWidth"));
874      }
875      return {
876        top: top - toFloat(css(element, "marginTop")),
877        left: left - toFloat(css(element, "marginLeft"))
878      };
879    }
880    function offsetPosition(element) {
881      element = toNode(element);
882      const offset2 = [element.offsetTop, element.offsetLeft];
883      while (element = element.offsetParent) {
884        offset2[0] += element.offsetTop + toFloat(css(element, `borderTopWidth`));
885        offset2[1] += element.offsetLeft + toFloat(css(element, `borderLeftWidth`

885));
886        if (css(element, "position") === "fixed") {
887          const win = toWindow(element);
888          offset2[0] += win.scrollY;
889          offset2[1] += win.scrollX;
890          return offset2;
891        }
892      }
893      return offset2;
894    }
895    const height = dimension("height");
896    const width = dimension("width");
897    function dimension(prop) {
898      const propName = ucfirst(prop);
899      return (element, value) => {
900        if (isUndefined(value)) {
901          if (isWindow(element)) {
902            return element[`inner${propName}`];
903          }
904          if (isDocument(element)) {
905            const doc = element.documentElement;
906            return Math.max(doc[`offset${propName}`], doc[`scroll${propName}`]);
907          }
908          element = toNode(element);
909          value = css(element, prop);
910          value = value === "auto" ? element[`offset${propName}`] : toFloat(value) || 0;
911          return value - boxModelAdjust(element, prop);
912        } else {
913          return css(
914            element,
915            prop,
916            !value && value !== 0 ? "" : +value + boxModelAdjust(element, prop) + "px"
917          );
918        }
919      };
920    }
921    function boxModelAdjust(element, prop, sizing = "border-box") {
922      return css(element, "boxSizing") === sizing ? sumBy(
923        dirs$1[prop],
924        (prop2) => toFloat(css(element, `padding-${prop2}`)) + toFloat(css(element, `border-${prop2}-width`))
925      ) : 0;
926    }
927    function flipPosition(pos) {
928      for (const dir in dirs$1) {
929        for (const i in dirs$1[dir]) {
930          if (dirs$1[dir][i] === pos) {
931            return dirs$1[dir][1 - i];
932          }
933        }
934      }
935      return pos;
936    }
937    function toPx(value, property = "width", element = window, offsetDim = false) {
938      if (!isString(value)) {
939        return toFloat(value);
940      }
941      return sumBy(parseCalc(value), (value2) => {
942        const unit = parseUnit(value2);
943        return unit ? percent(
944          unit === "vh" ? getViewportHeight() : unit === "vw" ? width(toWindow(element)) : offsetDim ? element[`offset${ucfirst(property)}`] : dimensions$1(element)[property],
945          value2
946        ) : value2;
947      });
948    }
949    const calcRe = /-?\d+(?:\.\d+)?(?:v[wh]|%|px)?/g;
950    const parseCalc = memoize((calc) => calc.toString().replace(/\s/g, "").match(calcRe) || []);
951    const unitRe$1 = /(?:v[hw]|%)$/;
952    const parseUnit = memoize((str) => (str.match(unitRe$1) || [])[0]);
953    function percent(base, value) {
954      return base * toFloat(value) / 100;
955    }
956    let vh;
957    let vhEl;
958    function getViewportHeight() {
959      if (vh) {
960        return vh;
961      }
962      if (!vhEl) {
963        vhEl = $("<div>");
964        css(vhEl, {
965          height: "100vh",
966          position: "fixed"
967        });
968        on(window, "resize", () => vh = null);
969      }
970      append(document.body, vhEl);
971      vh = vhEl.clientHeight;
972      remove$1(vhEl);
973      return vh;
974    }
975
976    const fastdom = { read, write, clear, flush };
977    const reads = [];
978    const writes = [];
979    function read(task) {
980      reads.push(task);
981      scheduleFlush();
982      return task;
983    }
984    function write(task) {
985      writes.push(task);
986      scheduleFlush();
987      return task;
988    }
989    function clear(task) {
990      remove(reads, task);
991      remove(writes, task);
992    }
993    let scheduled = false;
994    function flush() {
995      runTasks(reads);
996      runTasks(writes.splice(0));
997      scheduled = false;
998      if (reads.length || writes.length) {
999        scheduleFlush();
1000      }
1001    }
1002    function scheduleFlush() {
1003      if (!scheduled) {
1004        scheduled = true;
1005        queueMicrotask(flush);
1006      }
1007    }
1008    function runTasks(tasks) {
1009      let task;
1010      while (task = tasks.shift()) {
1011        try {
1012          task();
1013        } catch (e) {
1014          console.error(e);
1015        }
1016      }
1017    }
1018    function remove(array, item) {
1019      const index = array.indexOf(item);
1020      return ~index && array.splice(index, 1);
1021    }
1022
1023    class MouseTracker {
1024      init() {
1025        this.positions = [];
1026        let position;
1027        this.unbind = on(document, "mousemove", (e) => position = getEventPos(e));
1028        this.interval = setInterval(() => {
1029          if (!position) {
1030            return;
1031          }
1032          this.positions.push(position);
1033          if (this.positions.length > 5) {
1034            this.positions.shift();
1035          }
1036        }, 50);
1037      }
1038      cancel() {
1039        var _a;
1040        (_a = this.unbind) == null ? void 0 : _a.call(this);
1041        clearInterval(this.interval);
1042      }
1043      movesTo(target) {
1044        if (!this.positions || this.positions.length < 2) {
1045          return false;
1046        }
1047        const p = dimensions$1(target);
1048        const { left, right, top, bottom } = p;
1049        const [prevPosition] = this.positions;
1050        const position = last(this.positions);
1051        const path = [prevPosition, position];
1052        if (pointInRect(position, p)) {
1053          return false;
1054        }
1055        const diagonals = [
1056          [
1057            { x: left, y: top },
1058            { x: right, y: bottom }
1059          ],
1060          [
1061            { x: left, y: bottom },
1062            { x: right, y: top }
1063          ]
1064        ];
1065        return diagonals.some((diagonal) => {
1066          const intersection = intersect(path, diagonal);
1067          return intersection && pointInRect(intersection, p);
1068        });
1069      }
1070    }
1071    function intersect([{ x: x1, y: y1 }, { x: x2, y: y2 }], [{ x: x3, y: y3 }, { x: x4, y: y4 }]) {
1072      const denominator = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
1073      if (denominator === 0) {
1074        return false;
1075      }
1076      const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator;
1077      if (ua < 0) {
1078        return false;
1079      }
1080      return { x: x1 + ua * (x2 - x1), y: y1 + ua * (y2 - y1) };
1081    }
1082
1083    function observeIntersection(targets, cb, options = {}, { intersecting = true } = {}) {
1084      const observer = new IntersectionObserver(
1085        intersecting ? (entries, observer2) => {
1086          if (entries.some((entry) => entry.isIntersecting)) {
1087            cb(entries, observer2);
1088          }
1089        } : cb,
1090        options
1091      );
1092      for (const el of toNodes(targets)) {
1093        observer.observe(el);
1094      }
1095      return observer;
1096    }
1097    const hasResizeObserver = inBrowser && window.ResizeObserver;
1098    function observeResize(targets, cb, options = { box: "border-box" }) {
1099      if (hasResizeObserver) {
1100        return observe$1(ResizeObserver, targets, cb, options);
1101      }
1102      const off = [on(window, "load resize", cb), on(document, "loadedmetadata load", cb, true)];
1103      return { disconnect: () => off.

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

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

1596        isInput: isInput,
1597        isNode: isNode,
1598        isNumber: isNumber,
1599        isNumeric: isNumeric,
1600        isObject: isObject,
1601        isPlainObject: isPlainObject,
1602        isRtl: isRtl,
1603        isSameSiteAnchor: isSameSiteAnchor,
1604        isString: isString,
1605        isTag: isTag,
1606        isTouch: isTouch,
1607        isUndefined: isUndefined,
1608        isVisible: isVisible,
1609        isVoidElement: isVoidElement,
1610        isWindow: isWindow,
1611        last: last,
1612        matches: matches,
1613        memoize: memoize,
1614        mute: mute,
1615        noop: noop,
1616        observeIntersection: observeIntersection,
1617        observeMutation: observeMutation,
1618        observeResize: observeResize,
1619        observeViewportResize: observeViewportResize,
1620        off: off,
1621        offset: offset,
1622        offsetPosition: offsetPosition,
1623        offsetViewport: offsetViewport,
1624        on: on,
1625        once: once,
1626        overflowParents: overflowParents,
1627        parent: parent,
1628        parents: parents,
1629        pause: pause,
1630        pick: pick,
1631        play: play,
1632        pointInRect: pointInRect,
1633        pointerCancel: pointerCancel,
1634        pointerDown: pointerDown$1,
1635        pointerEnter: pointerEnter,
1636        pointerLeave: pointerLeave,
1637        pointerMove: pointerMove$1,
1638        pointerUp: pointerUp$1,
1639        position: position,
1640        positionAt: positionAt,
1641        prepend: prepend,
1642        propName: propName,
1643        query: query,
1644        queryAll: queryAll,
1645        ready: ready,
1646        remove: remove$1,
1647        removeAttr: removeAttr,
1648        removeClass: removeClass,
1649        replaceClass: replaceClass,
1650        scrollIntoView: scrollIntoView,
1651        scrollParent: scrollParent,
1652        scrollParents: scrollParents,
1653        scrolledOver: scrolledOver,
1654        selFocusable: selFocusable,
1655        selInput: selInput,
1656        sortBy: sortBy,
1657        startsWith: startsWith,
1658        sumBy: sumBy,
1659        swap: swap,
1660        toArray: toArray,
1661        toBoolean: toBoolean,
1662        toEventTargets: toEventTargets,
1663        toFloat: toFloat,
1664        toNode: toNode,
1665        toNodes: toNodes,
1666        toNumber: toNumber,
1667        toPx: toPx,
1668        toWindow: toWindow,
1669        toggleClass: toggleClass,
1670        trigger: trigger,
1671        ucfirst: ucfirst,
1672        uniqueBy: uniqueBy,
1673        unwrap: unwrap,
1674        width: width,
1675        wrapAll: wrapAll,
1676        wrapInner: wrapInner
1677    });
1678
1679    var Class = {
1680      connected() {
1681        addClass(this.$el, this.$options.id);
1682      }
1683    };
1684
1685    const units = ["days", "hours", "minutes", "seconds"];
1686    var countdown = {
1687      mixins: [Class],
1688      props: {
1689        date: String,
1690        clsWrapper: String,
1691        role: String
1692      },
1693      data: {
1694        date: "",
1695        clsWrapper: ".hk-countdown-%unit%",
1696        role: "timer"
1697      },
1698      connected() {
1699        attr(this.$el, "role", this.role);
1700        this.date = toFloat(Date.parse(this.$props.date));
1701        this.end = false;
1702        this.start();
1703      },
1704      disconnected() {
1705        this.stop();
1706      },
1707      events: {
1708        name: "visibilitychange",
1709        el: () => document,
1710        handler() {
1711          if (document.hidden) {
1712            this.stop();
1713          } else {
1714            this.start();
1715          }
1716        }
1717      },
1718      methods: {
1719        start() {
1720          this.stop();
1721          this.update();
1722          if (!this.timer) {
1723            trigger(this.$el, "countdownstart");
1724            this.timer = setInterval(this.update, 1e3);
1725          }
1726        },
1727        stop() {
1728          if (this.timer) {
1729            clearInterval(this.timer);
1730            trigger(this.$el, "countdownstop");
1731            this.timer = null;
1732          }
1733        },
1734        update() {
1735          const timespan = getTimeSpan(this.date);
1736          if (!timespan.total) {
1737            this.stop();
1738            if (!this.end) {
1739              trigger(this.$el, "countdownend");
1740              this.end = true;
1741            }
1742          }
1743          for (const unit of units) {
1744            const el = $(this.clsWrapper.replace("%unit%", unit), this.$el);
1745            if (!el) {
1746              continue;
1747            }
1748            let digits = Math.trunc(timespan[unit]).toString().padStart(2, "0");
1749            if (el.textContent !== digits) {
1750              digits = digits.split("");
1751              if (digits.length !== el.children.length) {
1752                html(el, digits.map(() => "<span></span>").join(""));
1753              }
1754              digits.forEach((digit, i) => el.children[i].textContent = digit);
1755            }
1756          }
1757        }
1758      }
1759    };
1760    function getTimeSpan(date) {
1761      const total = Math.max(0, date - Date.now()) / 1e3;
1762      return {
1763        total,
1764        seconds: total % 60,
1765        minutes: total / 60 % 60,
1766        hours: total / 60 / 60 % 24,
1767        days: total / 60 / 60 / 24
1768      };
1769    }
1770
1771    const strats = {};
1772    strats.events = strats.watch = strats.observe = strats.created = strats.beforeConnect = strats.connected = strats.beforeDisconnect = strats.disconnected = strats.destroy = concatStrat;
1773    strats.args = function(parentVal, childVal) {
1774      return childVal !== false && concatStrat(childVal || parentVal);
1775    };
1776    strats.update = function(parentVal, childVal) {
1777      return sortBy(
1778        concatStrat(parentVal, isFunction(childVal) ? { read: childVal } : childVal),
1779        "order"
1780      );
1781    };
1782    strats.props = function(parentVal, childVal) {
1783      if (isArray(childVal)) {
1784        const value = {};
1785        for (const key of childVal) {
1786          value[key] = String;
1787        }
1788        childVal = value;
1789      }
1790      return strats.methods(parentVal, childVal);
1791    };
1792    strats.computed = strats.methods = function(parentVal, childVal) {
1793      return childVal ? parentVal ? { ...parentVal, ...childVal } : childVal : parentVal;
1794    };
1795    strats.i18n = strats.data = function(parentVal, childVal, vm) {
1796      if (!vm) {
1797        if (!childVal) {
1798          return parentVal;
1799        }
1800        if (!parentVal) {
1801          return childVal;
1802        }
1803        return function(vm2) {
1804          return mergeFnData(parentVal, childVal, vm2);
1805        };
1806      }
1807      return mergeFnData(parentVal, childVal, vm);
1808    };
1809    function mergeFnData(parentVal, childVal, vm) {
1810      return strats.computed(
1811        isFunction(parentVal) ? parentVal.call(vm, vm) : parentVal,
1812        isFunction(childVal) ? childVal.call(vm, vm) : childVal
1813      );
1814    }
1815    function concatStrat(parentVal, childVal) {
1816      parentVal = parentVal && !isArray(parentVal) ? [parentVal] : parentVal;
1817      return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal;
1818    }
1819    function defaultStrat(parentVal, childVal) {
1820      return isUndefined(childVal) ? parentVal : childVal;
1821    }
1822    function mergeOptions(parent, child, vm) {
1823      const options = {};
1824      if (isFunction(child)) {
1825        child = child.options;
1826      }
1827      if (child.extends) {
1828        parent = mergeOptions(parent, child.extends, vm);
1829      }
1830      if (child.mixins) {
1831        for (const mixin of child.mixins) {
1832          parent = mergeOptions(parent, mixin, vm);
1833        }
1834      }
1835      for (const key in parent) {
1836        mergeKey(key);
1837      }
1838      for (const key in child) {
1839        if (!hasOwn(parent, key)) {
1840          mergeKey(key);
1841        }
1842      }
1843      function mergeKey(key) {
1844        options[key] = (strats[key] || defaultStrat)(parent[key], child[key], vm);
1845      }
1846      return options;
1847    }
1848    function parseOptions(options, args = []) {
1849      try {
1850        return options ? startsWith(options, "{") ? JSON.parse(options) : args.length && !includes(options, ":") ? { [args[0]]: options } : options.split(";").reduce((options2, option) => {
1851          const [key, value] = option.split(/:(.*)/);
1852          if (key && !isUndefined(value)) {
1853            options2[key.trim()] = value.trim();
1854          }
1855          return options2;
1856        }, {}) : {};
1857      } catch (e) {
1858        return {};
1859      }
1860    }
1861    function coerce$1(type, value) {
1862      if (type === Boolean) {
1863        return toBoolean(value);
1864      } else if (type === Number) {
1865        return toNumber(value);
1866      } else if (type === "list") {
1867        return toList(value);
1868      } else if (type === Object && isString(value)) {
1869        return parseOptions(value);
1870      }
1871      return type ? type(value) : value;
1872    }
1873    const listRe = /,(?![^(]*\))/;
1874    function toList(value) {
1875      return isArray(value) ? value : isString(value) ? value.split(listRe).map((value2) => isNumeric(value2) ? toNumber(value2) : toBoolean(value2.trim())) : [value];
1876    }
1877
1878    function initUpdates(instance) {
1879      instance._data = {};
1880      instance._updates = [...instance.$options.update || []];
1881      instance._disconnect.push(() => instance._updates = instance._data = null);
1882    }
1883    function prependUpdate(instance, update) {
1884      instance._updates.unshift(update);
1885    }
1886    function callUpdate(instance, e = "update") {
1887      if (!instance._connected) {
1888        return;
1889      }
1890      if (!instance._updates.length) {
1891        return;
1892      }
1893      if (!instance._queued) {
1894        instance._queued = /* @__PURE__ */ new Set();
1895        fastdom.read(() => {
1896          if (instance._connected) {
1897            runUpdates(instance, instance._queued);
1898          }
1899          instance._queued = null;
1900        });
1901      }
1902      instance._queued.add(e.type || e);
1903    }
1904    function runUpdates(instance, types) {
1905      for (const { read, write, events = [] } of instance._updates) {
1906        if (!types.has("update") && !events.some((type) => types.has(type))) {
1907          continue;
1908        }
1909        let result;
1910        if (read) {
1911          result = read.call(instance, instance._data, types);
1912          if (result && isPlainObject(result)) {
1913            assign(instance._data, result);
1914          }
1915        }
1916        if (write && result !== false) {
1917          fastdom.write(() => {
1918            if (instance._connected) {
1919              write.call(instance, instance._data, types);
1920            }
1921          });
1922        }
1923      }
1924    }
1925
1926    function resize(options) {
1927      return observe(observeResize, options, "resize");
1928    }
1929    function intersection(options) {
1930      return observe(observeIntersection, options);
1931    }
1932    function mutation(options) {
1933      return observe(observeMutation, options);
1934    }
1935    function lazyload(options = {}) {
1936      return intersection({
1937        handler: function(entries, observer) {
1938          const { targets = this.$el, preload = 5 } = options;
1939          for (const el of toNodes(isFunction(targets) ? targets(this) : targets)) {
1940            $$('[loading="lazy"]', el).slice(0, preload - 1).forEach((el2) => removeAttr(el2, "loading"));
1941          }
1942          for (const el of entries.filter(({ isIntersecting }) => isIntersecting).map(({ target }) => target)) {
1943            observer.unobserve(el);
1944          }
1945        },
1946        ...options
1947      });
1948    }
1949    function viewport(options) {
1950      return observe((target, handler) => observeViewportResize(handler), options, "resize");
1951    }
1952    function scroll$1(options) {
1953      return observe(
1954        (target, handler) => ({
1955          disconnect: on(toScrollTargets(target), "scroll", handler, { passive: true })
1956        }),
1957        options,
1958        "scroll"
1959      );
1960    }
1961    function swipe(options) {
1962      return {
1963        observe(target, handler) {
1964          return {
1965            observe: noop,
1966            unobserve: noop,
1967            disconnect: on(target, pointerDown$1, handler, { passive: true })
1968          };
1969        },
1970        handler(e) {
1971          if (!isTouch(e)) {
1972            return;
1973          }
1974          const pos = getEventPos(e);
1975          const target = "tagName" in e.target ? e.target : parent(e.target);
1976          once(document, `${pointerUp$1} ${pointerCancel} scroll`, (e2) => {
1977            const { x, y } = getEventPos(e2);
1978            if (e2.type !== "scroll" && target && x && Math.abs(pos.x - x) > 100 || y && Math.abs(pos.y - y) > 100) {
1979              setTimeout(() => {
1980                trigger(target, "swipe");
1981                trigger(target, `swipe${swipeDirection(pos.x, pos.y, x, y)}`);
1982              });
1983            }
1984          });
1985        },
1986        ...options
1987      };
1988    }
1989    function observe(observe2, options, emit) {
1990      return {
1991        observe: observe2,
1992        handler() {
1993          callUpdate(this, emit);
1994        },
1995        ...options
1996      };
1997    }
1998    function swipeDirection(x1, y1, x2, y2) {
1999      return Math.abs(x1 - x2) >= Math.abs(y1 - y2) ? x1 - x2 > 0 ? "Left" : "Right" : y1 - y2 > 0 ? "Up" : "Down";
2000    }
2001    function toScrollTargets(elements) {
2002      return toNodes(elements).map((node) => {
2003        const { ownerDocument } = node;
2004        const parent2 = scrollParent(node, true);
2005        return parent2 === ownerDocument.scrollingElement ? ownerDocument : parent2;
2006      });
2007    }
2008
2009    var Margin = {
2010      props: {
2011        margin: String,
2012        firstColumn: Boolean
2013      },
2014      data: {
2015        margin: "hk-margin-small-top",
2016        firstColumn: "hk-first-column"
2017      },
2018      observe: [
2019        mutation({
2020          options: {
2021            childList: true
2022          }
2023        }),
2024        mutation({
2025          options: {
2026            attributes: true,
2027            attributeFilter: ["style"]
2028          },
2029          target: ({ $el }) => [$el, ...children($el)]
2030        }),
2031        resize({
2032          target: ({ $el }) => [$el, ...children($el)]
2033        })
2034      ],
2035      update: {
2036        read() {
2037          return {
2038            rows: getRows(children(this.$el))
2039          };
2040        },
2041        write({ rows }) {
2042          for (const row of rows) {
2043            for (const el of row) {
2044              toggleClass(el, this.margin, rows[0] !== row);
2045              toggleClass(el, this.firstColumn, row[isRtl ? row.length - 1 : 0] === el);
2046            }
2047          }
2048        },
2049        events: ["resize"]
2050      }
2051    };
2052    function getRows(elements) {
2053      const sorted = [[]];
2054      const withOffset = elements.some(
2055        (el, i) => i && elements[i - 1].offsetParent !== el.offsetParent
2056      );
2057      for (const el of elements) {
2058        if (!isVisible(el)) {
2059          continue;
2060        }
2061        const offset = getOffset(el, withOffset);
2062        for (let i = sorted.length - 1; i >= 0; i--) {
2063          const current = sorted[i];
2064          if (!current[0]) {
2065            current.push(el);
2066            break;
2067          }
2068          const offsetCurrent = getOffset(current[0], withOffset);
2069          if (offset.top >= offsetCurrent.bottom - 1 && offset.top !== offsetCurrent.top) {
2070            sorted.push([el]);
2071            break;
2072          }
2073          if (offset.bottom - 1 > offsetCurrent.top || offset.top === offsetCurrent.top) {
2074            let j = current.length - 1;
2075            for (; j >= 0; j--) {
2076              const offsetCurrent2 = getOffset(current[j], withOffset);
2077              if (offset.left >= offsetCurrent2.left) {
2078                break;
2079              }
2080            }
2081            current.splice(j + 1, 0, el);
2082            break;
2083          }
2084          if (i === 0) {
2085            sorted.unshift([el]);
2086            break;
2087          }
2088        }
2089      }
2090      return sorted;
2091    }
2092    function getOffset(element, offset = false) {
2093      let { offsetTop, offsetLeft, offsetHeight, offsetWidth } = element;
2094      if (offset) {
2095        [offsetTop, offsetLeft] = offsetPosition(element);
2096      }
2097      return {
2098        top: offsetTop,
2099        left: offsetLeft,
2100        bottom: offsetTop + offsetHeight,
2101        right: offsetLeft + offsetWidth
2102      };
2103    }
2104
2105    async function slide(action, target, duration) {
2106      await awaitFrame();
2107      let nodes = children(target);
2108      const currentProps = nodes.map((el) => getProps$1(el, true));
2109      const targetProps = { ...css(target, ["height", "padding"]), display: "block" };
2110      const targets = nodes.concat(target);
2111      await Promise.all(targets.map(Transition.cancel));
2112      css(targets, "transitionProperty", "none");
2113      await action();
2114      nodes = nodes.concat(children(target).filter((el) => !includes(nodes, el)));
2115      await Promise.resolve();
2116      css(targets, "transitionProperty", "");
2117      const targetStyle = attr(target, "style");
2118      const targetPropsTo = css(target, ["height", "padding"]);
2119      const [propsTo, propsFrom] = getTransitionProps(target, nodes, currentProps);
2120      const attrsTo = nodes.map((el) => ({ style: attr(el, "style") }));

2294    const keyMap = {
2295      TAB: 9,
2296      ESC: 27,
2297      SPACE: 32,
2298      END: 35,
2299      HOME: 36,
2300      LEFT: 37,
2301      UP: 38,
2302      RIGHT: 39,
2303      DOWN: 40
2304    };
2305
2306    var filter = {
2307      mixins: [Animate],
2308      args: "target",
2309      props: {
2310        target: String,
2311        selActive: Boolean
2312      },
2313      data: {
2314        target: "",
2315        selActive: false,
2316        attrItem: "hk-filter-control",
2317        cls: "hk-active",
2318        duration: 250
2319      },
2320      computed: {
2321        children: ({ target }, $el) => $$(`${target} > *`, $el),
2322        toggles: ({ attrItem }, $el) => $$(`[${attrItem}],[data-${attrItem}]`, $el)
2323      },
2324      watch: {
2325        toggles(toggles) {
2326          this.updateState();
2327          const actives = $$(this.selActive, this.$el);
2328          for (const toggle of toggles) {
2329            if (this.selActive !== false) {
2330              toggleClass(toggle, this.cls, includes(actives, toggle));
2331            }
2332            const button = findButton(toggle);
2333            if (isTag(button, "a")) {
2334              attr(button, "role", "button");
2335            }
2336          }
2337        },
2338        children(list, prev) {
2339          if (prev) {
2340            this.updateState();
2341          }
2342        }
2343      },
2344      events: {
2345        name: "click keydown",
2346        delegate: ({ attrItem }) => `[${attrItem}],[data-${attrItem}]`,
2347        handler(e) {
2348          if (e.type === "keydown" && e.keyCode !== keyMap.SPACE) {
2349            return;
2350          }
2351          if (e.target.closest("a,button")) {
2352            e.preventDefault();
2353            this.apply(e.current);
2354          }
2355        }
2356      },
2357      methods: {
2358        apply(el) {
2359          const prevState = this.getState();
2360          const newState = mergeState(el, this.attrItem, this.getState());
2361          if (!isEqualState(prevState, newState)) {
2362            this.setState(newState);
2363          }
2364        },
2365        getState() {
2366          return this.toggles.filter((item) => hasClass(item, this.cls)).reduce((state, el) => mergeState(el, this.attrItem, state), {
2367            filter: { "": "" },
2368            sort: []
2369          });
2370        },
2371        async setState(state, animate = true) {
2372          state = { filter: { "": "" }, sort: [], ...state };
2373          trigger(this.$el, "beforeFilter", [this, state]);
2374          for (const toggle of this.toggles) {
2375            toggleClass(toggle, this.cls, matchFilter(toggle, this.attrItem, state));
2376          }
2377          await Promise.all(
2378            $$(this.target, this.$el).map((target) => {
2379              const filterFn = () => applyState(state, target, children(target));
2380              return animate ? this.animate(filterFn, target) : filterFn();
2381            })
2382          );
2383          trigger(this.$el, "afterFilter", [this]);
2384        },
2385        updateState() {
2386          fastdom.write(() => this.setState(this.getState(), false));
2387        }
2388      }
2389    };
2390    function getFilter(el, attr2) {
2391      return parseOptions(data(el, attr2), ["filter"]);
2392    }
2393    function isEqualState(stateA, stateB) {
2394      return ["filter", "sort"].every((prop) => isEqual(stateA[prop], stateB[prop]));
2395    }
2396    function applyState(state, target, children) {
2397      for (const el of children) {
2398        css(
2399          el,
2400          "display",
2401          Object.values(state.filter).every((selector) => !selector || matches(el, selector)) ? "" : "none"
2402        );
2403      }
2404      const [sort, order] = state.sort;
2405      if (sort) {
2406        const sorted = sortItems(children, sort, order);
2407        if (!isEqual(sorted, children)) {
2408          append(target, sorted);
2409        }
2410      }
2411    }
2412    function mergeState(el, attr2, state) {
2413      const { filter, group, sort, order = "asc" } = getFilter(el, attr2);
2414      if (filter || isUndefined(sort)) {
2415        if (group) {
2416          if (filter) {
2417            delete state.filter[""];
2418            state.filter[group] = filter;
2419          } else {
2420            delete state.filter[group];
2421            if (isEmpty(state.filter) || "" in state.filter) {
2422              state.filter = { "": filter || "" };
2423            }
2424          }
2425        } else {
2426          state.filter = { "": filter || "" };
2427        }
2428      }
2429      if (!isUndefined(sort)) {
2430        state.sort = [sort, order];
2431      }
2432      return state;
2433    }
2434    function matchFilter(el, attr2, { filter: stateFilter = { "": "" }, sort: [stateSort, stateOrder] }) {
2435      const { filter = "", group = "", sort, order = "asc" } = getFilter(el, attr2);
2436      return isUndefined(sort) ? group in stateFilter && filter === stateFilter[group] || !filter && group && !(group in stateFilter) && !stateFilter[""] : stateSort === sort && stateOrder === order;
2437    }
2438    function sortItems(nodes, sort, order) {
2439      return [...nodes].sort(
2440        (a, b) => data(a, sort).localeCompare(data(b, sort), void 0, { numeric: true }) * (order === "asc" || -1)
2441      );
2442    }
2443    function findButton(el) {
2444      return $("a,button", el) || el;
2445    }
2446
2447    var img = {
2448      args: "dataSrc",
2449      props: {
2450        dataSrc: String,
2451        sources: String,
2452        margin: String,
2453        target: String,
2454        loading: String
2455      },
2456      data: {
2457        dataSrc: "",
2458        sources: false,
2459        margin: "50%",
2460        target: false,
2461        loading: "lazy"
2462      },
2463      connected() {
2464        if (this.loading !== "lazy") {
2465          this.load();
2466        } else if (isImg(this.$el)) {
2467          this.$el.loading = "lazy";
2468          setSrcAttrs(this.$el);
2469        }
2470      },
2471      disconnected() {
2472        if (this.img) {
2473          this.img.onload = "";
2474        }
2475        delete this.img;
2476      },
2477      observe: intersection({
2478        handler(entries, observer) {
2479          this.load();
2480          observer.disconnect();
2481        },
2482        options: ({ margin }) => ({ rootMargin: margin }),
2483        filter: ({ loading }) => loading === "lazy",
2484        target: ({ $el, $props }) => $props.target ? [$el, ...queryAll($props.target, $el)] : $el
2485      }),
2486      methods: {
2487        load() {
2488          if (this.img) {
2489            return this.img;
2490          }
2491          const image = isImg(this.$el) ? this.$el : getImageFromElement(this.$el, this.dataSrc, this.sources);
2492          removeAttr(image, "loading");
2493          setSrcAttrs(this.$el, image.currentSrc);
2494          return this.img = image;
2495        }
2496      }
2497    };
2498    function setSrcAttrs(el, src) {
2499      if (isImg(el)) {
2500        const parentNode = parent(el);
2501        const elements = isTag(parentNode, "picture") ? children(parentNode) : [el];
2502        elements.forEach((el2) => setSourceProps(el2, el2));
2503      } else if (src) {
2504        const change = !includes(el.style.backgroundImage, src);
2505        if (change) {
2506          css(el, "backgroundImage", `url(${escape(src)})`);
2507          trigger(el, createEvent("load", false));
2508        }
2509      }
2510    }
2511    const srcProps = ["data-src", "data-srcset", "sizes"];
2512    function setSourceProps(sourceEl, targetEl) {
2513      for (const prop of srcProps) {
2514        const value = data(sourceEl, prop);
2515        if (value) {
2516          attr(targetEl, prop.replace(/data-/g, ""), value);
2517        }
2518      }
2519    }
2520    function getImageFromElement(el, src, sources) {
2521      const img = new Image();
2522      wrapInPicture(img, sources);
2523      setSourceProps(el, img);
2524      img.onload = () => setSrcAttrs(el, img.currentSrc);
2525      attr(img, "src", src);
2526      return img;
2527    }
2528    function wrapInPicture(img, sources) {
2529      sources = parseSources(sources);
2530      if (sources.length) {
2531        const picture = fragment("<picture>");
2532        for (const attrs of sources) {
2533          const source = fragment("<source>");
2534          attr(source, attrs);
2535          append(picture, source);
2536        }
2537        append(picture, img);
2538      }
2539    }
2540    function parseSources(sources) {
2541      if (!sources) {
2542        return [];
2543      }
2544      if (startsWith(sources, "[")) {
2545        try {
2546          sources = JSON.parse(sources);
2547        } catch (e) {
2548          sources = [];
2549        }
2550      } else {
2551        sources = parseOptions(sources);
2552      }
2553      if (!isArray(sources)) {
2554        sources = [sources];
2555      }
2556      return sources.filter((source) => !isEmpty(source));
2557    }
2558    function isImg(el) {
2559      return isTag(el, "img");
2560    }
2561
2562    let prevented;
2563    function preventBackgroundScroll(el) {
2564      const off = on(
2565        el,
2566        "touchstart",
2567        (e) => {
2568          if (e.targetTouches.length !== 1 || matches(e.target, 'input[type="range"')) {
2569            return;
2570          }
2571          let prev = getEventPos(e).y;
2572          const offMove = on(
2573            el,
2574            "touchmove",
2575            (e2) => {
2576              const pos = getEventPos(e2).y;
2577              if (pos === prev) {
2578                return;
2579              }
2580              prev = pos;
2581              if (!scrollParents(e2.target).some((scrollParent) => {
2582                if (!el.contains(scrollParent)) {
2583                  return false;
2584                }
2585                let { scrollHeight, clientHeight } = scrollParent;
2586                return clientHeight < scrollHeight;
2587              })) {
2588                e2.preventDefault();
2589              }
2590            },
2591            { passive: false }
2592          );
2593          once(el, "scroll touchend touchcanel", offMove, { capture: true });
2594        },
2595        { passive: true }
2596      );
2597      if (prevented) {
2598        return off;
2599      }
2600      prevented = true;
2601      const { scrollingElement } = document;
2602      css(scrollingElement, {
2603        overflowY: CSS.supports("overflow", "clip") ? "clip" : "hidden",
2604        touchAction: "none",
2605        paddingRight: width(window) - scrollingElement.clientWidth || ""
2606      });
2607      return () => {
2608        prevented = false;
2609        off();
2610        css(scrollingElement, { overflowY: "", touchAction: "", paddingRight: "" });
2611      };
2612    }
2613
2614    var Container = {
2615      props: {
2616        container: Boolean
2617      },
2618      data: {
2619        container: true
2620      },
2621      computed: {
2622        container({ container }) {
2623          return container === true && this.$container || container && $(container);
2624        }
2625      }
2626    };
2627
2628    var Position = {
2629      props: {
2630        pos: String,
2631        offset: Boolean,
2632        flip: Boolean,
2633        shift: Boolean,
2634        inset: Boolean
2635      },
2636      data: {
2637        pos: `bottom-${isRtl ? "right" : "left"}`,
2638        offset: false,
2639        flip: true,
2640        shift: true,
2641        inset: false
2642      },
2643      connected() {
2644        this.pos = this.$props.pos.split("-").concat("center").slice(0, 2);
2645        [this.dir, this.align] = this.pos;
2646        this.axis = includes(["top", "bottom"], this.dir) ? "y" : "x";
2647      },
2648      methods: {
2649        positionAt(element, target, boundary) {
2650          let offset = [this.getPositionOffset(element), this.getShiftOffset(element)];
2651          const placement = [this.flip && "flip", this.shift && "shift"];
2652          const attach = {
2653            element: [this.inset ? this.dir : flipPosition(this.dir), this.align],
2654            target: [this.dir, this.align]
2655          };
2656          if (this.axis === "y") {
2657            for (const prop in attach) {
2658              attach[prop].reverse();
2659            }
2660            offset.reverse();
2661            placement.reverse();
2662          }
2663          const restoreScrollPosition = storeScrollPosition(element);
2664          const elDim = dimensions$1(element);
2665          css(element, { top: -elDim.height, left: -elDim.width });
2666          positionAt(element, target, {
2667            attach,
2668            offset,
2669            boundary,
2670            placement,
2671            viewportOffset: this.getViewportOffset(element)
2672          });
2673          restoreScrollPosition();
2674        },
2675        getPositionOffset(element = this.$el) {
2676          return toPx(
2677            this.offset === false ? css(element, "--hk-position-offset") : this.offset,
2678            this.axis === "x" ? "width" : "height",
2679            element
2680          ) * (includes(["left", "top"], this.dir) ? -1 : 1) * (this.inset ? -1 : 1);
2681        },
2682        getShiftOffset(element = this.$el) {
2683          return this.align === "center" ? 0 : toPx(
2684            css(element, "--hk-position-shift-offset"),
2685            this.axis === "y" ? "width" : "height",
2686            element
2687          ) * (includes(["left", "top"], this.align) ? 1 : -1);
2688        },
2689        getViewportOffset(element) {
2690          return toPx(css(element, "--hk-position-viewport-offset"));
2691        }
2692      }
2693    };
2694    function storeScrollPosition(element) {
2695      const scrollElement = scrollParent(element);
2696      const { scrollTop } = scrollElement;
2697      return () => {
2698        if (scrollTop !== scrollElement.scrollTop) {
2699          scrollElement.scrollTop = scrollTop;
2700        }
2701      };
2702    }
2703
2704    var Togglable = {
2705      props: {
2706        cls: Boolean,
2707        animation: "list",
2708        duration: Number,
2709        velocity: Number,
2710        origin: String,
2711        transition: String
2712      },
2713      data: {
2714        cls: false,
2715        animation: [false],
2716        duration: 200,
2717        velocity: 0.2,
2718        origin: false,
2719        transition: "ease",
2720        clsEnter: "hk-togglable-enter",
2721        clsLeave: "hk-togglable-leave"
2722      },
2723      computed: {
2724        hasAnimation: ({ animation }) => !!animation[0],
2725        hasTransition: ({ animation }) => ["slide", "reveal"].some((transition) => startsWith(animation[0], transition))
2726      },
2727      methods: {
2728        async toggleElement(targets, toggle, animate) {
2729          try {
2730            await Promise.all(
2731              toNodes(targets).map((el) => {
2732                const show = isBoolean(toggle) ? toggle : !this.isToggled(el);
2733                if (!trigger(el, `before${show ? "show" : "hide"}`, [this])) {
2734                  return Promise.reject();
2735                }
2736                const promise = (isFunction(animate) ? animate : animate === false || !this.hasAnimation ? toggleInstant : this.hasTransition ? toggleTransition : toggleAnimation)(el, show, this);
2737                const cls = show ? this.clsEnter : this.clsLeave;
2738                addClass(el, cls);
2739                trigger(el, show ? "show" : "hide", [this]);
2740                const done = () => {
2741                  var _a;
2742                  removeClass(el, cls);
2743                  trigger(el, show ? "shown" : "hidden", [this]);
2744                  if (show) {
2745                    const restoreScrollPosition = storeScrollPosition(el);
2746                    (_a = $$("[autofocus]", el).find(isVisible)) == null ? void 0 : _a.focus();
2747                    restoreScrollPosition();
2748                  }
2749                };
2750                return promise ? promise.then(done, () => {
2751                  removeClass(el, cls);
2752                  return Promise.reject();
2753                }) : done();
2754              })
2755            );
2756            return true;
2757          } catch (e) {
2758            return false;
2759          }
2760        },
2761        isToggled(el = this.$el) {
2762          el = toNode(el);
2763          return hasClass(el, this.clsEnter) ? true : hasClass(el, this.clsLeave) ? false : this.cls ? hasClass(el, this.cls.split(" ")[0]) : isVisible(el);
2764        },
2765        _toggle(el, toggled) {
2766          if (!el) {
2767            return;
2768          }
2769          toggled = Boolean(toggled);
2770          let changed;
2771          if (this.cls) {
2772            changed = includes(this.cls, " ") || toggled !== hasClass(el, this.cls);
2773            changed && toggleClass(el, this.cls, includes(this.cls, " ") ? void 0 : toggled);
2774          } else {
2775            changed = toggled === el.hidden;
2776            changed && (el.hidden = !toggled);
2777          }
2778          if (changed) {
2779            trigger(el, "toggled", [toggled, this]);
2780          }
2781        }
2782      }
2783    };
2784    function toggleInstant(el, show, { _toggle }) {
2785      Animation.cancel(el);
2786      Transition.cancel(el);
2787      return _toggle(el, show);
2788    }
2789    async function toggleTransition(el, show, { animation, duration, velocity, transition, _toggle }) {
2790      var _a;
2791      const [mode = "reveal", startProp = "top"] = ((_a = animation[0]) == null ? void 0 : _a.split("-")) || [];
2792      const dirs = [
2793        ["left", "right"],
2794        ["top", "bottom"]
2795      ];
2796      const dir = dirs[includes(dirs[0], startProp) ? 0 : 1];
2797      const end = dir[1] === startProp;
2798      const props = ["width", "height"];
2799      const dimProp = props[dirs.indexOf(dir)];
2800      const marginProp = `margin-${dir[0]}`;
2801      const marginStartProp = `margin-${startProp}`;
2802      let currentDim = dimensions$1(el)[dimProp];
2803      const inProgress = Transition.inProgress(el);
2804      await Transition.cancel(el);
2805      if (show) {
2806        _toggle(el, true);
2807      }
2808      const prevProps = Object.fromEntries(
2809        [
2810          "padding",
2811          "border",
2812          "width",
2813          "height",
2814          "minWidth",
2815          "minHeight",
2816          "overflowY",
2817          "overflowX",
2818          marginProp,
2819          marginStartProp
2820        ].map((key) => [key, el.style[key]])
2821      );
2822      const dim = dimensions$1(el);
2823      const currentMargin = toFloat(css(el, marginProp));
2824      const marginStart = toFloat(css(el, marginStartProp));
2825      const endDim = dim[dimProp] + marginStart;
2826      if (!inProgress && !show) {
2827        currentDim += marginStart;
2828      }
2829      const [wrapper] = wrapInner(el, "<div>");
2830      css(wrapper, {
2831        boxSizing: "border-box",
2832        height: dim.height,
2833        width: dim.width,
2834        ...css(el, [
2835          "overflow",
2836          "padding",
2837          "borderTop",
2838          "borderRight",
2839          "borderBottom",
2840          "borderLeft",
2841          "borderImage",
2842          marginStartProp
2843        ])
2844      });
2845      css(el, {
2846        padding: 0,
2847        border: 0,
2848        minWidth: 0,
2849        minHeight: 0,
2850        [marginStartProp]: 0,
2851        width: dim.width,
2852        height: dim.height,
2853        overflow: "hidden",
2854        [dimProp]: currentDim
2855      });
2856      const percent = currentDim / endDim;
2857      duration = (velocity * endDim + duration) * (show ? 1 - percent : percent);
2858      const endProps = { [dimProp]: show ? endDim : 0 };
2859      if (end) {
2860        css(el, marginProp, endDim - currentDim + currentMargin);
2861        endProps[marginProp] = show ? currentMargin : endDim + currentMargin;
2862      }
2863      if (!end ^ mode === "reveal") {
2864        css(wrapper, marginProp, -endDim + currentDim);
2865        Transition.start(wrapper, { [marginProp]: show ? 0 : -endDim }, duration, transition);
2866      }
2867      try {
2868        await Transition.start(el, endProps, duration, transition);
2869      } finally {
2870        css(el, prevProps);
2871        unwrap(wrapper.firstChild);
2872        if (!show) {
2873          _toggle(el, false);
2874        }
2875      }
2876    }
2877    function toggleAnimation(el, show, cmp) {
2878      const { animation, duration, _toggle } = cmp;
2879      if (show) {
2880        _toggle(el, true);
2881        return Animation.in(el, animation[0], duration, cmp.origin);
2882      }
2883      return Animation.out(el, animation[1] || animation[0], duration, cmp.origin).then(
2884        () => _toggle(el, false)
2885      );
2886    }
2887
2888    const active$1 = [];
2889    var Modal = {
2890      mixins: [Class, Container, Togglable],
2891      props: {
2892        selPanel: String,
2893        selClose: String,
2894        escClose: Boolean,
2895        bgClose: Boolean,
2896        stack: Boolean,
2897        role: String
2898      },
2899      data: {
2900        cls: "hk-open",
2901        escClose: true,
2902        bgClose: true,
2903        overlay: true,
2904        stack: false,
2905        role: "dialog"
2906      },
2907      computed: {
2908        panel: ({ selPanel }, $el) => $(selPanel, $el),