https://wolli.ai/wp-content/plugins/bdthemes-element-pack-lite/assets/js/bdt-uikit.js?ver=3.21.7

1/*! bdtUIkit 3.21.7 | 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.bdtUIkit = 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 ownerDocument.getElementById(id) || ownerDocument.getElementsByName(id)[0];
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 isString(selector) && parseSelector(selector).isContextSelector || isDocument(context) ? context : context.ownerDocument;
371    }
372    const addStarRe = /([!>+~-])(?=\s+[!>+~-]|\s*$)/g;
373    const splitSelectorRe = /(\([^)]*\)|[^,])+/g;
374    const parseSelector = memoize((selector) => {
375      selector = selector.replace(addStarRe, "$1 *");
376      let isContextSelector = false;
377      const selectors = [];
378      for (let sel of selector.match(splitSelectorRe)) {
379        sel = sel.trim();
380        isContextSelector || (isContextSelector = ["!", "+", "~", "-", ">"].includes(sel[0]));
381        selectors.push(sel);
382      }
383      return {
384        selector: selectors.join(","),
385        selectors,
386        isContextSelector
387      };
388    });
389    const positionRe = /(\([^)]*\)|\S)*/;
390    const parsePositionSelector = memoize((selector) => {
391      selector = selector.slice(1).trim();
392      const [position] = selector.match(positionRe);
393      return [position, selector.slice(position.length + 1)];
394    });
395    function _query(selector, context = document, queryFn) {
396      if (!selector || !isString(selector)) {
397        return selector;
398      }
399      const parsed = parseSelector(selector);
400      if (!parsed.isContextSelector) {
401        return _doQuery(context, queryFn, parsed.selector);
402      }
403      selector = "";
404      const isSingle = parsed.selectors.length === 1;
405      for (let sel of parsed.selectors) {
406        let positionSel;
407        let ctx = context;
408        if (sel[0] === "!") {
409          [positionSel, sel] = parsePositionSelector(sel);
410          ctx = context.parentElement.closest(positionSel);
411          if (!sel && isSingle) {
412            return ctx;
413          }
414        }
415        if (ctx && sel[0] === "-") {
416          [positionSel, sel] = parsePositionSelector(sel);
417          ctx = ctx.previousElementSibling;
418          ctx = matches(ctx, positionSel) ? ctx : null;
419          if (!sel && isSingle) {
420            return ctx;
421          }
422        }
423        if (!ctx) {
424          continue;
425        }
426        if (isSingle) {
427          if (sel[0] === "~" || sel[0] === "+") {
428            sel = `:scope > :nth-child(${index(ctx) + 1}) ${sel}`;
429            ctx = ctx.parentElement;
430          } else if (sel[0] === ">") {
431            sel = `:scope ${sel}`;
432          }
433          return _doQuery(ctx, queryFn, sel);
434        }
435        selector += `${selector ? "," : ""}${domPath(ctx)} ${sel}`;
436      }
437      if (!isDocument(context)) {
438        context = context.ownerDocument;
439      }
440      return _doQuery(context, queryFn, selector);
441    }
442    function _doQuery(context, queryFn, selector) {
443      try {
444        return context[queryFn](selector);
445      } catch (e) {
446        return null;
447      }
448    }
449    function domPath(element) {
450      const names = [];
451      while (element.parentNode) {
452        const id = attr(element, "id");
453        if (id) {
454          names.unshift(`#${escape(id)}`);
455          break;
456        } else {
457          let { tagName } = element;
458          if (tagName !== "HTML") {
459            tagName += `:nth-child(${index(element) + 1})`;
460          }
461          names.unshift(tagName);
462          element = element.parentNode;
463        }
464      }
465      return names.join(" > ");
466    }
467    function escape(css) {
468      return isString(css) ? CSS.escape(css) : "";
469    }
470
471    function on(...args) {
472      let [targets, types, selector, listener, useCapture = false] = getArgs(args);
473      if (listener.length > 1) {
474        listener = detail(listener);
475      }
476      if (useCapture == null ? void 0 : useCapture.self) {
477        listener = selfFilter(listener);
478      }
479      if (selector) {
480        listener = delegate(selector, listener);
481      }
482      for (const type of types) {
483        for (const target of targets) {
484          target.addEventListener(type, listener, useCapture);
485        }
486      }
487      return () => off(targets, types, listener, useCapture);
488    }
489    function off(...args) {
490      let [targets, types, , listener, useCapture = false] = getArgs(args);
491      for (const type of types) {
492        for (const target of targets) {
493          target.removeEventListener(type, listener, useCapture);
494        }
495      }
496    }
497    function once(...args) {
498      const [element, types, selector, listener, useCapture = false, condition] = getArgs(args);
499      const off2 = on(
500        element,
501        types,
502        selector,
503        (e) => {
504          const result = !condition || condition(e);
505          if (result) {
506            off2();
507            listener(e, result);
508          }
509        },
510        useCapture
511      );
512      return off2;
513    }
514    function trigger(targets, event, detail2) {
515      return toEventTargets(targets).every(
516        (target) => target.dispatchEvent(createEvent(event, true, true, detail2))
517      );
518    }
519    function createEvent(e, bubbles = true, cancelable = false, detail2) {
520      if (isString(e)) {

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

764        (_a = $(ref)) == null ? void 0 : _a[fn](...nodes);
765        return unwrapSingle(nodes);
766      };
767    }
768    function remove$1(element) {
769      toNodes(element).forEach((element2) => element2.remove());
770    }
771    function wrapAll(element, structure) {
772      structure = toNode(before(element, structure));
773      while (structure.firstElementChild) {
774        structure = structure.firstElementChild;
775      }
776      append(structure, element);
777      return structure;
778    }
779    function wrapInner(element, structure) {
780      return toNodes(
781        toNodes(element).map(
782          (element2) => element2.hasChildNodes() ? wrapAll(toArray(element2.childNodes), structure) : append(element2, structure)
783        )
784      );
785    }
786    function unwrap(element) {
787      toNodes(element).map(parent).filter((value, index, self) => self.indexOf(value) === index).forEach((parent2) => parent2.replaceWith(...parent2.childNodes));
788    }
789    const singleTagRe = /^<(\w+)\s*\/?>(?:<\/\1>)?$/;
790    function fragment(html2) {
791      const matches = singleTagRe.exec(html2);
792      if (matches) {
793        return document.createElement(matches[1]);
794      }
795      const container = document.createElement("template");
796      container.innerHTML = html2.trim();
797      return unwrapSingle(container.content.childNodes);
798    }
799    function unwrapSingle(nodes) {
800      return nodes.length > 1 ? nodes : nodes[0];
801    }
802    function apply(node, fn) {
803      if (!isElement(node)) {
804        return;
805      }
806      fn(node);
807      node = node.firstElementChild;
808      while (node) {
809        apply(node, fn);
810        node = node.nextElementSibling;
811      }
812    }
813    function $(selector, context) {
814      return isHtml(selector) ? toNode(fragment(selector)) : find(selector, context);
815    }
816    function $$(selector, context) {
817      return isHtml(selector) ? toNodes(fragment(selector)) : findAll(selector, context);
818    }
819    function isHtml(str) {
820      return isString(str) && startsWith(str.trim(), "<");
821    }
822
823    const dirs$1 = {
824      width: ["left", "right"],
825      height: ["top", "bottom"]
826    };
827    function dimensions$1(element) {
828      const rect = isElement(element) ? toNode(element).getBoundingClientRect() : { height: height(element), width: width(element), top: 0, left: 0 };
829      return {
830        height: rect.height,
831        width: rect.width,
832        top: rect.top,
833        left: rect.left,
834        bottom: rect.top + rect.height,
835        right: rect.left + rect.width
836      };
837    }
838    function offset(element, coordinates) {
839      if (coordinates) {
840        css(element, { left: 0, top: 0 });
841      }
842      const currentOffset = dimensions$1(element);
843      if (element) {
844        const { scrollY, scrollX } = toWindow(element);
845        const offsetBy = { height: scrollY, width: scrollX };
846        for (const dir in dirs$1) {
847          for (const prop of dirs$1[dir]) {
848            currentOffset[prop] += offsetBy[dir];
849          }
850        }
851      }
852      if (!coordinates) {
853        return currentOffset;
854      }
855      for (const prop of ["left", "top"]) {
856        css(element, prop, coordinates[prop] - currentOffset[prop]);
857      }
858    }
859    function position(element) {
860      let { top, left } = offset(element);
861      const {
862        ownerDocument: { body, documentElement },
863        offsetParent
864      } = toNode(element);
865      let parent = offsetParent || documentElement;
866      while (parent && (parent === body || parent === documentElement) && css(parent, "position") === "static") {
867        parent = parent.parentNode;
868      }
869      if (isElement(parent)) {
870        const parentOffset = offset(parent);
871        top -= parentOffset.top + toFloat(css(parent, "borderTopWidth"));
872        left -= parentOffset.left + toFloat(css(parent, "borderLeftWidth"));
873      }
874      return {
875        top: top - toFloat(css(element, "marginTop")),
876        left: left - toFloat(css(element, "marginLeft"))
877      };
878    }
879    function offsetPosition(element) {
880      element = toNode(element);
881      const offset2 = [element.offsetTop, element.offsetLeft];
882      while (element = element.offsetParent) {
883        offset2[0] += element.offsetTop + toFloat(css(element, `borderTopWidth`));
884        offset2[1] += element.offsetLeft + toFloat(css(element, `borderLeftWidth`));
885        if (css(element, "position") === "fixed") {
886          const win = toWindow(element);
887          offset2[0] += win.scrollY;
888          offset2[1] += win.scrollX;
889          return offset2;
890        }
891      }
892      return offset2;
893    }
894    const height = dimension("height");
895    const width = dimension("width");
896    function dimension(prop) {
897      const propName = ucfirst(prop);
898      return (element, value) => {
899        if (isUndefined(value)) {
900          if (isWindow(element)) {
901            return element[`inner${propName}`];
902          }
903          if (isDocument(element)) {
904            const doc = element.documentElement;
905            return Math.max(doc[`offset${propName}`], doc[`scroll${propName}`]);
906          }
907          element = toNode(element);
908          value = css(element, prop);
909          value = value === "auto" ? element[`offset${propName}`] : toFloat(value) || 0;
910          return value - boxModelAdjust(element, prop);
911        } else {
912          return css(
913            element,
914            prop,
915            !value && value !== 0 ? "" : +value + boxModelAdjust(element, prop) + "px"
916          );
917        }
918      };
919    }
920    function boxModelAdjust(element, prop, sizing = "border-box") {
921      return css(element, "boxSizing") === sizing ? sumBy(
922        dirs$1[prop].map(ucfirst),
923        (prop2) => toFloat(css(element, `padding${prop2}`)) + toFloat(css(element, `border${prop2}W

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

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

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

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

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

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