vendor: 8,569 bytes, lines 1-233
1/*! UIkit 3.17.11 | https://www.getuikit.com | (c) 2014 - 2023 YOOtheme | MIT License */ 2 3(function (global, factory) { 4 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : 5 typeof define === 'function' && define.amd ? define('uikit', factory) : 6 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.UIkit = factory()); 7})(this, (function () { 'use strict'; 8 9 const { hasOwnProperty, toString } = Object.prototype; 10 function hasOwn(obj, key) { 11 return hasOwnProperty.call(obj, key); 12 } 13 const hyphenateRe = /\B([A-Z])/g; 14 const hyphenate = memoize((str) => str.replace(hyphenateRe, "-$1").toLowerCase()); 15 const camelizeRe = /-(\w)/g; 16 const camelize = memoize( 17 (str) => (str.charAt(0).toLowerCase() + str.slice(1)).replace(camelizeRe, (_, c) => c.toUpperCase()) 18 ); 19 const ucfirst = memoize((str) => str.charAt(0).toUpperCase() + str.slice(1)); 20 function startsWith(str, search) { 21 var _a; 22 return (_a = str == null ? void 0 : str.startsWith) == null ? void 0 : _a.call(str, search); 23 } 24 function endsWith(str, search) { 25 var _a; 26 return (_a = str == null ? void 0 : str.endsWith) == null ? void 0 : _a.call(str, search); 27 } 28 function includes(obj, search) { 29 var _a; 30 return (_a = obj == null ? void 0 : obj.includes) == null ? void 0 : _a.call(obj, search); 31 } 32 function findIndex(array, predicate) { 33 var _a; 34 return (_a = array == null ? void 0 : array.findIndex) == null ? void 0 : _a.call(array, predicate); 35 } 36 const { isArray, from: toArray } = Array; 37 const { assign } = Object; 38 function isFunction(obj) { 39 return typeof obj === "function"; 40 } 41 function isObject(obj) { 42 return obj !== null && typeof obj === "object"; 43 } 44 function isPlainObject(obj) { 45 return toString.call(obj) === "[object Object]"; 46 } 47 function isWindow(obj) { 48 return isObject(obj) && obj === obj.window; 49 } 50 function isDocument(obj) { 51 return nodeType(obj) === 9; 52 } 53 function isNode(obj) { 54 return nodeType(obj) >= 1; 55 } 56 function isElement(obj) { 57 return nodeType(obj) === 1; 58 } 59 function nodeType(obj) { 60 return !isWindow(obj) && isObject(obj) && obj.nodeType; 61 } 62 function isBoolean(value) { 63 return typeof value === "boolean"; 64 } 65 function isString(value) { 66 return typeof value === "string"; 67 } 68 function isNumber(value) { 69 return typeof value === "number"; 70 } 71 function isNumeric(value) { 72 return isNumber(value) || isString(value) && !isNaN(value - parseFloat(value)); 73 } 74 function isEmpty(obj) { 75 return !(isArray(obj) ? obj.length : isObject(obj) ? Object.keys(obj).length : false); 76 } 77 function isUndefined(value) { 78 return value === void 0; 79 } 80 function toBoolean(value) { 81 return isBoolean(value) ? value : value === "true" || value === "1" || value === "" ? true : value === "false" || value === "0" ? false : value; 82 } 83 function toNumber(value) { 84 const number = Number(value); 85 return isNaN(number) ? false : number; 86 } 87 function toFloat(value) { 88 return parseFloat(value) || 0; 89 } 90 function toNode(element) { 91 return toNodes(element)[0]; 92 } 93 function toNodes(element) { 94 return isNode(element) ? [element] : Array.from(element || []).filter(isNode); 95 } 96 function toWindow(element) { 97 if (isWindow(element)) { 98 return element; 99 } 100 element = toNode(element); 101 const document = isDocument(element) ? element : element == null ? void 0 : element.ownerDocument; 102 return (document == null ? void 0 : document.defaultView) || window; 103 } 104 function isEqual(value, other) { 105 return value === other || isObject(value) && isObject(other) && Object.keys(value).length === Object.keys(other).length && each(value, (val, key) => val === other[key]); 106 } 107 function swap(value, a, b) { 108 return value.replace(new RegExp(`${a}|${b}`, "g"), (match) => match === a ? b : a); 109 } 110 function last(array) { 111 return array[array.length - 1]; 112 } 113 function each(obj, cb) { 114 for (const key in obj) { 115 if (false === cb(obj[key], key)) { 116 return false; 117 } 118 } 119 return true; 120 } 121 function sortBy(array, prop) { 122 return array.slice().sort( 123 ({ [prop]: propA = 0 }, { [prop]: propB = 0 }) => propA > propB ? 1 : propB > propA ? -1 : 0 124 ); 125 } 126 function sumBy(array, iteratee) { 127 return array.reduce( 128 (sum, item) => sum + toFloat(isFunction(iteratee) ? iteratee(item) : item[iteratee]), 129 0 130 ); 131 } 132 function uniqueBy(array, prop) { 133 const seen = /* @__PURE__ */ new Set(); 134 return array.filter(({ [prop]: check }) => seen.has(check) ? false : seen.add(check)); 135 } 136 function pick(obj, props) { 137 return props.reduce((res, prop) => ({ ...res, [prop]: obj[prop] }), {}); 138 } 139 function clamp(number, min = 0, max = 1) { 140 return Math.min(Math.max(toNumber(number) || 0, min), max); 141 } 142 function noop() { 143 } 144 function intersectRect(...rects) { 145 return [ 146 ["bottom", "top"], 147 ["right", "left"] 148 ].every( 149 ([minProp, maxProp]) => Math.min(...rects.map(({ [minProp]: min }) => min)) - Math.max(...rects.map(({ [maxProp]: max }) => max)) > 0 150 ); 151 } 152 function pointInRect(point, rect) { 153 return point.x <= rect.right && point.x >= rect.left && point.y <= rect.bottom && point.y >= rect.top; 154 } 155 function ratio(dimensions, prop, value) { 156 const aProp = prop === "width" ? "height" : "width"; 157 return { 158 [aProp]: dimensions[prop] ? Math.round(value * dimensions[aProp] / dimensions[prop]) : dimensions[aProp], 159 [prop]: value 160 }; 161 } 162 function contain(dimensions, maxDimensions) { 163 dimensions = { ...dimensions }; 164 for (const prop in dimensions) { 165 dimensions = dimensions[prop] > maxDimensions[prop] ? ratio(dimensions, prop, maxDimensions[prop]) : dimensions; 166 } 167 return dimensions; 168 } 169 function cover$1(dimensions, maxDimensions) { 170 dimensions = contain(dimensions, maxDimensions); 171 for (const prop in dimensions) { 172 dimensions = dimensions[prop] < maxDimensions[prop] ? ratio(dimensions, prop, maxDimensions[prop]) : dimensions; 173 } 174 return dimensions; 175 } 176 const Dimensions = { ratio, contain, cover: cover$1 }; 177 function getIndex(i, elements, current = 0, finite = false) { 178 elements = toNodes(elements); 179 const { length } = elements; 180 if (!length) { 181 return -1; 182 } 183 i = isNumeric(i) ? toNumber(i) : i === "next" ? current + 1 : i === "previous" ? current - 1 : i === "last" ? length - 1 : elements.indexOf(toNode(i)); 184 if (finite) { 185 return clamp(i, 0, length - 1); 186 } 187 i %= length; 188 return i < 0 ? i + length : i; 189 } 190 function memoize(fn) { 191 const cache = /* @__PURE__ */ Object.create(null); 192 return (key, ...args) => cache[key] || (cache[key] = fn(key, ...args)); 193 } 194 195 function attr(element, name, value) { 196 var _a; 197 if (isObject(name)) { 198 for (const key in name) { 199 attr(element, key, name[key]); 200 } 201 return; 202 } 203 if (isUndefined(value)) { 204 return (_a = toNode(element)) == null ? void 0 : _a.getAttribute(name); 205 } else { 206 for (const el of toNodes(element)) { 207 if (isFunction(value)) { 208 value = value.call(el, attr(el, name)); 209 } 210 if (value === null) { 211 removeAttr(el, name); 212 } else { 213 el.setAttribute(name, value); 214 } 215 } 216 } 217 } 218 function hasAttr(element, name) { 219 return toNodes(element).some((element2) => element2.hasAttribute(name)); 220 } 221 function removeAttr(element, name) { 222 toNodes(element).forEach((element2) => element2.removeAttribute(name)); 223 } 224 function data(element, attribute) { 225 for (const name of [attribute, `data-${attribute}`]) { 226 if (hasAttr(element, name)) { 227 return attr(element, name); 228 } 229 } 230 } 231 232 function addClass(element, ...classes) { 233 for (const node of toNodes(element)) {
vendor: 4,693 bytes, lines 234-365
234 const add = toClasses(classes).filter((cls) => !hasClass(node, cls)); 235 if (add.length) { 236 node.classList.add(...add); 237 } 238 } 239 } 240 function removeClass(element, ...classes) { 241 for (const node of toNodes(element)) { 242 const remove = toClasses(classes).filter((cls) => hasClass(node, cls)); 243 if (remove.length) { 244 node.classList.remove(...remove); 245 } 246 } 247 } 248 function removeClasses$1(element, clsRegex) { 249 clsRegex = new RegExp(clsRegex); 250 for (const node of toNodes(element)) { 251 node.classList.remove(...toArray(node.classList).filter((cls) => cls.match(clsRegex))); 252 } 253 } 254 function replaceClass(element, oldClass, newClass) { 255 newClass = toClasses(newClass); 256 oldClass = toClasses(oldClass).filter((cls) => !includes(newClass, cls)); 257 removeClass(element, oldClass); 258 addClass(element, newClass); 259 } 260 function hasClass(element, cls) { 261 [cls] = toClasses(cls); 262 return toNodes(element).some((node) => node.classList.contains(cls)); 263 } 264 function toggleClass(element, cls, force) { 265 const classes = toClasses(cls); 266 if (!isUndefined(force)) { 267 force = !!force; 268 } 269 for (const node of toNodes(element)) { 270 for (const cls2 of classes) { 271 node.classList.toggle(cls2, force); 272 } 273 } 274 } 275 function toClasses(str) { 276 return str ? isArray(str) ? str.map(toClasses).flat() : String(str).split(/[ ,]/).filter(Boolean) : []; 277 } 278 279 const voidElements = { 280 area: true, 281 base: true, 282 br: true, 283 col: true, 284 embed: true, 285 hr: true, 286 img: true, 287 input: true, 288 keygen: true, 289 link: true, 290 meta: true, 291 param: true, 292 source: true, 293 track: true, 294 wbr: true 295 }; 296 function isVoidElement(element) { 297 return toNodes(element).some((element2) => voidElements[element2.tagName.toLowerCase()]); 298 } 299 function isVisible(element) { 300 return toNodes(element).some( 301 (element2) => element2.offsetWidth || element2.offsetHeight || element2.getClientRects().length 302 ); 303 } 304 const selInput = "input,select,textarea,button"; 305 function isInput(element) { 306 return toNodes(element).some((element2) => matches(element2, selInput)); 307 } 308 const selFocusable = `${selInput},a[href],[tabindex]`; 309 function isFocusable(element) { 310 return matches(element, selFocusable); 311 } 312 function parent(element) { 313 var _a; 314 return (_a = toNode(element)) == null ? void 0 : _a.parentElement; 315 } 316 function filter$1(element, selector) { 317 return toNodes(element).filter((element2) => matches(element2, selector)); 318 } 319 function matches(element, selector) { 320 return toNodes(element).some((element2) => element2.matches(selector)); 321 } 322 function closest(element, selector) { 323 var _a; 324 return (_a = toNode(element)) == null ? void 0 : _a.closest(startsWith(selector, ">") ? selector.slice(1) : selector); 325 } 326 function within(element, selector) { 327 return isString(selector) ? !!closest(element, selector) : toNode(selector).contains(toNode(element)); 328 } 329 function parents(element, selector) { 330 const elements = []; 331 while (element = parent(element)) { 332 if (!selector || matches(element, selector)) { 333 elements.push(element); 334 } 335 } 336 return elements; 337 } 338 function children(element, selector) { 339 element = toNode(element); 340 const children2 = element ? toArray(element.children) : []; 341 return selector ? filter$1(children2, selector) : children2; 342 } 343 function index(element, ref) { 344 return ref ? toNodes(element).indexOf(toNode(ref)) : children(parent(element)).indexOf(element); 345 } 346 function isSameSiteAnchor(el) { 347 el = toNode(el); 348 return el && ["origin", "pathname", "search"].every((part) => el[part] === location[part]); 349 } 350 function getTargetedElement(el) { 351 if (isSameSiteAnchor(el)) { 352 el = toNode(el); 353 const id = decodeURIComponent(el.hash).substring(1); 354 return document.getElementById(id) || document.getElementsByName(id)[0]; 355 } 356 } 357 358 function query(selector, context) { 359 return find(selector, getContext(selector, context)); 360 } 361 function queryAll(selector, context) { 362 return findAll(selector, getContext(selector, context)); 363 } 364 function find(selector, context) { 365 return toNode(_query(selector, toNode(context), "querySelector"));
366 } 367 function findAll(selector, context) { 368 return toNodes(_query(selector, toNode(context), "querySelectorAll")); 369 } 370 const contextSelectorRe = /(^|[^\\],)\s*[!>+~-]/; 371 const isContextSelector = memoize((selector) => selector.match(contextSelectorRe)); 372 function getContext(selector, context = document) { 373 return isString(selector) && isContextSelector(selector) || isDocument(context) ? context : context.ownerDocument; 374 } 375 const contextSanitizeRe = /([!>+~-])(?=\s+[!>+~-]|\s*$)/g; 376 const sanatize = memoize((selector) => selector.replace(contextSanitizeRe, "$1 *")); 377 function _query(selector, context = document, queryFn) { 378 if (!selector || !isString(selector)) { 379 return selector; 380 } 381 selector = sanatize(selector); 382 if (isContextSelector(selector)) { 383 const split = splitSelector(selector); 384 selector = ""; 385 for (let sel of split) { 386 let ctx = context; 387 if (sel[0] === "!") { 388 const selectors = sel.substr(1).trim().split(" "); 389 ctx = parent(context).closest(selectors[0]); 390 sel = selectors.slice(1).join(" ").trim(); 391 if (!sel.length && split.length === 1) { 392 return ctx; 393 } 394 } 395 if (sel[0] === "-") { 396 const selectors = sel.substr(1).trim().split(" "); 397 const prev = (ctx || context).previousElementSibling; 398 ctx = matches(prev, sel.substr(1)) ? prev : null; 399 sel = selectors.slice(1).join(" "); 400 } 401 if (ctx) { 402 selector += `${selector ? "," : ""}${domPath(ctx)} ${sel}`; 403 } 404 } 405 context = document; 406 } 407 try { 408 return context[queryFn](selector); 409 } catch (e) { 410 return null; 411 } 412 } 413 const selectorRe = /.*?[^\\](?:,|$)/g; 414 const splitSelector = memoize( 415 (selector) => selector.match(selectorRe).map((selector2) => selector2.replace(/,$/, "").trim()) 416 ); 417 function domPath(element) { 418 const names = []; 419 while (element.parentNode) { 420 const id = attr(element, "id"); 421 if (id) { 422 names.unshift(`#${escape(id)}`); 423 break; 424 } else { 425 let { tagName } = element; 426 if (tagName !== "HTML") { 427 tagName += `:nth-child(${index(element) + 1})`; 428 } 429 names.unshift(tagName); 430 element = element.parentNode; 431 } 432 } 433 return names.join(" > "); 434 } 435 function escape(css) { 436 return isString(css) ? CSS.escape(css) : ""; 437 } 438 439 function on(...args) { 440 let [targets, types, selector, listener, useCapture = false] = getArgs(args); 441 if (listener.length > 1) { 442 listener = detail(listener); 443 } 444 if (useCapture == null ? void 0 : useCapture.self) { 445 listener = selfFilter(listener); 446 } 447 if (selector) { 448 listener = delegate(selector, listener); 449 } 450 for (const type of types) { 451 for (const target of targets) { 452 target.addEventListener(type, listener, useCapture); 453 } 454 } 455 return () => off(targets, types, listener, useCapture); 456 } 457 function off(...args) { 458 let [targets, types, , listener, useCapture = false] = getArgs(args); 459 for (const type of types) { 460 for (const target of targets) { 461 target.removeEventListener(type, listener, useCapture); 462 } 463 } 464 } 465 function once(...args) { 466 const [element, types, selector, listener, useCapture = false, condition] = getArgs(args); 467 const off2 = on( 468 element, 469 types, 470 selector, 471 (e) => { 472 const result = !condition || condition(e); 473 if (result) { 474 off2(); 475 listener(e, result); 476 } 477 }, 478 useCapture 479 ); 480 return off2; 481 } 482 function trigger(targets, event, detail2) { 483 return toEventTargets(targets).every( 484 (target) => target.dispatchEvent(createEvent(event, true, true, detail2)) 485 ); 486 } 487 function createEvent(e, bubbles = true, cancelable = false, detail2) { 488 if (isString(e)) {
vendor: 6,517 bytes, lines 489-673
489 e = new CustomEvent(e, { bubbles, cancelable, detail: detail2 }); 490 } 491 return e; 492 } 493 function getArgs(args) { 494 args[0] = toEventTargets(args[0]); 495 if (isString(args[1])) { 496 args[1] = args[1].split(" "); 497 } 498 if (isFunction(args[2])) { 499 args.splice(2, 0, false); 500 } 501 return args; 502 } 503 function delegate(selector, listener) { 504 return (e) => { 505 const current = selector[0] === ">" ? findAll(selector, e.currentTarget).reverse().find((element) => element.contains(e.target)) : e.target.closest(selector); 506 if (current) { 507 e.current = current; 508 listener.call(this, e); 509 delete e.current; 510 } 511 }; 512 } 513 function detail(listener) { 514 return (e) => isArray(e.detail) ? listener(e, ...e.detail) : listener(e); 515 } 516 function selfFilter(listener) { 517 return function(e) { 518 if (e.target === e.currentTarget || e.target === e.current) { 519 return listener.call(null, e); 520 } 521 }; 522 } 523 function isEventTarget(target) { 524 return target && "addEventListener" in target; 525 } 526 function toEventTarget(target) { 527 return isEventTarget(target) ? target : toNode(target); 528 } 529 function toEventTargets(target) { 530 return isArray(target) ? target.map(toEventTarget).filter(Boolean) : isString(target) ? findAll(target) : isEventTarget(target) ? [target] : toNodes(target); 531 } 532 function isTouch(e) { 533 return e.pointerType === "touch" || !!e.touches; 534 } 535 function getEventPos(e) { 536 var _a, _b; 537 const { clientX: x, clientY: y } = ((_a = e.touches) == null ? void 0 : _a[0]) || ((_b = e.changedTouches) == null ? void 0 : _b[0]) || e; 538 return { x, y }; 539 } 540 541 const cssNumber = { 542 "animation-iteration-count": true, 543 "column-count": true, 544 "fill-opacity": true, 545 "flex-grow": true, 546 "flex-shrink": true, 547 "font-weight": true, 548 "line-height": true, 549 opacity: true, 550 order: true, 551 orphans: true, 552 "stroke-dasharray": true, 553 "stroke-dashoffset": true, 554 widows: true, 555 "z-index": true, 556 zoom: true 557 }; 558 function css(element, property, value, priority) { 559 const elements = toNodes(element); 560 for (const element2 of elements) { 561 if (isString(property)) { 562 property = propName(property); 563 if (isUndefined(value)) { 564 return getComputedStyle(element2).getPropertyValue(property); 565 } else { 566 element2.style.setProperty( 567 property, 568 isNumeric(value) && !cssNumber[property] ? `${value}px` : value || isNumber(value) ? value : "", 569 priority 570 ); 571 } 572 } else if (isArray(property)) { 573 const props = {}; 574 for (const prop of property) { 575 props[prop] = css(element2, prop); 576 } 577 return props; 578 } else if (isObject(property)) { 579 priority = value; 580 each(property, (value2, property2) => css(element2, property2, value2, priority)); 581 } 582 } 583 return elements[0]; 584 } 585 const propName = memoize((name) => vendorPropName(name)); 586 function vendorPropName(name) { 587 if (startsWith(name, "--")) { 588 return name; 589 } 590 name = hyphenate(name); 591 const { style } = document.documentElement; 592 if (name in style) { 593 return name; 594 } 595 for (const prefix of ["webkit", "moz"]) { 596 const prefixedName = `-${prefix}-${name}`; 597 if (prefixedName in style) { 598 return prefixedName; 599 } 600 } 601 } 602 603 const clsTransition = "uk-transition"; 604 const clsTransitionEnd = "transitionend"; 605 const clsTransitionCanceled = "transitioncanceled"; 606 function transition$1(element, props, duration = 400, timing = "linear") { 607 duration = Math.round(duration); 608 return Promise.all( 609 toNodes(element).map( 610 (element2) => new Promise((resolve, reject) => { 611 for (const name in props) { 612 const value = css(element2, name); 613 if (value === "") { 614 css(element2, name, value); 615 } 616 } 617 const timer = setTimeout(() => trigger(element2, clsTransitionEnd), duration); 618 once( 619 element2, 620 [clsTransitionEnd, clsTransitionCanceled], 621 ({ type }) => { 622 clearTimeout(timer); 623 removeClass(element2, clsTransition); 624 css(element2, { 625 transitionProperty: "", 626 transitionDuration: "", 627 transitionTimingFunction: "" 628 }); 629 type === clsTransitionCanceled ? reject() : resolve(element2); 630 }, 631 { self: true } 632 ); 633 addClass(element2, clsTransition); 634 css(element2, { 635 transitionProperty: Object.keys(props).map(propName).join(","), 636 transitionDuration: `${duration}ms`, 637 transitionTimingFunction: timing, 638 ...props 639 }); 640 }) 641 ) 642 ); 643 } 644 const Transition = { 645 start: transition$1, 646 async stop(element) { 647 trigger(element, clsTransitionEnd); 648 await Promise.resolve(); 649 }, 650 async cancel(element) { 651 trigger(element, clsTransitionCanceled); 652 await Promise.resolve(); 653 }, 654 inProgress(element) { 655 return hasClass(element, clsTransition); 656 } 657 }; 658 const animationPrefix = "uk-animation-"; 659 const clsAnimationEnd = "animationend"; 660 const clsAnimationCanceled = "animationcanceled"; 661 function animate$2(element, animation, duration = 200, origin, out) { 662 return Promise.all( 663 toNodes(element).map( 664 (element2) => new Promise((resolve, reject) => { 665 trigger(element2, clsAnimationCanceled); 666 const timer = setTimeout(() => trigger(element2, clsAnimationEnd), duration); 667 once( 668 element2, 669 [clsAnimationEnd, clsAnimationCanceled], 670 ({ type }) => { 671 clearTimeout(timer); 672 type === clsAnimationCanceled ? reject() : resolve(element2); 673 css(element2, "animationDuration", "");
vendor: 14,456 bytes, lines 674-1093
674 removeClasses$1(element2, `${animationPrefix}\\S*`); 675 }, 676 { self: true } 677 ); 678 css(element2, "animationDuration", `${duration}ms`); 679 addClass(element2, animation, animationPrefix + (out ? "leave" : "enter")); 680 if (startsWith(animation, animationPrefix)) { 681 origin && addClass(element2, `uk-transform-origin-${origin}`); 682 out && addClass(element2, `${animationPrefix}reverse`); 683 } 684 }) 685 ) 686 ); 687 } 688 const inProgressRe = new RegExp(`${animationPrefix}(enter|leave)`); 689 const Animation = { 690 in: animate$2, 691 out(element, animation, duration, origin) { 692 return animate$2(element, animation, duration, origin, true); 693 }, 694 inProgress(element) { 695 return inProgressRe.test(attr(element, "class")); 696 }, 697 cancel(element) { 698 trigger(element, clsAnimationCanceled); 699 } 700 }; 701 702 function ready(fn) { 703 if (document.readyState !== "loading") { 704 fn(); 705 return; 706 } 707 once(document, "DOMContentLoaded", fn); 708 } 709 function isTag(element, ...tagNames) { 710 return tagNames.some((tagName) => { 711 var _a; 712 return ((_a = element == null ? void 0 : element.tagName) == null ? void 0 : _a.toLowerCase()) === tagName.toLowerCase(); 713 }); 714 } 715 function empty(element) { 716 element = $(element); 717 element.innerHTML = ""; 718 return element; 719 } 720 function html(parent2, html2) { 721 return isUndefined(html2) ? $(parent2).innerHTML : append(empty(parent2), html2); 722 } 723 const prepend = applyFn("prepend"); 724 const append = applyFn("append"); 725 const before = applyFn("before"); 726 const after = applyFn("after"); 727 function applyFn(fn) { 728 return function(ref, element) { 729 var _a; 730 const nodes = toNodes(isString(element) ? fragment(element) : element); 731 (_a = $(ref)) == null ? void 0 : _a[fn](...nodes); 732 return unwrapSingle(nodes); 733 }; 734 } 735 function remove$1(element) { 736 toNodes(element).forEach((element2) => element2.remove()); 737 } 738 function wrapAll(element, structure) { 739 structure = toNode(before(element, structure)); 740 while (structure.firstChild) { 741 structure = structure.firstChild; 742 } 743 append(structure, element); 744 return structure; 745 } 746 function wrapInner(element, structure) { 747 return toNodes( 748 toNodes(element).map( 749 (element2) => element2.hasChildNodes() ? wrapAll(toArray(element2.childNodes), structure) : append(element2, structure) 750 ) 751 ); 752 } 753 function unwrap(element) { 754 toNodes(element).map(parent).filter((value, index, self) => self.indexOf(value) === index).forEach((parent2) => parent2.replaceWith(...parent2.childNodes)); 755 } 756 const singleTagRe = /^<(\w+)\s*\/?>(?:<\/\1>)?$/; 757 function fragment(html2) { 758 const matches = singleTagRe.exec(html2); 759 if (matches) { 760 return document.createElement(matches[1]); 761 } 762 const container = document.createElement("template"); 763 container.innerHTML = html2.trim(); 764 return unwrapSingle(container.content.childNodes); 765 } 766 function unwrapSingle(nodes) { 767 return nodes.length > 1 ? nodes : nodes[0]; 768 } 769 function apply(node, fn) { 770 if (!isElement(node)) { 771 return; 772 } 773 fn(node); 774 node = node.firstElementChild; 775 while (node) { 776 const next = node.nextElementSibling; 777 apply(node, fn); 778 node = next; 779 } 780 } 781 function $(selector, context) { 782 return isHtml(selector) ? toNode(fragment(selector)) : find(selector, context); 783 } 784 function $$(selector, context) { 785 return isHtml(selector) ? toNodes(fragment(selector)) : findAll(selector, context); 786 } 787 function isHtml(str) { 788 return isString(str) && startsWith(str.trim(), "<"); 789 } 790 791 const dirs$1 = { 792 width: ["left", "right"], 793 height: ["top", "bottom"] 794 }; 795 function dimensions$1(element) { 796 const rect = isElement(element) ? toNode(element).getBoundingClientRect() : { height: height(element), width: width(element), top: 0, left: 0 }; 797 return { 798 height: rect.height, 799 width: rect.width, 800 top: rect.top, 801 left: rect.left, 802 bottom: rect.top + rect.height, 803 right: rect.left + rect.width 804 }; 805 } 806 function offset(element, coordinates) { 807 if (coordinates) { 808 css(element, { left: 0, top: 0 }); 809 } 810 const currentOffset = dimensions$1(element); 811 if (element) { 812 const { scrollY, scrollX } = toWindow(element); 813 const offsetBy = { height: scrollY, width: scrollX }; 814 for (const dir in dirs$1) { 815 for (const prop of dirs$1[dir]) { 816 currentOffset[prop] += offsetBy[dir]; 817 } 818 } 819 } 820 if (!coordinates) { 821 return currentOffset; 822 } 823 for (const prop of ["left", "top"]) { 824 css(element, prop, coordinates[prop] - currentOffset[prop]); 825 } 826 } 827 function position(element) { 828 let { top, left } = offset(element); 829 const { 830 ownerDocument: { body, documentElement }, 831 offsetParent 832 } = toNode(element); 833 let parent = offsetParent || documentElement; 834 while (parent && (parent === body || parent === documentElement) && css(parent, "position") === "static") { 835 parent = parent.parentNode; 836 } 837 if (isElement(parent)) { 838 const parentOffset = offset(parent); 839 top -= parentOffset.top + toFloat(css(parent, "borderTopWidth")); 840 left -= parentOffset.left + toFloat(css(parent, "borderLeftWidth")); 841 } 842 return { 843 top: top - toFloat(css(element, "marginTop")), 844 left: left - toFloat(css(element, "marginLeft")) 845 }; 846 } 847 function offsetPosition(element) { 848 element = toNode(element); 849 const offset2 = [element.offsetTop, element.offsetLeft]; 850 while (element = element.offsetParent) { 851 offset2[0] += element.offsetTop + toFloat(css(element, `borderTopWidth`)); 852 offset2[1] += element.offsetLeft + toFloat(css(element, `borderLeftWidth`)); 853 if (css(element, "position") === "fixed") { 854 const win = toWindow(element); 855 offset2[0] += win.scrollY; 856 offset2[1] += win.scrollX; 857 return offset2; 858 } 859 } 860 return offset2; 861 } 862 const height = dimension("height"); 863 const width = dimension("width"); 864 function dimension(prop) { 865 const propName = ucfirst(prop); 866 return (element, value) => { 867 if (isUndefined(value)) { 868 if (isWindow(element)) { 869 return element[`inner${propName}`]; 870 } 871 if (isDocument(element)) { 872 const doc = element.documentElement; 873 return Math.max(doc[`offset${propName}`], doc[`scroll${propName}`]); 874 } 875 element = toNode(element); 876 value = css(element, prop); 877 value = value === "auto" ? element[`offset${propName}`] : toFloat(value) || 0; 878 return value - boxModelAdjust(element, prop); 879 } else { 880 return css( 881 element, 882 prop, 883 !value && value !== 0 ? "" : +value + boxModelAdjust(element, prop) + "px" 884 ); 885 } 886 }; 887 } 888 function boxModelAdjust(element, prop, sizing = "border-box") { 889 return css(element, "boxSizing") === sizing ? sumBy( 890 dirs$1[prop].map(ucfirst), 891 (prop2) => toFloat(css(element, `padding${prop2}`)) + toFloat(css(element, `border${prop2}Width`)) 892 ) : 0; 893 } 894 function flipPosition(pos) { 895 for (const dir in dirs$1) { 896 for (const i in dirs$1[dir]) { 897 if (dirs$1[dir][i] === pos) { 898 return dirs$1[dir][1 - i]; 899 } 900 } 901 } 902 return pos; 903 } 904 function toPx(value, property = "width", element = window, offsetDim = false) { 905 if (!isString(value)) { 906 return toFloat(value); 907 } 908 return sumBy(parseCalc(value), (value2) => { 909 const unit = parseUnit(value2); 910 return unit ? percent( 911 unit === "vh" ? getViewportHeight() : unit === "vw" ? width(toWindow(element)) : offsetDim ? element[`offset${ucfirst(property)}`] : dimensions$1(element)[property], 912 value2 913 ) : value2; 914 }); 915 } 916 const calcRe = /-?\d+(?:\.\d+)?(?:v[wh]|%|px)?/g; 917 const parseCalc = memoize((calc) => calc.toString().replace(/\s/g, "").match(calcRe) || []); 918 const unitRe$1 = /(?:v[hw]|%)$/; 919 const parseUnit = memoize((str) => (str.match(unitRe$1) || [])[0]); 920 function percent(base, value) { 921 return base * toFloat(value) / 100; 922 } 923 let vh; 924 let vhEl; 925 function getViewportHeight() { 926 if (vh) { 927 return vh; 928 } 929 if (!vhEl) { 930 vhEl = $("<div>"); 931 css(vhEl, { 932 height: "100vh", 933 position: "fixed" 934 }); 935 on(window, "resize", () => vh = null); 936 } 937 append(document.body, vhEl); 938 vh = vhEl.clientHeight; 939 remove$1(vhEl); 940 return vh; 941 } 942 943 const inBrowser = typeof window !== "undefined"; 944 const isRtl = inBrowser && document.dir === "rtl"; 945 const hasTouch = inBrowser && "ontouchstart" in window; 946 const hasPointerEvents = inBrowser && window.PointerEvent; 947 const pointerDown$1 = hasPointerEvents ? "pointerdown" : hasTouch ? "touchstart" : "mousedown"; 948 const pointerMove$1 = hasPointerEvents ? "pointermove" : hasTouch ? "touchmove" : "mousemove"; 949 const pointerUp$1 = hasPointerEvents ? "pointerup" : hasTouch ? "touchend" : "mouseup"; 950 const pointerEnter = hasPointerEvents ? "pointerenter" : hasTouch ? "" : "mouseenter"; 951 const pointerLeave = hasPointerEvents ? "pointerleave" : hasTouch ? "" : "mouseleave"; 952 const pointerCancel = hasPointerEvents ? "pointercancel" : "touchcancel"; 953 954 const fastdom = { 955 reads: [], 956 writes: [], 957 read(task) { 958 this.reads.push(task); 959 scheduleFlush(); 960 return task; 961 }, 962 write(task) { 963 this.writes.push(task); 964 scheduleFlush(); 965 return task; 966 }, 967 clear(task) { 968 remove(this.reads, task); 969 remove(this.writes, task); 970 }, 971 flush 972 }; 973 function flush(recursion) { 974 runTasks(fastdom.reads); 975 runTasks(fastdom.writes.splice(0)); 976 fastdom.scheduled = false; 977 if (fastdom.reads.length || fastdom.writes.length) { 978 scheduleFlush(recursion + 1); 979 } 980 } 981 const RECURSION_LIMIT = 4; 982 function scheduleFlush(recursion) { 983 if (fastdom.scheduled) { 984 return; 985 } 986 fastdom.scheduled = true; 987 if (recursion && recursion < RECURSION_LIMIT) { 988 Promise.resolve().then(() => flush(recursion)); 989 } else { 990 requestAnimationFrame(() => flush(1)); 991 } 992 } 993 function runTasks(tasks) { 994 let task; 995 while (task = tasks.shift()) { 996 try { 997 task(); 998 } catch (e) { 999 console.error(e); 1000 } 1001 } 1002 } 1003 function remove(array, item) { 1004 const index = array.indexOf(item); 1005 return ~index && array.splice(index, 1); 1006 } 1007 1008 function MouseTracker() { 1009 } 1010 MouseTracker.prototype = { 1011 positions: [], 1012 init() { 1013 this.positions = []; 1014 let position; 1015 this.unbind = on(document, "mousemove", (e) => position = getEventPos(e)); 1016 this.interval = setInterval(() => { 1017 if (!position) { 1018 return; 1019 } 1020 this.positions.push(position); 1021 if (this.positions.length > 5) { 1022 this.positions.shift(); 1023 } 1024 }, 50); 1025 }, 1026 cancel() { 1027 var _a; 1028 (_a = this.unbind) == null ? void 0 : _a.call(this); 1029 clearInterval(this.interval); 1030 }, 1031 movesTo(target) { 1032 if (this.positions.length < 2) { 1033 return false; 1034 } 1035 const p = target.getBoundingClientRect(); 1036 const { left, right, top, bottom } = p; 1037 const [prevPosition] = this.positions; 1038 const position = last(this.positions); 1039 const path = [prevPosition, position]; 1040 if (pointInRect(position, p)) { 1041 return false; 1042 } 1043 const diagonals = [ 1044 [ 1045 { x: left, y: top }, 1046 { x: right, y: bottom } 1047 ], 1048 [ 1049 { x: left, y: bottom }, 1050 { x: right, y: top } 1051 ] 1052 ]; 1053 return diagonals.some((diagonal) => { 1054 const intersection = intersect(path, diagonal); 1055 return intersection && pointInRect(intersection, p); 1056 }); 1057 } 1058 }; 1059 function intersect([{ x: x1, y: y1 }, { x: x2, y: y2 }], [{ x: x3, y: y3 }, { x: x4, y: y4 }]) { 1060 const denominator = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1); 1061 if (denominator === 0) { 1062 return false; 1063 } 1064 const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator; 1065 if (ua < 0) { 1066 return false; 1067 } 1068 return { x: x1 + ua * (x2 - x1), y: y1 + ua * (y2 - y1) }; 1069 } 1070 1071 function observeIntersection(targets, cb, options = {}, { intersecting = true } = {}) { 1072 const observer = new IntersectionObserver( 1073 intersecting ? (entries, observer2) => { 1074 if (entries.some((entry) => entry.isIntersecting)) { 1075 cb(entries, observer2); 1076 } 1077 } : cb, 1078 options 1079 ); 1080 for (const el of toNodes(targets)) { 1081 observer.observe(el); 1082 } 1083 return observer; 1084 } 1085 const hasResizeObserver = inBrowser && window.ResizeObserver; 1086 function observeResize(targets, cb, options = { box: "border-box" }) { 1087 if (hasResizeObserver) { 1088 return observe$1(ResizeObserver, targets, cb, options); 1089 } 1090 const off = [on(window, "load resize", cb), on(document, "loadedmetadata load", cb, true)]; 1091 return { disconnect: () => off.map((cb2) => cb2()) }; 1092 } 1093 function observeViewportResize(cb) {
vendor: 1,761 bytes, lines 1094-1155
1094 return { disconnect: on([window, window.visualViewport], "resize", cb) }; 1095 } 1096 function observeMutation(targets, cb, options) { 1097 return observe$1(MutationObserver, targets, cb, options); 1098 } 1099 function observe$1(Observer, targets, cb, options) { 1100 const observer = new Observer(cb); 1101 for (const el of toNodes(targets)) { 1102 observer.observe(el, options); 1103 } 1104 return observer; 1105 } 1106 1107 function play(el) { 1108 if (isIFrame(el)) { 1109 call(el, { func: "playVideo", method: "play" }); 1110 } 1111 if (isHTML5(el)) { 1112 el.play(); 1113 } 1114 } 1115 function pause(el) { 1116 if (isIFrame(el)) { 1117 call(el, { func: "pauseVideo", method: "pause" }); 1118 } 1119 if (isHTML5(el)) { 1120 el.pause(); 1121 } 1122 } 1123 function mute(el) { 1124 if (isIFrame(el)) { 1125 call(el, { func: "mute", method: "setVolume", value: 0 }); 1126 } 1127 if (isHTML5(el)) { 1128 el.muted = true; 1129 } 1130 } 1131 function isVideo(el) { 1132 return isHTML5(el) || isIFrame(el); 1133 } 1134 function isHTML5(el) { 1135 return isTag(el, "video"); 1136 } 1137 function isIFrame(el) { 1138 return isTag(el, "iframe") && (isYoutube(el) || isVimeo(el)); 1139 } 1140 function isYoutube(el) { 1141 return !!el.src.match( 1142 /\/\/.*?youtube(-nocookie)?\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/ 1143 ); 1144 } 1145 function isVimeo(el) { 1146 return !!el.src.match(/vimeo\.com\/video\/.*/); 1147 } 1148 async function call(el, cmd) { 1149 await enableApi(el); 1150 post(el, cmd); 1151 } 1152 function post(el, cmd) { 1153 el.contentWindow.postMessage(JSON.stringify({ event: "command", ...cmd }), "*"); 1154 } 1155 const stateKey = "_ukPlayer";
vendor: 4,428 bytes, lines 1156-1265
1156 let counter = 0; 1157 function enableApi(el) { 1158 if (el[stateKey]) { 1159 return el[stateKey]; 1160 } 1161 const youtube = isYoutube(el); 1162 const vimeo = isVimeo(el); 1163 const id = ++counter; 1164 let poller; 1165 return el[stateKey] = new Promise((resolve) => { 1166 youtube && once(el, "load", () => { 1167 const listener = () => post(el, { event: "listening", id }); 1168 poller = setInterval(listener, 100); 1169 listener(); 1170 }); 1171 once(window, "message", resolve, false, ({ data }) => { 1172 try { 1173 data = JSON.parse(data); 1174 return youtube && (data == null ? void 0 : data.id) === id && data.event === "onReady" || vimeo && Number(data == null ? void 0 : data.player_id) === id; 1175 } catch (e) { 1176 } 1177 }); 1178 el.src = `${el.src}${includes(el.src, "?") ? "&" : "?"}${youtube ? "enablejsapi=1" : `api=1&player_id=${id}`}`; 1179 }).then(() => clearInterval(poller)); 1180 } 1181 1182 function isInView(element, offsetTop = 0, offsetLeft = 0) { 1183 if (!isVisible(element)) { 1184 return false; 1185 } 1186 return intersectRect( 1187 ...overflowParents(element).map((parent2) => { 1188 const { top, left, bottom, right } = offsetViewport(parent2); 1189 return { 1190 top: top - offsetTop, 1191 left: left - offsetLeft, 1192 bottom: bottom + offsetTop, 1193 right: right + offsetLeft 1194 }; 1195 }).concat(offset(element)) 1196 ); 1197 } 1198 function scrollIntoView(element, { offset: offsetBy = 0 } = {}) { 1199 const parents2 = isVisible(element) ? scrollParents(element, false, ["hidden"]) : []; 1200 return parents2.reduce( 1201 (fn, scrollElement, i) => { 1202 const { scrollTop, scrollHeight, offsetHeight } = scrollElement; 1203 const viewport = offsetViewport(scrollElement); 1204 const maxScroll = scrollHeight - viewport.height; 1205 const { height: elHeight, top: elTop } = parents2[i - 1] ? offsetViewport(parents2[i - 1]) : offset(element); 1206 let top = Math.ceil(elTop - viewport.top - offsetBy + scrollTop); 1207 if (offsetBy > 0 && offsetHeight < elHeight + offsetBy) { 1208 top += offsetBy; 1209 } else { 1210 offsetBy = 0; 1211 } 1212 if (top > maxScroll) { 1213 offsetBy -= top - maxScroll; 1214 top = maxScroll; 1215 } else if (top < 0) { 1216 offsetBy -= top; 1217 top = 0; 1218 } 1219 return () => scrollTo(scrollElement, top - scrollTop, element, maxScroll).then(fn); 1220 }, 1221 () => Promise.resolve() 1222 )(); 1223 function scrollTo(element2, top, targetEl, maxScroll) { 1224 return new Promise((resolve) => { 1225 const scroll = element2.scrollTop; 1226 const duration = getDuration(Math.abs(top)); 1227 const start = Date.now(); 1228 const isScrollingElement = scrollingElement(element2) === element2; 1229 const targetTop = offset(targetEl).top + (isScrollingElement ? 0 : scroll); 1230 let prev = 0; 1231 let frames = 15; 1232 (function step() { 1233 const percent = ease(clamp((Date.now() - start) / duration)); 1234 let diff = 0; 1235 if (parents2[0] === element2 && scroll + top < maxScroll) { 1236 diff = offset(targetEl).top + (isScrollingElement ? 0 : element2.scrollTop) - targetTop; 1237 const coverEl = getCoveringElement(targetEl); 1238 diff -= coverEl ? offset(coverEl).height : 0; 1239 } 1240 element2.scrollTop = Math[top + diff > 0 ? "max" : "min"]( 1241 element2.scrollTop, 1242 scroll + (top + diff) * percent 1243 ); 1244 if (percent === 1 && (prev === diff || !frames--)) { 1245 resolve(); 1246 } else { 1247 prev = diff; 1248 requestAnimationFrame(step); 1249 } 1250 })(); 1251 }); 1252 } 1253 function getDuration(dist) { 1254 return 40 * Math.pow(dist, 0.375); 1255 } 1256 function ease(k) { 1257 return 0.5 * (1 - Math.cos(Math.PI * k)); 1258 } 1259 } 1260 function scrolledOver(element, startOffset = 0, endOffset = 0) { 1261 if (!isVisible(element)) { 1262 return 0; 1263 } 1264 const scrollElement = scrollParent(element, true); 1265 const { scrollHeight, scrollTop } = scrollElement;
vendor: 7,246 bytes, lines 1266-1437
1266 const { height: viewportHeight } = offsetViewport(scrollElement); 1267 const maxScroll = scrollHeight - viewportHeight; 1268 const elementOffsetTop = offsetPosition(element)[0] - offsetPosition(scrollElement)[0]; 1269 const start = Math.max(0, elementOffsetTop - viewportHeight + startOffset); 1270 const end = Math.min(maxScroll, elementOffsetTop + element.offsetHeight - endOffset); 1271 return clamp((scrollTop - start) / (end - start)); 1272 } 1273 function scrollParents(element, scrollable = false, props = []) { 1274 const scrollEl = scrollingElement(element); 1275 let ancestors = parents(element).reverse(); 1276 ancestors = ancestors.slice(ancestors.indexOf(scrollEl) + 1); 1277 const fixedIndex = findIndex(ancestors, (el) => css(el, "position") === "fixed"); 1278 if (~fixedIndex) { 1279 ancestors = ancestors.slice(fixedIndex); 1280 } 1281 return [scrollEl].concat( 1282 ancestors.filter( 1283 (parent2) => css(parent2, "overflow").split(" ").some((prop) => includes(["auto", "scroll", ...props], prop)) && (!scrollable || parent2.scrollHeight > offsetViewport(parent2).height) 1284 ) 1285 ).reverse(); 1286 } 1287 function scrollParent(...args) { 1288 return scrollParents(...args)[0]; 1289 } 1290 function overflowParents(element) { 1291 return scrollParents(element, false, ["hidden", "clip"]); 1292 } 1293 function offsetViewport(scrollElement) { 1294 const window = toWindow(scrollElement); 1295 const { 1296 visualViewport, 1297 document: { documentElement } 1298 } = window; 1299 let viewportElement = scrollElement === scrollingElement(scrollElement) ? window : scrollElement; 1300 if (isWindow(viewportElement) && visualViewport) { 1301 let { height, width, scale, pageTop: top, pageLeft: left } = visualViewport; 1302 height = Math.round(height * scale); 1303 width = Math.round(width * scale); 1304 return { height, width, top, left, bottom: top + height, right: left + width }; 1305 } 1306 let rect = offset(viewportElement); 1307 if (css(viewportElement, "display") === "inline") { 1308 return rect; 1309 } 1310 for (let [prop, dir, start, end] of [ 1311 ["width", "x", "left", "right"], 1312 ["height", "y", "top", "bottom"] 1313 ]) { 1314 if (isWindow(viewportElement)) { 1315 viewportElement = documentElement; 1316 } else { 1317 rect[start] += toFloat(css(viewportElement, `border-${start}-width`)); 1318 } 1319 const subpixel = rect[prop] % 1; 1320 rect[prop] = rect[dir] = viewportElement[`client${ucfirst(prop)}`] - (subpixel ? subpixel < 0.5 ? -subpixel : 1 - subpixel : 0); 1321 rect[end] = rect[prop] + rect[start]; 1322 } 1323 return rect; 1324 } 1325 function getCoveringElement(target) { 1326 return target.ownerDocument.elementsFromPoint(offset(target).left, 0).find( 1327 (el) => !el.contains(target) && (hasPosition(el, "fixed") && zIndex( 1328 parents(target).reverse().find((parent2) => !parent2.contains(el) && !hasPosition(parent2, "static")) 1329 ) < zIndex(el) || hasPosition(el, "sticky") && parent(el).contains(target)) 1330 ); 1331 } 1332 function zIndex(element) { 1333 return toFloat(css(element, "zIndex")); 1334 } 1335 function hasPosition(element, position) { 1336 return css(element, "position") === position; 1337 } 1338 function scrollingElement(element) { 1339 return toWindow(element).document.scrollingElement; 1340 } 1341 1342 const dirs = [ 1343 ["width", "x", "left", "right"], 1344 ["height", "y", "top", "bottom"] 1345 ]; 1346 function positionAt(element, target, options) { 1347 options = { 1348 attach: { 1349 element: ["left", "top"], 1350 target: ["left", "top"], 1351 ...options.attach 1352 }, 1353 offset: [0, 0], 1354 placement: [], 1355 ...options 1356 }; 1357 if (!isArray(target)) { 1358 target = [target, target]; 1359 } 1360 offset(element, getPosition(element, target, options)); 1361 } 1362 function getPosition(element, target, options) { 1363 const position = attachTo(element, target, options); 1364 const { boundary, viewportOffset = 0, placement } = options; 1365 let offsetPosition = position; 1366 for (const [i, [prop, , start, end]] of Object.entries(dirs)) { 1367 const viewport = getViewport$2(element, target[i], viewportOffset, boundary, i); 1368 if (isWithin(position, viewport, i)) { 1369 continue; 1370 } 1371 let offsetBy = 0; 1372 if (placement[i] === "flip") { 1373 const attach = options.attach.target[i]; 1374 if (attach === end && position[end] <= viewport[end] || attach === start && position[start] >= viewport[start]) { 1375 continue; 1376 } 1377 offsetBy = flip(element, target, options, i)[start] - position[start]; 1378 const scrollArea = getScrollArea(element, target[i], viewportOffset, i); 1379 if (!isWithin(applyOffset(position, offsetBy, i), scrollArea, i)) { 1380 if (isWithin(position, scrollArea, i)) { 1381 continue; 1382 } 1383 if (options.recursion) { 1384 return false; 1385 } 1386 const newPos = flipAxis(element, target, options); 1387 if (newPos && isWithin(newPos, scrollArea, 1 - i)) { 1388 return newPos; 1389 } 1390 continue; 1391 } 1392 } else if (placement[i] === "shift") { 1393 const targetDim = offset(target[i]); 1394 const { offset: elOffset } = options; 1395 offsetBy = clamp( 1396 clamp(position[start], viewport[start], viewport[end] - position[prop]), 1397 targetDim[start] - position[prop] + elOffset[i], 1398 targetDim[end] - elOffset[i] 1399 ) - position[start]; 1400 } 1401 offsetPosition = applyOffset(offsetPosition, offsetBy, i); 1402 } 1403 return offsetPosition; 1404 } 1405 function attachTo(element, target, options) { 1406 let { attach, offset: offsetBy } = { 1407 attach: { 1408 element: ["left", "top"], 1409 target: ["left", "top"], 1410 ...options.attach 1411 }, 1412 offset: [0, 0], 1413 ...options 1414 }; 1415 let elOffset = offset(element); 1416 for (const [i, [prop, , start, end]] of Object.entries(dirs)) { 1417 const targetOffset = attach.target[i] === attach.element[i] ? offsetViewport(target[i]) : offset(target[i]); 1418 elOffset = applyOffset( 1419 elOffset, 1420 targetOffset[start] - elOffset[start] + moveBy(attach.target[i], end, targetOffset[prop]) - moveBy(attach.element[i], end, elOffset[prop]) + +offsetBy[i], 1421 i 1422 ); 1423 } 1424 return elOffset; 1425 } 1426 function applyOffset(position, offset2, i) { 1427 const [, dir, start, end] = dirs[i]; 1428 const newPos = { ...position }; 1429 newPos[start] = position[dir] = position[start] + offset2; 1430 newPos[end] += offset2; 1431 return newPos; 1432 } 1433 function moveBy(attach, end, dim) { 1434 return attach === "center" ? dim / 2 : attach === end ? dim : 0; 1435 } 1436 function getViewport$2(element, target, viewportOffset, boundary, i) { 1437 let viewport = getIntersectionArea(...commonScrollParents(element, target).map(offsetViewport));
vendor: 4,630 bytes, lines 1438-1580
1438 if (viewportOffset) { 1439 viewport[dirs[i][2]] += viewportOffset; 1440 viewport[dirs[i][3]] -= viewportOffset; 1441 } 1442 if (boundary) { 1443 viewport = getIntersectionArea( 1444 viewport, 1445 offset(isArray(boundary) ? boundary[i] : boundary) 1446 ); 1447 } 1448 return viewport; 1449 } 1450 function getScrollArea(element, target, viewportOffset, i) { 1451 const [prop, axis, start, end] = dirs[i]; 1452 const [scrollElement] = commonScrollParents(element, target); 1453 const viewport = offsetViewport(scrollElement); 1454 if (["auto", "scroll"].includes(css(scrollElement, `overflow-${axis}`))) { 1455 viewport[start] -= scrollElement[`scroll${ucfirst(start)}`]; 1456 viewport[end] = viewport[start] + scrollElement[`scroll${ucfirst(prop)}`]; 1457 } 1458 viewport[start] += viewportOffset; 1459 viewport[end] -= viewportOffset; 1460 return viewport; 1461 } 1462 function commonScrollParents(element, target) { 1463 return overflowParents(target).filter((parent) => parent.contains(element)); 1464 } 1465 function getIntersectionArea(...rects) { 1466 let area = {}; 1467 for (const rect of rects) { 1468 for (const [, , start, end] of dirs) { 1469 area[start] = Math.max(area[start] || 0, rect[start]); 1470 area[end] = Math.min(...[area[end], rect[end]].filter(Boolean)); 1471 } 1472 } 1473 return area; 1474 } 1475 function isWithin(positionA, positionB, i) { 1476 const [, , start, end] = dirs[i]; 1477 return positionA[start] >= positionB[start] && positionA[end] <= positionB[end]; 1478 } 1479 function flip(element, target, { offset: offset2, attach }, i) { 1480 return attachTo(element, target, { 1481 attach: { 1482 element: flipAttach(attach.element, i), 1483 target: flipAttach(attach.target, i) 1484 }, 1485 offset: flipOffset(offset2, i) 1486 }); 1487 } 1488 function flipAxis(element, target, options) { 1489 return getPosition(element, target, { 1490 ...options, 1491 attach: { 1492 element: options.attach.element.map(flipAttachAxis).reverse(), 1493 target: options.attach.target.map(flipAttachAxis).reverse() 1494 }, 1495 offset: options.offset.reverse(), 1496 placement: options.placement.reverse(), 1497 recursion: true 1498 }); 1499 } 1500 function flipAttach(attach, i) { 1501 const newAttach = [...attach]; 1502 const index = dirs[i].indexOf(attach[i]); 1503 if (~index) { 1504 newAttach[i] = dirs[i][1 - index % 2 + 2]; 1505 } 1506 return newAttach; 1507 } 1508 function flipAttachAxis(prop) { 1509 for (let i = 0; i < dirs.length; i++) { 1510 const index = dirs[i].indexOf(prop); 1511 if (~index) { 1512 return dirs[1 - i][index % 2 + 2]; 1513 } 1514 } 1515 } 1516 function flipOffset(offset2, i) { 1517 offset2 = [...offset2]; 1518 offset2[i] *= -1; 1519 return offset2; 1520 } 1521 1522 var util = /*#__PURE__*/Object.freeze({ 1523 __proto__: null, 1524 $: $, 1525 $$: $$, 1526 Animation: Animation, 1527 Dimensions: Dimensions, 1528 MouseTracker: MouseTracker, 1529 Transition: Transition, 1530 addClass: addClass, 1531 after: after, 1532 append: append, 1533 apply: apply, 1534 assign: assign, 1535 attr: attr, 1536 before: before, 1537 boxModelAdjust: boxModelAdjust, 1538 camelize: camelize, 1539 children: children, 1540 clamp: clamp, 1541 closest: closest, 1542 createEvent: createEvent, 1543 css: css, 1544 data: data, 1545 dimensions: dimensions$1, 1546 each: each, 1547 empty: empty, 1548 endsWith: endsWith, 1549 escape: escape, 1550 fastdom: fastdom, 1551 filter: filter$1, 1552 find: find, 1553 findAll: findAll, 1554 findIndex: findIndex, 1555 flipPosition: flipPosition, 1556 fragment: fragment, 1557 getCoveringElement: getCoveringElement, 1558 getEventPos: getEventPos, 1559 getIndex: getIndex, 1560 getTargetedElement: getTargetedElement, 1561 hasAttr: hasAttr, 1562 hasClass: hasClass, 1563 hasOwn: hasOwn, 1564 hasTouch: hasTouch, 1565 height: height, 1566 html: html, 1567 hyphenate: hyphenate, 1568 inBrowser: inBrowser, 1569 includes: includes, 1570 index: index, 1571 intersectRect: intersectRect, 1572 isArray: isArray, 1573 isBoolean: isBoolean, 1574 isDocument: isDocument, 1575 isElement: isElement, 1576 isEmpty: isEmpty, 1577 isEqual: isEqual, 1578 isFocusable: isFocusable, 1579 isFunction: isFunction, 1580 isInView: isInView,
1581 isInput: isInput, 1582 isNode: isNode, 1583 isNumber: isNumber, 1584 isNumeric: isNumeric, 1585 isObject: isObject, 1586 isPlainObject: isPlainObject, 1587 isRtl: isRtl, 1588 isSameSiteAnchor: isSameSiteAnchor, 1589 isString: isString, 1590 isTag: isTag, 1591 isTouch: isTouch, 1592 isUndefined: isUndefined, 1593 isVideo: isVideo, 1594 isVisible: isVisible, 1595 isVoidElement: isVoidElement, 1596 isWindow: isWindow, 1597 last: last, 1598 matches: matches, 1599 memoize: memoize, 1600 mute: mute, 1601 noop: noop, 1602 observeIntersection: observeIntersection, 1603 observeMutation: observeMutation, 1604 observeResize: observeResize, 1605 observeViewportResize: observeViewportResize, 1606 off: off, 1607 offset: offset, 1608 offsetPosition: offsetPosition, 1609 offsetViewport: offsetViewport, 1610 on: on, 1611 once: once, 1612 overflowParents: overflowParents, 1613 parent: parent, 1614 parents: parents, 1615 pause: pause, 1616 pick: pick, 1617 play: play, 1618 pointInRect: pointInRect, 1619 pointerCancel: pointerCancel, 1620 pointerDown: pointerDown$1, 1621 pointerEnter: pointerEnter, 1622 pointerLeave: pointerLeave, 1623 pointerMove: pointerMove$1, 1624 pointerUp: pointerUp$1, 1625 position: position, 1626 positionAt: positionAt, 1627 prepend: prepend, 1628 propName: propName, 1629 query: query, 1630 queryAll: queryAll, 1631 ready: ready, 1632 remove: remove$1, 1633 removeAttr: removeAttr, 1634 removeClass: removeClass, 1635 removeClasses: removeClasses$1, 1636 replaceClass: replaceClass, 1637 scrollIntoView: scrollIntoView, 1638 scrollParent: scrollParent, 1639 scrollParents: scrollParents, 1640 scrolledOver: scrolledOver, 1641 selFocusable: selFocusable, 1642 selInput: selInput, 1643 sortBy: sortBy, 1644 startsWith: startsWith, 1645 sumBy: sumBy, 1646 swap: swap, 1647 toArray: toArray, 1648 toBoolean: toBoolean, 1649 toEventTargets: toEventTargets, 1650 toFloat: toFloat, 1651 toNode: toNode, 1652 toNodes: toNodes, 1653 toNumber: toNumber, 1654 toPx: toPx, 1655 toWindow: toWindow, 1656 toggleClass: toggleClass, 1657 trigger: trigger, 1658 ucfirst: ucfirst, 1659 uniqueBy: uniqueBy, 1660 unwrap: unwrap, 1661 width: width, 1662 within: within, 1663 wrapAll: wrapAll, 1664 wrapInner: wrapInner 1665 }); 1666 1667 var Class = { 1668 connected() { 1669 addClass(this.$el, this.$options.id); 1670 } 1671 }; 1672 1673 const units = ["hours", "minutes", "seconds"]; 1674 var countdown = { 1675 mixins: [Class], 1676 props: { 1677 date: String, 1678 clsWrapper: String, 1679 role: String 1680 }, 1681 data: { 1682 date: "", 1683 clsWrapper: ".time-count-%unit%", 1684 role: "timer" 1685 }, 1686 connected() { 1687 attr(this.$el, "role", this.role); 1688 this.date = toFloat(Date.parse(this.$props.date)); 1689 this.end = false; 1690 this.start(); 1691 }, 1692 disconnected() { 1693 this.stop(); 1694 }, 1695 events: { 1696 name: "visibilitychange", 1697 el() { 1698 return document; 1699 }, 1700 handler() { 1701 if (document.hidden) { 1702 this.stop(); 1703 } else { 1704 this.start(); 1705 } 1706 } 1707 }, 1708 methods: { 1709 start() { 1710 this.stop(); 1711 this.update(); 1712 if (!this.timer) { 1713 trigger(this.$el, "countdownstart"); 1714 this.timer = setInterval(this.update, 1e3); 1715 } 1716 }, 1717 stop() { 1718 if (this.timer) { 1719 clearInterval(this.timer); 1720 trigger(this.$el, "countdownstop"); 1721 this.timer = null; 1722 } 1723 }, 1724 update() { 1725 const timespan = getTimeSpan(this.date); 1726 if (!timespan.total) { 1727 this.stop(); 1728 if (!this.end) { 1729 trigger(this.$el, "countdownend"); 1730 this.end = true; 1731 } 1732 } 1733 for (const unit of units) { 1734 const el = $(this.clsWrapper.replace("%unit%", unit), this.$el); 1735 if (!el) { 1736 continue; 1737 } 1738 let digits = String(Math.trunc(timespan[unit])); 1739 digits = digits.length < 2 ? `0${digits}` : digits; 1740 if (el.textContent !== digits) { 1741 digits = digits.split(""); 1742 if (digits.length !== el.children.length) { 1743 html(el, digits.map(() => "<span></span>").join("")); 1744 }
vendor: 29,589 bytes, lines 1745-2611
1745 digits.forEach((digit, i) => el.children[i].textContent = digit); 1746 } 1747 } 1748 } 1749 } 1750 }; 1751 function getTimeSpan(date) { 1752 const total = Math.max(0, date - Date.now()) / 1e3; 1753 return { 1754 total, 1755 seconds: total % 60, 1756 minutes: total / 60 % 60, 1757 hours: total / 60 / 60, 1758 //days: total / 60 / 60 / 24 1759 }; 1760 } 1761 1762 const strats = {}; 1763 strats.events = strats.watch = strats.observe = strats.created = strats.beforeConnect = strats.connected = strats.beforeDisconnect = strats.disconnected = strats.destroy = concatStrat; 1764 strats.args = function(parentVal, childVal) { 1765 return childVal !== false && concatStrat(childVal || parentVal); 1766 }; 1767 strats.update = function(parentVal, childVal) { 1768 return sortBy( 1769 concatStrat(parentVal, isFunction(childVal) ? { read: childVal } : childVal), 1770 "order" 1771 ); 1772 }; 1773 strats.props = function(parentVal, childVal) { 1774 if (isArray(childVal)) { 1775 const value = {}; 1776 for (const key of childVal) { 1777 value[key] = String; 1778 } 1779 childVal = value; 1780 } 1781 return strats.methods(parentVal, childVal); 1782 }; 1783 strats.computed = strats.methods = function(parentVal, childVal) { 1784 return childVal ? parentVal ? { ...parentVal, ...childVal } : childVal : parentVal; 1785 }; 1786 strats.i18n = strats.data = function(parentVal, childVal, vm) { 1787 if (!vm) { 1788 if (!childVal) { 1789 return parentVal; 1790 } 1791 if (!parentVal) { 1792 return childVal; 1793 } 1794 return function(vm2) { 1795 return mergeFnData(parentVal, childVal, vm2); 1796 }; 1797 } 1798 return mergeFnData(parentVal, childVal, vm); 1799 }; 1800 function mergeFnData(parentVal, childVal, vm) { 1801 return strats.computed( 1802 isFunction(parentVal) ? parentVal.call(vm, vm) : parentVal, 1803 isFunction(childVal) ? childVal.call(vm, vm) : childVal 1804 ); 1805 } 1806 function concatStrat(parentVal, childVal) { 1807 parentVal = parentVal && !isArray(parentVal) ? [parentVal] : parentVal; 1808 return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal; 1809 } 1810 function defaultStrat(parentVal, childVal) { 1811 return isUndefined(childVal) ? parentVal : childVal; 1812 } 1813 function mergeOptions(parent, child, vm) { 1814 const options = {}; 1815 if (isFunction(child)) { 1816 child = child.options; 1817 } 1818 if (child.extends) { 1819 parent = mergeOptions(parent, child.extends, vm); 1820 } 1821 if (child.mixins) { 1822 for (const mixin of child.mixins) { 1823 parent = mergeOptions(parent, mixin, vm); 1824 } 1825 } 1826 for (const key in parent) { 1827 mergeKey(key); 1828 } 1829 for (const key in child) { 1830 if (!hasOwn(parent, key)) { 1831 mergeKey(key); 1832 } 1833 } 1834 function mergeKey(key) { 1835 options[key] = (strats[key] || defaultStrat)(parent[key], child[key], vm); 1836 } 1837 return options; 1838 } 1839 function parseOptions(options, args = []) { 1840 try { 1841 return options ? startsWith(options, "{") ? JSON.parse(options) : args.length && !includes(options, ":") ? { [args[0]]: options } : options.split(";").reduce((options2, option) => { 1842 const [key, value] = option.split(/:(.*)/); 1843 if (key && !isUndefined(value)) { 1844 options2[key.trim()] = value.trim(); 1845 } 1846 return options2; 1847 }, {}) : {}; 1848 } catch (e) { 1849 return {}; 1850 } 1851 } 1852 function coerce$1(type, value) { 1853 if (type === Boolean) { 1854 return toBoolean(value); 1855 } else if (type === Number) { 1856 return toNumber(value); 1857 } else if (type === "list") { 1858 return toList(value); 1859 } else if (type === Object && isString(value)) { 1860 return parseOptions(value); 1861 } 1862 return type ? type(value) : value; 1863 } 1864 const listRe = /,(?![^(]*\))/; 1865 function toList(value) { 1866 return isArray(value) ? value : isString(value) ? value.split(listRe).map((value2) => isNumeric(value2) ? toNumber(value2) : toBoolean(value2.trim())) : [value]; 1867 } 1868 1869 function initUpdates(instance) { 1870 instance._data = {}; 1871 instance._updates = [...instance.$options.update || []]; 1872 } 1873 function prependUpdate(instance, update) { 1874 instance._updates.unshift(update); 1875 } 1876 function clearUpdateData(instance) { 1877 delete instance._data; 1878 } 1879 function callUpdate(instance, e = "update") { 1880 if (!instance._connected) { 1881 return; 1882 } 1883 if (!instance._updates.length) { 1884 return; 1885 } 1886 if (!instance._queued) { 1887 instance._queued = /* @__PURE__ */ new Set(); 1888 fastdom.read(() => { 1889 if (instance._connected) { 1890 runUpdates(instance, instance._queued); 1891 } 1892 delete instance._queued; 1893 }); 1894 } 1895 instance._queued.add(e.type || e); 1896 } 1897 function runUpdates(instance, types) { 1898 for (const { read, write, events = [] } of instance._updates) { 1899 if (!types.has("update") && !events.some((type) => types.has(type))) { 1900 continue; 1901 } 1902 let result; 1903 if (read) { 1904 result = read.call(instance, instance._data, types); 1905 if (result && isPlainObject(result)) { 1906 assign(instance._data, result); 1907 } 1908 } 1909 if (write && result !== false) { 1910 fastdom.write(() => { 1911 if (instance._connected) { 1912 write.call(instance, instance._data, types); 1913 } 1914 }); 1915 } 1916 } 1917 } 1918 1919 function resize(options) { 1920 return observe(observeResize, options, "resize"); 1921 } 1922 function intersection(options) { 1923 return observe(observeIntersection, options); 1924 } 1925 function mutation(options) { 1926 return observe(observeMutation, options); 1927 } 1928 function lazyload(options = {}) { 1929 return intersection({ 1930 handler: function(entries, observer) { 1931 const { targets = this.$el, preload = 5 } = options; 1932 for (const el of toNodes(isFunction(targets) ? targets(this) : targets)) { 1933 $$('[loading="lazy"]', el).slice(0, preload - 1).forEach((el2) => removeAttr(el2, "loading")); 1934 } 1935 for (const el of entries.filter(({ isIntersecting }) => isIntersecting).map(({ target }) => target)) { 1936 observer.unobserve(el); 1937 } 1938 }, 1939 ...options 1940 }); 1941 } 1942 function viewport(options) { 1943 return observe((target, handler) => observeViewportResize(handler), options); 1944 } 1945 function scroll$1(options) { 1946 return observe( 1947 (target, handler) => ({ 1948 disconnect: on(toScrollTargets(target), "scroll", handler, { passive: true }) 1949 }), 1950 options, 1951 "scroll" 1952 ); 1953 } 1954 function swipe(options) { 1955 return { 1956 observe(target, handler) { 1957 return { 1958 observe: noop, 1959 unobserve: noop, 1960 disconnect: on(target, pointerDown$1, handler, { passive: true }) 1961 }; 1962 }, 1963 handler(e) { 1964 if (!isTouch(e)) { 1965 return; 1966 } 1967 const pos = getEventPos(e); 1968 const target = "tagName" in e.target ? e.target : parent(e.target); 1969 once(document, `${pointerUp$1} ${pointerCancel} scroll`, (e2) => { 1970 const { x, y } = getEventPos(e2); 1971 if (e2.type !== "scroll" && target && x && Math.abs(pos.x - x) > 100 || y && Math.abs(pos.y - y) > 100) { 1972 setTimeout(() => { 1973 trigger(target, "swipe"); 1974 trigger(target, `swipe${swipeDirection(pos.x, pos.y, x, y)}`); 1975 }); 1976 } 1977 }); 1978 }, 1979 ...options 1980 }; 1981 } 1982 function observe(observe2, options, emit) { 1983 return { 1984 observe: observe2, 1985 handler() { 1986 callUpdate(this, emit); 1987 }, 1988 ...options 1989 }; 1990 } 1991 function swipeDirection(x1, y1, x2, y2) { 1992 return Math.abs(x1 - x2) >= Math.abs(y1 - y2) ? x1 - x2 > 0 ? "Left" : "Right" : y1 - y2 > 0 ? "Up" : "Down"; 1993 } 1994 function toScrollTargets(elements) { 1995 return toNodes(elements).map((node) => { 1996 const { ownerDocument } = node; 1997 const parent2 = scrollParent(node, true); 1998 return parent2 === ownerDocument.scrollingElement ? ownerDocument : parent2; 1999 }); 2000 } 2001 2002 var Margin = { 2003 props: { 2004 margin: String, 2005 firstColumn: Boolean 2006 }, 2007 data: { 2008 margin: "uk-margin-small-top", 2009 firstColumn: "uk-first-column" 2010 }, 2011 observe: [ 2012 mutation({ 2013 options: { 2014 childList: true, 2015 attributes: true, 2016 attributeFilter: ["style"] 2017 } 2018 }), 2019 resize({ 2020 target: ({ $el }) => [$el, ...children($el)] 2021 }) 2022 ], 2023 update: { 2024 read() { 2025 return { 2026 rows: getRows(toArray(this.$el.children)) 2027 }; 2028 }, 2029 write({ rows }) { 2030 for (const row of rows) { 2031 for (const el of row) { 2032 toggleClass(el, this.margin, rows[0] !== row); 2033 toggleClass(el, this.firstColumn, row[isRtl ? row.length - 1 : 0] === el); 2034 } 2035 } 2036 }, 2037 events: ["resize"] 2038 } 2039 }; 2040 function getRows(elements) { 2041 const sorted = [[]]; 2042 const withOffset = elements.some( 2043 (el, i) => i && elements[i - 1].offsetParent !== el.offsetParent 2044 ); 2045 for (const el of elements) { 2046 if (!isVisible(el)) { 2047 continue; 2048 } 2049 const offset = getOffset(el, withOffset); 2050 for (let i = sorted.length - 1; i >= 0; i--) { 2051 const current = sorted[i]; 2052 if (!current[0]) { 2053 current.push(el); 2054 break; 2055 } 2056 const offsetCurrent = getOffset(current[0], withOffset); 2057 if (offset.top >= offsetCurrent.bottom - 1 && offset.top !== offsetCurrent.top) { 2058 sorted.push([el]); 2059 break; 2060 } 2061 if (offset.bottom - 1 > offsetCurrent.top || offset.top === offsetCurrent.top) { 2062 let j = current.length - 1; 2063 for (; j >= 0; j--) { 2064 const offsetCurrent2 = getOffset(current[j], withOffset); 2065 if (offset.left >= offsetCurrent2.left) { 2066 break; 2067 } 2068 } 2069 current.splice(j + 1, 0, el); 2070 break; 2071 } 2072 if (i === 0) { 2073 sorted.unshift([el]); 2074 break; 2075 } 2076 } 2077 } 2078 return sorted; 2079 } 2080 function getOffset(element, offset = false) { 2081 let { offsetTop, offsetLeft, offsetHeight, offsetWidth } = element; 2082 if (offset) { 2083 [offsetTop, offsetLeft] = offsetPosition(element); 2084 } 2085 return { 2086 top: offsetTop, 2087 left: offsetLeft, 2088 bottom: offsetTop + offsetHeight, 2089 right: offsetLeft + offsetWidth 2090 }; 2091 } 2092 2093 const clsLeave = "uk-transition-leave"; 2094 const clsEnter = "uk-transition-enter"; 2095 function fade(action, target, duration, stagger = 0) { 2096 const index = transitionIndex(target, true); 2097 const propsIn = { opacity: 1 }; 2098 const propsOut = { opacity: 0 }; 2099 const wrapIndexFn = (fn) => () => index === transitionIndex(target) ? fn() : Promise.reject(); 2100 const leaveFn = wrapIndexFn(async () => { 2101 addClass(target, clsLeave); 2102 await Promise.all( 2103 getTransitionNodes(target).map( 2104 (child, i) => new Promise( 2105 (resolve) => setTimeout( 2106 () => Transition.start(child, propsOut, duration / 2, "ease").then( 2107 resolve 2108 ), 2109 i * stagger 2110 ) 2111 ) 2112 ) 2113 ); 2114 removeClass(target, clsLeave); 2115 }); 2116 const enterFn = wrapIndexFn(async () => { 2117 const oldHeight = height(target); 2118 addClass(target, clsEnter); 2119 action(); 2120 css(children(target), { opacity: 0 }); 2121 await awaitFrame$1(); 2122 const nodes = children(target); 2123 const newHeight = height(target); 2124 css(target, "alignContent", "flex-start"); 2125 height(target, oldHeight); 2126 const transitionNodes = getTransitionNodes(target); 2127 css(nodes, propsOut); 2128 const transitions = transitionNodes.map(async (child, i) => { 2129 await awaitTimeout(i * stagger); 2130 await Transition.start(child, propsIn, duration / 2, "ease"); 2131 }); 2132 if (oldHeight !== newHeight) { 2133 transitions.push( 2134 Transition.start( 2135 target, 2136 { height: newHeight }, 2137 duration / 2 + transitionNodes.length * stagger, 2138 "ease" 2139 ) 2140 ); 2141 } 2142 await Promise.all(transitions).then(() => { 2143 removeClass(target, clsEnter); 2144 if (index === transitionIndex(target)) { 2145 css(target, { height: "", alignContent: "" }); 2146 css(nodes, { opacity: "" }); 2147 delete target.dataset.transition; 2148 } 2149 }); 2150 }); 2151 return hasClass(target, clsLeave) ? waitTransitionend(target).then(enterFn) : hasClass(target, clsEnter) ? waitTransitionend(target).then(leaveFn).then(enterFn) : leaveFn().then(enterFn); 2152 } 2153 function transitionIndex(target, next) { 2154 if (next) { 2155 target.dataset.transition = 1 + transitionIndex(target); 2156 } 2157 return toNumber(target.dataset.transition) || 0; 2158 } 2159 function waitTransitionend(target) { 2160 return Promise.all( 2161 children(target).filter(Transition.inProgress).map( 2162 (el) => new Promise((resolve) => once(el, "transitionend transitioncanceled", resolve)) 2163 ) 2164 ); 2165 } 2166 function getTransitionNodes(target) { 2167 return getRows(children(target)).flat().filter((node) => isVisible(node)); 2168 } 2169 function awaitFrame$1() { 2170 return new Promise((resolve) => requestAnimationFrame(resolve)); 2171 } 2172 function awaitTimeout(timeout) { 2173 return new Promise((resolve) => setTimeout(resolve, timeout)); 2174 } 2175 2176 async function slide(action, target, duration) { 2177 await awaitFrame(); 2178 let nodes = children(target); 2179 const currentProps = nodes.map((el) => getProps$1(el, true)); 2180 const targetProps = { ...css(target, ["height", "padding"]), display: "block" }; 2181 await Promise.all(nodes.concat(target).map(Transition.cancel)); 2182 action(); 2183 nodes = nodes.concat(children(target).filter((el) => !includes(nodes, el))); 2184 await Promise.resolve(); 2185 fastdom.flush(); 2186 const targetStyle = attr(target, "style"); 2187 const targetPropsTo = css(target, ["height", "padding"]); 2188 const [propsTo, propsFrom] = getTransitionProps(target, nodes, currentProps); 2189 const attrsTo = nodes.map((el) => ({ style: attr(el, "style") })); 2190 nodes.forEach((el, i) => propsFrom[i] && css(el, propsFrom[i])); 2191 css(target, targetProps); 2192 trigger(target, "scroll"); 2193 fastdom.flush(); 2194 await awaitFrame(); 2195 const transitions = nodes.map((el, i) => parent(el) === target && Transition.start(el, propsTo[i], duration, "ease")).concat(Transition.start(target, targetPropsTo, duration, "ease")); 2196 try { 2197 await Promise.all(transitions); 2198 nodes.forEach((el, i) => { 2199 attr(el, attrsTo[i]); 2200 if (parent(el) === target) { 2201 css(el, "display", propsTo[i].opacity === 0 ? "none" : ""); 2202 } 2203 }); 2204 attr(target, "style", targetStyle); 2205 } catch (e) { 2206 attr(nodes, "style", ""); 2207 resetProps(target, targetProps); 2208 } 2209 } 2210 function getProps$1(el, opacity) { 2211 const zIndex = css(el, "zIndex"); 2212 return isVisible(el) ? { 2213 display: "", 2214 opacity: opacity ? css(el, "opacity") : "0", 2215 pointerEvents: "none", 2216 position: "absolute", 2217 zIndex: zIndex === "auto" ? index(el) : zIndex, 2218 ...getPositionWithMargin(el) 2219 } : false; 2220 } 2221 function getTransitionProps(target, nodes, currentProps) { 2222 const propsTo = nodes.map( 2223 (el, i) => parent(el) && i in currentProps ? currentProps[i] ? isVisible(el) ? getPositionWithMargin(el) : { opacity: 0 } : { opacity: isVisible(el) ? 1 : 0 } : false 2224 ); 2225 const propsFrom = propsTo.map((props, i) => { 2226 const from = parent(nodes[i]) === target && (currentProps[i] || getProps$1(nodes[i])); 2227 if (!from) { 2228 return false; 2229 } 2230 if (!props) { 2231 delete from.opacity; 2232 } else if (!("opacity" in props)) { 2233 const { opacity } = from; 2234 if (opacity % 1) { 2235 props.opacity = 1; 2236 } else { 2237 delete from.opacity; 2238 } 2239 } 2240 return from; 2241 }); 2242 return [propsTo, propsFrom]; 2243 } 2244 function resetProps(el, props) { 2245 for (const prop in props) { 2246 css(el, prop, ""); 2247 } 2248 } 2249 function getPositionWithMargin(el) { 2250 const { height, width } = offset(el); 2251 return { 2252 height, 2253 width, 2254 transform: "", 2255 ...position(el), 2256 ...css(el, ["marginTop", "marginLeft"]) 2257 }; 2258 } 2259 function awaitFrame() { 2260 return new Promise((resolve) => requestAnimationFrame(resolve)); 2261 } 2262 2263 var Animate = { 2264 props: { 2265 duration: Number, 2266 animation: Boolean 2267 }, 2268 data: { 2269 duration: 150, 2270 animation: "slide" 2271 }, 2272 methods: { 2273 animate(action, target = this.$el) { 2274 const name = this.animation; 2275 const animationFn = name === "fade" ? fade : name === "delayed-fade" ? (...args) => fade(...args, 40) : name ? slide : () => { 2276 action(); 2277 return Promise.resolve(); 2278 }; 2279 return animationFn(action, target, this.duration).catch(noop); 2280 } 2281 } 2282 }; 2283 2284 const keyMap = { 2285 TAB: 9, 2286 ESC: 27, 2287 SPACE: 32, 2288 END: 35, 2289 HOME: 36, 2290 LEFT: 37, 2291 UP: 38, 2292 RIGHT: 39, 2293 DOWN: 40 2294 }; 2295 2296 var filter = { 2297 mixins: [Animate], 2298 args: "target", 2299 props: { 2300 target: String, 2301 selActive: Boolean 2302 }, 2303 data: { 2304 target: "", 2305 selActive: false, 2306 attrItem: "uk-filter-control", 2307 cls: "uk-active", 2308 duration: 250 2309 }, 2310 computed: { 2311 children: ({ target }, $el) => $$(`${target} > *`, $el), 2312 toggles: ({ attrItem }, $el) => $$(`[${attrItem}],[data-${attrItem}]`, $el) 2313 }, 2314 watch: { 2315 toggles(toggles) { 2316 this.updateState(); 2317 const actives = $$(this.selActive, this.$el); 2318 for (const toggle of toggles) { 2319 if (this.selActive !== false) { 2320 toggleClass(toggle, this.cls, includes(actives, toggle)); 2321 } 2322 const button = findButton(toggle); 2323 if (isTag(button, "a")) { 2324 attr(button, "role", "button"); 2325 } 2326 } 2327 }, 2328 children(list, prev) { 2329 if (prev) { 2330 this.updateState(); 2331 } 2332 } 2333 }, 2334 events: { 2335 name: "click keydown", 2336 delegate() { 2337 return `[${this.attrItem}],[data-${this.attrItem}]`; 2338 }, 2339 handler(e) { 2340 if (e.type === "keydown" && e.keyCode !== keyMap.SPACE) { 2341 return; 2342 } 2343 if (e.target.closest("a,button")) { 2344 e.preventDefault(); 2345 this.apply(e.current); 2346 } 2347 } 2348 }, 2349 methods: { 2350 apply(el) { 2351 const prevState = this.getState(); 2352 const newState = mergeState(el, this.attrItem, this.getState()); 2353 if (!isEqualState(prevState, newState)) { 2354 this.setState(newState); 2355 } 2356 }, 2357 getState() { 2358 return this.toggles.filter((item) => hasClass(item, this.cls)).reduce((state, el) => mergeState(el, this.attrItem, state), { 2359 filter: { "": "" }, 2360 sort: [] 2361 }); 2362 }, 2363 async setState(state, animate = true) { 2364 state = { filter: { "": "" }, sort: [], ...state }; 2365 trigger(this.$el, "beforeFilter", [this, state]); 2366 for (const toggle of this.toggles) { 2367 toggleClass(toggle, this.cls, matchFilter(toggle, this.attrItem, state)); 2368 } 2369 await Promise.all( 2370 $$(this.target, this.$el).map((target) => { 2371 const filterFn = () => { 2372 applyState(state, target, children(target)); 2373 this.$update(this.$el); 2374 }; 2375 return animate ? this.animate(filterFn, target) : filterFn(); 2376 }) 2377 ); 2378 trigger(this.$el, "afterFilter", [this]); 2379 }, 2380 updateState() { 2381 fastdom.write(() => this.setState(this.getState(), false)); 2382 } 2383 } 2384 }; 2385 function getFilter(el, attr2) { 2386 return parseOptions(data(el, attr2), ["filter"]); 2387 } 2388 function isEqualState(stateA, stateB) { 2389 return ["filter", "sort"].every((prop) => isEqual(stateA[prop], stateB[prop])); 2390 } 2391 function applyState(state, target, children) { 2392 const selector = getSelector(state); 2393 children.forEach((el) => css(el, "display", selector && !matches(el, selector) ? "none" : "")); 2394 const [sort, order] = state.sort; 2395 if (sort) { 2396 const sorted = sortItems(children, sort, order); 2397 if (!isEqual(sorted, children)) { 2398 append(target, sorted); 2399 } 2400 } 2401 } 2402 function mergeState(el, attr2, state) { 2403 const { filter, group, sort, order = "asc" } = getFilter(el, attr2); 2404 if (filter || isUndefined(sort)) { 2405 if (group) { 2406 if (filter) { 2407 delete state.filter[""]; 2408 state.filter[group] = filter; 2409 } else { 2410 delete state.filter[group]; 2411 if (isEmpty(state.filter) || "" in state.filter) { 2412 state.filter = { "": filter || "" }; 2413 } 2414 } 2415 } else { 2416 state.filter = { "": filter || "" }; 2417 } 2418 } 2419 if (!isUndefined(sort)) { 2420 state.sort = [sort, order]; 2421 } 2422 return state; 2423 } 2424 function matchFilter(el, attr2, { filter: stateFilter = { "": "" }, sort: [stateSort, stateOrder] }) { 2425 const { filter = "", group = "", sort, order = "asc" } = getFilter(el, attr2); 2426 return isUndefined(sort) ? group in stateFilter && filter === stateFilter[group] || !filter && group && !(group in stateFilter) && !stateFilter[""] : stateSort === sort && stateOrder === order; 2427 } 2428 function getSelector({ filter }) { 2429 let selector = ""; 2430 each(filter, (value) => selector += value || ""); 2431 return selector; 2432 } 2433 function sortItems(nodes, sort, order) { 2434 return [...nodes].sort( 2435 (a, b) => data(a, sort).localeCompare(data(b, sort), void 0, { numeric: true }) * (order === "asc" || -1) 2436 ); 2437 } 2438 function findButton(el) { 2439 return $("a,button", el) || el; 2440 } 2441 2442 var Container = { 2443 props: { 2444 container: Boolean 2445 }, 2446 data: { 2447 container: true 2448 }, 2449 computed: { 2450 container({ container }) { 2451 return container === true && this.$container || container && $(container); 2452 } 2453 } 2454 }; 2455 2456 let prevented; 2457 function preventBackgroundScroll(el) { 2458 const off = on( 2459 el, 2460 "touchmove", 2461 (e) => { 2462 if (e.targetTouches.length !== 1 || matches(e.target, 'input[type="range"')) { 2463 return; 2464 } 2465 let { scrollHeight, clientHeight } = scrollParent(e.target); 2466 if (clientHeight >= scrollHeight && e.cancelable) { 2467 e.preventDefault(); 2468 } 2469 }, 2470 { passive: false } 2471 ); 2472 if (prevented) { 2473 return off; 2474 } 2475 prevented = true; 2476 const { scrollingElement } = document; 2477 css(scrollingElement, { 2478 overflowY: CSS.supports("overflow", "clip") ? "clip" : "hidden", 2479 touchAction: "none", 2480 paddingRight: width(window) - scrollingElement.clientWidth || "" 2481 }); 2482 return () => { 2483 prevented = false; 2484 off(); 2485 css(scrollingElement, { overflowY: "", touchAction: "", paddingRight: "" }); 2486 }; 2487 } 2488 2489 var Togglable = { 2490 props: { 2491 cls: Boolean, 2492 animation: "list", 2493 duration: Number, 2494 velocity: Number, 2495 origin: String, 2496 transition: String 2497 }, 2498 data: { 2499 cls: false, 2500 animation: [false], 2501 duration: 200, 2502 velocity: 0.2, 2503 origin: false, 2504 transition: "ease", 2505 clsEnter: "uk-togglabe-enter", 2506 clsLeave: "uk-togglabe-leave" 2507 }, 2508 computed: { 2509 hasAnimation: ({ animation }) => !!animation[0], 2510 hasTransition: ({ animation }) => ["slide", "reveal"].some((transition) => startsWith(animation[0], transition)) 2511 }, 2512 methods: { 2513 async toggleElement(targets, toggle, animate) { 2514 try { 2515 await Promise.all( 2516 toNodes(targets).map((el) => { 2517 const show = isBoolean(toggle) ? toggle : !this.isToggled(el); 2518 if (!trigger(el, `before${show ? "show" : "hide"}`, [this])) { 2519 return Promise.reject(); 2520 } 2521 const promise = (isFunction(animate) ? animate : animate === false || !this.hasAnimation ? toggleInstant : this.hasTransition ? toggleTransition : toggleAnimation)(el, show, this); 2522 const cls = show ? this.clsEnter : this.clsLeave; 2523 addClass(el, cls); 2524 trigger(el, show ? "show" : "hide", [this]); 2525 const done = () => { 2526 removeClass(el, cls); 2527 trigger(el, show ? "shown" : "hidden", [this]); 2528 }; 2529 return promise ? promise.then(done, () => { 2530 removeClass(el, cls); 2531 return Promise.reject(); 2532 }) : done(); 2533 }) 2534 ); 2535 return true; 2536 } catch (e) { 2537 return false; 2538 } 2539 }, 2540 isToggled(el = this.$el) { 2541 el = toNode(el); 2542 return hasClass(el, this.clsEnter) ? true : hasClass(el, this.clsLeave) ? false : this.cls ? hasClass(el, this.cls.split(" ")[0]) : isVisible(el); 2543 }, 2544 _toggle(el, toggled) { 2545 if (!el) { 2546 return; 2547 } 2548 toggled = Boolean(toggled); 2549 let changed; 2550 if (this.cls) { 2551 changed = includes(this.cls, " ") || toggled !== hasClass(el, this.cls); 2552 changed && toggleClass(el, this.cls, includes(this.cls, " ") ? void 0 : toggled); 2553 } else { 2554 changed = toggled === el.hidden; 2555 changed && (el.hidden = !toggled); 2556 } 2557 $$("[autofocus]", el).some((el2) => isVisible(el2) ? el2.focus() || true : el2.blur()); 2558 if (changed) { 2559 trigger(el, "toggled", [toggled, this]); 2560 } 2561 } 2562 } 2563 }; 2564 function toggleInstant(el, show, { _toggle }) { 2565 Animation.cancel(el); 2566 Transition.cancel(el); 2567 return _toggle(el, show); 2568 } 2569 async function toggleTransition(el, show, { animation, duration, velocity, transition, _toggle }) { 2570 var _a; 2571 const [mode = "reveal", startProp = "top"] = ((_a = animation[0]) == null ? void 0 : _a.split("-")) || []; 2572 const dirs = [ 2573 ["left", "right"], 2574 ["top", "bottom"] 2575 ]; 2576 const dir = dirs[includes(dirs[0], startProp) ? 0 : 1]; 2577 const end = dir[1] === startProp; 2578 const props = ["width", "height"]; 2579 const dimProp = props[dirs.indexOf(dir)]; 2580 const marginProp = `margin-${dir[0]}`; 2581 const marginStartProp = `margin-${startProp}`; 2582 let currentDim = dimensions$1(el)[dimProp]; 2583 const inProgress = Transition.inProgress(el); 2584 await Transition.cancel(el); 2585 if (show) { 2586 _toggle(el, true); 2587 } 2588 const prevProps = Object.fromEntries( 2589 [ 2590 "padding", 2591 "border", 2592 "width", 2593 "height", 2594 "minWidth", 2595 "minHeight", 2596 "overflowY", 2597 "overflowX", 2598 marginProp, 2599 marginStartProp 2600 ].map((key) => [key, el.style[key]]) 2601 ); 2602 const dim = dimensions$1(el); 2603 const currentMargin = toFloat(css(el, marginProp)); 2604 const marginStart = toFloat(css(el, marginStartProp)); 2605 const endDim = dim[dimProp] + marginStart; 2606 if (!inProgress && !show) { 2607 currentDim += marginStart; 2608 } 2609 const [wrapper] = wrapInner(el, "<div>"); 2610 css(wrapper, { 2611 boxSizing: "border-box",
vendor: 4,205 bytes, lines 2612-2756
2612 height: dim.height, 2613 width: dim.width, 2614 ...css(el, [ 2615 "overflow", 2616 "padding", 2617 "borderTop", 2618 "borderRight", 2619 "borderBottom", 2620 "borderLeft", 2621 "borderImage", 2622 marginStartProp 2623 ]) 2624 }); 2625 css(el, { 2626 padding: 0, 2627 border: 0, 2628 minWidth: 0, 2629 minHeight: 0, 2630 [marginStartProp]: 0, 2631 width: dim.width, 2632 height: dim.height, 2633 overflow: "hidden", 2634 [dimProp]: currentDim 2635 }); 2636 const percent = currentDim / endDim; 2637 duration = (velocity * endDim + duration) * (show ? 1 - percent : percent); 2638 const endProps = { [dimProp]: show ? endDim : 0 }; 2639 if (end) { 2640 css(el, marginProp, endDim - currentDim + currentMargin); 2641 endProps[marginProp] = show ? currentMargin : endDim + currentMargin; 2642 } 2643 if (!end ^ mode === "reveal") { 2644 css(wrapper, marginProp, -endDim + currentDim); 2645 Transition.start(wrapper, { [marginProp]: show ? 0 : -endDim }, duration, transition); 2646 } 2647 try { 2648 await Transition.start(el, endProps, duration, transition); 2649 } finally { 2650 css(el, prevProps); 2651 unwrap(wrapper.firstChild); 2652 if (!show) { 2653 _toggle(el, false); 2654 } 2655 } 2656 } 2657 function toggleAnimation(el, show, cmp) { 2658 const { animation, duration, _toggle } = cmp; 2659 if (show) { 2660 _toggle(el, true); 2661 return Animation.in(el, animation[0], duration, cmp.origin); 2662 } 2663 return Animation.out(el, animation[1] || animation[0], duration, cmp.origin).then( 2664 () => _toggle(el, false) 2665 ); 2666 } 2667 2668 const active$1 = []; 2669 var Modal = { 2670 mixins: [Class, Container, Togglable], 2671 props: { 2672 selPanel: String, 2673 selClose: String, 2674 escClose: Boolean, 2675 bgClose: Boolean, 2676 stack: Boolean, 2677 role: String 2678 }, 2679 data: { 2680 cls: "uk-open", 2681 escClose: true, 2682 bgClose: true, 2683 overlay: true, 2684 stack: false, 2685 role: "dialog" 2686 }, 2687 computed: { 2688 panel: ({ selPanel }, $el) => $(selPanel, $el), 2689 transitionElement() { 2690 return this.panel; 2691 }, 2692 bgClose({ bgClose }) { 2693 return bgClose && this.panel; 2694 } 2695 }, 2696 connected() { 2697 attr(this.panel || this.$el, "role", this.role); 2698 if (this.overlay) { 2699 attr(this.panel || this.$el, "aria-modal", true); 2700 } 2701 }, 2702 beforeDisconnect() { 2703 if (includes(active$1, this)) { 2704 this.toggleElement(this.$el, false, false); 2705 } 2706 }, 2707 events: [ 2708 { 2709 name: "click", 2710 delegate() { 2711 return `${this.selClose},a[href*="#"]`; 2712 }, 2713 handler(e) { 2714 const { current, defaultPrevented } = e; 2715 const { hash } = current; 2716 if (!defaultPrevented && hash && isSameSiteAnchor(current) && !this.$el.contains($(hash))) { 2717 this.hide(); 2718 } else if (matches(current, this.selClose)) { 2719 e.preventDefault(); 2720 this.hide(); 2721 } 2722 } 2723 }, 2724 { 2725 name: "toggle", 2726 self: true, 2727 handler(e) { 2728 if (e.defaultPrevented) { 2729 return; 2730 } 2731 e.preventDefault(); 2732 if (this.isToggled() === includes(active$1, this)) { 2733 this.toggle(); 2734 } 2735 } 2736 }, 2737 { 2738 name: "beforeshow", 2739 self: true, 2740 handler(e) { 2741 if (includes(active$1, this)) { 2742 return false; 2743 } 2744 if (!this.stack && active$1.length) { 2745 Promise.all(active$1.map((modal) => modal.hide())).then(this.show); 2746 e.preventDefault(); 2747 } else { 2748 active$1.push(this); 2749 } 2750 } 2751 }, 2752 { 2753 name: "show", 2754 self: true, 2755 handler() { 2756 if (this.stack) {
2757 css(this.$el, "zIndex", toFloat(css(this.$el, "zIndex")) + active$1.length); 2758 } 2759 const handlers = [ 2760 this.overlay && preventBackgroundFocus(this), 2761 this.overlay && preventBackgroundScroll(this.$el), 2762 this.bgClose && listenForBackgroundClose$1(this), 2763 this.escClose && listenForEscClose$1(this) 2764 ]; 2765 once( 2766 this.$el, 2767 "hidden", 2768 () => handlers.forEach((handler) => handler && handler()), 2769 { self: true } 2770 ); 2771 addClass(document.documentElement, this.clsPage); 2772 } 2773 }, 2774 { 2775 name: "shown", 2776 self: true, 2777 handler() { 2778 if (!isFocusable(this.$el)) { 2779 attr(this.$el, "tabindex", "-1"); 2780 } 2781 if (!matches(this.$el, ":focus-within")) { 2782 this.$el.focus(); 2783 } 2784 } 2785 }, 2786 { 2787 name: "hidden", 2788 self: true, 2789 handler() { 2790 if (includes(active$1, this)) { 2791 active$1.splice(active$1.indexOf(this), 1); 2792 } 2793 css(this.$el, "zIndex", ""); 2794 if (!active$1.some((modal) => modal.clsPage === this.clsPage)) { 2795 removeClass(document.documentElement, this.clsPage); 2796 } 2797 } 2798 } 2799 ], 2800 methods: { 2801 toggle() { 2802 return this.isToggled() ? this.hide() : this.show(); 2803 }, 2804 show() { 2805 if (this.container && parent(this.$el) !== this.container) { 2806 append(this.container, this.$el); 2807 return new Promise( 2808 (resolve) => requestAnimationFrame(() => this.show().then(resolve)) 2809 ); 2810 } 2811 return this.toggleElement(this.$el, true, animate$1); 2812 }, 2813 hide() { 2814 return this.toggleElement(this.$el, false, animate$1); 2815 } 2816 } 2817 }; 2818 function animate$1(el, show, { transitionElement, _toggle }) { 2819 return new Promise( 2820 (resolve, reject) => once(el, "show hide", () => { 2821 var _a; 2822 (_a = el._reject) == null ? void 0 : _a.call(el); 2823 el._reject = reject; 2824 _toggle(el, show); 2825 const off = once( 2826 transitionElement, 2827 "transitionstart", 2828 () => { 2829 once(transitionElement, "transitionend transitioncancel", resolve, { 2830 self: true 2831 }); 2832 clearTimeout(timer); 2833 }, 2834 { self: true } 2835 ); 2836 const timer = setTimeout( 2837 () => { 2838 off(); 2839 resolve(); 2840 }, 2841 toMs(css(transitionElement, "transitionDuration")) 2842 ); 2843 }) 2844 ).then(() => delete el._reject); 2845 } 2846 function toMs(time) { 2847 return time ? endsWith(time, "ms") ? toFloat(time) : toFloat(time) * 1e3 : 0; 2848 } 2849 function preventBackgroundFocus(modal) { 2850 return on(document, "focusin", (e) => { 2851 if (last(active$1) === modal && !modal.$el.contains(e.target)) { 2852 modal.$el.focus(); 2853 } 2854 }); 2855 }
vendor: 14,657 bytes, lines 2856-3294
2856 function listenForBackgroundClose$1(modal) { 2857 return on(document, pointerDown$1, ({ target }) => { 2858 if (last(active$1) !== modal || modal.overlay && !modal.$el.contains(target) || modal.panel.contains(target)) { 2859 return; 2860 } 2861 once( 2862 document, 2863 `${pointerUp$1} ${pointerCancel} scroll`, 2864 ({ defaultPrevented, type, target: newTarget }) => { 2865 if (!defaultPrevented && type === pointerUp$1 && target === newTarget) { 2866 modal.hide(); 2867 } 2868 }, 2869 true 2870 ); 2871 }); 2872 } 2873 function listenForEscClose$1(modal) { 2874 return on(document, "keydown", (e) => { 2875 if (e.keyCode === 27 && last(active$1) === modal) { 2876 modal.hide(); 2877 } 2878 }); 2879 } 2880 2881 var Animations$2 = { 2882 slide: { 2883 show(dir) { 2884 return [{ transform: translate(dir * -100) }, { transform: translate() }]; 2885 }, 2886 percent(current) { 2887 return translated(current); 2888 }, 2889 translate(percent, dir) { 2890 return [ 2891 { transform: translate(dir * -100 * percent) }, 2892 { transform: translate(dir * 100 * (1 - percent)) } 2893 ]; 2894 } 2895 } 2896 }; 2897 function translated(el) { 2898 return Math.abs(css(el, "transform").split(",")[4] / el.offsetWidth); 2899 } 2900 function translate(value = 0, unit = "%") { 2901 value += value ? unit : ""; 2902 return `translate3d(${value}, 0, 0)`; 2903 } 2904 function scale3d(value) { 2905 return `scale3d(${value}, ${value}, 1)`; 2906 } 2907 2908 function Transitioner$1(prev, next, dir, { animation, easing }) { 2909 const { percent, translate, show = noop } = animation; 2910 const props = show(dir); 2911 let resolve; 2912 return { 2913 dir, 2914 show(duration, percent2 = 0, linear) { 2915 const timing = linear ? "linear" : easing; 2916 duration -= Math.round(duration * clamp(percent2, -1, 1)); 2917 this.translate(percent2); 2918 triggerUpdate$1(next, "itemin", { percent: percent2, duration, timing, dir }); 2919 triggerUpdate$1(prev, "itemout", { percent: 1 - percent2, duration, timing, dir }); 2920 return new Promise((res) => { 2921 resolve || (resolve = res); 2922 Promise.all([ 2923 Transition.start(next, props[1], duration, timing), 2924 Transition.start(prev, props[0], duration, timing) 2925 ]).then(() => { 2926 this.reset(); 2927 resolve(); 2928 }, noop); 2929 }); 2930 }, 2931 cancel() { 2932 return Transition.cancel([next, prev]); 2933 }, 2934 reset() { 2935 for (const prop in props[0]) { 2936 css([next, prev], prop, ""); 2937 } 2938 }, 2939 async forward(duration, percent2 = this.percent()) { 2940 await this.cancel(); 2941 return this.show(duration, percent2, true); 2942 }, 2943 translate(percent2) { 2944 this.reset(); 2945 const props2 = translate(percent2, dir); 2946 css(next, props2[1]); 2947 css(prev, props2[0]); 2948 triggerUpdate$1(next, "itemtranslatein", { percent: percent2, dir }); 2949 triggerUpdate$1(prev, "itemtranslateout", { percent: 1 - percent2, dir }); 2950 }, 2951 percent() { 2952 return percent(prev || next, next, dir); 2953 }, 2954 getDistance() { 2955 return prev == null ? void 0 : prev.offsetWidth; 2956 } 2957 }; 2958 } 2959 function triggerUpdate$1(el, type, data) { 2960 trigger(el, createEvent(type, false, false, data)); 2961 } 2962 2963 var I18n = { 2964 props: { 2965 i18n: Object 2966 }, 2967 data: { 2968 i18n: null 2969 }, 2970 methods: { 2971 t(key, ...params) { 2972 var _a, _b, _c; 2973 let i = 0; 2974 return ((_c = ((_a = this.i18n) == null ? void 0 : _a[key]) || ((_b = this.$options.i18n) == null ? void 0 : _b[key])) == null ? void 0 : _c.replace( 2975 /%s/g, 2976 () => params[i++] || "" 2977 )) || ""; 2978 } 2979 } 2980 }; 2981 2982 var SliderAutoplay = { 2983 props: { 2984 autoplay: Boolean, 2985 autoplayInterval: Number, 2986 pauseOnHover: Boolean 2987 }, 2988 data: { 2989 autoplay: false, 2990 autoplayInterval: 7e3, 2991 pauseOnHover: true 2992 }, 2993 connected() { 2994 attr(this.list, "aria-live", this.autoplay ? "off" : "polite"); 2995 this.autoplay && this.startAutoplay(); 2996 }, 2997 disconnected() { 2998 this.stopAutoplay(); 2999 }, 3000 update() { 3001 attr(this.slides, "tabindex", "-1"); 3002 }, 3003 events: [ 3004 { 3005 name: "visibilitychange", 3006 el() { 3007 return document; 3008 }, 3009 filter() { 3010 return this.autoplay; 3011 }, 3012 handler() { 3013 if (document.hidden) { 3014 this.stopAutoplay(); 3015 } else { 3016 this.startAutoplay(); 3017 } 3018 } 3019 } 3020 ], 3021 methods: { 3022 startAutoplay() { 3023 this.stopAutoplay(); 3024 this.interval = setInterval(() => { 3025 if (!(this.stack.length || this.draggable && matches(this.$el, ":focus-within") || this.pauseOnHover && matches(this.$el, ":hover"))) { 3026 this.show("next"); 3027 } 3028 }, this.autoplayInterval); 3029 }, 3030 stopAutoplay() { 3031 clearInterval(this.interval); 3032 } 3033 } 3034 }; 3035 3036 const pointerOptions = { passive: false, capture: true }; 3037 const pointerUpOptions = { passive: true, capture: true }; 3038 const pointerDown = "touchstart mousedown"; 3039 const pointerMove = "touchmove mousemove"; 3040 const pointerUp = "touchend touchcancel mouseup click input scroll"; 3041 var SliderDrag = { 3042 props: { 3043 draggable: Boolean 3044 }, 3045 data: { 3046 draggable: true, 3047 threshold: 10 3048 }, 3049 created() { 3050 for (const key of ["start", "move", "end"]) { 3051 const fn = this[key]; 3052 this[key] = (e) => { 3053 const pos = getEventPos(e).x * (isRtl ? -1 : 1); 3054 this.prevPos = pos === this.pos ? this.prevPos : this.pos; 3055 this.pos = pos; 3056 fn(e); 3057 }; 3058 } 3059 }, 3060 events: [ 3061 { 3062 name: pointerDown, 3063 passive: true, 3064 delegate() { 3065 return `${this.selList} > *`; 3066 }, 3067 handler(e) { 3068 if (!this.draggable || !isTouch(e) && hasSelectableText(e.target) || e.target.closest(selInput) || e.button > 0 || this.length < 2) { 3069 return; 3070 } 3071 this.start(e); 3072 } 3073 }, 3074 { 3075 name: "dragstart", 3076 handler(e) { 3077 e.preventDefault(); 3078 } 3079 }, 3080 { 3081 // iOS workaround for slider stopping if swiping fast 3082 name: pointerMove, 3083 el() { 3084 return this.list; 3085 }, 3086 handler: noop, 3087 ...pointerOptions 3088 } 3089 ], 3090 methods: { 3091 start() { 3092 this.drag = this.pos; 3093 if (this._transitioner) { 3094 this.percent = this._transitioner.percent(); 3095 this.drag += this._transitioner.getDistance() * this.percent * this.dir; 3096 this._transitioner.cancel(); 3097 this._transitioner.translate(this.percent); 3098 this.dragging = true; 3099 this.stack = []; 3100 } else { 3101 this.prevIndex = this.index; 3102 } 3103 on(document, pointerMove, this.move, pointerOptions); 3104 on(document, pointerUp, this.end, pointerUpOptions); 3105 css(this.list, "userSelect", "none"); 3106 }, 3107 move(e) { 3108 const distance = this.pos - this.drag; 3109 if (distance === 0 || this.prevPos === this.pos || !this.dragging && Math.abs(distance) < this.threshold) { 3110 return; 3111 } 3112 css(this.list, "pointerEvents", "none"); 3113 e.cancelable && e.preventDefault(); 3114 this.dragging = true; 3115 this.dir = distance < 0 ? 1 : -1; 3116 let { slides, prevIndex } = this; 3117 let dis = Math.abs(distance); 3118 let nextIndex = this.getIndex(prevIndex + this.dir); 3119 let width = this._getDistance(prevIndex, nextIndex); 3120 while (nextIndex !== prevIndex && dis > width) { 3121 this.drag -= width * this.dir; 3122 prevIndex = nextIndex; 3123 dis -= width; 3124 nextIndex = this.getIndex(prevIndex + this.dir); 3125 width = this._getDistance(prevIndex, nextIndex); 3126 } 3127 this.percent = dis / width; 3128 const prev = slides[prevIndex]; 3129 const next = slides[nextIndex]; 3130 const changed = this.index !== nextIndex; 3131 const edge = prevIndex === nextIndex; 3132 let itemShown; 3133 for (const i of [this.index, this.prevIndex]) { 3134 if (!includes([nextIndex, prevIndex], i)) { 3135 trigger(slides[i], "itemhidden", [this]); 3136 if (edge) { 3137 itemShown = true; 3138 this.prevIndex = prevIndex; 3139 } 3140 } 3141 } 3142 if (this.index === prevIndex && this.prevIndex !== prevIndex || itemShown) { 3143 trigger(slides[this.index], "itemshown", [this]); 3144 } 3145 if (changed) { 3146 this.prevIndex = prevIndex; 3147 this.index = nextIndex; 3148 !edge && trigger(prev, "beforeitemhide", [this]); 3149 trigger(next, "beforeitemshow", [this]); 3150 } 3151 this._transitioner = this._translate(Math.abs(this.percent), prev, !edge && next); 3152 if (changed) { 3153 !edge && trigger(prev, "itemhide", [this]); 3154 trigger(next, "itemshow", [this]); 3155 } 3156 }, 3157 end() { 3158 off(document, pointerMove, this.move, pointerOptions); 3159 off(document, pointerUp, this.end, pointerUpOptions); 3160 if (this.dragging) { 3161 this.dragging = null; 3162 if (this.index === this.prevIndex) { 3163 this.percent = 1 - this.percent; 3164 this.dir *= -1; 3165 this._show(false, this.index, true); 3166 this._transitioner = null; 3167 } else { 3168 const dirChange = (isRtl ? this.dir * (isRtl ? 1 : -1) : this.dir) < 0 === this.prevPos > this.pos; 3169 this.index = dirChange ? this.index : this.prevIndex; 3170 if (dirChange) { 3171 this.percent = 1 - this.percent; 3172 } 3173 this.show( 3174 this.dir > 0 && !dirChange || this.dir < 0 && dirChange ? "next" : "previous", 3175 true 3176 ); 3177 } 3178 } 3179 css(this.list, { userSelect: "", pointerEvents: "" }); 3180 this.drag = this.percent = null; 3181 }, 3182 _getDistance(prev, next) { 3183 return this._getTransitioner(prev, prev !== next && next).getDistance() || this.slides[prev].offsetWidth; 3184 } 3185 } 3186 }; 3187 function hasSelectableText(el) { 3188 return css(el, "userSelect") !== "none" && toArray(el.childNodes).some((el2) => el2.nodeType === 3 && el2.textContent.trim()); 3189 } 3190 3191 function initWatches(instance) { 3192 instance._watches = []; 3193 for (const watches of instance.$options.watch || []) { 3194 for (const [name, watch] of Object.entries(watches)) { 3195 registerWatch(instance, watch, name); 3196 } 3197 } 3198 instance._initial = true; 3199 } 3200 function registerWatch(instance, watch, name) { 3201 instance._watches.push({ 3202 name, 3203 ...isPlainObject(watch) ? watch : { handler: watch } 3204 }); 3205 } 3206 function runWatches(instance, values) { 3207 for (const { name, handler, immediate = true } of instance._watches) { 3208 if (instance._initial && immediate || hasOwn(values, name) && !isEqual(values[name], instance[name])) { 3209 handler.call(instance, instance[name], values[name]); 3210 } 3211 } 3212 instance._initial = false; 3213 } 3214 3215 function initComputed(instance) { 3216 const { computed } = instance.$options; 3217 instance._computed = {}; 3218 if (computed) { 3219 for (const key in computed) { 3220 registerComputed(instance, key, computed[key]); 3221 } 3222 } 3223 } 3224 function registerComputed(instance, key, cb) { 3225 instance._hasComputed = true; 3226 Object.defineProperty(instance, key, { 3227 enumerable: true, 3228 get() { 3229 const { _computed, $props, $el } = instance; 3230 if (!hasOwn(_computed, key)) { 3231 _computed[key] = (cb.get || cb).call(instance, $props, $el); 3232 } 3233 return _computed[key]; 3234 }, 3235 set(value) { 3236 const { _computed } = instance; 3237 _computed[key] = cb.set ? cb.set.call(instance, value) : value; 3238 if (isUndefined(_computed[key])) { 3239 delete _computed[key]; 3240 } 3241 } 3242 }); 3243 } 3244 function initComputedUpdates(instance) { 3245 if (!instance._hasComputed) { 3246 return; 3247 } 3248 prependUpdate(instance, { 3249 read: () => runWatches(instance, resetComputed(instance)), 3250 events: ["resize", "computed"] 3251 }); 3252 registerComputedObserver(); 3253 instances$1.add(instance); 3254 } 3255 function disconnectComputedUpdates(instance) { 3256 instances$1 == null ? void 0 : instances$1.delete(instance); 3257 resetComputed(instance); 3258 } 3259 function resetComputed(instance) { 3260 const values = { ...instance._computed }; 3261 instance._computed = {}; 3262 return values; 3263 } 3264 let observer; 3265 let instances$1; 3266 function registerComputedObserver() { 3267 if (observer) { 3268 return; 3269 } 3270 instances$1 = /* @__PURE__ */ new Set(); 3271 observer = new MutationObserver(() => { 3272 for (const instance of instances$1) { 3273 callUpdate(instance, "computed"); 3274 } 3275 }); 3276 observer.observe(document, { 3277 subtree: true, 3278 childList: true 3279 }); 3280 } 3281 3282 function initEvents(instance) { 3283 instance._events = []; 3284 for (const event of instance.$options.events || []) { 3285 if (hasOwn(event, "handler")) { 3286 registerEvent(instance, event); 3287 } else { 3288 for (const key in event) { 3289 registerEvent(instance, event[key], key); 3290 } 3291 } 3292 } 3293 } 3294 function unbindEvents(instance) {
3295 instance._events.forEach((unbind) => unbind()); 3296 delete instance._events; 3297 } 3298 function registerEvent(instance, event, key) { 3299 let { name, el, handler, capture, passive, delegate, filter, self } = isPlainObject(event) ? event : { name: key, handler: event }; 3300 el = isFunction(el) ? el.call(instance, instance) : el || instance.$el; 3301 if (!el || isArray(el) && !el.length || filter && !filter.call(instance)) { 3302 return; 3303 } 3304 instance._events.push( 3305 on( 3306 el, 3307 name, 3308 delegate ? isString(delegate) ? delegate : delegate.call(instance, instance) : null, 3309 isString(handler) ? instance[handler] : handler.bind(instance), 3310 { passive, capture, self } 3311 ) 3312 ); 3313 } 3314 3315 function initObservers(instance) { 3316 instance._observers = []; 3317 for (const observer of instance.$options.observe || []) { 3318 if (hasOwn(observer, "handler")) { 3319 registerObservable(instance, observer); 3320 } else { 3321 for (const observable of observer) { 3322 registerObservable(instance, observable); 3323 } 3324 } 3325 } 3326 } 3327 function registerObserver(instance, ...observer) { 3328 instance._observers.push(...observer); 3329 } 3330 function disconnectObservers(instance) { 3331 for (const observer of instance._observers) { 3332 observer.disconnect(); 3333 } 3334 } 3335 function registerObservable(instance, observable) { 3336 let { observe, target = instance.$el, handler, options, filter, args } = observable; 3337 if (filter && !filter.call(instance, instance)) { 3338 return; 3339 } 3340 const key = `_observe${instance._observers.length}`; 3341 if (isFunction(target) && !hasOwn(instance, key)) { 3342 registerComputed(instance, key, () => target.call(instance, instance)); 3343 } 3344 handler = isString(handler) ? instance[handler] : handler.bind(instance); 3345 if (isFunction(options)) { 3346 options = options.call(instance, instance); 3347 } 3348 const targets = hasOwn(instance, key) ? instance[key] : target; 3349 const observer = observe(targets, handler, options, args); 3350 if (isFunction(target) && isArray(instance[key]) && observer.unobserve) { 3351 registerWatch(instance, { handler: updateTargets(observer), immediate: false }, key); 3352 } 3353 registerObserver(instance, observer); 3354 } 3355 function updateTargets(observer) { 3356 return (targets, prev) => { 3357 for (const target of prev) { 3358 !includes(targets, target) && observer.unobserve(target); 3359 } 3360 for (const target of targets) { 3361 !includes(prev, target) && observer.observe(target); 3362 } 3363 }; 3364 } 3365 3366 function initProps(instance) { 3367 const { $options, $props } = instance; 3368 const props = getProps($options); 3369 assign($props, props); 3370 const { computed, methods } = $options; 3371 for (let key in $props) { 3372 if (key in props && (!computed || !hasOwn(computed, key)) && (!methods || !hasOwn(methods, key))) { 3373 instance[key] = $props[key]; 3374 } 3375 } 3376 } 3377 function getProps(opts) { 3378 const data$1 = {}; 3379 const { args = [], props = {}, el, id } = opts; 3380 if (!props) { 3381 return data$1; 3382 } 3383 for (const key in props) { 3384 const prop = hyphenate(key); 3385 let value = data(el, prop); 3386 if (isUndefined(value)) { 3387 continue; 3388 } 3389 value = props[key] === Boolean && value === "" ? true : coerce$1(props[key], value); 3390 if (prop === "target" && startsWith(value, "_")) { 3391 continue; 3392 } 3393 data$1[key] = value; 3394 } 3395 const options = parseOptions(data(el, id), args); 3396 for (const key in options) { 3397 const prop = camelize(key); 3398 if (!isUndefined(props[prop])) { 3399 data$1[prop] = coerce$1(props[prop], options[key]); 3400 } 3401 } 3402 return data$1; 3403 } 3404 const getAttributes = memoize((id, props) => { 3405 const attributes = Object.keys(props); 3406 const filter = attributes.concat(id).map((key) => [hyphenate(key), `data-${hyphenate(key)}`]).flat(); 3407 return { attributes, filter }; 3408 });
vendor: 1,336 bytes, lines 3409-3447
3409 function initPropsObserver(instance) { 3410 const { $options, $props } = instance; 3411 const { id, props, el } = $options; 3412 if (!props) { 3413 return; 3414 } 3415 const { attributes, filter } = getAttributes(id, props); 3416 const observer = new MutationObserver((records) => { 3417 const data = getProps($options); 3418 if (records.some(({ attributeName }) => { 3419 const prop = attributeName.replace("data-", ""); 3420 return (prop === id ? attributes : [camelize(prop), camelize(attributeName)]).some( 3421 (prop2) => !isUndefined(data[prop2]) && data[prop2] !== $props[prop2] 3422 ); 3423 })) { 3424 instance.$reset(); 3425 } 3426 }); 3427 observer.observe(el, { 3428 attributes: true, 3429 attributeFilter: filter 3430 }); 3431 registerObserver(instance, observer); 3432 } 3433 3434 function callHook(instance, hook) { 3435 var _a; 3436 (_a = instance.$options[hook]) == null ? void 0 : _a.forEach((handler) => handler.call(instance)); 3437 } 3438 function callConnected(instance) { 3439 if (instance._connected) { 3440 return; 3441 } 3442 initProps(instance); 3443 callHook(instance, "beforeConnect"); 3444 instance._connected = true; 3445 initEvents(instance); 3446 initUpdates(instance); 3447 initWatches(instance);
vendor: 19,790 bytes, lines 3448-4064
3448 initObservers(instance); 3449 initPropsObserver(instance); 3450 initComputedUpdates(instance); 3451 callHook(instance, "connected"); 3452 callUpdate(instance); 3453 } 3454 function callDisconnected(instance) { 3455 if (!instance._connected) { 3456 return; 3457 } 3458 callHook(instance, "beforeDisconnect"); 3459 unbindEvents(instance); 3460 clearUpdateData(instance); 3461 disconnectObservers(instance); 3462 disconnectComputedUpdates(instance); 3463 callHook(instance, "disconnected"); 3464 instance._connected = false; 3465 } 3466 3467 let uid = 0; 3468 function init$1(instance, options = {}) { 3469 options.data = normalizeData(options, instance.constructor.options); 3470 instance.$options = mergeOptions(instance.constructor.options, options, instance); 3471 instance.$props = {}; 3472 instance._uid = uid++; 3473 initData(instance); 3474 initMethods(instance); 3475 initComputed(instance); 3476 callHook(instance, "created"); 3477 if (options.el) { 3478 instance.$mount(options.el); 3479 } 3480 } 3481 function initData(instance) { 3482 const { data = {} } = instance.$options; 3483 for (const key in data) { 3484 instance.$props[key] = instance[key] = data[key]; 3485 } 3486 } 3487 function initMethods(instance) { 3488 const { methods } = instance.$options; 3489 if (methods) { 3490 for (const key in methods) { 3491 instance[key] = methods[key].bind(instance); 3492 } 3493 } 3494 } 3495 function normalizeData({ data = {} }, { args = [], props = {} }) { 3496 if (isArray(data)) { 3497 data = data.slice(0, args.length).reduce((data2, value, index) => { 3498 if (isPlainObject(value)) { 3499 assign(data2, value); 3500 } else { 3501 data2[args[index]] = value; 3502 } 3503 return data2; 3504 }, {}); 3505 } 3506 for (const key in data) { 3507 if (isUndefined(data[key])) { 3508 delete data[key]; 3509 } else if (props[key]) { 3510 data[key] = coerce$1(props[key], data[key]); 3511 } 3512 } 3513 return data; 3514 } 3515 3516 const App = function(options) { 3517 init$1(this, options); 3518 }; 3519 App.util = util; 3520 App.options = {}; 3521 App.version = "3.17.11"; 3522 3523 const PREFIX = "uk-"; 3524 const DATA = "__uikit__"; 3525 const components$2 = {}; 3526 function component(name, options) { 3527 var _a; 3528 const id = PREFIX + hyphenate(name); 3529 if (!options) { 3530 if (isPlainObject(components$2[id])) { 3531 components$2[id] = App.extend(components$2[id]); 3532 } 3533 return components$2[id]; 3534 } 3535 name = camelize(name); 3536 App[name] = (element, data) => createComponent(name, element, data); 3537 const opt = isPlainObject(options) ? { ...options } : options.options; 3538 opt.id = id; 3539 opt.name = name; 3540 (_a = opt.install) == null ? void 0 : _a.call(opt, App, opt, name); 3541 if (App._initialized && !opt.functional) { 3542 requestAnimationFrame(() => createComponent(name, `[${id}],[data-${id}]`)); 3543 } 3544 return components$2[id] = opt; 3545 } 3546 function createComponent(name, element, data, ...args) { 3547 const Component = component(name); 3548 return Component.options.functional ? new Component({ data: isPlainObject(element) ? element : [element, data, ...args] }) : element ? $$(element).map(init)[0] : init(); 3549 function init(element2) { 3550 const instance = getComponent(element2, name); 3551 if (instance) { 3552 if (data) { 3553 instance.$destroy(); 3554 } else { 3555 return instance; 3556 } 3557 } 3558 return new Component({ el: element2, data }); 3559 } 3560 } 3561 function getComponents(element) { 3562 return (element == null ? void 0 : element[DATA]) || {}; 3563 } 3564 function getComponent(element, name) { 3565 return getComponents(element)[name]; 3566 } 3567 function attachToElement(element, instance) { 3568 if (!element[DATA]) { 3569 element[DATA] = {}; 3570 } 3571 element[DATA][instance.$options.name] = instance; 3572 } 3573 function detachFromElement(element, instance) { 3574 var _a; 3575 (_a = element[DATA]) == null ? true : delete _a[instance.$options.name]; 3576 if (!isEmpty(element[DATA])) { 3577 delete element[DATA]; 3578 } 3579 } 3580 3581 function globalApi(App) { 3582 App.component = component; 3583 App.getComponents = getComponents; 3584 App.getComponent = getComponent; 3585 App.update = update; 3586 App.use = function(plugin) { 3587 if (plugin.installed) { 3588 return; 3589 } 3590 plugin.call(null, this); 3591 plugin.installed = true; 3592 return this; 3593 }; 3594 App.mixin = function(mixin, component2) { 3595 component2 = (isString(component2) ? this.component(component2) : component2) || this; 3596 component2.options = mergeOptions(component2.options, mixin); 3597 }; 3598 App.extend = function(options) { 3599 options || (options = {}); 3600 const Super = this; 3601 const Sub = function UIkitComponent(options2) { 3602 init$1(this, options2); 3603 }; 3604 Sub.prototype = Object.create(Super.prototype); 3605 Sub.prototype.constructor = Sub; 3606 Sub.options = mergeOptions(Super.options, options); 3607 Sub.super = Super; 3608 Sub.extend = Super.extend; 3609 return Sub; 3610 }; 3611 let container; 3612 Object.defineProperty(App, "container", { 3613 get() { 3614 return container || document.body; 3615 }, 3616 set(element) { 3617 container = $(element); 3618 } 3619 }); 3620 } 3621 function update(element, e) { 3622 element = element ? toNode(element) : document.body; 3623 for (const parentEl of parents(element).reverse()) { 3624 updateElement(parentEl, e); 3625 } 3626 apply(element, (element2) => updateElement(element2, e)); 3627 } 3628 function updateElement(element, e) { 3629 const components = getComponents(element); 3630 for (const name in components) { 3631 callUpdate(components[name], e); 3632 } 3633 } 3634 3635 function instanceApi(App) { 3636 App.prototype.$mount = function(el) { 3637 const instance = this; 3638 attachToElement(el, instance); 3639 instance.$options.el = el; 3640 if (document.contains(el)) { 3641 callConnected(instance); 3642 } 3643 }; 3644 App.prototype.$destroy = function(removeEl = false) { 3645 const instance = this; 3646 const { el } = instance.$options; 3647 if (el) { 3648 callDisconnected(instance); 3649 } 3650 callHook(instance, "destroy"); 3651 detachFromElement(el, instance); 3652 if (removeEl) { 3653 remove$1(instance.$el); 3654 } 3655 }; 3656 App.prototype.$create = createComponent; 3657 App.prototype.$emit = function(e) { 3658 callUpdate(this, e); 3659 }; 3660 App.prototype.$update = function(element = this.$el, e) { 3661 update(element, e); 3662 }; 3663 App.prototype.$reset = function() { 3664 callDisconnected(this); 3665 callConnected(this); 3666 }; 3667 App.prototype.$getComponent = getComponent; 3668 Object.defineProperties(App.prototype, { 3669 $el: { 3670 get() { 3671 return this.$options.el; 3672 } 3673 }, 3674 $container: Object.getOwnPropertyDescriptor(App, "container") 3675 }); 3676 } 3677 let id = 1; 3678 function generateId(instance, el = null) { 3679 return (el == null ? void 0 : el.id) || `${instance.$options.id}-${id++}`; 3680 } 3681 3682 var SliderNav = { 3683 i18n: { 3684 next: "Next slide", 3685 previous: "Previous slide", 3686 slideX: "Slide %s", 3687 slideLabel: "%s of %s", 3688 role: "String" 3689 }, 3690 data: { 3691 selNav: false, 3692 role: "region" 3693 }, 3694 computed: { 3695 nav: ({ selNav }, $el) => $(selNav, $el), 3696 navChildren() { 3697 return children(this.nav); 3698 }, 3699 selNavItem: ({ attrItem }) => `[${attrItem}],[data-${attrItem}]`, 3700 navItems(_, $el) { 3701 return $$(this.selNavItem, $el); 3702 } 3703 }, 3704 watch: { 3705 nav(nav, prev) { 3706 attr(nav, "role", "tablist"); 3707 if (prev) { 3708 this.$emit(); 3709 } 3710 }, 3711 list(list) { 3712 attr(list, "role", "presentation"); 3713 }, 3714 navChildren(children2) { 3715 attr(children2, "role", "presentation"); 3716 }, 3717 navItems(items) { 3718 for (const el of items) { 3719 const cmd = data(el, this.attrItem); 3720 const button = $("a,button", el) || el; 3721 let ariaLabel; 3722 let ariaControls = null; 3723 if (isNumeric(cmd)) { 3724 const item = toNumber(cmd); 3725 const slide = this.slides[item]; 3726 if (slide) { 3727 if (!slide.id) { 3728 slide.id = generateId(this, slide); 3729 } 3730 ariaControls = slide.id; 3731 } 3732 ariaLabel = this.t("slideX", toFloat(cmd) + 1); 3733 attr(button, "role", "tab"); 3734 } else { 3735 if (this.list) { 3736 if (!this.list.id) { 3737 this.list.id = generateId(this, this.list); 3738 } 3739 ariaControls = this.list.id; 3740 } 3741 ariaLabel = this.t(cmd); 3742 } 3743 attr(button, { 3744 "aria-controls": ariaControls, 3745 "aria-label": attr(button, "aria-label") || ariaLabel 3746 }); 3747 } 3748 }, 3749 slides(slides) { 3750 slides.forEach( 3751 (slide, i) => attr(slide, { 3752 role: this.nav ? "tabpanel" : "group", 3753 "aria-label": this.t("slideLabel", i + 1, this.length), 3754 "aria-roledescription": this.nav ? null : "slide" 3755 }) 3756 ); 3757 }, 3758 length(length) { 3759 const navLength = this.navChildren.length; 3760 if (this.nav && length !== navLength) { 3761 empty(this.nav); 3762 for (let i = 0; i < length; i++) { 3763 append(this.nav, `<li ${this.attrItem}="${i}"><a href></a></li>`); 3764 } 3765 } 3766 } 3767 }, 3768 connected() { 3769 attr(this.$el, { 3770 role: this.role, 3771 "aria-roledescription": "carousel" 3772 }); 3773 }, 3774 update: [ 3775 { 3776 write() { 3777 this.navItems.concat(this.nav).forEach((el) => el && (el.hidden = !this.maxIndex)); 3778 this.updateNav(); 3779 }, 3780 events: ["resize"] 3781 } 3782 ], 3783 events: [ 3784 { 3785 name: "click keydown", 3786 delegate() { 3787 return this.selNavItem; 3788 }, 3789 handler(e) { 3790 if (e.target.closest("a,button") && (e.type === "click" || e.keyCode === keyMap.SPACE)) { 3791 e.preventDefault(); 3792 this.show(data(e.current, this.attrItem)); 3793 } 3794 } 3795 }, 3796 { 3797 name: "itemshow", 3798 handler: "updateNav" 3799 }, 3800 { 3801 name: "keydown", 3802 delegate() { 3803 return this.selNavItem; 3804 }, 3805 handler(e) { 3806 const { current, keyCode } = e; 3807 const cmd = data(current, this.attrItem); 3808 if (!isNumeric(cmd)) { 3809 return; 3810 } 3811 let i = keyCode === keyMap.HOME ? 0 : keyCode === keyMap.END ? "last" : keyCode === keyMap.LEFT ? "previous" : keyCode === keyMap.RIGHT ? "next" : -1; 3812 if (~i) { 3813 e.preventDefault(); 3814 this.show(i); 3815 } 3816 } 3817 } 3818 ], 3819 methods: { 3820 updateNav() { 3821 const index = this.getValidIndex(); 3822 for (const el of this.navItems) { 3823 const cmd = data(el, this.attrItem); 3824 const button = $("a,button", el) || el; 3825 if (isNumeric(cmd)) { 3826 const item = toNumber(cmd); 3827 const active = item === index; 3828 toggleClass(el, this.clsActive, active); 3829 attr(button, { 3830 "aria-selected": active, 3831 tabindex: active ? null : -1 3832 }); 3833 if (active && button && matches(parent(el), ":focus-within")) { 3834 button.focus(); 3835 } 3836 } else { 3837 toggleClass( 3838 el, 3839 "uk-invisible", 3840 this.finite && (cmd === "previous" && index === 0 || cmd === "next" && index >= this.maxIndex) 3841 ); 3842 } 3843 } 3844 } 3845 } 3846 }; 3847 3848 var Slider = { 3849 mixins: [SliderAutoplay, SliderDrag, SliderNav, I18n], 3850 props: { 3851 clsActivated: Boolean, 3852 easing: String, 3853 index: Number, 3854 finite: Boolean, 3855 velocity: Number 3856 }, 3857 data: () => ({ 3858 easing: "ease", 3859 finite: false, 3860 velocity: 1, 3861 index: 0, 3862 prevIndex: -1, 3863 stack: [], 3864 percent: 0, 3865 clsActive: "uk-active", 3866 clsActivated: false, 3867 Transitioner: false, 3868 transitionOptions: {} 3869 }), 3870 connected() { 3871 this.prevIndex = -1; 3872 this.index = this.getValidIndex(this.$props.index); 3873 this.stack = []; 3874 }, 3875 disconnected() { 3876 removeClass(this.slides, this.clsActive); 3877 }, 3878 computed: { 3879 duration: ({ velocity }, $el) => speedUp($el.offsetWidth / velocity), 3880 list: ({ selList }, $el) => $(selList, $el), 3881 maxIndex() { 3882 return this.length - 1; 3883 }, 3884 slides() { 3885 return children(this.list); 3886 }, 3887 length() { 3888 return this.slides.length; 3889 } 3890 }, 3891 watch: { 3892 slides(slides, prev) { 3893 if (prev) { 3894 this.$emit(); 3895 } 3896 } 3897 }, 3898 observe: resize(), 3899 methods: { 3900 show(index, force = false) { 3901 var _a; 3902 if (this.dragging || !this.length) { 3903 return; 3904 } 3905 const { stack } = this; 3906 const queueIndex = force ? 0 : stack.length; 3907 const reset = () => { 3908 stack.splice(queueIndex, 1); 3909 if (stack.length) { 3910 this.show(stack.shift(), true); 3911 } 3912 }; 3913 stack[force ? "unshift" : "push"](index); 3914 if (!force && stack.length > 1) { 3915 if (stack.length === 2) { 3916 (_a = this._transitioner) == null ? void 0 : _a.forward(Math.min(this.duration, 200)); 3917 } 3918 return; 3919 } 3920 const prevIndex = this.getIndex(this.index); 3921 const prev = hasClass(this.slides, this.clsActive) && this.slides[prevIndex]; 3922 const nextIndex = this.getIndex(index, this.index); 3923 const next = this.slides[nextIndex]; 3924 if (prev === next) { 3925 reset(); 3926 return; 3927 } 3928 this.dir = getDirection(index, prevIndex); 3929 this.prevIndex = prevIndex; 3930 this.index = nextIndex; 3931 if (prev && !trigger(prev, "beforeitemhide", [this]) || !trigger(next, "beforeitemshow", [this, prev])) { 3932 this.index = this.prevIndex; 3933 reset(); 3934 return; 3935 } 3936 const promise = this._show(prev, next, force).then(() => { 3937 prev && trigger(prev, "itemhidden", [this]); 3938 trigger(next, "itemshown", [this]); 3939 stack.shift(); 3940 this._transitioner = null; 3941 requestAnimationFrame(() => stack.length && this.show(stack.shift(), true)); 3942 }); 3943 prev && trigger(prev, "itemhide", [this]); 3944 trigger(next, "itemshow", [this]); 3945 return promise; 3946 }, 3947 getIndex(index = this.index, prev = this.index) { 3948 return clamp( 3949 getIndex(index, this.slides, prev, this.finite), 3950 0, 3951 Math.max(0, this.maxIndex) 3952 ); 3953 }, 3954 getValidIndex(index = this.index, prevIndex = this.prevIndex) { 3955 return this.getIndex(index, prevIndex); 3956 }, 3957 _show(prev, next, force) { 3958 this._transitioner = this._getTransitioner(prev, next, this.dir, { 3959 easing: force ? next.offsetWidth < 600 ? "cubic-bezier(0.25, 0.46, 0.45, 0.94)" : "cubic-bezier(0.165, 0.84, 0.44, 1)" : this.easing, 3960 ...this.transitionOptions 3961 }); 3962 if (!force && !prev) { 3963 this._translate(1); 3964 return Promise.resolve(); 3965 } 3966 const { length } = this.stack; 3967 return this._transitioner[length > 1 ? "forward" : "show"]( 3968 length > 1 ? Math.min(this.duration, 75 + 75 / (length - 1)) : this.duration, 3969 this.percent 3970 ); 3971 }, 3972 _translate(percent, prev = this.prevIndex, next = this.index) { 3973 const transitioner = this._getTransitioner(prev === next ? false : prev, next); 3974 transitioner.translate(percent); 3975 return transitioner; 3976 }, 3977 _getTransitioner(prev = this.prevIndex, next = this.index, dir = this.dir || 1, options = this.transitionOptions) { 3978 return new this.Transitioner( 3979 isNumber(prev) ? this.slides[prev] : prev, 3980 isNumber(next) ? this.slides[next] : next, 3981 dir * (isRtl ? -1 : 1), 3982 options 3983 ); 3984 } 3985 } 3986 }; 3987 function getDirection(index, prevIndex) { 3988 return index === "next" ? 1 : index === "previous" ? -1 : index < prevIndex ? -1 : 1; 3989 } 3990 function speedUp(x) { 3991 return 0.5 * x + 300; 3992 } 3993 3994 var Slideshow = { 3995 mixins: [Slider], 3996 props: { 3997 animation: String 3998 }, 3999 data: { 4000 animation: "slide", 4001 clsActivated: "uk-transition-active", 4002 Animations: Animations$2, 4003 Transitioner: Transitioner$1 4004 }, 4005 computed: { 4006 animation({ animation, Animations: Animations2 }) { 4007 return { ...Animations2[animation] || Animations2.slide, name: animation }; 4008 }, 4009 transitionOptions() { 4010 return { animation: this.animation }; 4011 } 4012 }, 4013 events: { 4014 beforeitemshow({ target }) { 4015 addClass(target, this.clsActive); 4016 }, 4017 itemshown({ target }) { 4018 addClass(target, this.clsActivated); 4019 }, 4020 itemhidden({ target }) { 4021 removeClass(target, this.clsActive, this.clsActivated); 4022 } 4023 } 4024 }; 4025 4026 var Animations$1 = { 4027 ...Animations$2, 4028 fade: { 4029 show() { 4030 return [{ opacity: 0 }, { opacity: 1 }]; 4031 }, 4032 percent(current) { 4033 return 1 - css(current, "opacity"); 4034 }, 4035 translate(percent) { 4036 return [{ opacity: 1 - percent }, { opacity: percent }]; 4037 } 4038 }, 4039 scale: { 4040 show() { 4041 return [ 4042 { opacity: 0, transform: scale3d(1 - 0.2) }, 4043 { opacity: 1, transform: scale3d(1) } 4044 ]; 4045 }, 4046 percent(current) { 4047 return 1 - css(current, "opacity"); 4048 }, 4049 translate(percent) { 4050 return [ 4051 { opacity: 1 - percent, transform: scale3d(1 - 0.2 * percent) }, 4052 { opacity: percent, transform: scale3d(1 - 0.2 + 0.2 * percent) } 4053 ]; 4054 } 4055 } 4056 }; 4057 4058 var LightboxPanel = { 4059 mixins: [Modal, Slideshow], 4060 functional: true, 4061 props: { 4062 delayControls: Number, 4063 preload: Number, 4064 videoAutoplay: Boolean,
4065 template: String 4066 }, 4067 data: () => ({ 4068 preload: 1, 4069 videoAutoplay: false, 4070 delayControls: 3e3, 4071 items: [], 4072 cls: "uk-open", 4073 clsPage: "uk-lightbox-page", 4074 selList: ".uk-lightbox-items", 4075 attrItem: "uk-lightbox-item", 4076 selClose: ".uk-close-large", 4077 selCaption: ".uk-lightbox-caption", 4078 pauseOnHover: false, 4079 velocity: 2, 4080 Animations: Animations$1, 4081 template: `<div class="uk-lightbox uk-overflow-hidden"> <ul class="uk-lightbox-items"></ul> <div class="uk-lightbox-toolbar uk-position-top uk-text-right uk-transition-slide-top uk-transition-opaque"> <button class="uk-lightbox-toolbar-icon uk-close-large" type="button" uk-close></button> </div> <a class="uk-lightbox-button uk-position-center-left uk-position-medium uk-transition-fade" href uk-slidenav-previous uk-lightbox-item="previous"></a> <a class="uk-lightbox-button uk-position-center-right uk-position-medium uk-transition-fade" href uk-slidenav-next uk-lightbox-item="next"></a> <div class="uk-lightbox-toolbar uk-lightbox-caption uk-position-bottom uk-text-center uk-transition-sli
vendor: 45,433 bytes, lines 4081-5440
4081de-bottom uk-transition-opaque"></div> </div>` 4082 }), 4083 created() { 4084 const $el = $(this.template); 4085 const list = $(this.selList, $el); 4086 this.items.forEach(() => append(list, "<li>")); 4087 const close = $("[uk-close]", $el); 4088 const closeLabel = this.t("close"); 4089 if (close && closeLabel) { 4090 close.dataset.i18n = JSON.stringify({ label: closeLabel }); 4091 } 4092 this.$mount(append(this.container, $el)); 4093 }, 4094 computed: { 4095 caption: ({ selCaption }, $el) => $(selCaption, $el) 4096 }, 4097 events: [ 4098 { 4099 name: `${pointerMove$1} ${pointerDown$1} keydown`, 4100 handler: "showControls" 4101 }, 4102 { 4103 name: "click", 4104 self: true, 4105 delegate() { 4106 return `${this.selList} > *`; 4107 }, 4108 handler(e) { 4109 if (!e.defaultPrevented) { 4110 this.hide(); 4111 } 4112 } 4113 }, 4114 { 4115 name: "shown", 4116 self: true, 4117 handler() { 4118 this.showControls(); 4119 } 4120 }, 4121 { 4122 name: "hide", 4123 self: true, 4124 handler() { 4125 this.hideControls(); 4126 removeClass(this.slides, this.clsActive); 4127 Transition.stop(this.slides); 4128 } 4129 }, 4130 { 4131 name: "hidden", 4132 self: true, 4133 handler() { 4134 this.$destroy(true); 4135 } 4136 }, 4137 { 4138 name: "keyup", 4139 el() { 4140 return document; 4141 }, 4142 handler({ keyCode }) { 4143 if (!this.isToggled(this.$el) || !this.draggable) { 4144 return; 4145 } 4146 let i = -1; 4147 if (keyCode === keyMap.LEFT) { 4148 i = "previous"; 4149 } else if (keyCode === keyMap.RIGHT) { 4150 i = "next"; 4151 } else if (keyCode === keyMap.HOME) { 4152 i = 0; 4153 } else if (keyCode === keyMap.END) { 4154 i = "last"; 4155 } 4156 if (~i) { 4157 this.show(i); 4158 } 4159 } 4160 }, 4161 { 4162 name: "beforeitemshow", 4163 handler(e) { 4164 if (this.isToggled()) { 4165 return; 4166 } 4167 this.draggable = false; 4168 e.preventDefault(); 4169 this.toggleElement(this.$el, true, false); 4170 this.animation = Animations$1["scale"]; 4171 removeClass(e.target, this.clsActive); 4172 this.stack.splice(1, 0, this.index); 4173 } 4174 }, 4175 { 4176 name: "itemshow", 4177 handler() { 4178 html(this.caption, this.getItem().caption || ""); 4179 for (let j = -this.preload; j <= this.preload; j++) { 4180 this.loadItem(this.index + j); 4181 } 4182 } 4183 }, 4184 { 4185 name: "itemshown", 4186 handler() { 4187 this.draggable = this.$props.draggable; 4188 } 4189 }, 4190 { 4191 name: "itemload", 4192 async handler(_, item) { 4193 const { source: src, type, alt = "", poster, attrs = {} } = item; 4194 this.setItem(item, "<span uk-spinner></span>"); 4195 if (!src) { 4196 return; 4197 } 4198 let matches; 4199 const iframeAttrs = { 4200 allowfullscreen: "", 4201 style: "max-width: 100%; box-sizing: border-box;", 4202 "uk-responsive": "", 4203 "uk-video": `${this.videoAutoplay}` 4204 }; 4205 if (type === "image" || src.match(/\.(avif|jpe?g|jfif|a?png|gif|svg|webp)($|\?)/i)) { 4206 const img = createEl("img", { src, alt, ...attrs }); 4207 on(img, "load", () => this.setItem(item, img)); 4208 on(img, "error", () => this.setError(item)); 4209 } else if (type === "video" || src.match(/\.(mp4|webm|ogv)($|\?)/i)) { 4210 const video = createEl("video", { 4211 src, 4212 poster, 4213 controls: "", 4214 playsinline: "", 4215 "uk-video": `${this.videoAutoplay}`, 4216 ...attrs 4217 }); 4218 on(video, "loadedmetadata", () => this.setItem(item, video)); 4219 on(video, "error", () => this.setError(item)); 4220 } else if (type === "iframe" || src.match(/\.(html|php)($|\?)/i)) { 4221 this.setItem( 4222 item, 4223 createEl("iframe", { 4224 src, 4225 allowfullscreen: "", 4226 class: "uk-lightbox-iframe", 4227 ...attrs 4228 }) 4229 ); 4230 } else if (matches = src.match( 4231 /\/\/(?:.*?youtube(-nocookie)?\..*?(?:[?&]v=|\/shorts\/)|youtu\.be\/)([\w-]{11})[&?]?(.*)?/ 4232 )) { 4233 this.setItem( 4234 item, 4235 createEl("iframe", { 4236 src: `https://www.youtube${matches[1] || ""}.com/embed/${matches[2]}${matches[3] ? `?${matches[3]}` : ""}`, 4237 width: 1920, 4238 height: 1080, 4239 ...iframeAttrs, 4240 ...attrs 4241 }) 4242 ); 4243 } else if (matches = src.match(/\/\/.*?vimeo\.[a-z]+\/(\d+)[&?]?(.*)?/)) { 4244 try { 4245 const { height, width } = await (await fetch( 4246 `https://vimeo.com/api/oembed.json?maxwidth=1920&url=${encodeURI( 4247 src 4248 )}`, 4249 { credentials: "omit" } 4250 )).json(); 4251 this.setItem( 4252 item, 4253 createEl("iframe", { 4254 src: `https://player.vimeo.com/video/${matches[1]}${matches[2] ? `?${matches[2]}` : ""}`, 4255 width, 4256 height, 4257 ...iframeAttrs, 4258 ...attrs 4259 }) 4260 ); 4261 } catch (e) { 4262 this.setError(item); 4263 } 4264 } 4265 } 4266 } 4267 ], 4268 methods: { 4269 loadItem(index = this.index) { 4270 const item = this.getItem(index); 4271 if (!this.getSlide(item).childElementCount) { 4272 trigger(this.$el, "itemload", [item]); 4273 } 4274 }, 4275 getItem(index = this.index) { 4276 return this.items[getIndex(index, this.slides)]; 4277 }, 4278 setItem(item, content) { 4279 trigger(this.$el, "itemloaded", [this, html(this.getSlide(item), content)]); 4280 }, 4281 getSlide(item) { 4282 return this.slides[this.items.indexOf(item)]; 4283 }, 4284 setError(item) { 4285 this.setItem(item, '<span uk-icon="icon: bolt; ratio: 2"></span>'); 4286 }, 4287 showControls() { 4288 clearTimeout(this.controlsTimer); 4289 this.controlsTimer = setTimeout(this.hideControls, this.delayControls); 4290 addClass(this.$el, "uk-active", "uk-transition-active"); 4291 }, 4292 hideControls() { 4293 removeClass(this.$el, "uk-active", "uk-transition-active"); 4294 } 4295 } 4296 }; 4297 function createEl(tag, attrs) { 4298 const el = fragment(`<${tag}>`); 4299 attr(el, attrs); 4300 return el; 4301 } 4302 4303 var lightbox = { 4304 install: install$3, 4305 props: { toggle: String }, 4306 data: { toggle: "a" }, 4307 computed: { 4308 toggles: ({ toggle }, $el) => $$(toggle, $el) 4309 }, 4310 watch: { 4311 toggles(toggles) { 4312 this.hide(); 4313 for (const toggle of toggles) { 4314 if (isTag(toggle, "a")) { 4315 attr(toggle, "role", "button"); 4316 } 4317 } 4318 } 4319 }, 4320 disconnected() { 4321 this.hide(); 4322 }, 4323 events: { 4324 name: "click", 4325 delegate() { 4326 return `${this.toggle}:not(.uk-disabled)`; 4327 }, 4328 handler(e) { 4329 e.preventDefault(); 4330 this.show(e.current); 4331 } 4332 }, 4333 methods: { 4334 show(index) { 4335 const items = uniqueBy(this.toggles.map(toItem), "source"); 4336 if (isElement(index)) { 4337 const { source } = toItem(index); 4338 index = findIndex(items, ({ source: src }) => source === src); 4339 } 4340 this.panel = this.panel || this.$create("lightboxPanel", { ...this.$props, items }); 4341 on(this.panel.$el, "hidden", () => this.panel = null); 4342 return this.panel.show(index); 4343 }, 4344 hide() { 4345 var _a; 4346 return (_a = this.panel) == null ? void 0 : _a.hide(); 4347 } 4348 } 4349 }; 4350 function install$3(UIkit, Lightbox) { 4351 if (!UIkit.lightboxPanel) { 4352 UIkit.component("lightboxPanel", LightboxPanel); 4353 } 4354 assign(Lightbox.props, UIkit.component("lightboxPanel").options.props); 4355 } 4356 function toItem(el) { 4357 const item = {}; 4358 for (const attr2 of ["href", "caption", "type", "poster", "alt", "attrs"]) { 4359 item[attr2 === "href" ? "source" : attr2] = data(el, attr2); 4360 } 4361 item.attrs = parseOptions(item.attrs); 4362 return item; 4363 } 4364 4365 var notification = { 4366 mixins: [Container], 4367 functional: true, 4368 args: ["message", "status"], 4369 data: { 4370 message: "", 4371 status: "", 4372 timeout: 5e3, 4373 group: "", 4374 pos: "top-center", 4375 clsContainer: "uk-notification", 4376 clsClose: "uk-notification-close", 4377 clsMsg: "uk-notification-message" 4378 }, 4379 install: install$2, 4380 computed: { 4381 marginProp: ({ pos }) => `margin-${pos.match(/[a-z]+(?=-)/)[0]}`, 4382 startProps() { 4383 return { opacity: 0, [this.marginProp]: -this.$el.offsetHeight }; 4384 } 4385 }, 4386 created() { 4387 const posClass = `${this.clsContainer}-${this.pos}`; 4388 let container = $(`.${posClass}`, this.container); 4389 if (!container || !isVisible(container)) { 4390 container = append( 4391 this.container, 4392 `<div class="${this.clsContainer} ${posClass}"></div>` 4393 ); 4394 } 4395 this.$mount( 4396 append( 4397 container, 4398 `<div class="${this.clsMsg}${this.status ? ` ${this.clsMsg}-${this.status}` : ""}" role="alert"> <a href class="${this.clsClose}" data-uk-close></a> <div>${this.message}</div> </div>` 4399 ) 4400 ); 4401 }, 4402 async connected() { 4403 const margin = toFloat(css(this.$el, this.marginProp)); 4404 await Transition.start(css(this.$el, this.startProps), { 4405 opacity: 1, 4406 [this.marginProp]: margin 4407 }); 4408 if (this.timeout) { 4409 this.timer = setTimeout(this.close, this.timeout); 4410 } 4411 }, 4412 events: { 4413 click(e) { 4414 if (e.target.closest('a[href="#"],a[href=""]')) { 4415 e.preventDefault(); 4416 } 4417 this.close(); 4418 }, 4419 [pointerEnter]() { 4420 if (this.timer) { 4421 clearTimeout(this.timer); 4422 } 4423 }, 4424 [pointerLeave]() { 4425 if (this.timeout) { 4426 this.timer = setTimeout(this.close, this.timeout); 4427 } 4428 } 4429 }, 4430 methods: { 4431 async close(immediate) { 4432 const removeFn = (el) => { 4433 const container = parent(el); 4434 trigger(el, "close", [this]); 4435 remove$1(el); 4436 if (!(container == null ? void 0 : container.hasChildNodes())) { 4437 remove$1(container); 4438 } 4439 }; 4440 if (this.timer) { 4441 clearTimeout(this.timer); 4442 } 4443 if (!immediate) { 4444 await Transition.start(this.$el, this.startProps); 4445 } 4446 removeFn(this.$el); 4447 } 4448 } 4449 }; 4450 function install$2(UIkit) { 4451 UIkit.notification.closeAll = function(group, immediate) { 4452 apply(document.body, (el) => { 4453 const notification = UIkit.getComponent(el, "notification"); 4454 if (notification && (!group || group === notification.group)) { 4455 notification.close(immediate); 4456 } 4457 }); 4458 }; 4459 } 4460 4461 var Media = { 4462 props: { 4463 media: Boolean 4464 }, 4465 data: { 4466 media: false 4467 }, 4468 connected() { 4469 const media = toMedia(this.media, this.$el); 4470 this.matchMedia = true; 4471 if (media) { 4472 this.mediaObj = window.matchMedia(media); 4473 const handler = () => { 4474 this.matchMedia = this.mediaObj.matches; 4475 trigger(this.$el, createEvent("mediachange", false, true, [this.mediaObj])); 4476 }; 4477 this.offMediaObj = on(this.mediaObj, "change", () => { 4478 handler(); 4479 this.$emit("resize"); 4480 }); 4481 handler(); 4482 } 4483 }, 4484 disconnected() { 4485 var _a; 4486 (_a = this.offMediaObj) == null ? void 0 : _a.call(this); 4487 } 4488 }; 4489 function toMedia(value, element) { 4490 if (isString(value)) { 4491 if (startsWith(value, "@")) { 4492 value = toFloat(css(element, `--uk-breakpoint-${value.substr(1)}`)); 4493 } else if (isNaN(value)) { 4494 return value; 4495 } 4496 } 4497 return value && isNumeric(value) ? `(min-width: ${value}px)` : ""; 4498 } 4499 4500 function getMaxPathLength(el) { 4501 return Math.ceil( 4502 Math.max( 4503 0, 4504 ...$$("[stroke]", el).map((stroke) => { 4505 try { 4506 return stroke.getTotalLength(); 4507 } catch (e) { 4508 return 0; 4509 } 4510 }) 4511 ) 4512 ); 4513 } 4514 4515 const props = { 4516 x: transformFn, 4517 y: transformFn, 4518 rotate: transformFn, 4519 scale: transformFn, 4520 color: colorFn, 4521 backgroundColor: colorFn, 4522 borderColor: colorFn, 4523 blur: filterFn, 4524 hue: filterFn, 4525 fopacity: filterFn, 4526 grayscale: filterFn, 4527 invert: filterFn, 4528 saturate: filterFn, 4529 sepia: filterFn, 4530 opacity: cssPropFn, 4531 stroke: strokeFn, 4532 bgx: backgroundFn, 4533 bgy: backgroundFn 4534 }; 4535 const { keys } = Object; 4536 var Parallax = { 4537 mixins: [Media], 4538 props: fillObject(keys(props), "list"), 4539 data: fillObject(keys(props), void 0), 4540 computed: { 4541 props(properties, $el) { 4542 const stops = {}; 4543 for (const prop in properties) { 4544 if (prop in props && !isUndefined(properties[prop])) { 4545 stops[prop] = properties[prop].slice(); 4546 } 4547 } 4548 const result = {}; 4549 for (const prop in stops) { 4550 result[prop] = props[prop](prop, $el, stops[prop], stops); 4551 } 4552 return result; 4553 } 4554 }, 4555 events: { 4556 load() { 4557 this.$emit(); 4558 } 4559 }, 4560 methods: { 4561 reset() { 4562 for (const prop in this.getCss(0)) { 4563 css(this.$el, prop, ""); 4564 } 4565 }, 4566 getCss(percent) { 4567 const css2 = {}; 4568 for (const prop in this.props) { 4569 this.props[prop](css2, clamp(percent)); 4570 } 4571 css2.willChange = Object.keys(css2).map(propName).join(","); 4572 return css2; 4573 } 4574 } 4575 }; 4576 function transformFn(prop, el, stops) { 4577 let unit = getUnit(stops) || { x: "px", y: "px", rotate: "deg" }[prop] || ""; 4578 let transformFn2; 4579 if (prop === "x" || prop === "y") { 4580 prop = `translate${ucfirst(prop)}`; 4581 transformFn2 = (stop) => toFloat(toFloat(stop).toFixed(unit === "px" ? 0 : 6)); 4582 } else if (prop === "scale") { 4583 unit = ""; 4584 transformFn2 = (stop) => { 4585 var _a; 4586 return getUnit([stop]) ? toPx(stop, "width", el, true) / el[`offset${((_a = stop.endsWith) == null ? void 0 : _a.call(stop, "vh")) ? "Height" : "Width"}`] : toFloat(stop); 4587 }; 4588 } 4589 if (stops.length === 1) { 4590 stops.unshift(prop === "scale" ? 1 : 0); 4591 } 4592 stops = parseStops(stops, transformFn2); 4593 return (css2, percent) => { 4594 css2.transform = `${css2.transform || ""} ${prop}(${getValue(stops, percent)}${unit})`; 4595 }; 4596 } 4597 function colorFn(prop, el, stops) { 4598 if (stops.length === 1) { 4599 stops.unshift(getCssValue(el, prop, "")); 4600 } 4601 stops = parseStops(stops, (stop) => parseColor(el, stop)); 4602 return (css2, percent) => { 4603 const [start, end, p] = getStop(stops, percent); 4604 const value = start.map((value2, i) => { 4605 value2 += p * (end[i] - value2); 4606 return i === 3 ? toFloat(value2) : parseInt(value2, 10); 4607 }).join(","); 4608 css2[prop] = `rgba(${value})`; 4609 }; 4610 } 4611 function parseColor(el, color) { 4612 return getCssValue(el, "color", color).split(/[(),]/g).slice(1, -1).concat(1).slice(0, 4).map(toFloat); 4613 } 4614 function filterFn(prop, el, stops) { 4615 if (stops.length === 1) { 4616 stops.unshift(0); 4617 } 4618 const unit = getUnit(stops) || { blur: "px", hue: "deg" }[prop] || "%"; 4619 prop = { fopacity: "opacity", hue: "hue-rotate" }[prop] || prop; 4620 stops = parseStops(stops); 4621 return (css2, percent) => { 4622 const value = getValue(stops, percent); 4623 css2.filter = `${css2.filter || ""} ${prop}(${value + unit})`; 4624 }; 4625 } 4626 function cssPropFn(prop, el, stops) { 4627 if (stops.length === 1) { 4628 stops.unshift(getCssValue(el, prop, "")); 4629 } 4630 stops = parseStops(stops); 4631 return (css2, percent) => { 4632 css2[prop] = getValue(stops, percent); 4633 }; 4634 } 4635 function strokeFn(prop, el, stops) { 4636 if (stops.length === 1) { 4637 stops.unshift(0); 4638 } 4639 const unit = getUnit(stops); 4640 const length = getMaxPathLength(el); 4641 stops = parseStops(stops.reverse(), (stop) => { 4642 stop = toFloat(stop); 4643 return unit === "%" ? stop * length / 100 : stop; 4644 }); 4645 if (!stops.some(([value]) => value)) { 4646 return noop; 4647 } 4648 css(el, "strokeDasharray", length); 4649 return (css2, percent) => { 4650 css2.strokeDashoffset = getValue(stops, percent); 4651 }; 4652 } 4653 function backgroundFn(prop, el, stops, props2) { 4654 if (stops.length === 1) { 4655 stops.unshift(0); 4656 } 4657 const attr = prop === "bgy" ? "height" : "width"; 4658 props2[prop] = parseStops(stops, (stop) => toPx(stop, attr, el)); 4659 const bgProps = ["bgx", "bgy"].filter((prop2) => prop2 in props2); 4660 if (bgProps.length === 2 && prop === "bgx") { 4661 return noop; 4662 } 4663 if (getCssValue(el, "backgroundSize", "") === "cover") { 4664 return backgroundCoverFn(prop, el, stops, props2); 4665 } 4666 const positions = {}; 4667 for (const prop2 of bgProps) { 4668 positions[prop2] = getBackgroundPos(el, prop2); 4669 } 4670 return setBackgroundPosFn(bgProps, positions, props2); 4671 } 4672 function backgroundCoverFn(prop, el, stops, props2) { 4673 const dimImage = getBackgroundImageDimensions(el); 4674 if (!dimImage.width) { 4675 return noop; 4676 } 4677 const dimEl = { 4678 width: el.offsetWidth, 4679 height: el.offsetHeight 4680 }; 4681 const bgProps = ["bgx", "bgy"].filter((prop2) => prop2 in props2); 4682 const positions = {}; 4683 for (const prop2 of bgProps) { 4684 const values = props2[prop2].map(([value]) => value); 4685 const min = Math.min(...values); 4686 const max = Math.max(...values); 4687 const down = values.indexOf(min) < values.indexOf(max); 4688 const diff = max - min; 4689 positions[prop2] = `${(down ? -diff : 0) - (down ? min : max)}px`; 4690 dimEl[prop2 === "bgy" ? "height" : "width"] += diff; 4691 } 4692 const dim = Dimensions.cover(dimImage, dimEl); 4693 for (const prop2 of bgProps) { 4694 const attr = prop2 === "bgy" ? "height" : "width"; 4695 const overflow = dim[attr] - dimEl[attr]; 4696 positions[prop2] = `max(${getBackgroundPos(el, prop2)},-${overflow}px) + ${positions[prop2]}`; 4697 } 4698 const fn = setBackgroundPosFn(bgProps, positions, props2); 4699 return (css2, percent) => { 4700 fn(css2, percent); 4701 css2.backgroundSize = `${dim.width}px ${dim.height}px`; 4702 css2.backgroundRepeat = "no-repeat"; 4703 }; 4704 } 4705 function getBackgroundPos(el, prop) { 4706 return getCssValue(el, `background-position-${prop.substr(-1)}`, ""); 4707 } 4708 function setBackgroundPosFn(bgProps, positions, props2) { 4709 return function(css2, percent) { 4710 for (const prop of bgProps) { 4711 const value = getValue(props2[prop], percent); 4712 css2[`background-position-${prop.substr(-1)}`] = `calc(${positions[prop]} + ${value}px)`; 4713 } 4714 }; 4715 } 4716 const dimensions = {}; 4717 function getBackgroundImageDimensions(el) { 4718 const src = css(el, "backgroundImage").replace(/^none|url\(["']?(.+?)["']?\)$/, "$1"); 4719 if (dimensions[src]) { 4720 return dimensions[src]; 4721 } 4722 const image = new Image(); 4723 if (src) { 4724 image.src = src; 4725 if (!image.naturalWidth) { 4726 image.onload = () => { 4727 dimensions[src] = toDimensions(image); 4728 trigger(el, createEvent("load", false)); 4729 }; 4730 return toDimensions(image); 4731 } 4732 } 4733 return dimensions[src] = toDimensions(image); 4734 } 4735 function toDimensions(image) { 4736 return { 4737 width: image.naturalWidth, 4738 height: image.naturalHeight 4739 }; 4740 } 4741 function parseStops(stops, fn = toFloat) { 4742 const result = []; 4743 const { length } = stops; 4744 let nullIndex = 0; 4745 for (let i = 0; i < length; i++) { 4746 let [value, percent] = isString(stops[i]) ? stops[i].trim().split(/ (?![^(]*\))/) : [stops[i]]; 4747 value = fn(value); 4748 percent = percent ? toFloat(percent) / 100 : null; 4749 if (i === 0) { 4750 if (percent === null) { 4751 percent = 0; 4752 } else if (percent) { 4753 result.push([value, 0]); 4754 } 4755 } else if (i === length - 1) { 4756 if (percent === null) { 4757 percent = 1; 4758 } else if (percent !== 1) { 4759 result.push([value, percent]); 4760 percent = 1; 4761 } 4762 } 4763 result.push([value, percent]); 4764 if (percent === null) { 4765 nullIndex++; 4766 } else if (nullIndex) { 4767 const leftPercent = result[i - nullIndex - 1][1]; 4768 const p = (percent - leftPercent) / (nullIndex + 1); 4769 for (let j = nullIndex; j > 0; j--) { 4770 result[i - j][1] = leftPercent + p * (nullIndex - j + 1); 4771 } 4772 nullIndex = 0; 4773 } 4774 } 4775 return result; 4776 } 4777 function getStop(stops, percent) { 4778 const index = findIndex(stops.slice(1), ([, targetPercent]) => percent <= targetPercent) + 1; 4779 return [ 4780 stops[index - 1][0], 4781 stops[index][0], 4782 (percent - stops[index - 1][1]) / (stops[index][1] - stops[index - 1][1]) 4783 ]; 4784 } 4785 function getValue(stops, percent) { 4786 const [start, end, p] = getStop(stops, percent); 4787 return start + Math.abs(start - end) * p * (start < end ? 1 : -1); 4788 } 4789 const unitRe = /^-?\d+(?:\.\d+)?(\S+)?/; 4790 function getUnit(stops, defaultUnit) { 4791 var _a; 4792 for (const stop of stops) { 4793 const match = (_a = stop.match) == null ? void 0 : _a.call(stop, unitRe); 4794 if (match) { 4795 return match[1]; 4796 } 4797 } 4798 return defaultUnit; 4799 } 4800 function getCssValue(el, prop, value) { 4801 const prev = el.style[prop]; 4802 const val = css(css(el, prop, value), prop); 4803 el.style[prop] = prev; 4804 return val; 4805 } 4806 function fillObject(keys2, value) { 4807 return keys2.reduce((data, prop) => { 4808 data[prop] = value; 4809 return data; 4810 }, {}); 4811 } 4812 4813 var parallax = { 4814 mixins: [Parallax], 4815 props: { 4816 target: String, 4817 viewport: Number, 4818 // Deprecated 4819 easing: Number, 4820 start: String, 4821 end: String 4822 }, 4823 data: { 4824 target: false, 4825 viewport: 1, 4826 easing: 1, 4827 start: 0, 4828 end: 0 4829 }, 4830 computed: { 4831 target: ({ target }, $el) => getOffsetElement(target && query(target, $el) || $el), 4832 start({ start }) { 4833 return toPx(start, "height", this.target, true); 4834 }, 4835 end({ end, viewport: viewport2 }) { 4836 return toPx( 4837 end || (viewport2 = (1 - viewport2) * 100) && `${viewport2}vh+${viewport2}%`, 4838 "height", 4839 this.target, 4840 true 4841 ); 4842 } 4843 }, 4844 observe: [ 4845 viewport(), 4846 scroll$1({ target: ({ target }) => target }), 4847 resize({ target: ({ $el, target }) => [$el, target, scrollParent(target, true)] }) 4848 ], 4849 update: { 4850 read({ percent }, types) { 4851 if (!types.has("scroll")) { 4852 percent = false; 4853 } 4854 if (!isVisible(this.$el)) { 4855 return false; 4856 } 4857 if (!this.matchMedia) { 4858 return; 4859 } 4860 const prev = percent; 4861 percent = ease(scrolledOver(this.target, this.start, this.end), this.easing); 4862 return { 4863 percent, 4864 style: prev === percent ? false : this.getCss(percent) 4865 }; 4866 }, 4867 write({ style }) { 4868 if (!this.matchMedia) { 4869 this.reset(); 4870 return; 4871 } 4872 style && css(this.$el, style); 4873 }, 4874 events: ["scroll", "resize"] 4875 } 4876 }; 4877 function ease(percent, easing) { 4878 return easing >= 0 ? Math.pow(percent, easing + 1) : 1 - Math.pow(1 - percent, 1 - easing); 4879 } 4880 function getOffsetElement(el) { 4881 return el ? "offsetTop" in el ? el : getOffsetElement(parent(el)) : document.documentElement; 4882 } 4883 4884 var SliderReactive = { 4885 update: { 4886 write() { 4887 if (this.stack.length || this.dragging) { 4888 return; 4889 } 4890 const index = this.getValidIndex(); 4891 if (!~this.prevIndex || this.index !== index) { 4892 this.show(index); 4893 } else { 4894 this._translate(1, this.prevIndex, this.index); 4895 } 4896 }, 4897 events: ["resize"] 4898 } 4899 }; 4900 4901 var SliderPreload = { 4902 observe: lazyload({ 4903 target: ({ slides }) => slides, 4904 targets: (instance) => instance.getAdjacentSlides() 4905 }) 4906 }; 4907 4908 function Transitioner(prev, next, dir, { center, easing, list }) { 4909 const from = prev ? getLeft(prev, list, center) : getLeft(next, list, center) + dimensions$1(next).width * dir; 4910 const to = next ? getLeft(next, list, center) : from + dimensions$1(prev).width * dir * (isRtl ? -1 : 1); 4911 let resolve; 4912 return { 4913 dir, 4914 show(duration, percent = 0, linear) { 4915 const timing = linear ? "linear" : easing; 4916 duration -= Math.round(duration * clamp(percent, -1, 1)); 4917 this.translate(percent); 4918 percent = prev ? percent : clamp(percent, 0, 1); 4919 triggerUpdate(this.getItemIn(), "itemin", { percent, duration, timing, dir }); 4920 prev && triggerUpdate(this.getItemIn(true), "itemout", { 4921 percent: 1 - percent, 4922 duration, 4923 timing, 4924 dir 4925 }); 4926 return new Promise((res) => { 4927 resolve || (resolve = res); 4928 Transition.start( 4929 list, 4930 { transform: translate(-to * (isRtl ? -1 : 1), "px") }, 4931 duration, 4932 timing 4933 ).then(resolve, noop); 4934 }); 4935 }, 4936 cancel() { 4937 return Transition.cancel(list); 4938 }, 4939 reset() { 4940 css(list, "transform", ""); 4941 }, 4942 async forward(duration, percent = this.percent()) { 4943 await this.cancel(); 4944 return this.show(duration, percent, true); 4945 }, 4946 translate(percent) { 4947 const distance = this.getDistance() * dir * (isRtl ? -1 : 1); 4948 css( 4949 list, 4950 "transform", 4951 translate( 4952 clamp( 4953 -to + (distance - distance * percent), 4954 -getWidth(list), 4955 dimensions$1(list).width 4956 ) * (isRtl ? -1 : 1), 4957 "px" 4958 ) 4959 ); 4960 const actives = this.getActives(); 4961 const itemIn = this.getItemIn(); 4962 const itemOut = this.getItemIn(true); 4963 percent = prev ? clamp(percent, -1, 1) : 0; 4964 for (const slide of children(list)) { 4965 const isActive = includes(actives, slide); 4966 const isIn = slide === itemIn; 4967 const isOut = slide === itemOut; 4968 const translateIn = isIn || !isOut && (isActive || dir * (isRtl ? -1 : 1) === -1 ^ getElLeft(slide, list) > getElLeft(prev || next)); 4969 triggerUpdate(slide, `itemtranslate${translateIn ? "in" : "out"}`, { 4970 dir, 4971 percent: isOut ? 1 - percent : isIn ? percent : isActive ? 1 : 0 4972 }); 4973 } 4974 }, 4975 percent() { 4976 return Math.abs( 4977 (css(list, "transform").split(",")[4] * (isRtl ? -1 : 1) + from) / (to - from) 4978 ); 4979 }, 4980 getDistance() { 4981 return Math.abs(to - from); 4982 }, 4983 getItemIn(out = false) { 4984 let actives = this.getActives(); 4985 let nextActives = inView(list, getLeft(next || prev, list, center)); 4986 if (out) { 4987 const temp = actives; 4988 actives = nextActives; 4989 nextActives = temp; 4990 } 4991 return nextActives[findIndex(nextActives, (el) => !includes(actives, el))]; 4992 }, 4993 getActives() { 4994 return inView(list, getLeft(prev || next, list, center)); 4995 } 4996 }; 4997 } 4998 function getLeft(el, list, center) { 4999 const left = getElLeft(el, list); 5000 return center ? left - centerEl(el, list) : Math.min(left, getMax(list)); 5001 } 5002 function getMax(list) { 5003 return Math.max(0, getWidth(list) - dimensions$1(list).width); 5004 } 5005 function getWidth(list) { 5006 return sumBy(children(list), (el) => dimensions$1(el).width); 5007 } 5008 function centerEl(el, list) { 5009 return dimensions$1(list).width / 2 - dimensions$1(el).width / 2; 5010 } 5011 function getElLeft(el, list) { 5012 return el && (position(el).left + (isRtl ? dimensions$1(el).width - dimensions$1(list).width : 0)) * (isRtl ? -1 : 1) || 0; 5013 } 5014 function inView(list, listLeft) { 5015 listLeft -= 1; 5016 const listWidth = dimensions$1(list).width; 5017 const listRight = listLeft + listWidth + 2; 5018 return children(list).filter((slide) => { 5019 const slideLeft = getElLeft(slide, list); 5020 const slideRight = slideLeft + Math.min(dimensions$1(slide).width, listWidth); 5021 return slideLeft >= listLeft && slideRight <= listRight; 5022 }); 5023 } 5024 function triggerUpdate(el, type, data) { 5025 trigger(el, createEvent(type, false, false, data)); 5026 } 5027 5028 var slider = { 5029 mixins: [Class, Slider, SliderReactive, SliderPreload], 5030 props: { 5031 center: Boolean, 5032 sets: Boolean 5033 }, 5034 data: { 5035 center: false, 5036 sets: false, 5037 attrItem: "uk-slider-item", 5038 selList: ".uk-slider-items", 5039 selNav: ".uk-slider-nav", 5040 clsContainer: "uk-slider-container", 5041 Transitioner 5042 }, 5043 computed: { 5044 avgWidth() { 5045 return getWidth(this.list) / this.length; 5046 }, 5047 finite({ finite }) { 5048 return finite || isFinite(this.list, this.center); 5049 }, 5050 maxIndex() { 5051 if (!this.finite || this.center && !this.sets) { 5052 return this.length - 1; 5053 } 5054 if (this.center) { 5055 return last(this.sets); 5056 } 5057 let lft = 0; 5058 const max = getMax(this.list); 5059 const index = findIndex(this.slides, (el) => { 5060 if (lft >= max) { 5061 return true; 5062 } 5063 lft += dimensions$1(el).width; 5064 }); 5065 return ~index ? index : this.length - 1; 5066 }, 5067 sets({ sets: enabled }) { 5068 if (!enabled) { 5069 return; 5070 } 5071 let left = 0; 5072 const sets = []; 5073 const width = dimensions$1(this.list).width; 5074 for (let i = 0; i < this.length; i++) { 5075 const slideWidth = dimensions$1(this.slides[i]).width; 5076 if (left + slideWidth > width) { 5077 left = 0; 5078 } 5079 if (this.center) { 5080 if (left < width / 2 && left + slideWidth + dimensions$1(getIndex(+i + 1, this.slides)).width / 2 > width / 2) { 5081 sets.push(+i); 5082 left = width / 2 - slideWidth / 2; 5083 } 5084 } else if (left === 0) { 5085 sets.push(Math.min(+i, this.maxIndex)); 5086 } 5087 left += slideWidth; 5088 } 5089 if (sets.length) { 5090 return sets; 5091 } 5092 }, 5093 transitionOptions() { 5094 return { 5095 center: this.center, 5096 list: this.list 5097 }; 5098 }, 5099 slides() { 5100 return children(this.list).filter(isVisible); 5101 } 5102 }, 5103 connected() { 5104 toggleClass(this.$el, this.clsContainer, !$(`.${this.clsContainer}`, this.$el)); 5105 }, 5106 observe: resize({ 5107 target: ({ slides }) => slides 5108 }), 5109 update: { 5110 write() { 5111 for (const el of this.navItems) { 5112 const index = toNumber(data(el, this.attrItem)); 5113 if (index !== false) { 5114 el.hidden = !this.maxIndex || index > this.maxIndex || this.sets && !includes(this.sets, index); 5115 } 5116 } 5117 if (this.length && !this.dragging && !this.stack.length) { 5118 this.reorder(); 5119 this._translate(1); 5120 } 5121 this.updateActiveClasses(); 5122 }, 5123 events: ["resize"] 5124 }, 5125 events: { 5126 beforeitemshow(e) { 5127 if (!this.dragging && this.sets && this.stack.length < 2 && !includes(this.sets, this.index)) { 5128 this.index = this.getValidIndex(); 5129 } 5130 const diff = Math.abs( 5131 this.index - this.prevIndex + (this.dir > 0 && this.index < this.prevIndex || this.dir < 0 && this.index > this.prevIndex ? (this.maxIndex + 1) * this.dir : 0) 5132 ); 5133 if (!this.dragging && diff > 1) { 5134 for (let i = 0; i < diff; i++) { 5135 this.stack.splice(1, 0, this.dir > 0 ? "next" : "previous"); 5136 } 5137 e.preventDefault(); 5138 return; 5139 } 5140 const index = this.dir < 0 || !this.slides[this.prevIndex] ? this.index : this.prevIndex; 5141 this.duration = speedUp(this.avgWidth / this.velocity) * (dimensions$1(this.slides[index]).width / this.avgWidth); 5142 this.reorder(); 5143 }, 5144 itemshow() { 5145 if (~this.prevIndex) { 5146 addClass(this._getTransitioner().getItemIn(), this.clsActive); 5147 } 5148 }, 5149 itemshown() { 5150 this.updateActiveClasses(); 5151 } 5152 }, 5153 methods: { 5154 reorder() { 5155 if (this.finite) { 5156 css(this.slides, "order", ""); 5157 return; 5158 } 5159 const index = this.dir > 0 && this.slides[this.prevIndex] ? this.prevIndex : this.index; 5160 this.slides.forEach( 5161 (slide, i) => css( 5162 slide, 5163 "order", 5164 this.dir > 0 && i < index ? 1 : this.dir < 0 && i >= this.index ? -1 : "" 5165 ) 5166 ); 5167 if (!this.center) { 5168 return; 5169 } 5170 const next = this.slides[index]; 5171 let width = dimensions$1(this.list).width / 2 - dimensions$1(next).width / 2; 5172 let j = 0; 5173 while (width > 0) { 5174 const slideIndex = this.getIndex(--j + index, index); 5175 const slide = this.slides[slideIndex]; 5176 css(slide, "order", slideIndex > index ? -2 : -1); 5177 width -= dimensions$1(slide).width; 5178 } 5179 }, 5180 updateActiveClasses() { 5181 const actives = this._getTransitioner(this.index).getActives(); 5182 const activeClasses = [ 5183 this.clsActive, 5184 (!this.sets || includes(this.sets, toFloat(this.index))) && this.clsActivated || "" 5185 ]; 5186 for (const slide of this.slides) { 5187 const active = includes(actives, slide); 5188 toggleClass(slide, activeClasses, active); 5189 attr(slide, "aria-hidden", !active); 5190 for (const focusable of $$(selFocusable, slide)) { 5191 if (!hasOwn(focusable, "_tabindex")) { 5192 focusable._tabindex = attr(focusable, "tabindex"); 5193 } 5194 attr(focusable, "tabindex", active ? focusable._tabindex : -1); 5195 } 5196 } 5197 }, 5198 getValidIndex(index = this.index, prevIndex = this.prevIndex) { 5199 index = this.getIndex(index, prevIndex); 5200 if (!this.sets) { 5201 return index; 5202 } 5203 let prev; 5204 do { 5205 if (includes(this.sets, index)) { 5206 return index; 5207 } 5208 prev = index; 5209 index = this.getIndex(index + this.dir, prevIndex); 5210 } while (index !== prev); 5211 return index; 5212 }, 5213 getAdjacentSlides() { 5214 const { width } = dimensions$1(this.list); 5215 const left = -width; 5216 const right = width * 2; 5217 const slideWidth = dimensions$1(this.slides[this.index]).width; 5218 const slideLeft = this.center ? width / 2 - slideWidth / 2 : 0; 5219 const slides = /* @__PURE__ */ new Set(); 5220 for (const i of [-1, 1]) { 5221 let currentLeft = slideLeft + (i > 0 ? slideWidth : 0); 5222 let j = 0; 5223 do { 5224 const slide = this.slides[this.getIndex(this.index + i + j++ * i)]; 5225 currentLeft += dimensions$1(slide).width * i; 5226 slides.add(slide); 5227 } while (this.length > j && currentLeft > left && currentLeft < right); 5228 } 5229 return Array.from(slides); 5230 } 5231 } 5232 }; 5233 function isFinite(list, center) { 5234 if (!list || list.length < 2) { 5235 return true; 5236 } 5237 const { width: listWidth } = dimensions$1(list); 5238 if (!center) { 5239 return Math.ceil(getWidth(list)) < Math.trunc(listWidth + getMaxElWidth(list)); 5240 } 5241 const slides = children(list); 5242 const listHalf = Math.trunc(listWidth / 2); 5243 for (const index in slides) { 5244 const slide = slides[index]; 5245 const slideWidth = dimensions$1(slide).width; 5246 const slidesInView = /* @__PURE__ */ new Set([slide]); 5247 let diff = 0; 5248 for (const i of [-1, 1]) { 5249 let left = slideWidth / 2; 5250 let j = 0; 5251 while (left < listHalf) { 5252 const nextSlide = slides[getIndex(+index + i + j++ * i, slides)]; 5253 if (slidesInView.has(nextSlide)) { 5254 return true; 5255 } 5256 left += dimensions$1(nextSlide).width; 5257 slidesInView.add(nextSlide); 5258 } 5259 diff = Math.max( 5260 diff, 5261 slideWidth / 2 + dimensions$1(slides[getIndex(+index + i, slides)]).width / 2 - (left - listHalf) 5262 ); 5263 } 5264 if (diff > sumBy( 5265 slides.filter((slide2) => !slidesInView.has(slide2)), 5266 (slide2) => dimensions$1(slide2).width 5267 )) { 5268 return true; 5269 } 5270 } 5271 return false; 5272 } 5273 function getMaxElWidth(list) { 5274 return Math.max(0, ...children(list).map((el) => dimensions$1(el).width)); 5275 } 5276 5277 var sliderParallax = { 5278 mixins: [Parallax], 5279 data: { 5280 selItem: "!li" 5281 }, 5282 beforeConnect() { 5283 this.item = query(this.selItem, this.$el); 5284 }, 5285 disconnected() { 5286 this.item = null; 5287 }, 5288 events: [ 5289 { 5290 name: "itemin itemout", 5291 self: true, 5292 el() { 5293 return this.item; 5294 }, 5295 handler({ type, detail: { percent, duration, timing, dir } }) { 5296 fastdom.read(() => { 5297 if (!this.matchMedia) { 5298 return; 5299 } 5300 const propsFrom = this.getCss(getCurrentPercent(type, dir, percent)); 5301 const propsTo = this.getCss(isIn(type) ? 0.5 : dir > 0 ? 1 : 0); 5302 fastdom.write(() => { 5303 css(this.$el, propsFrom); 5304 Transition.start(this.$el, propsTo, duration, timing).catch(noop); 5305 }); 5306 }); 5307 } 5308 }, 5309 { 5310 name: "transitioncanceled transitionend", 5311 self: true, 5312 el() { 5313 return this.item; 5314 }, 5315 handler() { 5316 Transition.cancel(this.$el); 5317 } 5318 }, 5319 { 5320 name: "itemtranslatein itemtranslateout", 5321 self: true, 5322 el() { 5323 return this.item; 5324 }, 5325 handler({ type, detail: { percent, dir } }) { 5326 fastdom.read(() => { 5327 if (!this.matchMedia) { 5328 this.reset(); 5329 return; 5330 } 5331 const props = this.getCss(getCurrentPercent(type, dir, percent)); 5332 fastdom.write(() => css(this.$el, props)); 5333 }); 5334 } 5335 } 5336 ] 5337 }; 5338 function isIn(type) { 5339 return endsWith(type, "in"); 5340 } 5341 function getCurrentPercent(type, dir, percent) { 5342 percent /= 2; 5343 return isIn(type) ^ dir < 0 ? percent : 1 - percent; 5344 } 5345 5346 var Animations = { 5347 ...Animations$2, 5348 fade: { 5349 show() { 5350 return [{ opacity: 0, zIndex: 0 }, { zIndex: -1 }]; 5351 }, 5352 percent(current) { 5353 return 1 - css(current, "opacity"); 5354 }, 5355 translate(percent) { 5356 return [{ opacity: 1 - percent, zIndex: 0 }, { zIndex: -1 }]; 5357 } 5358 }, 5359 scale: { 5360 show() { 5361 return [{ opacity: 0, transform: scale3d(1 + 0.5), zIndex: 0 }, { zIndex: -1 }]; 5362 }, 5363 percent(current) { 5364 return 1 - css(current, "opacity"); 5365 }, 5366 translate(percent) { 5367 return [ 5368 { opacity: 1 - percent, transform: scale3d(1 + 0.5 * percent), zIndex: 0 }, 5369 { zIndex: -1 } 5370 ]; 5371 } 5372 }, 5373 pull: { 5374 show(dir) { 5375 return dir < 0 ? [ 5376 { transform: translate(30), zIndex: -1 }, 5377 { transform: translate(), zIndex: 0 } 5378 ] : [ 5379 { transform: translate(-100), zIndex: 0 }, 5380 { transform: translate(), zIndex: -1 } 5381 ]; 5382 }, 5383 percent(current, next, dir) { 5384 return dir < 0 ? 1 - translated(next) : translated(current); 5385 }, 5386 translate(percent, dir) { 5387 return dir < 0 ? [ 5388 { transform: translate(30 * percent), zIndex: -1 }, 5389 { transform: translate(-100 * (1 - percent)), zIndex: 0 } 5390 ] : [ 5391 { transform: translate(-percent * 100), zIndex: 0 }, 5392 { transform: translate(30 * (1 - percent)), zIndex: -1 } 5393 ]; 5394 } 5395 }, 5396 push: { 5397 show(dir) { 5398 return dir < 0 ? [ 5399 { transform: translate(100), zIndex: 0 }, 5400 { transform: translate(), zIndex: -1 } 5401 ] : [ 5402 { transform: translate(-30), zIndex: -1 }, 5403 { transform: translate(), zIndex: 0 } 5404 ]; 5405 }, 5406 percent(current, next, dir) { 5407 return dir > 0 ? 1 - translated(next) : translated(current); 5408 }, 5409 translate(percent, dir) { 5410 return dir < 0 ? [ 5411 { transform: translate(percent * 100), zIndex: 0 }, 5412 { transform: translate(-30 * (1 - percent)), zIndex: -1 } 5413 ] : [ 5414 { transform: translate(-30 * percent), zIndex: -1 }, 5415 { transform: translate(100 * (1 - percent)), zIndex: 0 } 5416 ]; 5417 } 5418 } 5419 }; 5420 5421 const supportsAspectRatio = inBrowser && CSS.supports("aspect-ratio", "1/1"); 5422 var slideshow = { 5423 mixins: [Class, Slideshow, SliderReactive, SliderPreload], 5424 props: { 5425 ratio: String, 5426 minHeight: Number, 5427 maxHeight: Number 5428 }, 5429 data: { 5430 ratio: "16:9", 5431 minHeight: false, 5432 maxHeight: false, 5433 selList: ".uk-slideshow-items", 5434 attrItem: "uk-slideshow-item", 5435 selNav: ".uk-slideshow-nav", 5436 Animations 5437 }, 5438 watch: { 5439 list(list) { 5440 if (list && supportsAspectRatio) {
5441 css(list, { 5442 aspectRatio: this.ratio.replace(":", "/"), 5443 minHeight: this.minHeight || "", 5444 maxHeight: this.maxHeight || "", 5445 minWidth: "100%", 5446 maxWidth: "100%" 5447 }); 5448 } 5449 } 5450 }, 5451 update: { 5452 // deprecated: Remove with iOS 17 5453 read() { 5454 if (!this.list || supportsAspectRatio) { 5455 return false; 5456 } 5457 let [width, height] = this.ratio.split(":").map(Number); 5458 height = height * this.list.offsetWidth / width || 0; 5459 if (this.minHeight) { 5460 height = Math.max(this.minHeight, height); 5461 } 5462 if (this.maxHeight) { 5463 height = Math.min(this.maxHeight, height); 5464 } 5465 return { height: height - boxModelAdjust(this.list, "height", "content-box") }; 5466 }, 5467 write({ height }) { 5468 height > 0 && css(this.list, "minHeight", height); 5469 }, 5470 events: ["resize"] 5471 }, 5472 methods: { 5473 getAdjacentSlides() { 5474 return [1, -1].map((i) => this.slides[this.getIndex(this.index + i)]); 5475 } 5476 } 5477 }; 5478 5479 var sortable = { 5480 mixins: [Class, Animate], 5481 props: { 5482 group: String, 5483 threshold: Number, 5484 clsItem: String, 5485 clsPlaceholder: String, 5486 clsDrag: String, 5487 clsDragState: String, 5488 clsBase: String, 5489 clsNoDrag: String, 5490 clsEmpty: String, 5491 clsCustom: String, 5492 handle: String 5493 }, 5494 data: { 5495 group: false, 5496 threshold: 5, 5497 clsItem: "uk-sortable-item", 5498 clsPlaceholder: "uk-sortable-placeholder", 5499 clsDrag: "uk-sortable-drag", 5500 clsDragState: "uk-drag", 5501 clsBase: "uk-sortable", 5502 clsNoDrag: "uk-sortable-nodrag", 5503 clsEmpty: "uk-sortable-empty", 5504 clsCustom: "", 5505 handle: false, 5506 pos: {} 5507 }, 5508 created() { 5509 for (const key of ["init", "start", "move", "end"]) { 5510 const fn = this[key]; 5511 this[key] = (e) => { 5512 assign(this.pos, getEventPos(e)); 5513 fn(e); 5514 }; 5515 } 5516 }, 5517 events: { 5518 name: pointerDown$1, 5519 passive: false, 5520 handler: "init" 5521 }, 5522 computed: { 5523 target: (_, $el) => ($el.tBodies || [$el])[0], 5524 items() { 5525 return children(this.target); 5526 }, 5527 isEmpty() { 5528 return isEmpty(this.items); 5529 }, 5530 handles({ handle }, $el) { 5531 return handle ? $$(handle, $el) : this.items; 5532 } 5533 }, 5534 watch: { 5535 isEmpty(empty) { 5536 toggleClass(this.target, this.clsEmpty, empty); 5537 }, 5538 handles(handles, prev) { 5539 css(prev, { touchAction: "", userSelect: "" }); 5540 css(handles, { touchAction: hasTouch ? "none" : "", userSelect: "none" }); 5541 } 5542 }, 5543 update: { 5544 write(data) { 5545 if (!this.drag || !parent(this.placeholder)) { 5546 return; 5547 } 5548 const { 5549 pos: { x, y }, 5550 origin: { offsetTop, offsetLeft }, 5551 placeholder 5552 } = this; 5553 css(this.drag, { 5554 top: y - offsetTop, 5555 left: x - offsetLeft 5556 }); 5557 const sortable = this.getSortable(document.elementFromPoint(x, y)); 5558 if (!sortable) { 5559 return; 5560 } 5561 const { items } = sortable; 5562 if (items.some(Transition.inProgress)) { 5563 return; 5564 } 5565 const target = findTarget(items, { x, y }); 5566 if (items.length && (!target || target === placeholder)) { 5567 return; 5568 } 5569 const previous = this.getSortable(placeholder); 5570 const insertTarget = findInsertTarget( 5571 sortable.target, 5572 target, 5573 placeholder, 5574 x, 5575 y, 5576 sortable === previous && data.moved !== target 5577 ); 5578 if (insertTarget === false) { 5579 return; 5580 } 5581 if (insertTarget && placeholder === insertTarget) { 5582 return; 5583 } 5584 if (sortable !== previous) { 5585 previous.remove(placeholder); 5586 data.moved = target; 5587 } else { 5588 delete data.moved; 5589 } 5590 sortable.insert(placeholder, insertTarget); 5591 this.touched.add(sortable); 5592 }, 5593 events: ["move"] 5594 }, 5595 methods: { 5596 init(e) { 5597 const { target, button, defaultPrevented } = e; 5598 const [placeholder] = this.items.filter((el) => el.contains(target)); 5599 if (!placeholder || defaultPrevented || button > 0 || isInput(target) || target.closest(`.${this.clsNoDrag}`) || this.handle && !target.closest(this.handle)) { 5600 return; 5601 } 5602 e.preventDefault(); 5603 this.touched = /* @__PURE__ */ new Set([this]); 5604 this.placeholder = placeholder; 5605 this.origin = { target, index: index(placeholder), ...this.pos }; 5606 on(document, pointerMove$1, this.move); 5607 on(document, pointerUp$1, this.end); 5608 if (!this.threshold) { 5609 this.start(e); 5610 } 5611 }, 5612 start(e) { 5613 this.drag = appendDrag(this.$container, this.placeholder); 5614 const { left, top } = this.placeholder.getBoundingClientRect(); 5615 assign(this.origin, { offsetLeft: this.pos.x - left, offsetTop: this.pos.y - top }); 5616 addClass(this.drag, this.clsDrag, this.clsCustom); 5617 addClass(this.placeholder, this.clsPlaceholder); 5618 addClass(this.items, this.clsItem); 5619 addClass(document.documentElement, this.clsDragState); 5620 trigger(this.$el, "start", [this, this.placeholder]); 5621 trackScroll(this.pos); 5622 this.move(e); 5623 }, 5624 move(e) { 5625 if (this.drag) { 5626 this.$emit("move"); 5627 } else if (Math.abs(this.pos.x - this.origin.x) > this.threshold || Math.abs(this.pos.y - this.origin.y) > this.threshold) { 5628 this.start(e); 5629 } 5630 }, 5631 end() { 5632 off(document, pointerMove$1, this.move); 5633 off(document, pointerUp$1, this.end); 5634 if (!this.drag) { 5635 return; 5636 } 5637 untrackScroll();
vendor: 19,103 bytes, lines 5638-6201
5638 const sortable = this.getSortable(this.placeholder); 5639 if (this === sortable) { 5640 if (this.origin.index !== index(this.placeholder)) { 5641 trigger(this.$el, "moved", [this, this.placeholder]); 5642 } 5643 } else { 5644 trigger(sortable.$el, "added", [sortable, this.placeholder]); 5645 trigger(this.$el, "removed", [this, this.placeholder]); 5646 } 5647 trigger(this.$el, "stop", [this, this.placeholder]); 5648 remove$1(this.drag); 5649 this.drag = null; 5650 for (const { clsPlaceholder, clsItem } of this.touched) { 5651 for (const sortable2 of this.touched) { 5652 removeClass(sortable2.items, clsPlaceholder, clsItem); 5653 } 5654 } 5655 this.touched = null; 5656 removeClass(document.documentElement, this.clsDragState); 5657 }, 5658 insert(element, target) { 5659 addClass(this.items, this.clsItem); 5660 const insert = () => target ? before(target, element) : append(this.target, element); 5661 this.animate(insert); 5662 }, 5663 remove(element) { 5664 if (!this.target.contains(element)) { 5665 return; 5666 } 5667 this.animate(() => remove$1(element)); 5668 }, 5669 getSortable(element) { 5670 do { 5671 const sortable = this.$getComponent(element, "sortable"); 5672 if (sortable && (sortable === this || this.group !== false && sortable.group === this.group)) { 5673 return sortable; 5674 } 5675 } while (element = parent(element)); 5676 } 5677 } 5678 }; 5679 let trackTimer; 5680 function trackScroll(pos) { 5681 let last = Date.now(); 5682 trackTimer = setInterval(() => { 5683 let { x, y } = pos; 5684 y += document.scrollingElement.scrollTop; 5685 const dist = (Date.now() - last) * 0.3; 5686 last = Date.now(); 5687 scrollParents(document.elementFromPoint(x, pos.y)).reverse().some((scrollEl) => { 5688 let { scrollTop: scroll, scrollHeight } = scrollEl; 5689 const { top, bottom, height: height2 } = offsetViewport(scrollEl); 5690 if (top < y && top + 35 > y) { 5691 scroll -= dist; 5692 } else if (bottom > y && bottom - 35 < y) { 5693 scroll += dist; 5694 } else { 5695 return; 5696 } 5697 if (scroll > 0 && scroll < scrollHeight - height2) { 5698 scrollEl.scrollTop = scroll; 5699 return true; 5700 } 5701 }); 5702 }, 15); 5703 } 5704 function untrackScroll() { 5705 clearInterval(trackTimer); 5706 } 5707 function appendDrag(container, element) { 5708 let clone; 5709 if (isTag(element, "li", "tr")) { 5710 clone = $("<div>"); 5711 append(clone, element.cloneNode(true).children); 5712 for (const attribute of element.getAttributeNames()) { 5713 attr(clone, attribute, element.getAttribute(attribute)); 5714 } 5715 } else { 5716 clone = element.cloneNode(true); 5717 } 5718 append(container, clone); 5719 css(clone, "margin", "0", "important"); 5720 css(clone, { 5721 boxSizing: "border-box", 5722 width: element.offsetWidth, 5723 height: element.offsetHeight, 5724 padding: css(element, "padding") 5725 }); 5726 height(clone.firstElementChild, height(element.firstElementChild)); 5727 return clone; 5728 } 5729 function findTarget(items, point) { 5730 return items[findIndex(items, (item) => pointInRect(point, item.getBoundingClientRect()))]; 5731 } 5732 function findInsertTarget(list, target, placeholder, x, y, sameList) { 5733 if (!children(list).length) { 5734 return; 5735 } 5736 const rect = target.getBoundingClientRect(); 5737 if (!sameList) { 5738 if (!isHorizontal(list, placeholder)) { 5739 return y < rect.top + rect.height / 2 ? target : target.nextElementSibling; 5740 } 5741 return target; 5742 } 5743 const placeholderRect = placeholder.getBoundingClientRect(); 5744 const sameRow = linesIntersect( 5745 [rect.top, rect.bottom], 5746 [placeholderRect.top, placeholderRect.bottom] 5747 ); 5748 const [pointerPos, lengthProp, startProp, endProp] = sameRow ? [x, "width", "left", "right"] : [y, "height", "top", "bottom"]; 5749 const diff = placeholderRect[lengthProp] < rect[lengthProp] ? rect[lengthProp] - placeholderRect[lengthProp] : 0; 5750 if (placeholderRect[startProp] < rect[startProp]) { 5751 if (diff && pointerPos < rect[startProp] + diff) { 5752 return false; 5753 } 5754 return target.nextElementSibling; 5755 } 5756 if (diff && pointerPos > rect[endProp] - diff) { 5757 return false; 5758 } 5759 return target; 5760 } 5761 function isHorizontal(list, placeholder) { 5762 const single = children(list).length === 1; 5763 if (single) { 5764 append(list, placeholder); 5765 } 5766 const items = children(list); 5767 const isHorizontal2 = items.some((el, i) => { 5768 const rectA = el.getBoundingClientRect(); 5769 return items.slice(i + 1).some((el2) => { 5770 const rectB = el2.getBoundingClientRect(); 5771 return !linesIntersect([rectA.left, rectA.right], [rectB.left, rectB.right]); 5772 }); 5773 }); 5774 if (single) { 5775 remove$1(placeholder); 5776 } 5777 return isHorizontal2; 5778 } 5779 function linesIntersect(lineA, lineB) { 5780 return lineA[1] > lineB[0] && lineB[1] > lineA[0]; 5781 } 5782 5783 var Position = { 5784 props: { 5785 pos: String, 5786 offset: null, 5787 flip: Boolean, 5788 shift: Boolean, 5789 inset: Boolean 5790 }, 5791 data: { 5792 pos: `bottom-${isRtl ? "right" : "left"}`, 5793 offset: false, 5794 flip: true, 5795 shift: true, 5796 inset: false 5797 }, 5798 connected() { 5799 this.pos = this.$props.pos.split("-").concat("center").slice(0, 2); 5800 [this.dir, this.align] = this.pos; 5801 this.axis = includes(["top", "bottom"], this.dir) ? "y" : "x"; 5802 }, 5803 methods: { 5804 positionAt(element, target, boundary) { 5805 let offset = [this.getPositionOffset(element), this.getShiftOffset(element)]; 5806 const placement = [this.flip && "flip", this.shift && "shift"]; 5807 const attach = { 5808 element: [this.inset ? this.dir : flipPosition(this.dir), this.align], 5809 target: [this.dir, this.align] 5810 }; 5811 if (this.axis === "y") { 5812 for (const prop in attach) { 5813 attach[prop].reverse(); 5814 } 5815 offset.reverse(); 5816 placement.reverse(); 5817 } 5818 const restoreScrollPosition = storeScrollPosition(element); 5819 const elDim = dimensions$1(element); 5820 css(element, { top: -elDim.height, left: -elDim.width }); 5821 positionAt(element, target, { 5822 attach, 5823 offset, 5824 boundary, 5825 placement, 5826 viewportOffset: this.getViewportOffset(element) 5827 }); 5828 restoreScrollPosition(); 5829 }, 5830 getPositionOffset(element) { 5831 return toPx( 5832 this.offset === false ? css(element, "--uk-position-offset") : this.offset, 5833 this.axis === "x" ? "width" : "height", 5834 element 5835 ) * (includes(["left", "top"], this.dir) ? -1 : 1) * (this.inset ? -1 : 1); 5836 }, 5837 getShiftOffset(element) { 5838 return this.align === "center" ? 0 : toPx( 5839 css(element, "--uk-position-shift-offset"), 5840 this.axis === "y" ? "width" : "height", 5841 element 5842 ) * (includes(["left", "top"], this.align) ? 1 : -1); 5843 }, 5844 getViewportOffset(element) { 5845 return toPx(css(element, "--uk-position-viewport-offset")); 5846 } 5847 } 5848 }; 5849 function storeScrollPosition(element) { 5850 const scrollElement = scrollParent(element); 5851 const { scrollTop } = scrollElement; 5852 return () => { 5853 if (scrollTop !== scrollElement.scrollTop) { 5854 scrollElement.scrollTop = scrollTop; 5855 } 5856 }; 5857 } 5858 5859 var tooltip = { 5860 mixins: [Container, Togglable, Position], 5861 data: { 5862 pos: "top", 5863 animation: ["uk-animation-scale-up"], 5864 duration: 100, 5865 cls: "uk-active" 5866 }, 5867 connected() { 5868 makeFocusable(this.$el); 5869 }, 5870 disconnected() { 5871 this.hide(); 5872 }, 5873 methods: { 5874 show() { 5875 if (this.isToggled(this.tooltip || null)) { 5876 return; 5877 } 5878 const { delay = 0, title } = parseProps(this.$options); 5879 if (!title) { 5880 return; 5881 } 5882 const titleAttr = attr(this.$el, "title"); 5883 const off = on(this.$el, ["blur", pointerLeave], (e) => !isTouch(e) && this.hide()); 5884 this.reset = () => { 5885 attr(this.$el, { title: titleAttr, "aria-describedby": null }); 5886 off(); 5887 }; 5888 const id = generateId(this); 5889 attr(this.$el, { title: null, "aria-describedby": id }); 5890 clearTimeout(this.showTimer); 5891 this.showTimer = setTimeout(() => this._show(title, id), delay); 5892 }, 5893 async hide() { 5894 var _a; 5895 if (matches(this.$el, "input:focus")) { 5896 return; 5897 } 5898 clearTimeout(this.showTimer); 5899 if (this.isToggled(this.tooltip || null)) { 5900 await this.toggleElement(this.tooltip, false, false); 5901 } 5902 (_a = this.reset) == null ? void 0 : _a.call(this); 5903 remove$1(this.tooltip); 5904 this.tooltip = null; 5905 }, 5906 async _show(title, id) { 5907 this.tooltip = append( 5908 this.container, 5909 `<div id="${id}" class="uk-${this.$options.name}" role="tooltip"> <div class="uk-${this.$options.name}-inner">${title}</div> </div>` 5910 ); 5911 on(this.tooltip, "toggled", (e, toggled) => { 5912 if (!toggled) { 5913 return; 5914 } 5915 const update = () => this.positionAt(this.tooltip, this.$el); 5916 update(); 5917 const [dir, align] = getAlignment(this.tooltip, this.$el, this.pos); 5918 this.origin = this.axis === "y" ? `${flipPosition(dir)}-${align}` : `${align}-${flipPosition(dir)}`; 5919 const handlers = [ 5920 once( 5921 document, 5922 `keydown ${pointerDown$1}`, 5923 this.hide, 5924 false, 5925 (e2) => e2.type === pointerDown$1 && !this.$el.contains(e2.target) || e2.type === "keydown" && e2.keyCode === keyMap.ESC 5926 ), 5927 on([document, ...overflowParents(this.$el)], "scroll", update, { 5928 passive: true 5929 }) 5930 ]; 5931 once(this.tooltip, "hide", () => handlers.forEach((handler) => handler()), { 5932 self: true 5933 }); 5934 }); 5935 if (!await this.toggleElement(this.tooltip, true)) { 5936 this.hide(); 5937 } 5938 } 5939 }, 5940 events: { 5941 // Clicking a button does not give it focus on all browsers and platforms 5942 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#clicking_and_focus 5943 [`focus ${pointerEnter} ${pointerDown$1}`](e) { 5944 if (!isTouch(e)) { 5945 this.show(); 5946 } 5947 } 5948 } 5949 }; 5950 function makeFocusable(el) { 5951 if (!isFocusable(el)) { 5952 attr(el, "tabindex", "0"); 5953 } 5954 } 5955 function getAlignment(el, target, [dir, align]) { 5956 const elOffset = offset(el); 5957 const targetOffset = offset(target); 5958 const properties = [ 5959 ["left", "right"], 5960 ["top", "bottom"] 5961 ]; 5962 for (const props2 of properties) { 5963 if (elOffset[props2[0]] >= targetOffset[props2[1]]) { 5964 dir = props2[1]; 5965 break; 5966 } 5967 if (elOffset[props2[1]] <= targetOffset[props2[0]]) { 5968 dir = props2[0]; 5969 break; 5970 } 5971 } 5972 const props = includes(properties[0], dir) ? properties[1] : properties[0]; 5973 if (elOffset[props[0]] === targetOffset[props[0]]) { 5974 align = props[0]; 5975 } else if (elOffset[props[1]] === targetOffset[props[1]]) { 5976 align = props[1]; 5977 } else { 5978 align = "center"; 5979 } 5980 return [dir, align]; 5981 } 5982 function parseProps(options) { 5983 const { el, id, data: data$1 } = options; 5984 return ["delay", "title"].reduce((obj, key) => ({ [key]: data(el, key), ...obj }), { 5985 ...parseOptions(data(el, id), ["title"]), 5986 ...data$1 5987 }); 5988 } 5989 5990 var upload = { 5991 mixins: [I18n], 5992 i18n: { 5993 invalidMime: "Invalid File Type: %s", 5994 invalidName: "Invalid File Name: %s", 5995 invalidSize: "Invalid File Size: %s Kilobytes Max" 5996 }, 5997 props: { 5998 allow: String, 5999 clsDragover: String, 6000 concurrent: Number, 6001 maxSize: Number, 6002 method: String, 6003 mime: String, 6004 multiple: Boolean, 6005 name: String, 6006 params: Object, 6007 type: String, 6008 url: String 6009 }, 6010 data: { 6011 allow: false, 6012 clsDragover: "uk-dragover", 6013 concurrent: 1, 6014 maxSize: 0, 6015 method: "POST", 6016 mime: false, 6017 multiple: false, 6018 name: "files[]", 6019 params: {}, 6020 type: "", 6021 url: "", 6022 abort: noop, 6023 beforeAll: noop, 6024 beforeSend: noop, 6025 complete: noop, 6026 completeAll: noop, 6027 error: noop, 6028 fail: noop, 6029 load: noop, 6030 loadEnd: noop, 6031 loadStart: noop, 6032 progress: noop 6033 }, 6034 events: { 6035 change(e) { 6036 if (!matches(e.target, 'input[type="file"]')) { 6037 return; 6038 } 6039 e.preventDefault(); 6040 if (e.target.files) { 6041 this.upload(e.target.files); 6042 } 6043 e.target.value = ""; 6044 }, 6045 drop(e) { 6046 stop(e); 6047 const transfer = e.dataTransfer; 6048 if (!(transfer == null ? void 0 : transfer.files)) { 6049 return; 6050 } 6051 removeClass(this.$el, this.clsDragover); 6052 this.upload(transfer.files); 6053 }, 6054 dragenter(e) { 6055 stop(e); 6056 }, 6057 dragover(e) { 6058 stop(e); 6059 addClass(this.$el, this.clsDragover); 6060 }, 6061 dragleave(e) { 6062 stop(e); 6063 removeClass(this.$el, this.clsDragover); 6064 } 6065 }, 6066 methods: { 6067 async upload(files) { 6068 files = toArray(files); 6069 if (!files.length) { 6070 return; 6071 } 6072 trigger(this.$el, "upload", [files]); 6073 for (const file of files) { 6074 if (this.maxSize && this.maxSize * 1e3 < file.size) { 6075 this.fail(this.t("invalidSize", this.maxSize)); 6076 return; 6077 } 6078 if (this.allow && !match$1(this.allow, file.name)) { 6079 this.fail(this.t("invalidName", this.allow)); 6080 return; 6081 } 6082 if (this.mime && !match$1(this.mime, file.type)) { 6083 this.fail(this.t("invalidMime", this.mime)); 6084 return; 6085 } 6086 } 6087 if (!this.multiple) { 6088 files = files.slice(0, 1); 6089 } 6090 this.beforeAll(this, files); 6091 const chunks = chunk(files, this.concurrent); 6092 const upload = async (files2) => { 6093 const data = new FormData(); 6094 files2.forEach((file) => data.append(this.name, file)); 6095 for (const key in this.params) { 6096 data.append(key, this.params[key]); 6097 } 6098 try { 6099 const xhr = await ajax(this.url, { 6100 data, 6101 method: this.method, 6102 responseType: this.type, 6103 beforeSend: (env) => { 6104 const { xhr: xhr2 } = env; 6105 on(xhr2.upload, "progress", this.progress); 6106 for (const type of ["loadStart", "load", "loadEnd", "abort"]) { 6107 on(xhr2, type.toLowerCase(), this[type]); 6108 } 6109 return this.beforeSend(env); 6110 } 6111 }); 6112 this.complete(xhr); 6113 if (chunks.length) { 6114 await upload(chunks.shift()); 6115 } else { 6116 this.completeAll(xhr); 6117 } 6118 } catch (e) { 6119 this.error(e); 6120 } 6121 }; 6122 await upload(chunks.shift()); 6123 } 6124 } 6125 }; 6126 function match$1(pattern, path) { 6127 return path.match( 6128 new RegExp( 6129 `^${pattern.replace(/\//g, "\\/").replace(/\*\*/g, "(\\/[^\\/]+)*").replace(/\*/g, "[^\\/]+").replace(/((?!\\))\?/g, "$1.")}$`, 6130 "i" 6131 ) 6132 ); 6133 } 6134 function chunk(files, size) { 6135 const chunks = []; 6136 for (let i = 0; i < files.length; i += size) { 6137 chunks.push(files.slice(i, i + size)); 6138 } 6139 return chunks; 6140 } 6141 function stop(e) { 6142 e.preventDefault(); 6143 e.stopPropagation(); 6144 } 6145 function ajax(url, options) { 6146 const env = { 6147 data: null, 6148 method: "GET", 6149 headers: {}, 6150 xhr: new XMLHttpRequest(), 6151 beforeSend: noop, 6152 responseType: "", 6153 ...options 6154 }; 6155 return Promise.resolve().then(() => env.beforeSend(env)).then(() => send(url, env)); 6156 } 6157 function send(url, env) { 6158 return new Promise((resolve, reject) => { 6159 const { xhr } = env; 6160 for (const prop in env) { 6161 if (prop in xhr) { 6162 try { 6163 xhr[prop] = env[prop]; 6164 } catch (e) { 6165 } 6166 } 6167 } 6168 xhr.open(env.method.toUpperCase(), url); 6169 for (const header in env.headers) { 6170 xhr.setRequestHeader(header, env.headers[header]); 6171 } 6172 on(xhr, "load", () => { 6173 if (xhr.status === 0 || xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) { 6174 resolve(xhr); 6175 } else { 6176 reject( 6177 assign(Error(xhr.statusText), { 6178 xhr, 6179 status: xhr.status 6180 }) 6181 ); 6182 } 6183 }); 6184 on(xhr, "error", () => reject(assign(Error("Network Error"), { xhr }))); 6185 on(xhr, "timeout", () => reject(assign(Error("Network Timeout"), { xhr }))); 6186 xhr.send(env.data); 6187 }); 6188 } 6189 6190 var components$1 = /*#__PURE__*/Object.freeze({ 6191 __proto__: null, 6192 Countdown: countdown, 6193 Filter: filter, 6194 Lightbox: lightbox, 6195 LightboxPanel: LightboxPanel, 6196 Notification: notification, 6197 Parallax: parallax, 6198 Slider: slider, 6199 SliderParallax: sliderParallax, 6200 Slideshow: slideshow, 6201 SlideshowParallax: sliderParallax,
6202 Sortable: sortable, 6203 Tooltip: tooltip, 6204 Upload: upload 6205 }); 6206 6207 function boot(App) { 6208 if (inBrowser && window.MutationObserver) { 6209 if (document.body) { 6210 requestAnimationFrame(() => init(App)); 6211 } else { 6212 new MutationObserver((records, observer) => { 6213 if (document.body) { 6214 init(App); 6215 observer.disconnect(); 6216 } 6217 }).observe(document.documentElement, { childList: true }); 6218 } 6219 } 6220 } 6221 function init(App) { 6222 trigger(document, "uikit:init", App); 6223 if (document.body) { 6224 apply(document.body, connect); 6225 } 6226 new MutationObserver((records) => records.forEach(applyChildListMutation)).observe(document, { 6227 subtree: true, 6228 childList: true 6229 }); 6230 new MutationObserver((records) => records.forEach(applyAttributeMutation)).observe(document, { 6231 subtree: true, 6232 attributes: true 6233 }); 6234 App._initialized = true; 6235 } 6236 function applyChildListMutation({ addedNodes, removedNodes }) { 6237 for (const node of addedNodes) { 6238 apply(node, connect); 6239 } 6240 for (const node of removedNodes) { 6241 apply(node, disconnect); 6242 } 6243 } 6244 function applyAttributeMutation({ target, attributeName }) { 6245 var _a; 6246 const name = getComponentName(attributeName); 6247 if (name) { 6248 if (hasAttr(target, attributeName)) { 6249 createComponent(name, target); 6250 return; 6251 } 6252 (_a = getComponent(target, name)) == null ? void 0 : _a.$destroy(); 6253 } 6254 } 6255 function connect(node) { 6256 const components2 = getComponents(node); 6257 for (const name in getComponents(node)) { 6258 callConnected(components2[name]); 6259 } 6260 for (const attributeName of node.getAttributeNames()) { 6261 const name = getComponentName(attributeName); 6262 name && createComponent(name, node); 6263 } 6264 } 6265 function disconnect(node) { 6266 const components2 = getComponents(node); 6267 for (const name in getComponents(node)) { 6268 callDisconnected(components2[name]); 6269 } 6270 } 6271 function getComponentName(attribute) { 6272 if (startsWith(attribute, "data-")) { 6273 attribute = attribute.slice(5); 6274 } 6275 const cmp = components$2[attribute]; 6276 return cmp && (isPlainObject(cmp) ? cmp : cmp.options).name; 6277 } 6278 6279 globalApi(App); 6280 instanceApi(App); 6281 6282 var Accordion = { 6283 mixins: [Class, Togglable], 6284 props: { 6285 animation: Boolean, 6286 targets: String, 6287 active: null, 6288 collapsible: Boolean, 6289 multiple: Boolean, 6290 toggle: String, 6291 content: String, 6292 offset: Number 6293 }, 6294 data: { 6295 targets: "> *", 6296 active: false, 6297 animation: true, 6298 collapsible: true, 6299 multiple: false, 6300 clsOpen: "uk-open", 6301 toggle: "> .uk-accordion-title", 6302 content: "> .uk-accordion-content", 6303 offset: 0 6304 }, 6305 computed: { 6306 items: ({ targets }, $el) => $$(targets, $el), 6307 toggles({ toggle }) { 6308 return this.items.map((item) => $(toggle, item)); 6309 }, 6310 contents({ content }) { 6311 return this.items.map((item) => { 6312 var _a; 6313 return ((_a = item._wrapper) == null ? void 0 : _a.firstElementChild) || $(content, item); 6314 }); 6315 } 6316 }, 6317 watch: { 6318 items(items, prev) { 6319 if (prev || hasClass(items, this.clsOpen)) { 6320 return; 6321 } 6322 const active = this.active !== false && items[Number(this.active)] || !this.collapsible && items[0]; 6323 if (active) { 6324 this.toggle(active, false); 6325 } 6326 }, 6327 toggles() { 6328 this.$emit(); 6329 }, 6330 contents(items) { 6331 for (const el of items) { 6332 const isOpen = hasClass( 6333 this.items.find((item) => item.contains(el)), 6334 this.clsOpen 6335 ); 6336 hide(el, !isOpen); 6337 } 6338 this.$emit(); 6339 } 6340 }, 6341 observe: lazyload(), 6342 events: [ 6343 { 6344 name: "click keydown", 6345 delegate() { 6346 return `${this.targets} ${this.$props.toggle}`; 6347 }, 6348 async handler(e) { 6349 var _a; 6350 if (e.type === "keydown" && e.keyCode !== keyMap.SPACE) { 6351 return; 6352 } 6353 e.preventDefault(); 6354 (_a = this._off) == null ? void 0 : _a.call(this); 6355 this._off = keepScrollPosition(e.target); 6356 await this.toggle(index(this.toggles, e.current)); 6357 this._off(); 6358 } 6359 }, 6360 { 6361 name: "shown hidden", 6362 self: true, 6363 delegate() { 6364 return this.targets; 6365 }, 6366 handler() { 6367 this.$emit(); 6368 } 6369 } 6370 ], 6371 update() { 6372 const activeItems = filter$1(this.items, `.${this.clsOpen}`); 6373 for (const index2 in this.items) { 6374 const toggle = this.toggles[index2]; 6375 const content = this.contents[index2]; 6376 if (!toggle || !content) { 6377 continue; 6378 } 6379 toggle.id = generateId(this, toggle); 6380 content.id = generateId(this, content); 6381 const active = includes(activeItems, this.items[index2]); 6382 attr(toggle, { 6383 role: isTag(toggle, "a") ? "button" : null, 6384 "aria-controls": content.id, 6385 "aria-expanded": active, 6386 "aria-disabled": !this.collapsible && activeItems.length < 2 && active 6387 });
6388 attr(content, { role: "region", "aria-labelledby": toggle.id }); 6389 if (isTag(content, "ul")) { 6390 attr(children(content), "role", "presentation"); 6391 } 6392 } 6393 }, 6394 methods: { 6395 toggle(item, animate) { 6396 item = this.items[getIndex(item, this.items)]; 6397 let items = [item]; 6398 const activeItems = filter$1(this.items, `.${this.clsOpen}`); 6399 if (!this.multiple && !includes(activeItems, items[0])) { 6400 items = items.concat(activeItems); 6401 } 6402 if (!this.collapsible && activeItems.length < 2 && includes(activeItems, item)) { 6403 return; 6404 } 6405 return Promise.all( 6406 items.map( 6407 (el) => this.toggleElement(el, !includes(activeItems, el), (el2, show) => { 6408 toggleClass(el2, this.clsOpen, show); 6409 if (animate === false || !this.animation) { 6410 hide($(this.content, el2), !show); 6411 return; 6412 } 6413 return transition(el2, show, this); 6414 }) 6415 ) 6416 ); 6417 } 6418 } 6419 }; 6420 function hide(el, hide2) { 6421 el && (el.hidden = hide2); 6422 } 6423 async function transition(el, show, { content, duration, velocity, transition: transition2 }) { 6424 var _a; 6425 content = ((_a = el._wrapper) == null ? void 0 : _a.firstElementChild) || $(content, el); 6426 if (!el._wrapper) { 6427 el._wrapper = wrapAll(content, "<div>"); 6428 } 6429 const wrapper = el._wrapper; 6430 css(wrapper, "overflow", "hidden"); 6431 const currentHeight = toFloat(css(wrapper, "height")); 6432 await Transition.cancel(wrapper); 6433 hide(content, false); 6434 const endHeight = sumBy(["marginTop", "marginBottom"], (prop) => css(content, prop)) + dimensions$1(content).height; 6435 const percent = currentHeight / endHeight; 6436 duration = (velocity * endHeight + duration) * (show ? 1 - percent : percent); 6437 css(wrapper, "height", currentHeight); 6438 await Transition.start(wrapper, { height: show ? endHeight : 0 }, duration, transition2); 6439 unwrap(content); 6440 delete el._wrapper; 6441 if (!show) { 6442 hide(content, true); 6443 } 6444 } 6445 function keepScrollPosition(el) { 6446 const scrollElement = scrollParent(el, true); 6447 let frame; 6448 (function scroll() { 6449 frame = requestAnimationFrame(() => { 6450 const { top } = el.getBoundingClientRect(); 6451 if (top < 0) { 6452 scrollElement.scrollTop += top; 6453 } 6454 scroll(); 6455 }); 6456 })(); 6457 return () => requestAnimationFrame(() => cancelAnimationFrame(frame)); 6458 } 6459 6460 var alert = { 6461 mixins: [Class, Togglable], 6462 args: "animation", 6463 props: { 6464 animation: Boolean, 6465 close: String 6466 }, 6467 data: { 6468 animation: true, 6469 selClose: ".uk-alert-close", 6470 duration: 150 6471 }, 6472 events: { 6473 name: "click", 6474 delegate() { 6475 return this.selClose; 6476 }, 6477 handler(e) { 6478 e.preventDefault(); 6479 this.close(); 6480 } 6481 }, 6482 methods: { 6483 async close() { 6484 await this.toggleElement(this.$el, false, animate); 6485 this.$destroy(true); 6486 } 6487 } 6488 }; 6489 function animate(el, show, { duration, transition, velocity }) { 6490 const height = toFloat(css(el, "height")); 6491 css(el, "height", height); 6492 return Transition.start( 6493 el, 6494 { 6495 height: 0, 6496 marginTop: 0, 6497 marginBottom: 0, 6498 paddingTop: 0, 6499 paddingBottom: 0, 6500 borderTop: 0, 6501 borderBottom: 0, 6502 opacity: 0 6503 }, 6504 velocity * height + duration, 6505 transition 6506 ); 6507 } 6508 6509 var Video = { 6510 args: "autoplay", 6511 props: { 6512 automute: Boolean, 6513 autoplay: Boolean 6514 }, 6515 data: { 6516 automute: false, 6517 autoplay: true 6518 }, 6519 connected() { 6520 if (this.autoplay === "inview" && !hasAttr(this.$el, "preload")) { 6521 this.$el.preload = "none"; 6522 } 6523 if (isTag(this.$el, "iframe") && !hasAttr(this.$el, "allow")) { 6524 this.$el.allow = "autoplay"; 6525 } 6526 if (this.automute) { 6527 mute(this.$el); 6528 } 6529 }, 6530 observe: [ 6531 intersection({ 6532 filter: ({ $el, autoplay }) => autoplay && isVideo($el), 6533 handler([{ isIntersecting }]) { 6534 if (isIntersecting) { 6535 play(this.$el); 6536 } else { 6537 pause(this.$el); 6538 } 6539 }, 6540 args: { intersecting: false }, 6541 options: ({ $el, autoplay }) => ({ root: autoplay === "inview" ? null : parent($el) }) 6542 }) 6543 ] 6544 }; 6545 6546 var cover = { 6547 mixins: [Video], 6548 props: { 6549 width: Number, 6550 height: Number 6551 }, 6552 data: { 6553 automute: true 6554 }, 6555 events: { 6556 "load loadedmetadata"() { 6557 this.$emit("resize"); 6558 } 6559 }, 6560 observe: resize({ 6561 target: ({ $el }) => [getPositionedParent($el) || parent($el)], 6562 filter: ({ $el }) => !useObjectFit($el) 6563 }), 6564 update: { 6565 read() { 6566 if (useObjectFit(this.$el)) { 6567 return; 6568 } 6569 const { ratio, cover } = Dimensions; 6570 const { $el, width, height } = this; 6571 let dim = { width, height }; 6572 if (!width || !height) { 6573 const intrinsic = {
6574 width: $el.naturalWidth || $el.videoWidth || $el.clientWidth, 6575 height: $el.naturalHeight || $el.videoHeight || $el.clientHeight 6576 }; 6577 if (width) { 6578 dim = ratio(intrinsic, "width", width); 6579 } else if (height) { 6580 dim = ratio(intrinsic, "height", height); 6581 } else { 6582 dim = intrinsic; 6583 } 6584 } 6585 const { offsetHeight: coverHeight, offsetWidth: coverWidth } = getPositionedParent($el) || parent($el); 6586 const coverDim = cover(dim, { 6587 width: coverWidth + (coverWidth % 2 ? 1 : 0), 6588 height: coverHeight + (coverHeight % 2 ? 1 : 0) 6589 }); 6590 if (!coverDim.width || !coverDim.height) { 6591 return false; 6592 } 6593 return coverDim; 6594 }, 6595 write({ height, width }) { 6596 css(this.$el, { height, width }); 6597 }, 6598 events: ["resize"] 6599 } 6600 }; 6601 function getPositionedParent(el) { 6602 while (el = parent(el)) { 6603 if (css(el, "position") !== "static") { 6604 return el; 6605 } 6606 } 6607 } 6608 function useObjectFit(el) { 6609 return isTag(el, "img", "video"); 6610 } 6611 6612 let active; 6613 var drop = { 6614 mixins: [Container, Position, Togglable], 6615 args: "pos", 6616 props: { 6617 mode: "list", 6618 toggle: Boolean, 6619 boundary: Boolean, 6620 boundaryX: Boolean, 6621 boundaryY: Boolean, 6622 target: Boolean, 6623 targetX: Boolean, 6624 targetY: Boolean, 6625 stretch: Boolean, 6626 delayShow: Number, 6627 delayHide: Number, 6628 autoUpdate: Boolean, 6629 clsDrop: String, 6630 animateOut: Boolean, 6631 bgScroll: Boolean, 6632 closeOnScroll: Boolean 6633 }, 6634 data: { 6635 mode: ["click", "hover"], 6636 toggle: "- *", 6637 boundary: false, 6638 boundaryX: false, 6639 boundaryY: false, 6640 target: false, 6641 targetX: false, 6642 targetY: false, 6643 stretch: false, 6644 delayShow: 0, 6645 delayHide: 800, 6646 autoUpdate: true, 6647 clsDrop: false, 6648 animateOut: false, 6649 bgScroll: true, 6650 animation: ["uk-animation-fade"], 6651 cls: "uk-open", 6652 container: false, 6653 closeOnScroll: false 6654 }, 6655 computed: { 6656 boundary({ boundary, boundaryX, boundaryY }, $el) { 6657 return [ 6658 query(boundaryX || boundary, $el) || window, 6659 query(boundaryY || boundary, $el) || window 6660 ]; 6661 }, 6662 target({ target, targetX, targetY }, $el) { 6663 targetX || (targetX = target || this.targetEl); 6664 targetY || (targetY = target || this.targetEl); 6665 return [ 6666 targetX === true ? window : query(targetX, $el), 6667 targetY === true ? window : query(targetY, $el) 6668 ]; 6669 } 6670 }, 6671 created() { 6672 this.tracker = new MouseTracker(); 6673 }, 6674 beforeConnect() { 6675 this.clsDrop = this.$props.clsDrop || `uk-${this.$options.name}`; 6676 }, 6677 connected() { 6678 addClass(this.$el, "uk-drop", this.clsDrop); 6679 if (this.toggle && !this.targetEl) { 6680 this.targetEl = createToggleComponent(this); 6681 } 6682 this._style = pick(this.$el.style, ["width", "height"]); 6683 }, 6684 disconnected() { 6685 if (this.isActive()) { 6686 this.hide(false); 6687 active = null; 6688 } 6689 css(this.$el, this._style); 6690 }, 6691 observe: lazyload({ 6692 target: ({ toggle, $el }) => query(toggle, $el), 6693 targets: ({ $el }) => $el 6694 }), 6695 events: [ 6696 { 6697 name: "click", 6698 delegate() { 6699 return ".uk-drop-close"; 6700 }, 6701 handler(e) { 6702 e.preventDefault(); 6703 this.hide(false); 6704 } 6705 }, 6706 { 6707 name: "click", 6708 delegate() { 6709 return 'a[href*="#"]'; 6710 }, 6711 handler({ defaultPrevented, current }) { 6712 const { hash } = current; 6713 if (!defaultPrevented && hash && isSameSiteAnchor(current) && !this.$el.contains($(hash))) { 6714 this.hide(false); 6715 } 6716 } 6717 }, 6718 { 6719 name: "beforescroll", 6720 handler() { 6721 this.hide(false); 6722 } 6723 }, 6724 { 6725 name: "toggle", 6726 self: true, 6727 handler(e, toggle) { 6728 e.preventDefault(); 6729 if (this.isToggled()) { 6730 this.hide(false); 6731 } else { 6732 this.show(toggle == null ? void 0 : toggle.$el, false); 6733 } 6734 } 6735 }, 6736 { 6737 name: "toggleshow", 6738 self: true, 6739 handler(e, toggle) { 6740 e.preventDefault(); 6741 this.show(toggle == null ? void 0 : toggle.$el); 6742 } 6743 }, 6744 { 6745 name: "togglehide", 6746 self: true, 6747 handler(e) { 6748 e.preventDefault(); 6749 if (!matches(this.$el, ":focus,:hover")) { 6750 this.hide(); 6751 } 6752 } 6753 }, 6754 { 6755 name: `${pointerEnter} focusin`, 6756 filter() { 6757 return includes(this.mode, "hover"); 6758 }, 6759 handler(e) { 6760 if (!isTouch(e)) { 6761 this.clearTimers(); 6762 } 6763 } 6764 }, 6765 { 6766 name: `${pointerLeave} focusout`, 6767 filter() { 6768 return includes(this.mode, "hover"); 6769 }, 6770 handler(e) { 6771 if (!isTouch(e) && e.relatedTarget) { 6772 this.hide(); 6773 } 6774 } 6775 }, 6776 { 6777 name: "toggled", 6778 self: true, 6779 handler(e, toggled) { 6780 if (toggled) { 6781 this.clearTimers(); 6782 this.position(); 6783 } 6784 } 6785 }, 6786 { 6787 name: "show", 6788 self: true, 6789 handler() { 6790 active = this; 6791 this.tracker.init(); 6792 attr(this.targetEl, "aria-expanded", true); 6793 const handlers = [ 6794 listenForResize(this), 6795 listenForEscClose(this),
vendor: 20,875 bytes, lines 6796-7411
6796 listenForBackgroundClose(this), 6797 this.autoUpdate && listenForScroll(this), 6798 this.closeOnScroll && listenForScrollClose(this), 6799 !this.bgScroll && preventBackgroundScroll(this.$el) 6800 ]; 6801 once(this.$el, "hide", () => handlers.forEach((handler) => handler && handler()), { 6802 self: true 6803 }); 6804 } 6805 }, 6806 { 6807 name: "beforehide", 6808 self: true, 6809 handler() { 6810 this.clearTimers(); 6811 } 6812 }, 6813 { 6814 name: "hide", 6815 handler({ target }) { 6816 if (this.$el !== target) { 6817 active = active === null && this.$el.contains(target) && this.isToggled() ? this : active; 6818 return; 6819 } 6820 active = this.isActive() ? null : active; 6821 this.tracker.cancel(); 6822 attr(this.targetEl, "aria-expanded", null); 6823 } 6824 } 6825 ], 6826 update: { 6827 write() { 6828 if (this.isToggled() && !hasClass(this.$el, this.clsEnter)) { 6829 this.position(); 6830 } 6831 } 6832 }, 6833 methods: { 6834 show(target = this.targetEl, delay = true) { 6835 if (this.isToggled() && target && this.targetEl && target !== this.targetEl) { 6836 this.hide(false, false); 6837 } 6838 this.targetEl = target; 6839 this.clearTimers(); 6840 if (this.isActive()) { 6841 return; 6842 } 6843 if (active) { 6844 if (delay && active.isDelaying) { 6845 this.showTimer = setTimeout(() => matches(target, ":hover") && this.show(), 10); 6846 return; 6847 } 6848 let prev; 6849 while (active && prev !== active && !active.$el.contains(this.$el)) { 6850 prev = active; 6851 active.hide(false, false); 6852 } 6853 } 6854 if (this.container && parent(this.$el) !== this.container) { 6855 append(this.container, this.$el); 6856 } 6857 this.showTimer = setTimeout( 6858 () => this.toggleElement(this.$el, true), 6859 delay && this.delayShow || 0 6860 ); 6861 }, 6862 hide(delay = true, animate = true) { 6863 const hide = () => this.toggleElement(this.$el, false, this.animateOut && animate); 6864 this.clearTimers(); 6865 this.isDelayedHide = delay; 6866 this.isDelaying = getPositionedElements(this.$el).some( 6867 (el) => this.tracker.movesTo(el) 6868 ); 6869 if (delay && this.isDelaying) { 6870 this.hideTimer = setTimeout(this.hide, 50); 6871 } else if (delay && this.delayHide) { 6872 this.hideTimer = setTimeout(hide, this.delayHide); 6873 } else { 6874 hide(); 6875 } 6876 }, 6877 clearTimers() { 6878 clearTimeout(this.showTimer); 6879 clearTimeout(this.hideTimer); 6880 this.showTimer = null; 6881 this.hideTimer = null; 6882 this.isDelaying = false; 6883 }, 6884 isActive() { 6885 return active === this; 6886 }, 6887 position() { 6888 removeClass(this.$el, "uk-drop-stack"); 6889 css(this.$el, this._style); 6890 this.$el.hidden = true; 6891 const viewports = this.target.map((target) => getViewport$1(this.$el, target)); 6892 const viewportOffset = this.getViewportOffset(this.$el); 6893 const dirs = [ 6894 [0, ["x", "width", "left", "right"]], 6895 [1, ["y", "height", "top", "bottom"]] 6896 ]; 6897 for (const [i, [axis, prop]] of dirs) { 6898 if (this.axis !== axis && includes([axis, true], this.stretch)) { 6899 css(this.$el, { 6900 [prop]: Math.min( 6901 offset(this.boundary[i])[prop], 6902 viewports[i][prop] - 2 * viewportOffset 6903 ), 6904 [`overflow-${axis}`]: "auto" 6905 }); 6906 } 6907 } 6908 const maxWidth = viewports[0].width - 2 * viewportOffset; 6909 this.$el.hidden = false; 6910 css(this.$el, "maxWidth", ""); 6911 if (this.$el.offsetWidth > maxWidth) { 6912 addClass(this.$el, "uk-drop-stack"); 6913 } 6914 css(this.$el, "maxWidth", maxWidth); 6915 this.positionAt(this.$el, this.target, this.boundary); 6916 for (const [i, [axis, prop, start, end]] of dirs) { 6917 if (this.axis === axis && includes([axis, true], this.stretch)) { 6918 const positionOffset = Math.abs(this.getPositionOffset(this.$el)); 6919 const targetOffset = offset(this.target[i]); 6920 const elOffset = offset(this.$el); 6921 css(this.$el, { 6922 [prop]: (targetOffset[start] > elOffset[start] ? targetOffset[this.inset ? end : start] - Math.max( 6923 offset(this.boundary[i])[start], 6924 viewports[i][start] + viewportOffset 6925 ) : Math.min( 6926 offset(this.boundary[i])[end], 6927 viewports[i][end] - viewportOffset 6928 ) - targetOffset[this.inset ? start : end]) - positionOffset, 6929 [`overflow-${axis}`]: "auto" 6930 }); 6931 this.positionAt(this.$el, this.target, this.boundary); 6932 } 6933 } 6934 } 6935 } 6936 }; 6937 function getPositionedElements(el) { 6938 const result = []; 6939 apply(el, (el2) => css(el2, "position") !== "static" && result.push(el2)); 6940 return result; 6941 } 6942 function getViewport$1(el, target) { 6943 return offsetViewport(overflowParents(target).find((parent2) => parent2.contains(el))); 6944 } 6945 function createToggleComponent(drop) { 6946 const { $el } = drop.$create("toggle", query(drop.toggle, drop.$el), { 6947 target: drop.$el, 6948 mode: drop.mode 6949 }); 6950 attr($el, "aria-haspopup", true); 6951 return $el; 6952 } 6953 function listenForResize(drop) { 6954 const update = () => drop.$emit(); 6955 const off = [ 6956 observeViewportResize(update), 6957 observeResize(overflowParents(drop.$el).concat(drop.target), update) 6958 ]; 6959 return () => off.map((observer) => observer.disconnect()); 6960 } 6961 function listenForScroll(drop, fn = () => drop.$emit()) { 6962 return on([document, ...overflowParents(drop.$el)], "scroll", fn, { 6963 passive: true 6964 }); 6965 } 6966 function listenForEscClose(drop) { 6967 return on(document, "keydown", (e) => { 6968 if (e.keyCode === keyMap.ESC) { 6969 drop.hide(false); 6970 } 6971 }); 6972 } 6973 function listenForScrollClose(drop) { 6974 return listenForScroll(drop, () => drop.hide(false)); 6975 } 6976 function listenForBackgroundClose(drop) { 6977 return on(document, pointerDown$1, ({ target }) => { 6978 if (drop.$el.contains(target)) { 6979 return; 6980 } 6981 once( 6982 document, 6983 `${pointerUp$1} ${pointerCancel} scroll`, 6984 ({ defaultPrevented, type, target: newTarget }) => { 6985 if (!defaultPrevented && type === pointerUp$1 && target === newTarget && !(drop.targetEl && within(target, drop.targetEl))) { 6986 drop.hide(false); 6987 } 6988 }, 6989 true 6990 ); 6991 }); 6992 } 6993 6994 var Dropnav = { 6995 mixins: [Class, Container], 6996 props: { 6997 align: String, 6998 clsDrop: String, 6999 boundary: Boolean, 7000 dropbar: Boolean, 7001 dropbarAnchor: Boolean, 7002 duration: Number, 7003 mode: Boolean, 7004 offset: Boolean, 7005 stretch: Boolean, 7006 delayShow: Boolean, 7007 delayHide: Boolean, 7008 target: Boolean, 7009 targetX: Boolean, 7010 targetY: Boolean, 7011 animation: Boolean, 7012 animateOut: Boolean, 7013 closeOnScroll: Boolean 7014 }, 7015 data: { 7016 align: isRtl ? "right" : "left", 7017 clsDrop: "uk-dropdown", 7018 clsDropbar: "uk-dropnav-dropbar", 7019 boundary: true, 7020 dropbar: false, 7021 dropbarAnchor: false, 7022 duration: 200, 7023 container: false, 7024 selNavItem: "> li > a, > ul > li > a" 7025 }, 7026 computed: { 7027 dropbarAnchor: ({ dropbarAnchor }, $el) => query(dropbarAnchor, $el) || $el, 7028 dropbar({ dropbar }) { 7029 if (!dropbar) { 7030 return null; 7031 } 7032 dropbar = this._dropbar || query(dropbar, this.$el) || $(`+ .${this.clsDropbar}`, this.$el); 7033 return dropbar ? dropbar : this._dropbar = $("<div></div>"); 7034 }, 7035 dropbarOffset() { 7036 return 0; 7037 }, 7038 dropContainer(_, $el) { 7039 return this.container || $el; 7040 }, 7041 dropdowns({ clsDrop }, $el) { 7042 var _a; 7043 const dropdowns = $$(`.${clsDrop}`, $el); 7044 if (this.dropContainer !== $el) { 7045 for (const el of $$(`.${clsDrop}`, this.dropContainer)) { 7046 const target = (_a = this.getDropdown(el)) == null ? void 0 : _a.targetEl; 7047 if (!includes(dropdowns, el) && target && this.$el.contains(target)) { 7048 dropdowns.push(el); 7049 } 7050 } 7051 } 7052 return dropdowns; 7053 }, 7054 items({ selNavItem }, $el) { 7055 return $$(selNavItem, $el); 7056 } 7057 }, 7058 watch: { 7059 dropbar(dropbar) { 7060 addClass( 7061 dropbar, 7062 "uk-dropbar", 7063 "uk-dropbar-top", 7064 this.clsDropbar, 7065 `uk-${this.$options.name}-dropbar` 7066 ); 7067 }, 7068 dropdowns() { 7069 this.initializeDropdowns(); 7070 } 7071 }, 7072 connected() { 7073 this.initializeDropdowns(); 7074 }, 7075 disconnected() { 7076 remove$1(this._dropbar); 7077 delete this._dropbar; 7078 }, 7079 events: [ 7080 { 7081 name: "mouseover focusin", 7082 delegate() { 7083 return this.selNavItem; 7084 }, 7085 handler({ current }) { 7086 const active2 = this.getActive(); 7087 if (active2 && includes(active2.mode, "hover") && active2.targetEl && !current.contains(active2.targetEl) && !active2.isDelaying) { 7088 active2.hide(false); 7089 } 7090 } 7091 }, 7092 { 7093 name: "keydown", 7094 self: true, 7095 delegate() { 7096 return this.selNavItem; 7097 }, 7098 handler(e) { 7099 var _a; 7100 const { current, keyCode } = e; 7101 const active2 = this.getActive(); 7102 if (keyCode === keyMap.DOWN && (active2 == null ? void 0 : active2.targetEl) === current) { 7103 e.preventDefault(); 7104 (_a = $(selFocusable, active2.$el)) == null ? void 0 : _a.focus(); 7105 } 7106 handleNavItemNavigation(e, this.items, active2); 7107 } 7108 }, 7109 { 7110 name: "keydown", 7111 el() { 7112 return this.dropContainer; 7113 }, 7114 delegate() { 7115 return `.${this.clsDrop}`; 7116 }, 7117 handler(e) { 7118 var _a; 7119 const { current, keyCode } = e; 7120 if (!includes(this.dropdowns, current)) { 7121 return; 7122 } 7123 const active2 = this.getActive(); 7124 let next = -1; 7125 if (keyCode === keyMap.HOME) { 7126 next = 0; 7127 } else if (keyCode === keyMap.END) { 7128 next = "last"; 7129 } else if (keyCode === keyMap.UP) { 7130 next = "previous"; 7131 } else if (keyCode === keyMap.DOWN) { 7132 next = "next"; 7133 } else if (keyCode === keyMap.ESC) { 7134 (_a = active2.targetEl) == null ? void 0 : _a.focus(); 7135 } 7136 if (~next) { 7137 e.preventDefault(); 7138 const elements = $$(selFocusable, current); 7139 elements[getIndex( 7140 next, 7141 elements, 7142 findIndex(elements, (el) => matches(el, ":focus")) 7143 )].focus(); 7144 } 7145 handleNavItemNavigation(e, this.items, active2); 7146 } 7147 }, 7148 { 7149 name: "mouseleave", 7150 el() { 7151 return this.dropbar; 7152 }, 7153 filter() { 7154 return this.dropbar; 7155 }, 7156 handler() { 7157 const active2 = this.getActive(); 7158 if (active2 && includes(active2.mode, "hover") && !this.dropdowns.some((el) => matches(el, ":hover"))) { 7159 active2.hide(); 7160 } 7161 } 7162 }, 7163 { 7164 name: "beforeshow", 7165 el() { 7166 return this.dropContainer; 7167 }, 7168 filter() { 7169 return this.dropbar; 7170 }, 7171 handler({ target }) { 7172 if (!this.isDropbarDrop(target)) { 7173 return; 7174 } 7175 if (this.dropbar.previousElementSibling !== this.dropbarAnchor) { 7176 after(this.dropbarAnchor, this.dropbar); 7177 } 7178 addClass(target, `${this.clsDrop}-dropbar`); 7179 } 7180 }, 7181 { 7182 name: "show", 7183 el() { 7184 return this.dropContainer; 7185 }, 7186 filter() { 7187 return this.dropbar; 7188 }, 7189 handler({ target }) { 7190 if (!this.isDropbarDrop(target)) { 7191 return; 7192 } 7193 const drop = this.getDropdown(target); 7194 const adjustHeight = () => { 7195 const targetOffsets = parents(target, `.${this.clsDrop}`).concat(target).map((el) => offset(el)); 7196 const minTop = Math.min(...targetOffsets.map(({ top }) => top)); 7197 const maxBottom = Math.max(...targetOffsets.map(({ bottom }) => bottom)); 7198 const dropbarOffset = offset(this.dropbar); 7199 css( 7200 this.dropbar, 7201 "top", 7202 this.dropbar.offsetTop - (dropbarOffset.top - minTop) - this.dropbarOffset 7203 ); 7204 this.transitionTo( 7205 maxBottom - minTop + toFloat(css(target, "marginBottom")) + this.dropbarOffset, 7206 target 7207 ); 7208 }; 7209 this._observer = observeResize([drop.$el, ...drop.target], adjustHeight); 7210 adjustHeight(); 7211 } 7212 }, 7213 { 7214 name: "beforehide", 7215 el() { 7216 return this.dropContainer; 7217 }, 7218 filter() { 7219 return this.dropbar; 7220 }, 7221 handler(e) { 7222 const active2 = this.getActive(); 7223 if (matches(this.dropbar, ":hover") && active2.$el === e.target && includes(active2.mode, "hover") && active2.isDelayedHide && !this.items.some((el) => active2.targetEl !== el && matches(el, ":focus"))) { 7224 e.preventDefault(); 7225 } 7226 } 7227 }, 7228 { 7229 name: "hide", 7230 el() { 7231 return this.dropContainer; 7232 }, 7233 filter() { 7234 return this.dropbar; 7235 }, 7236 handler({ target }) { 7237 var _a; 7238 if (!this.isDropbarDrop(target)) { 7239 return; 7240 } 7241 (_a = this._observer) == null ? void 0 : _a.disconnect(); 7242 const active2 = this.getActive(); 7243 if (!active2 || active2.$el === target) { 7244 this.transitionTo(0); 7245 } 7246 } 7247 } 7248 ], 7249 methods: { 7250 getActive() { 7251 var _a; 7252 return includes(this.dropdowns, (_a = active) == null ? void 0 : _a.$el) && active; 7253 }, 7254 async transitionTo(newHeight, el) { 7255 const { dropbar } = this; 7256 const oldHeight = height(dropbar); 7257 el = oldHeight < newHeight && el; 7258 await Transition.cancel([el, dropbar]); 7259 css(el, "clipPath", `polygon(0 0,100% 0,100% ${oldHeight}px,0 ${oldHeight}px)`); 7260 height(dropbar, oldHeight); 7261 await Promise.all([ 7262 Transition.start(dropbar, { height: newHeight }, this.duration), 7263 Transition.start( 7264 el, 7265 { 7266 clipPath: `polygon(0 0,100% 0,100% ${newHeight}px,0 ${newHeight}px)` 7267 }, 7268 this.duration 7269 ).finally(() => css(el, { clipPath: "" })) 7270 ]).catch(noop); 7271 }, 7272 getDropdown(el) { 7273 return this.$getComponent(el, "drop") || this.$getComponent(el, "dropdown"); 7274 }, 7275 isDropbarDrop(el) { 7276 return this.getDropdown(el) && hasClass(el, this.clsDrop); 7277 }, 7278 initializeDropdowns() { 7279 this.$create( 7280 "drop", 7281 this.dropdowns.filter((el) => !this.getDropdown(el)), 7282 { 7283 ...this.$props, 7284 flip: false, 7285 shift: true, 7286 pos: `bottom-${this.align}`, 7287 boundary: this.boundary === true ? this.$el : this.boundary 7288 } 7289 ); 7290 } 7291 } 7292 }; 7293 function handleNavItemNavigation(e, toggles, active2) { 7294 var _a, _b, _c; 7295 const { current, keyCode } = e; 7296 let next = -1; 7297 if (keyCode === keyMap.HOME) { 7298 next = 0; 7299 } else if (keyCode === keyMap.END) { 7300 next = "last"; 7301 } else if (keyCode === keyMap.LEFT) { 7302 next = "previous"; 7303 } else if (keyCode === keyMap.RIGHT) { 7304 next = "next"; 7305 } else if (keyCode === keyMap.TAB) { 7306 (_a = active2.targetEl) == null ? void 0 : _a.focus(); 7307 (_b = active2.hide) == null ? void 0 : _b.call(active2, false); 7308 } 7309 if (~next) { 7310 e.preventDefault(); 7311 (_c = active2.hide) == null ? void 0 : _c.call(active2, false); 7312 toggles[getIndex(next, toggles, toggles.indexOf(active2.targetEl || current))].focus(); 7313 } 7314 } 7315 7316 var formCustom = { 7317 mixins: [Class], 7318 args: "target", 7319 props: { 7320 target: Boolean 7321 }, 7322 data: { 7323 target: false 7324 }, 7325 computed: { 7326 input: (_, $el) => $(selInput, $el), 7327 state() { 7328 return this.input.nextElementSibling; 7329 }, 7330 target({ target }, $el) { 7331 return target && (target === true && parent(this.input) === $el && this.input.nextElementSibling || $(target, $el)); 7332 } 7333 }, 7334 update() { 7335 var _a; 7336 const { target, input } = this; 7337 if (!target) { 7338 return; 7339 } 7340 let option; 7341 const prop = isInput(target) ? "value" : "textContent"; 7342 const prev = target[prop]; 7343 const value = ((_a = input.files) == null ? void 0 : _a[0]) ? input.files[0].name : matches(input, "select") && (option = $$("option", input).filter((el) => el.selected)[0]) ? option.textContent : input.value; 7344 if (prev !== value) { 7345 target[prop] = value; 7346 } 7347 }, 7348 events: [ 7349 { 7350 name: "change", 7351 handler() { 7352 this.$emit(); 7353 } 7354 }, 7355 { 7356 name: "reset", 7357 el() { 7358 return this.$el.closest("form"); 7359 }, 7360 handler() { 7361 this.$emit(); 7362 } 7363 } 7364 ] 7365 }; 7366 7367 var grid = { 7368 extends: Margin, 7369 mixins: [Class], 7370 name: "grid", 7371 props: { 7372 masonry: Boolean, 7373 parallax: String, 7374 parallaxStart: String, 7375 parallaxEnd: String, 7376 parallaxJustify: Boolean 7377 }, 7378 data: { 7379 margin: "uk-grid-margin", 7380 clsStack: "uk-grid-stack", 7381 masonry: false, 7382 parallax: 0, 7383 parallaxStart: 0, 7384 parallaxEnd: 0, 7385 parallaxJustify: false 7386 }, 7387 connected() { 7388 this.masonry && addClass(this.$el, "uk-flex-top", "uk-flex-wrap-top"); 7389 }, 7390 observe: scroll$1({ filter: ({ parallax, parallaxJustify }) => parallax || parallaxJustify }), 7391 update: [ 7392 { 7393 write({ rows }) { 7394 toggleClass(this.$el, this.clsStack, !rows.some((row) => row.length > 1)); 7395 }, 7396 events: ["resize"] 7397 }, 7398 { 7399 read(data) { 7400 const { rows } = data; 7401 let { masonry, parallax, parallaxJustify, margin } = this; 7402 parallax = Math.max(0, toPx(parallax)); 7403 if (!(masonry || parallax || parallaxJustify) || positionedAbsolute(rows) || rows[0].some( 7404 (el, i) => rows.some((row) => row[i] && row[i].offsetWidth !== el.offsetWidth) 7405 )) { 7406 return data.translates = data.scrollColumns = false; 7407 } 7408 let gutter = getGutter(rows, margin); 7409 let columns; 7410 let translates; 7411 if (masonry) {
vendor: 4,756 bytes, lines 7412-7549
7412 [columns, translates] = applyMasonry(rows, gutter, masonry === "next"); 7413 } else { 7414 columns = transpose(rows); 7415 } 7416 const columnHeights = columns.map( 7417 (column) => sumBy(column, "offsetHeight") + gutter * (column.length - 1) 7418 ); 7419 const height = Math.max(0, ...columnHeights); 7420 let scrollColumns; 7421 let parallaxStart; 7422 let parallaxEnd; 7423 if (parallax || parallaxJustify) { 7424 scrollColumns = columnHeights.map( 7425 (hgt, i) => parallaxJustify ? height - hgt + parallax : parallax / (i % 2 || 8) 7426 ); 7427 if (!parallaxJustify) { 7428 parallax = Math.max( 7429 ...columnHeights.map((hgt, i) => hgt + scrollColumns[i] - height) 7430 ); 7431 } 7432 parallaxStart = toPx(this.parallaxStart, "height", this.$el, true); 7433 parallaxEnd = toPx(this.parallaxEnd, "height", this.$el, true); 7434 } 7435 return { 7436 columns, 7437 translates, 7438 scrollColumns, 7439 parallaxStart, 7440 parallaxEnd, 7441 padding: parallax, 7442 height: translates ? height : "" 7443 }; 7444 }, 7445 write({ height, padding }) { 7446 css(this.$el, "paddingBottom", padding || ""); 7447 height !== false && css(this.$el, "height", height); 7448 }, 7449 events: ["resize"] 7450 }, 7451 { 7452 read({ rows, scrollColumns, parallaxStart, parallaxEnd }) { 7453 if (scrollColumns && positionedAbsolute(rows)) { 7454 return false; 7455 } 7456 return { 7457 scrolled: scrollColumns ? scrolledOver(this.$el, parallaxStart, parallaxEnd) : false 7458 }; 7459 }, 7460 write({ columns, scrolled, scrollColumns, translates }) { 7461 if (!scrolled && !translates) { 7462 return; 7463 } 7464 columns.forEach( 7465 (column, i) => column.forEach((el, j) => { 7466 let [x, y] = translates && translates[i][j] || [0, 0]; 7467 if (scrolled) { 7468 y += scrolled * scrollColumns[i]; 7469 } 7470 css(el, "transform", `translate(${x}px, ${y}px)`); 7471 }) 7472 ); 7473 }, 7474 events: ["scroll", "resize"] 7475 } 7476 ] 7477 }; 7478 function positionedAbsolute(rows) { 7479 return rows.flat().some((el) => css(el, "position") === "absolute"); 7480 } 7481 function applyMasonry(rows, gutter, next) { 7482 const columns = []; 7483 const translates = []; 7484 const columnHeights = Array(rows[0].length).fill(0); 7485 let rowHeights = 0; 7486 for (let row of rows) { 7487 if (isRtl) { 7488 row = row.reverse(); 7489 } 7490 let height = 0; 7491 for (const j in row) { 7492 const { offsetWidth, offsetHeight } = row[j]; 7493 const index = next ? j : columnHeights.indexOf(Math.min(...columnHeights)); 7494 push(columns, index, row[j]); 7495 push(translates, index, [ 7496 (index - j) * offsetWidth * (isRtl ? -1 : 1), 7497 columnHeights[index] - rowHeights 7498 ]); 7499 columnHeights[index] += offsetHeight + gutter; 7500 height = Math.max(height, offsetHeight); 7501 } 7502 rowHeights += height + gutter; 7503 } 7504 return [columns, translates]; 7505 } 7506 function getGutter(rows, cls) { 7507 const node = rows.flat().find((el) => hasClass(el, cls)); 7508 return toFloat(node ? css(node, "marginTop") : css(rows[0][0], "paddingLeft")); 7509 } 7510 function transpose(rows) { 7511 const columns = []; 7512 for (const row of rows) { 7513 for (const i in row) { 7514 push(columns, i, row[i]); 7515 } 7516 } 7517 return columns; 7518 } 7519 function push(array, index, value) { 7520 if (!array[index]) { 7521 array[index] = []; 7522 } 7523 array[index].push(value); 7524 } 7525 7526 var heightMatch = { 7527 args: "target", 7528 props: { 7529 target: String, 7530 row: Boolean 7531 }, 7532 data: { 7533 target: "> *", 7534 row: true 7535 }, 7536 computed: { 7537 elements: ({ target }, $el) => $$(target, $el) 7538 }, 7539 observe: resize({ 7540 target: ({ $el, elements }) => elements.reduce((elements2, el) => elements2.concat(el, ...el.children), [$el]) 7541 }), 7542 update: { 7543 read() { 7544 return { 7545 rows: (this.row ? getRows(this.elements) : [this.elements]).map(match) 7546 }; 7547 }, 7548 write({ rows }) { 7549 for (const { heights, elements } of rows) {
vendor: 5,348 bytes, lines 7550-7657
7550 elements.forEach((el, i) => css(el, "minHeight", heights[i])); 7551 } 7552 }, 7553 events: ["resize"] 7554 } 7555 }; 7556 function match(elements) { 7557 if (elements.length < 2) { 7558 return { heights: [""], elements }; 7559 } 7560 let heights = elements.map(getHeight); 7561 const max = Math.max(...heights); 7562 return { 7563 heights: elements.map((el, i) => heights[i].toFixed(2) === max.toFixed(2) ? "" : max), 7564 elements 7565 }; 7566 } 7567 function getHeight(element) { 7568 const style = pick(element.style, ["display", "minHeight"]); 7569 if (!isVisible(element)) { 7570 css(element, "display", "block", "important"); 7571 } 7572 css(element, "minHeight", ""); 7573 const height = dimensions$1(element).height - boxModelAdjust(element, "height", "content-box"); 7574 css(element, style); 7575 return height; 7576 } 7577 7578 var heightViewport = { 7579 props: { 7580 expand: Boolean, 7581 offsetTop: Boolean, 7582 offsetBottom: Boolean, 7583 minHeight: Number 7584 }, 7585 data: { 7586 expand: false, 7587 offsetTop: false, 7588 offsetBottom: false, 7589 minHeight: 0 7590 }, 7591 // check for offsetTop change 7592 observe: [ 7593 viewport({ filter: ({ expand }) => expand }), 7594 resize({ target: ({ $el }) => scrollParents($el) }) 7595 ], 7596 update: { 7597 read() { 7598 if (!isVisible(this.$el)) { 7599 return false; 7600 } 7601 let minHeight = ""; 7602 const box = boxModelAdjust(this.$el, "height", "content-box"); 7603 const { body, scrollingElement } = document; 7604 const scrollElement = scrollParent(this.$el); 7605 const { height: viewportHeight } = offsetViewport( 7606 scrollElement === body ? scrollingElement : scrollElement 7607 ); 7608 const isScrollingElement = scrollingElement === scrollElement || body === scrollElement; 7609 minHeight = `calc(${isScrollingElement ? "100vh" : `${viewportHeight}px`}`; 7610 if (this.expand) { 7611 const diff = dimensions$1(scrollElement).height - dimensions$1(this.$el).height; 7612 minHeight += ` - ${diff}px`; 7613 } else { 7614 if (this.offsetTop) { 7615 if (isScrollingElement) { 7616 const offsetTopEl = this.offsetTop === true ? this.$el : query(this.offsetTop, this.$el); 7617 const top = offsetPosition(offsetTopEl)[0] - offsetPosition(scrollElement)[0]; 7618 minHeight += top > 0 && top < viewportHeight / 2 ? ` - ${top}px` : ""; 7619 } else { 7620 minHeight += ` - ${css(scrollElement, "paddingTop")}`; 7621 } 7622 } 7623 if (this.offsetBottom === true) { 7624 minHeight += ` - ${dimensions$1(this.$el.nextElementSibling).height}px`; 7625 } else if (isNumeric(this.offsetBottom)) { 7626 minHeight += ` - ${this.offsetBottom}vh`; 7627 } else if (this.offsetBottom && endsWith(this.offsetBottom, "px")) { 7628 minHeight += ` - ${toFloat(this.offsetBottom)}px`; 7629 } else if (isString(this.offsetBottom)) { 7630 minHeight += ` - ${dimensions$1(query(this.offsetBottom, this.$el)).height}px`; 7631 } 7632 } 7633 minHeight += `${box ? ` - ${box}px` : ""})`; 7634 return { minHeight }; 7635 }, 7636 write({ minHeight }) { 7637 css(this.$el, "minHeight", `max(${this.minHeight || 0}px, ${minHeight})`); 7638 }, 7639 events: ["resize"] 7640 } 7641 }; 7642 7643 var closeIcon = "<svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\"><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" x1=\"1\" y1=\"1\" x2=\"13\" y2=\"13\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" x1=\"13\" y1=\"1\" x2=\"1\" y2=\"13\"/></svg>"; 7644 7645 var closeLarge = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\"><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" x1=\"1\" y1=\"1\" x2=\"19\" y2=\"19\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" x1=\"19\" y1=\"1\" x2=\"1\" y2=\"19\"/></svg>"; 7646 7647 var dropParentIcon = "<svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" points=\"1 3.5 6 8.5 11 3.5\"/></svg>"; 7648 7649 var marker = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\"><rect x=\"9\" y=\"4\" width=\"1\" height=\"11\"/><rect x=\"4\" y=\"9\" width=\"11\" height=\"1\"/></svg>"; 7650 7651 var navParentIconLarge = "<svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" points=\"1 4 7 10 13 4\"/></svg>"; 7652 7653 var navParentIcon = "<svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" points=\"1 3.5 6 8.5 11 3.5\"/></svg>"; 7654 7655 var navbarParentIcon = "<svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" points=\"1 3.5 6 8.5 11 3.5\"/></svg>"; 7656 7657 var navbarToggleIcon = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\"><style>.uk-navbar-toggle-animate svg>[class*="line-"]{transition:0.2s ease-in-out;transition-property:transform, opacity;transform-origin:center;opacity:1}.uk-navbar-toggle svg>.line-3{opacity:0}
vendor: 11,016 bytes, lines 7657-7930
7657.uk-navbar-toggle-animate[aria-expanded="true"] svg>.line-3{opacity:1}.uk-navbar-toggle-animate[aria-expanded="true"] svg>.line-2{transform:rotate(45deg)}.uk-navbar-toggle-animate[aria-expanded="true"] svg>.line-3{transform:rotate(-45deg)}.uk-navbar-toggle-animate[aria-expanded="true"] svg>.line-1,.uk-navbar-toggle-animate[aria-expanded="true"] svg>.line-4{opacity:0}.uk-navbar-toggle-animate[aria-expanded="true"] svg>.line-1{transform:translateY(6px) scaleX(0)}.uk-navbar-toggle-animate[aria-expanded="true"] svg>.line-4{transform:translateY(-6px) scaleX(0)}</style><rect class=\"line-1\" y=\"3\" width=\"20\" height=\"2\"/><rect class=\"line-2\" y=\"9\" width=\"20\" height=\"2\"/><rect class=\"line-3\" y=\"9\" width=\"20\" height=\"2\"/><rect class=\"line-4\" y=\"15\" width=\"20\" height=\"2\"/></svg>"; 7658 7659 var overlayIcon = "<svg width=\"40\" height=\"40\" viewBox=\"0 0 40 40\"><rect x=\"19\" y=\"0\" width=\"1\" height=\"40\"/><rect x=\"0\" y=\"19\" width=\"40\" height=\"1\"/></svg>"; 7660 7661 var paginationNext = "<svg width=\"7\" height=\"12\" viewBox=\"0 0 7 12\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.2\" points=\"1 1 6 6 1 11\"/></svg>"; 7662 7663 var paginationPrevious = "<svg width=\"7\" height=\"12\" viewBox=\"0 0 7 12\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.2\" points=\"6 1 1 6 6 11\"/></svg>"; 7664 7665 var searchIcon = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\"><circle fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" cx=\"9\" cy=\"9\" r=\"7\"/><path fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" d=\"M14,14 L18,18 L14,14 Z\"/></svg>"; 7666 7667 var searchLarge = "<svg width=\"40\" height=\"40\" viewBox=\"0 0 40 40\"><circle fill=\"none\" stroke=\"#000\" stroke-width=\"1.8\" cx=\"17.5\" cy=\"17.5\" r=\"16.5\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.8\" x1=\"38\" y1=\"39\" x2=\"29\" y2=\"30\"/></svg>"; 7668 7669 var searchNavbar = "<svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\"><circle fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" cx=\"10.5\" cy=\"10.5\" r=\"9.5\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" x1=\"23\" y1=\"23\" x2=\"17\" y2=\"17\"/></svg>"; 7670 7671 var slidenavNextLarge = "<svg width=\"25\" height=\"40\" viewBox=\"0 0 25 40\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"2\" points=\"4.002,38.547 22.527,20.024 4,1.5\"/></svg>"; 7672 7673 var slidenavNext = "<svg width=\"14\" height=\"24\" viewBox=\"0 0 14 24\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" points=\"1.225,23 12.775,12 1.225,1\"/></svg>"; 7674 7675 var slidenavPreviousLarge = "<svg width=\"25\" height=\"40\" viewBox=\"0 0 25 40\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"2\" points=\"20.527,1.5 2,20.024 20.525,38.547\"/></svg>"; 7676 7677 var slidenavPrevious = "<svg width=\"14\" height=\"24\" viewBox=\"0 0 14 24\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" points=\"12.775,1 1.225,12 12.775,23\"/></svg>"; 7678 7679 var spinner = "<svg width=\"30\" height=\"30\" viewBox=\"0 0 30 30\"><circle fill=\"none\" stroke=\"#000\" cx=\"15\" cy=\"15\" r=\"14\"/></svg>"; 7680 7681 var totop = "<svg width=\"18\" height=\"10\" viewBox=\"0 0 18 10\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.2\" points=\"1 9 9 1 17 9\"/></svg>"; 7682 7683 var Svg = { 7684 args: "src", 7685 props: { 7686 width: Number, 7687 height: Number, 7688 ratio: Number 7689 }, 7690 data: { 7691 ratio: 1 7692 }, 7693 connected() { 7694 this.svg = this.getSvg().then((el) => { 7695 if (!this._connected) { 7696 return; 7697 } 7698 const svg = insertSVG(el, this.$el); 7699 if (this.svgEl && svg !== this.svgEl) { 7700 remove$1(this.svgEl); 7701 } 7702 applyWidthAndHeight.call(this, svg, el); 7703 return this.svgEl = svg; 7704 }, noop); 7705 }, 7706 disconnected() { 7707 this.svg.then((svg) => { 7708 if (this._connected) { 7709 return; 7710 } 7711 if (isVoidElement(this.$el)) { 7712 this.$el.hidden = false; 7713 } 7714 remove$1(svg); 7715 this.svgEl = null; 7716 }); 7717 this.svg = null; 7718 }, 7719 methods: { 7720 async getSvg() { 7721 } 7722 } 7723 }; 7724 function insertSVG(el, root) { 7725 if (isVoidElement(root) || isTag(root, "canvas")) { 7726 root.hidden = true; 7727 const next = root.nextElementSibling; 7728 return equals(el, next) ? next : after(root, el); 7729 } 7730 const last = root.lastElementChild; 7731 return equals(el, last) ? last : append(root, el); 7732 } 7733 function equals(el, other) { 7734 return isTag(el, "svg") && isTag(other, "svg") && el.innerHTML === other.innerHTML; 7735 } 7736 function applyWidthAndHeight(el, ref) { 7737 const props = ["width", "height"]; 7738 let dimensions = props.map((prop) => this[prop]); 7739 if (!dimensions.some((val) => val)) { 7740 dimensions = props.map((prop) => attr(ref, prop)); 7741 } 7742 const viewBox = attr(ref, "viewBox"); 7743 if (viewBox && !dimensions.some((val) => val)) { 7744 dimensions = viewBox.split(" ").slice(2); 7745 } 7746 dimensions.forEach((val, i) => attr(el, props[i], toFloat(val) * this.ratio || null)); 7747 } 7748 7749 const icons = { 7750 spinner, 7751 totop, 7752 marker, 7753 "close-icon": closeIcon, 7754 "close-large": closeLarge, 7755 "drop-parent-icon": dropParentIcon, 7756 "nav-parent-icon": navParentIcon, 7757 "nav-parent-icon-large": navParentIconLarge, 7758 "navbar-parent-icon": navbarParentIcon, 7759 "navbar-toggle-icon": navbarToggleIcon, 7760 "overlay-icon": overlayIcon, 7761 "pagination-next": paginationNext, 7762 "pagination-previous": paginationPrevious, 7763 "search-icon": searchIcon, 7764 "search-large": searchLarge, 7765 "search-navbar": searchNavbar, 7766 "slidenav-next": slidenavNext, 7767 "slidenav-next-large": slidenavNextLarge, 7768 "slidenav-previous": slidenavPrevious, 7769 "slidenav-previous-large": slidenavPreviousLarge 7770 }; 7771 const Icon = { 7772 install: install$1, 7773 mixins: [Svg], 7774 args: "icon", 7775 props: { icon: String }, 7776 isIcon: true, 7777 beforeConnect() { 7778 addClass(this.$el, "uk-icon"); 7779 }, 7780 methods: { 7781 async getSvg() { 7782 const icon = getIcon(this.icon); 7783 if (!icon) { 7784 throw "Icon not found."; 7785 } 7786 return icon; 7787 } 7788 } 7789 }; 7790 const IconComponent = { 7791 args: false, 7792 extends: Icon, 7793 data: (vm) => ({ 7794 icon: hyphenate(vm.constructor.options.name) 7795 }), 7796 beforeConnect() { 7797 addClass(this.$el, this.$options.id); 7798 } 7799 }; 7800 const NavParentIcon = { 7801 extends: IconComponent, 7802 beforeConnect() { 7803 const icon = this.$props.icon; 7804 this.icon = this.$el.closest(".uk-nav-primary") ? `${icon}-large` : icon; 7805 } 7806 }; 7807 const Search = { 7808 extends: IconComponent, 7809 mixins: [I18n], 7810 i18n: { toggle: "Open Search", submit: "Submit Search" }, 7811 beforeConnect() { 7812 this.icon = hasClass(this.$el, "uk-search-icon") && parents(this.$el, ".uk-search-large").length ? "search-large" : parents(this.$el, ".uk-search-navbar").length ? "search-navbar" : this.$props.icon; 7813 if (hasAttr(this.$el, "aria-label")) { 7814 return; 7815 } 7816 if (hasClass(this.$el, "uk-search-toggle") || hasClass(this.$el, "uk-navbar-toggle")) { 7817 const label = this.t("toggle"); 7818 attr(this.$el, "aria-label", label); 7819 } else { 7820 const button = this.$el.closest("a,button"); 7821 if (button) { 7822 const label = this.t("submit"); 7823 attr(button, "aria-label", label); 7824 } 7825 } 7826 } 7827 }; 7828 const Spinner = { 7829 extends: IconComponent, 7830 beforeConnect() { 7831 attr(this.$el, "role", "status"); 7832 }, 7833 methods: { 7834 async getSvg() { 7835 const icon = await Icon.methods.getSvg.call(this); 7836 if (this.ratio !== 1) { 7837 css($("circle", icon), "strokeWidth", 1 / this.ratio); 7838 } 7839 return icon; 7840 } 7841 } 7842 }; 7843 const ButtonComponent = { 7844 extends: IconComponent, 7845 mixins: [I18n], 7846 beforeConnect() { 7847 const button = this.$el.closest("a,button"); 7848 attr(button, "role", this.role !== null && isTag(button, "a") ? "button" : this.role); 7849 const label = this.t("label"); 7850 if (label && !hasAttr(button, "aria-label")) { 7851 attr(button, "aria-label", label); 7852 } 7853 } 7854 }; 7855 const Slidenav = { 7856 extends: ButtonComponent, 7857 beforeConnect() { 7858 addClass(this.$el, "uk-slidenav"); 7859 const icon = this.$props.icon; 7860 this.icon = hasClass(this.$el, "uk-slidenav-large") ? `${icon}-large` : icon; 7861 } 7862 }; 7863 const NavbarToggleIcon = { 7864 extends: ButtonComponent, 7865 i18n: { label: "Open menu" } 7866 }; 7867 const Close = { 7868 extends: ButtonComponent, 7869 i18n: { label: "Close" }, 7870 beforeConnect() { 7871 this.icon = `close-${hasClass(this.$el, "uk-close-large") ? "large" : "icon"}`; 7872 } 7873 }; 7874 const Marker = { 7875 extends: ButtonComponent, 7876 i18n: { label: "Open" } 7877 }; 7878 const Totop = { 7879 extends: ButtonComponent, 7880 i18n: { label: "Back to top" } 7881 }; 7882 const PaginationNext = { 7883 extends: ButtonComponent, 7884 i18n: { label: "Next page" }, 7885 data: { role: null } 7886 }; 7887 const PaginationPrevious = { 7888 extends: ButtonComponent, 7889 i18n: { label: "Previous page" }, 7890 data: { role: null } 7891 }; 7892 const parsed = {}; 7893 function install$1(UIkit) { 7894 UIkit.icon.add = (name, svg) => { 7895 const added = isString(name) ? { [name]: svg } : name; 7896 each(added, (svg2, name2) => { 7897 icons[name2] = svg2; 7898 delete parsed[name2]; 7899 }); 7900 if (UIkit._initialized) { 7901 apply( 7902 document.body, 7903 (el) => each(UIkit.getComponents(el), (cmp) => { 7904 cmp.$options.isIcon && cmp.icon in added && cmp.$reset(); 7905 }) 7906 ); 7907 } 7908 }; 7909 } 7910 function getIcon(icon) { 7911 if (!icons[icon]) { 7912 return null; 7913 } 7914 if (!parsed[icon]) { 7915 parsed[icon] = $((icons[applyRtl(icon)] || icons[icon]).trim()); 7916 } 7917 return parsed[icon].cloneNode(true); 7918 } 7919 function applyRtl(icon) { 7920 return isRtl ? swap(swap(icon, "left", "right"), "previous", "next") : icon; 7921 } 7922 7923 const nativeLazyLoad = inBrowser && "loading" in HTMLImageElement.prototype; 7924 var img = { 7925 args: "dataSrc", 7926 props: { 7927 dataSrc: String, 7928 sources: String, 7929 margin: String, 7930 target: String,
vendor: 5,057 bytes, lines 7931-8102
7931 loading: String 7932 }, 7933 data: { 7934 dataSrc: "", 7935 sources: false, 7936 margin: "50%", 7937 target: false, 7938 loading: "lazy" 7939 }, 7940 connected() { 7941 if (this.loading !== "lazy") { 7942 this.load(); 7943 return; 7944 } 7945 if (nativeLazyLoad && isImg(this.$el)) { 7946 this.$el.loading = "lazy"; 7947 setSrcAttrs(this.$el); 7948 } 7949 ensureSrcAttribute(this.$el); 7950 }, 7951 disconnected() { 7952 if (this.img) { 7953 this.img.onload = ""; 7954 } 7955 delete this.img; 7956 }, 7957 observe: intersection({ 7958 target: ({ $el, $props }) => [$el, ...queryAll($props.target, $el)], 7959 handler(entries, observer) { 7960 this.load(); 7961 observer.disconnect(); 7962 }, 7963 options: ({ margin }) => ({ rootMargin: margin }), 7964 filter: ({ loading }) => loading === "lazy" 7965 }), 7966 methods: { 7967 load() { 7968 if (this.img) { 7969 return this.img; 7970 } 7971 const image = isImg(this.$el) ? this.$el : getImageFromElement(this.$el, this.dataSrc, this.sources); 7972 removeAttr(image, "loading"); 7973 setSrcAttrs(this.$el, image.currentSrc); 7974 return this.img = image; 7975 } 7976 } 7977 }; 7978 function setSrcAttrs(el, src) { 7979 if (isImg(el)) { 7980 const parentNode = parent(el); 7981 const elements = isTag(parentNode, "picture") ? children(parentNode) : [el]; 7982 elements.forEach((el2) => setSourceProps(el2, el2)); 7983 } else if (src) { 7984 const change = !includes(el.style.backgroundImage, src); 7985 if (change) { 7986 css(el, "backgroundImage", `url(${escape(src)})`); 7987 trigger(el, createEvent("load", false)); 7988 } 7989 } 7990 } 7991 const srcProps = ["data-src", "data-srcset", "sizes"]; 7992 function setSourceProps(sourceEl, targetEl) { 7993 for (const prop of srcProps) { 7994 const value = data(sourceEl, prop); 7995 if (value) { 7996 attr(targetEl, prop.replace(/^(data-)+/, ""), value); 7997 } 7998 } 7999 } 8000 function getImageFromElement(el, src, sources) { 8001 const img = new Image(); 8002 wrapInPicture(img, sources); 8003 setSourceProps(el, img); 8004 img.onload = () => { 8005 setSrcAttrs(el, img.currentSrc); 8006 }; 8007 attr(img, "src", src); 8008 return img; 8009 } 8010 function wrapInPicture(img, sources) { 8011 sources = parseSources(sources); 8012 if (sources.length) { 8013 const picture = fragment("<picture>"); 8014 for (const attrs of sources) { 8015 const source = fragment("<source>"); 8016 attr(source, attrs); 8017 append(picture, source); 8018 } 8019 append(picture, img); 8020 } 8021 } 8022 function parseSources(sources) { 8023 if (!sources) { 8024 return []; 8025 } 8026 if (startsWith(sources, "[")) { 8027 try { 8028 sources = JSON.parse(sources); 8029 } catch (e) { 8030 sources = []; 8031 } 8032 } else { 8033 sources = parseOptions(sources); 8034 } 8035 if (!isArray(sources)) { 8036 sources = [sources]; 8037 } 8038 return sources.filter((source) => !isEmpty(source)); 8039 } 8040 function ensureSrcAttribute(el) { 8041 if (isImg(el) && !hasAttr(el, "src")) { 8042 attr(el, "src", 'data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"></svg>'); 8043 } 8044 } 8045 function isImg(el) { 8046 return isTag(el, "img"); 8047 } 8048 8049 var leader = { 8050 mixins: [Class, Media], 8051 props: { 8052 fill: String 8053 }, 8054 data: { 8055 fill: "", 8056 clsWrapper: "uk-leader-fill", 8057 clsHide: "uk-leader-hide", 8058 attrFill: "data-fill" 8059 }, 8060 computed: { 8061 fill: ({ fill }, $el) => fill || css($el, "--uk-leader-fill-content") 8062 }, 8063 connected() { 8064 [this.wrapper] = wrapInner(this.$el, `<span class="${this.clsWrapper}">`); 8065 }, 8066 disconnected() { 8067 unwrap(this.wrapper.childNodes); 8068 }, 8069 observe: resize(), 8070 update: { 8071 read() { 8072 const width = Math.trunc(this.$el.offsetWidth / 2); 8073 return { 8074 width, 8075 fill: this.fill, 8076 hide: !this.matchMedia 8077 }; 8078 }, 8079 write({ width, fill, hide }) { 8080 toggleClass(this.wrapper, this.clsHide, hide); 8081 attr(this.wrapper, this.attrFill, new Array(width).join(fill)); 8082 }, 8083 events: ["resize"] 8084 } 8085 }; 8086 8087 var modal = { 8088 install, 8089 mixins: [Modal], 8090 data: { 8091 clsPage: "uk-modal-page", 8092 selPanel: ".uk-modal-dialog", 8093 selClose: ".uk-modal-close, .uk-modal-close-default, .uk-modal-close-outside, .uk-modal-close-full" 8094 }, 8095 events: [ 8096 { 8097 name: "show", 8098 self: true, 8099 handler() { 8100 if (hasClass(this.panel, "uk-margin-auto-vertical")) { 8101 addClass(this.$el, "uk-flex"); 8102 } else {
vendor: 4,085 bytes, lines 8103-8210
8103 css(this.$el, "display", "block"); 8104 } 8105 height(this.$el); 8106 } 8107 }, 8108 { 8109 name: "hidden", 8110 self: true, 8111 handler() { 8112 css(this.$el, "display", ""); 8113 removeClass(this.$el, "uk-flex"); 8114 } 8115 } 8116 ] 8117 }; 8118 function install({ modal }) { 8119 modal.dialog = function(content, options) { 8120 const dialog = modal( 8121 `<div class="uk-modal"> <div class="uk-modal-dialog">${content}</div> </div>`, 8122 { stack: true, role: "alertdialog", ...options } 8123 ); 8124 dialog.show(); 8125 on( 8126 dialog.$el, 8127 "hidden", 8128 async () => { 8129 await Promise.resolve(); 8130 dialog.$destroy(true); 8131 }, 8132 { self: true } 8133 ); 8134 return dialog; 8135 }; 8136 modal.alert = function(message, options) { 8137 return openDialog( 8138 ({ i18n }) => `<div class="uk-modal-body">${isString(message) ? message : html(message)}</div> <div class="uk-modal-footer uk-text-right"> <button class="uk-button uk-button-primary uk-modal-close" autofocus>${i18n.ok}</button> </div>`, 8139 options 8140 ); 8141 }; 8142 modal.confirm = function(message, options) { 8143 return openDialog( 8144 ({ i18n }) => `<form> <div class="uk-modal-body">${isString(message) ? message : html(message)}</div> <div class="uk-modal-footer uk-text-right"> <button class="uk-button uk-button-default uk-modal-close" type="button">${i18n.cancel}</button> <button class="uk-button uk-button-primary" autofocus>${i18n.ok}</button> </div> </form>`, 8145 options, 8146 () => Promise.reject() 8147 ); 8148 }; 8149 modal.prompt = function(message, value, options) { 8150 const promise = openDialog( 8151 ({ i18n }) => `<form class="uk-form-stacked"> <div class="uk-modal-body"> <label>${isString(message) ? message : html(message)}</label> <input class="uk-input" value="${value || ""}" autofocus> </div> <div class="uk-modal-footer uk-text-right"> <button class="uk-button uk-button-default uk-modal-close" type="button">${i18n.cancel}</button> <button class="uk-button uk-button-primary">${i18n.ok}</button> </div> </form>`, 8152 options, 8153 () => null, 8154 () => input.value 8155 ); 8156 const { $el } = promise.dialog; 8157 const input = $("input", $el); 8158 on($el, "show", () => input.select()); 8159 return promise; 8160 }; 8161 modal.i18n = { 8162 ok: "Ok", 8163 cancel: "Cancel" 8164 }; 8165 function openDialog(tmpl, options, hideFn = noop, submitFn = noop) { 8166 options = { 8167 bgClose: false, 8168 escClose: true, 8169 ...options, 8170 i18n: { ...modal.i18n, ...options == null ? void 0 : options.i18n } 8171 }; 8172 const dialog = modal.dialog(tmpl(options), options); 8173 return assign( 8174 new Promise((resolve) => { 8175 const off = on(dialog.$el, "hide", () => resolve(hideFn())); 8176 on(dialog.$el, "submit", "form", (e) => { 8177 e.preventDefault(); 8178 resolve(submitFn(dialog)); 8179 off(); 8180 dialog.hide(); 8181 }); 8182 }), 8183 { dialog } 8184 ); 8185 } 8186 } 8187 8188 var nav = { 8189 extends: Accordion, 8190 data: { 8191 targets: "> .uk-parent", 8192 toggle: "> a", 8193 content: "> ul" 8194 } 8195 }; 8196 8197 var navbar = { 8198 extends: Dropnav, 8199 props: { 8200 dropbarTransparentMode: Boolean 8201 }, 8202 data: { 8203 clsDrop: "uk-navbar-dropdown", 8204 selNavItem: ".uk-navbar-nav > li > a,a.uk-navbar-item,button.uk-navbar-item,.uk-navbar-item a,.uk-navbar-item button,.uk-navbar-toggle", 8205 // Simplify with :where() selector once browser target is Safari 14+ 8206 selTransparentTarget: '[class*="uk-section"]', 8207 dropbarTransparentMode: false 8208 }, 8209 computed: { 8210 navbarContainer: (_, $el) => $el.closest(".uk-navbar-container"),
8211 dropbarOffset: ({ dropbarTransparentMode }, $el) => dropbarTransparentMode === "behind" ? $el.offsetHeight : 0 8212 }, 8213 watch: { 8214 items() { 8215 const justify = hasClass(this.$el, "uk-navbar-justify"); 8216 for (const container of $$( 8217 ".uk-navbar-nav, .uk-navbar-left, .uk-navbar-right", 8218 this.$el 8219 )) { 8220 css( 8221 container, 8222 "flexGrow", 8223 justify ? $$( 8224 ".uk-navbar-nav > li > a, .uk-navbar-item, .uk-navbar-toggle", 8225 container 8226 ).length : "" 8227 ); 8228 } 8229 } 8230 }, 8231 disconnect() { 8232 var _a; 8233 (_a = this._colorListener) == null ? void 0 : _a.call(this); 8234 }, 8235 observe: [ 8236 mutation({ 8237 target: ({ navbarContainer }) => navbarContainer, 8238 handler: "registerColorListener", 8239 options: { attributes: true, attributeFilter: ["class"], attributeOldValue: true } 8240 }), 8241 intersection({ 8242 handler(records) { 8243 this._isIntersecting = records[0].isIntersecting; 8244 this.registerColorListener(); 8245 }, 8246 args: { intersecting: false } 8247 }) 8248 ], 8249 events: [ 8250 { 8251 name: "show", 8252 el() { 8253 return this.dropContainer; 8254 }, 8255 handler({ target }) { 8256 const transparentMode = this.getTransparentMode(target); 8257 if (!transparentMode || this._mode) { 8258 return; 8259 } 8260 const storePrevColor = () => this._mode = removeClasses(this.navbarContainer, "uk-light", "uk-dark"); 8261 if (transparentMode === "behind") { 8262 const mode = getDropbarBehindColor(this.$el); 8263 if (mode) { 8264 storePrevColor(); 8265 addClass(this.navbarContainer, `uk-${mode}`); 8266 } 8267 } 8268 if (transparentMode === "remove") { 8269 storePrevColor(); 8270 removeClass(this.navbarContainer, "uk-navbar-transparent"); 8271 } 8272 } 8273 }, 8274 { 8275 name: "hide", 8276 el() { 8277 return this.dropContainer; 8278 }, 8279 async handler({ target }) { 8280 const transparentMode = this.getTransparentMode(target); 8281 if (!transparentMode || !this._mode) { 8282 return; 8283 } 8284 await awaitMacroTask(); 8285 if (this.getActive()) { 8286 return; 8287 } 8288 if (transparentMode === "behind") { 8289 const mode = getDropbarBehindColor(this.$el); 8290 if (mode) { 8291 removeClass(this.navbarContainer, `uk-${mode}`); 8292 } 8293 } 8294 addClass(this.navbarContainer, this._mode); 8295 if (transparentMode === "remove") { 8296 addClass(this.navbarContainer, "uk-navbar-transparent"); 8297 } 8298 this._mode = null; 8299 } 8300 } 8301 ], 8302 methods: { 8303 getTransparentMode(el) { 8304 if (!this.navbarContainer) { 8305 return; 8306 } 8307 if (this.dropbar && this.isDropbarDrop(el)) { 8308 return this.dropbarTransparentMode; 8309 } 8310 const drop = this.getDropdown(el); 8311 if (!drop || !hasClass(el, "uk-dropbar")) { 8312 return; 8313 } 8314 return drop.inset ? "behind" : "remove"; 8315 }, 8316 registerColorListener() { 8317 const active = this._isIntersecting && hasClass(this.navbarContainer, "uk-navbar-transparent") && !isWithinMixBlendMode(this.navbarContainer) && !$$(".uk-drop", this.dropContainer).map(this.getDropdown).some( 8318 (drop) => drop.isToggled() && (drop.inset || this.getTransparentMode(drop.$el) === "behind") 8319 ); 8320 if (this._colorListener) { 8321 if (!active) { 8322 this._colorListener(); 8323 this._colorListener = null; 8324 } 8325 return; 8326 } 8327 if (!active) { 8328 return; 8329 } 8330 this._colorListener = listenForPositionChange(this.navbarC
8330ontainer, () => { 8331 const { left, top, height } = offset(this.navbarContainer); 8332 const startPoint = { x: left, y: Math.max(0, top) + height / 2 }; 8333 const target = $$(this.selTransparentTarget).find( 8334 (target2) => pointInRect(startPoint, offset(target2)) 8335 ); 8336 const color = css(target, "--uk-navbar-color"); 8337 if (color) { 8338 replaceClass(this.navbarContainer, "uk-light,uk-dark", `uk-${color}`); 8339 } 8340 }); 8341 } 8342 } 8343 }; 8344 function removeClasses(el, ...classes) { 8345 for (const cls of classes) { 8346 if (hasClass(el, cls)) { 8347 removeClass(el, cls); 8348 return cls; 8349 } 8350 } 8351 } 8352 async function awaitMacroTask() { 8353 return new Promise((resolve) => setTimeout(resolve)); 8354 } 8355 function getDropbarBehindColor(el) { 8356 return css(el, "--uk-navbar-dropbar-behind-color"); 8357 } 8358 function listenForPositionChange(el, handler) { 8359 const parent2 = scrollParent(el, true); 8360 const scrollEl = parent2 === document.documentElement ? document : parent2; 8361 const off = on(scrollEl, "scroll", handler, { passive: true }); 8362 const observer = observeResize([el, parent2], handler); 8363 return () => { 8364 off(); 8365 observer.disconnect(); 8366 }; 8367 } 8368 function isWithinMixBlendMode(el) { 8369 do { 8370 if (css(el, "mixBlendMode") !== "normal") { 8371 return true; 8372 } 8373 } while (el = parent(el)); 8374 } 8375 8376 var offcanvas = { 8377 mixins: [Modal], 8378 args: "mode", 8379 props: { 8380 mode: String, 8381 flip: Boolean, 8382 overlay: Boolean, 8383 swiping: Boolean 8384 }, 8385 data: { 8386 mode: "slide", 8387 flip: false, 8388 overlay: false, 8389 clsPage: "uk-offcanvas-page", 8390 clsContainer: "uk-offcanvas-container", 8391 selPanel: ".uk-offcanvas-bar", 8392 clsFlip: "uk-offcanvas-flip", 8393 clsContainerAnimation: "uk-offcanvas-container-animation", 8394 clsSidebarAnimation: "uk-offcanvas-bar-animation", 8395 clsMode: "uk-offcanvas", 8396 clsOverlay: "uk-offcanvas-overlay", 8397 selClose: ".uk-offcanvas-close", 8398 container: false, 8399 swiping: true 8400 }, 8401 computed: { 8402 clsFlip: ({ flip, clsFlip }) => flip ? clsFlip : "", 8403 clsOverlay: ({ overlay, clsOverlay }) => overlay ? clsOverlay : "", 8404 clsMode: ({ mode, clsMode }) => `${clsMode}-${mode}`, 8405 clsSidebarAnimation: ({ mode, clsSidebarAnimation }) => mode === "none" || mode === "reveal" ? "" : clsSidebarAnimation, 8406 clsContainerAnimation: ({ mode, clsContainerAnimation }) => mode !== "push" && mode !== "reveal" ? "" : clsContainerAnimation, 8407 transitionElement({ mode }) { 8408 return mode === "reveal" ? parent(this.panel) : this.panel; 8409 } 8410 }, 8411 observe: swipe({ filter: ({ swiping }) => swiping }), 8412 update: { 8413 read() { 8414 if (this.isToggled() && !isVisible(this.$el)) { 8415 this.hide(); 8416 } 8417 }, 8418 events: ["resize"] 8419 }, 8420 events: [ 8421 { 8422 name: "touchmove", 8423 self: true, 8424 passive: false, 8425 filter() { 8426 return this.overlay; 8427 }, 8428 handler(e) { 8429 e.cancelable && e.preventDefault(); 8430 } 8431 }, 8432 { 8433 name: "show", 8434 self: true, 8435 handler() { 8436 if (this.mode === "reveal" && !hasClass(parent(this.panel), this.clsMode)) { 8437 wrapAll(this.panel, "<div>"); 8438 addClass(parent(this.panel), this.clsMode); 8439 } 8440 const { body, scrollingElement } = document; 8441 addClass(body, this.clsContainer, this.clsFlip); 8442 css(body, "touch-action", "pan-y pinch-zoom"); 8443 css(this.$el, "display", "block"); 8444 css(this.panel, "maxWidth", scrollingElement.clientWidth); 8445 addClass(this.$el, this.clsOverlay); 8446 addClass( 8447 this.panel, 8448 this.clsSidebarAnimation, 8449 this.mode === "reveal" ? "" : this.clsMode 8450 ); 8451 height(body); 8452 addClass(body, this.clsContainerAnimation); 8453 this.clsContainerAnimation && suppressUserScale(); 8454 } 8455 }, 8456 { 8457 name: "hide", 8458 self: true, 8459 handler() { 8460 removeClass(document.body, this.clsContainerAnimation); 8461 css(document.body, "touch-action", ""); 8462 } 8463 }, 8464 { 8465 name: "hidden", 8466 self: true, 8467 handler() { 8468 this.clsContainerAnimation && resumeUserScale(); 8469 if (this.mode === "reveal") { 8470 unwrap(this.panel); 8471 } 8472 removeClass(this.panel, this.clsSidebarAnimation, this.clsMode); 8473 removeClass(this.$el, this.clsOverlay);
vendor: 7,079 bytes, lines 8474-8708
8474 css(this.$el, "display", ""); 8475 css(this.panel, "maxWidth", ""); 8476 removeClass(document.body, this.clsContainer, this.clsFlip); 8477 } 8478 }, 8479 { 8480 name: "swipeLeft swipeRight", 8481 handler(e) { 8482 if (this.isToggled() && endsWith(e.type, "Left") ^ this.flip) { 8483 this.hide(); 8484 } 8485 } 8486 } 8487 ] 8488 }; 8489 function suppressUserScale() { 8490 getViewport().content += ",user-scalable=0"; 8491 } 8492 function resumeUserScale() { 8493 const viewport = getViewport(); 8494 viewport.content = viewport.content.replace(/,user-scalable=0$/, ""); 8495 } 8496 function getViewport() { 8497 return $('meta[name="viewport"]', document.head) || append(document.head, '<meta name="viewport">'); 8498 } 8499 8500 var overflowAuto = { 8501 mixins: [Class], 8502 props: { 8503 selContainer: String, 8504 selContent: String, 8505 minHeight: Number 8506 }, 8507 data: { 8508 selContainer: ".uk-modal", 8509 selContent: ".uk-modal-dialog", 8510 minHeight: 150 8511 }, 8512 computed: { 8513 container: ({ selContainer }, $el) => $el.closest(selContainer), 8514 content: ({ selContent }, $el) => $el.closest(selContent) 8515 }, 8516 observe: resize({ 8517 target: ({ container, content }) => [container, content] 8518 }), 8519 update: { 8520 read() { 8521 if (!this.content || !this.container || !isVisible(this.$el)) { 8522 return false; 8523 } 8524 return { 8525 max: Math.max( 8526 this.minHeight, 8527 height(this.container) - (dimensions$1(this.content).height - height(this.$el)) 8528 ) 8529 }; 8530 }, 8531 write({ max }) { 8532 css(this.$el, { minHeight: this.minHeight, maxHeight: max }); 8533 }, 8534 events: ["resize"] 8535 } 8536 }; 8537 8538 var responsive = { 8539 props: ["width", "height"], 8540 connected() { 8541 addClass(this.$el, "uk-responsive-width"); 8542 }, 8543 observe: resize({ 8544 target: ({ $el }) => [$el, parent($el)] 8545 }), 8546 update: { 8547 read() { 8548 return isVisible(this.$el) && this.width && this.height ? { width: width(parent(this.$el)), height: this.height } : false; 8549 }, 8550 write(dim) { 8551 height( 8552 this.$el, 8553 Dimensions.contain( 8554 { 8555 height: this.height, 8556 width: this.width 8557 }, 8558 dim 8559 ).height 8560 ); 8561 }, 8562 events: ["resize"] 8563 } 8564 }; 8565 8566 var scroll = { 8567 props: { 8568 offset: Number 8569 }, 8570 data: { 8571 offset: 0 8572 }, 8573 connected() { 8574 registerClick(this); 8575 }, 8576 disconnected() { 8577 unregisterClick(this); 8578 }, 8579 methods: { 8580 async scrollTo(el) { 8581 el = el && $(el) || document.body; 8582 if (trigger(this.$el, "beforescroll", [this, el])) { 8583 await scrollIntoView(el, { offset: this.offset }); 8584 trigger(this.$el, "scrolled", [this, el]); 8585 } 8586 } 8587 } 8588 }; 8589 const instances = /* @__PURE__ */ new Set(); 8590 function registerClick(cmp) { 8591 if (!instances.size) { 8592 on(document, "click", clickHandler); 8593 } 8594 instances.add(cmp); 8595 } 8596 function unregisterClick(cmp) { 8597 instances.delete(cmp); 8598 if (!instances.size) { 8599 off(document, "click", clickHandler); 8600 } 8601 } 8602 function clickHandler(e) { 8603 if (e.defaultPrevented) { 8604 return; 8605 } 8606 for (const instance of instances) { 8607 if (instance.$el.contains(e.target) && isSameSiteAnchor(instance.$el)) { 8608 e.preventDefault(); 8609 if (window.location.href !== instance.$el.href) { 8610 window.history.pushState({}, "", instance.$el.href); 8611 } 8612 instance.scrollTo(getTargetedElement(instance.$el)); 8613 } 8614 } 8615 } 8616 8617 var scrollspy = { 8618 args: "cls", 8619 props: { 8620 cls: String, 8621 target: String, 8622 hidden: Boolean, 8623 margin: String, 8624 repeat: Boolean, 8625 delay: Number 8626 }, 8627 data: () => ({ 8628 cls: "", 8629 target: false, 8630 hidden: true, 8631 margin: "-1px", 8632 repeat: false, 8633 delay: 0, 8634 inViewClass: "uk-scrollspy-inview" 8635 }), 8636 computed: { 8637 elements: ({ target }, $el) => target ? $$(target, $el) : [$el] 8638 }, 8639 watch: { 8640 elements(elements) { 8641 if (this.hidden) { 8642 css(filter$1(elements, `:not(.${this.inViewClass})`), "opacity", 0); 8643 } 8644 } 8645 }, 8646 connected() { 8647 this.elementData = /* @__PURE__ */ new Map(); 8648 }, 8649 disconnected() { 8650 for (const [el, state] of this.elementData.entries()) { 8651 removeClass(el, this.inViewClass, (state == null ? void 0 : state.cls) || ""); 8652 } 8653 delete this.elementData; 8654 }, 8655 observe: intersection({ 8656 target: ({ elements }) => elements, 8657 handler(records) { 8658 const elements = this.elementData; 8659 for (const { target: el, isIntersecting } of records) { 8660 if (!elements.has(el)) { 8661 elements.set(el, { 8662 cls: data(el, "uk-scrollspy-class") || this.cls 8663 }); 8664 } 8665 const state = elements.get(el); 8666 if (!this.repeat && state.show) { 8667 continue; 8668 } 8669 state.show = isIntersecting; 8670 } 8671 this.$emit(); 8672 }, 8673 options: ({ margin }) => ({ rootMargin: margin }), 8674 args: { intersecting: false } 8675 }), 8676 update: [ 8677 { 8678 write(data) { 8679 for (const [el, state] of this.elementData.entries()) { 8680 if (state.show && !state.inview && !state.queued) { 8681 state.queued = true; 8682 data.promise = (data.promise || Promise.resolve()).then(() => new Promise((resolve) => setTimeout(resolve, this.delay))).then(() => { 8683 this.toggle(el, true); 8684 setTimeout(() => { 8685 state.queued = false; 8686 this.$emit(); 8687 }, 300); 8688 }); 8689 } else if (!state.show && state.inview && !state.queued && this.repeat) { 8690 this.toggle(el, false); 8691 } 8692 } 8693 } 8694 } 8695 ], 8696 methods: { 8697 toggle(el, inview) { 8698 var _a; 8699 const state = this.elementData.get(el); 8700 if (!state) { 8701 return; 8702 } 8703 (_a = state.off) == null ? void 0 : _a.call(state); 8704 css(el, "opacity", !inview && this.hidden ? 0 : ""); 8705 toggleClass(el, this.inViewClass, inview); 8706 toggleClass(el, state.cls); 8707 if (/\buk-animation-/.test(state.cls)) { 8708 const removeAnimationClasses = () =>
8708 removeClasses$1(el, "uk-animation-[\\w-]+"); 8709 if (inview) { 8710 state.off = once(el, "animationcancel animationend", removeAnimationClasses); 8711 } else { 8712 removeAnimationClasses(); 8713 } 8714 } 8715 trigger(el, inview ? "inview" : "outview"); 8716 state.inview = inview; 8717 this.$update(el); 8718 } 8719 } 8720 }; 8721 8722 var scrollspyNav = { 8723 props: { 8724 cls: String, 8725 closest: Boolean, 8726 scroll: Boolean, 8727 overflow: Boolean, 8728 offset: Number 8729 }, 8730 data: { 8731 cls: "uk-active", 8732 closest: false, 8733 scroll: false, 8734 overflow: true, 8735 offset: 0 8736 }, 8737 computed: { 8738 links: (_, $el) => $$('a[href*="#"]', $el).filter((el) => el.hash && isSameSiteAnchor(el)), 8739 elements({ closest: selector }) { 8740 return this.links.map((el) => el.closest(selector || "*")); 8741 } 8742 }, 8743 watch: { 8744 links(links) { 8745 if (this.scroll) { 8746 this.$create("scroll", links, { offset: this.offset }); 8747 } 8748 } 8749 }, 8750 observe: [intersection(), scroll$1()], 8751 update: [ 8752 { 8753 read() { 8754 const targets = this.links.map(getTargetedElement).filter(Boolean); 8755 const { length } = targets; 8756 if (!length || !isVisible(this.$el)) { 8757 return false; 8758 } 8759 const scrollElement = scrollParent(targets, true); 8760 const { scrollTop, scrollHeight } = scrollElement; 8761 const viewport = offsetViewport(scrollElement); 8762 const max = scrollHeight - viewport.height; 8763 let active = false; 8764 if (scrollTop === max) { 8765 active = length - 1; 8766 } else { 8767 for (let i = 0; i < targets.length; i++) { 8768 const fixedEl = getCoveringElement(targets[i]); 8769 const offsetBy = this.offset + (fixedEl ? offset(fixedEl).height : 0); 8770 if (offset(targets[i]).top - viewport.top - offsetBy > 0) { 8771 break; 8772 } 8773 active = +i; 8774 } 8775 if (active === false && this.overflow) { 8776 active = 0; 8777 } 8778 } 8779 return { active }; 8780 }, 8781 write({ active }) { 8782 const changed = active !== false && !hasClass(this.elements[active], this.cls); 8783 this.links.forEach((el) => el.blur()); 8784 for (let i = 0; i < this.elements.length; i++) { 8785 toggleClass(this.elements[i], this.cls, +i === active); 8786 } 8787 if (changed) { 8788 trigger(this.$el, "active", [active, this.elements[active]]); 8789 } 8790 }, 8791 events: ["scroll", "resize"] 8792 } 8793 ] 8794 }; 8795 8796 var sticky = { 8797 mixins: [Class, Media], 8798 props: { 8799 position: String, 8800 top: null, 8801 bottom: null, 8802 start: null, 8803 end: null, 8804 offset: String, 8805 overflowFlip: Boolean, 8806 animation: String, 8807 clsActive: String, 8808 clsInactive: String, 8809 clsFixed: String, 8810 clsBelow: String, 8811 selTarget: String, 8812 showOnUp: Boolean, 8813 targetOffset: Number 8814 }, 8815 data: { 8816 position: "top", 8817 top: false, 8818 bottom: false, 8819 start: false, 8820 end: false, 8821 offset: 0, 8822 overflowFlip: false, 8823 animation: "", 8824 clsActive: "uk-active", 8825 clsInactive: "", 8826 clsFixed: "uk-sticky-fixed", 8827 clsBelow: "uk-sticky-below", 8828 selTarget: "", 8829 showOnUp: false, 8830 targetOffset: false 8831 }, 8832 computed: { 8833 selTarget: ({ selTarget }, $el) => selTarget && $(selTarget, $el) || $el 8834 }, 8835 connected() { 8836 this.start = coerce(this.start || this.top); 8837 this.end = coerce(this.end || this.bottom); 8838 this.placeholder = $("+ .uk-sticky-placeholder", this.$el) || $('<div class="uk-sticky-placeholder"></div>'); 8839 this.isFixed = false; 8840 this.setActive(false); 8841 }, 8842 beforeDisconnect() { 8843 if (this.isFixed) { 8844 this.hide(); 8845 removeClass(this.selTarget, this.clsInactive); 8846 } 8847 reset(this.$el); 8848 remove$1(this.placeholder); 8849 this.placeholder = null; 8850 }, 8851 observe: [ 8852 viewport(), 8853 scroll$1({ target: () => document.scrollingElement }), 8854 resize({ target: ({ $el }) => [$el, document.scrollingElement] }) 8855 ], 8856 events: [ 8857 { 8858 name: "load hashchange popstate", 8859 el() { 8860 return window; 8861 }, 8862 filter() { 8863 return this.targetOffset !== false; 8864 }, 8865 handler() { 8866 const { scrollingElement } = document; 8867 if (!location.hash || scrollingElement.scrollTop === 0) { 8868 return; 8869 } 8870 setTimeout(() => {
8871 const targetOffset = offset($(location.hash)); 8872 const elOffset = offset(this.$el); 8873 if (this.isFixed && intersectRect(targetOffset, elOffset)) { 8874 scrollingElement.scrollTop = targetOffset.top - elOffset.height - toPx(this.targetOffset, "height", this.placeholder) - toPx(this.offset, "height", this.placeholder); 8875 } 8876 }); 8877 } 8878 }, 8879 { 8880 name: "transitionstart", 8881 handler() { 8882 this.transitionInProgress = once( 8883 this.$el, 8884 "transitionend transitioncancel", 8885 () => this.transitionInProgress = null 8886 ); 8887 } 8888 } 8889 ], 8890 update: [ 8891 { 8892 read({ height: height$1, width, margin, sticky }) { 8893 this.inactive = !this.matchMedia || !isVisible(this.$el); 8894 if (this.inactive) { 8895 return; 8896 } 8897 const hide = this.isFixed && !this.transitionInProgress; 8898 if (hide) { 8899 preventTransition(this.$el); 8900 this.hide(); 8901 } 8902 if (!this.active) { 8903 ({ height: height$1, width } = offset(this.$el)); 8904 margin = css(this.$el, "margin"); 8905 } 8906 if (hide) { 8907 this.show(); 8908 } 8909 const viewport2 = toPx("100vh", "height"); 8910 const dynamicViewport = height(window); 8911 const maxScrollHeight = Math.max( 8912 0, 8913 document.scrollingElement.scrollHeight - viewport2 8914 ); 8915 let position = this.position; 8916 if (this.overflowFlip && height$1 > viewport2) { 8917 position = position === "top" ? "bottom" : "top"; 8918 } 8919 const referenceElement = this.isFixed ? this.placeholder : this.$el; 8920 let offset$1 = toPx(this.offset, "height", sticky ? this.$el : referenceElement); 8921 if (position === "bottom" && (height$1 < dynamicViewport || this.overflowFlip)) { 8922 offset$1 += dynamicViewport - height$1; 8923 } 8924 const overflow = this.overflowFlip ? 0 : Math.max(0, height$1 + offset$1 - viewport2); 8925 const topOffset = offset(referenceElement).top; 8926 const elHeight = offset(this.$el).height; 8927 const start = (this.start === false ? topOffset : parseProp(this.start, this.$el, topOffset)) - offset$1; 8928 const end = this.end === false ? maxScrollHeight : Math.min( 8929 maxScrollHeight, 8930 parseProp(this.end, this.$el, topOffset + height$1, true) - elHeight - offset$1 + overflow 8931 ); 8932 sticky = maxScrollHeight && !this.showOnUp && start + offset$1 === topOffset && end === Math.min( 8933 maxScrollHeight, 8934 parseProp("!*", this.$el, 0, true) - elHeight - offset$1 + overflow 8935 ) && css(parent(this.$el), "overflowY") === "visible"; 8936 return { 8937 start, 8938 end, 8939 offset: offset$1, 8940 overflow, 8941 topOffset, 8942 height: height$1, 8943 elHeight, 8944 width, 8945 margin, 8946 top: offsetPosition(referenceElement)[0], 8947 sticky 8948 }; 8949 }, 8950 write({ height, width, margin, offset, sticky }) { 8951 if (this.inactive || sticky || !this.isFixed) { 8952 reset(this.$el); 8953 } 8954 if (this.inactive) { 8955 return; 8956 } 8957 if (sticky) { 8958 height = width = margin = 0; 8959 css(this.$el, { position: "sticky", top: offset }); 8960 } 8961 const { placeholder } = this; 8962 css(placeholder, { height, width, margin }); 8963 if (!document.contains(placeholder)) { 8964 placeholder.hidden = true; 8965 } 8966 (sticky ? before : after)(this.$el, placeholder); 8967 }, 8968 events: ["resize"] 8969 }, 8970 { 8971 read({ 8972 scroll: prevScroll = 0, 8973 dir: prevDir = "down", 8974 overflow, 8975 overflowScroll = 0, 8976 start, 8977 end 8978 }) { 8979 const scroll2 = document.scrollingElement.scrollTop; 8980 const dir = prevScroll <= scroll2 ? "down" : "up"; 8981 return { 8982 dir, 8983 prevDir, 8984 scroll: scroll2, 8985 prevScroll, 8986 offsetParentTop: offset( 8987 (this.isFixed ? this.placeholder : this.$el).offsetParent 8988 ).top, 8989 overflowScroll: clamp( 8990 overflowScroll + clamp(scroll2, start, end) - clamp(prevScroll, start, end), 8991 0, 8992 overflow 8993 ) 8994 }; 8995 }, 8996 write(data, types) { 8997 const isScrollUpdate = types.has("scroll"); 8998 const { 8999 initTimestamp = 0, 9000 dir, 9001 prevDir, 9002 scroll: scroll2, 9003 prevScroll = 0, 9004 top, 9005 start, 9006 topOffset, 9007 height 9008 } = data; 9009 if (scroll2 < 0 || scroll2 === prevScroll && isScrollUpdate || this.showOnUp && !isScrollUpdate && !this.isFixed) { 9010 return; 9011 } 9012 const now = Date.now(); 9013 if (now - initTimestamp > 300 || dir !== prevDir) { 9014 data.initScroll = scroll2; 9015 data.initTimestamp = now; 9016 } 9017 if (this.showOnUp && !this.isFixed && Math.abs(data.initScroll - scroll2) <= 30 && Math.abs(prevScroll - scroll2) <= 10) { 9018 return; 9019 } 9020 if (this.inactive || scroll2 < start || this.showOnUp && (scroll2 <= start || dir === "down" && isScrollUpdate || dir === "up" && !this.isFixed && scroll2 <= topOffset + height)) { 9021 if (!this.isFixed) { 9022 if (Animation.inProgress(this.$el) && top > scroll2) { 9023 Animation.cancel(this.$el); 9024 this.hide(); 9025 } 9026 return; 9027 } 9028 if (this.animation && scroll2 > topOffset) { 9029 if (hasClass(this.$el, "uk-animation-leave")) { 9030 return; 9031 } 9032 Animation.out(this.$el, this.animation).then(() => this.hide(), noop); 9033 } else { 9034 this.hide(); 9035 } 9036 } else if (this.isFixed) { 9037 this.update(); 9038 } else if (this.animation && scroll2 > topOffset) { 9039 this.show(); 9040 Animation.in(this.$el, this.animation).catch(noop); 9041 } else { 9042 preventTransition(this.selTarget); 9043 this.show(); 9044 } 9045 }, 9046 events: ["resize", "resizeViewport", "scroll"] 9047 } 9048 ], 9049 methods: { 9050 show() { 9051 this.isFixed = true; 9052 this.update(); 9053 this.placeholder.hidden = false; 9054 }, 9055 hide() { 9056 const { offset, sticky } = this._data; 9057 this.setActive(false); 9058 removeClass(this.$el, this.clsFixed, this.clsBelow);
vendor: 4,968 bytes, lines 9059-9219
9059 if (sticky) { 9060 css(this.$el, "top", offset); 9061 } else { 9062 css(this.$el, { 9063 position: "", 9064 top: "", 9065 width: "", 9066 marginTop: "" 9067 }); 9068 } 9069 this.placeholder.hidden = true; 9070 this.isFixed = false; 9071 }, 9072 update() { 9073 let { 9074 width, 9075 scroll: scroll2 = 0, 9076 overflow, 9077 overflowScroll = 0, 9078 start, 9079 end, 9080 offset, 9081 topOffset, 9082 height, 9083 elHeight, 9084 offsetParentTop, 9085 sticky 9086 } = this._data; 9087 const active = start !== 0 || scroll2 > start; 9088 if (!sticky) { 9089 let position = "fixed"; 9090 if (scroll2 > end) { 9091 offset += end - offsetParentTop + overflowScroll - overflow; 9092 position = "absolute"; 9093 } 9094 css(this.$el, { position, width, marginTop: 0 }, "important"); 9095 } 9096 css(this.$el, "top", offset - overflowScroll); 9097 this.setActive(active); 9098 toggleClass( 9099 this.$el, 9100 this.clsBelow, 9101 scroll2 > topOffset + (sticky ? Math.min(height, elHeight) : height) 9102 ); 9103 addClass(this.$el, this.clsFixed); 9104 }, 9105 setActive(active) { 9106 const prev = this.active; 9107 this.active = active; 9108 if (active) { 9109 replaceClass(this.selTarget, this.clsInactive, this.clsActive); 9110 prev !== active && trigger(this.$el, "active"); 9111 } else { 9112 replaceClass(this.selTarget, this.clsActive, this.clsInactive); 9113 prev !== active && trigger(this.$el, "inactive"); 9114 } 9115 } 9116 } 9117 }; 9118 function parseProp(value, el, propOffset, padding) { 9119 if (!value) { 9120 return 0; 9121 } 9122 if (isNumeric(value) || isString(value) && value.match(/^-?\d/)) { 9123 return propOffset + toPx(value, "height", el, true); 9124 } else { 9125 const refElement = value === true ? parent(el) : query(value, el); 9126 return offset(refElement).bottom - (padding && (refElement == null ? void 0 : refElement.contains(el)) ? toFloat(css(refElement, "paddingBottom")) : 0); 9127 } 9128 } 9129 function coerce(value) { 9130 if (value === "true") { 9131 return true; 9132 } else if (value === "false") { 9133 return false; 9134 } 9135 return value; 9136 } 9137 function reset(el) { 9138 css(el, { position: "", top: "", marginTop: "", width: "" }); 9139 } 9140 function preventTransition(el) { 9141 addClass(el, "uk-transition-disable"); 9142 requestAnimationFrame(() => removeClass(el, "uk-transition-disable")); 9143 } 9144 9145 var svg = { 9146 mixins: [Svg], 9147 args: "src", 9148 props: { 9149 src: String, 9150 icon: String, 9151 attributes: "list", 9152 strokeAnimation: Boolean 9153 }, 9154 data: { 9155 strokeAnimation: false 9156 }, 9157 observe: [ 9158 mutation({ 9159 async handler() { 9160 const svg = await this.svg; 9161 if (svg) { 9162 applyAttributes.call(this, svg); 9163 } 9164 }, 9165 options: { 9166 attributes: true, 9167 attributeFilter: ["id", "class", "style"] 9168 } 9169 }) 9170 ], 9171 async connected() { 9172 if (includes(this.src, "#")) { 9173 [this.src, this.icon] = this.src.split("#"); 9174 } 9175 const svg = await this.svg; 9176 if (svg) { 9177 applyAttributes.call(this, svg); 9178 if (this.strokeAnimation) { 9179 applyAnimation(svg); 9180 } 9181 } 9182 }, 9183 methods: { 9184 async getSvg() { 9185 if (isTag(this.$el, "img") && !this.$el.complete && this.$el.loading === "lazy") { 9186 return new Promise( 9187 (resolve) => once(this.$el, "load", () => resolve(this.getSvg())) 9188 ); 9189 } 9190 return parseSVG(await loadSVG(this.src), this.icon) || Promise.reject("SVG not found."); 9191 } 9192 } 9193 }; 9194 function applyAttributes(el) { 9195 const { $el } = this; 9196 addClass(el, attr($el, "class"), "uk-svg"); 9197 for (let i = 0; i < $el.style.length; i++) { 9198 const prop = $el.style[i]; 9199 css(el, prop, css($el, prop)); 9200 } 9201 for (const attribute in this.attributes) { 9202 const [prop, value] = this.attributes[attribute].split(":", 2); 9203 attr(el, prop, value); 9204 } 9205 if (!this.$el.id) { 9206 removeAttr(el, "id"); 9207 } 9208 } 9209 const loadSVG = memoize(async (src) => { 9210 if (src) { 9211 if (startsWith(src, "data:")) { 9212 return decodeURIComponent(src.split(",")[1]); 9213 } else { 9214 return (await fetch(src)).text(); 9215 } 9216 } else { 9217 return Promise.reject(); 9218 } 9219 });
9220 function parseSVG(svg, icon) { 9221 if (icon && includes(svg, "<symbol")) { 9222 svg = parseSymbols(svg)[icon] || svg; 9223 } 9224 svg = $(svg.substr(svg.indexOf("<svg"))); 9225 return (svg == null ? void 0 : svg.hasChildNodes()) && svg; 9226 } 9227 const symbolRe = /<symbol([^]*?id=(['"])(.+?)\2[^]*?<\/)symbol>/g; 9228 const parseSymbols = memoize(function(svg) { 9229 const symbols = {}; 9230 symbolRe.lastIndex = 0; 9231 let match; 9232 while (match = symbolRe.exec(svg)) { 9233 symbols[match[3]] = `<svg ${match[1]}svg>`; 9234 } 9235 return symbols; 9236 }); 9237 function applyAnimation(el) { 9238 const length = getMaxPathLength(el); 9239 if (length) { 9240 css(el, "--uk-animation-stroke", length); 9241 } 9242 } 9243 9244 const selDisabled = ".uk-disabled *, .uk-disabled, [disabled]"; 9245 var Switcher = { 9246 mixins: [Togglable], 9247 args: "connect", 9248 props: { 9249 connect: String, 9250 toggle: String, 9251 itemNav: String, 9252 active: Number, 9253 followFocus: Boolean, 9254 swiping: Boolean 9255 }, 9256 data: { 9257 connect: "~.uk-switcher", 9258 toggle: "> * > :first-child", 9259 itemNav: false, 9260 active: 0, 9261 cls: "uk-active", 9262 attrItem: "uk-switcher-item", 9263 selVertical: ".uk-nav", 9264 followFocus: false, 9265 swiping: true 9266 }, 9267 computed: { 9268 connects: ({ connect }, $el) => queryAll(connect, $el), 9269 connectChildren() { 9270 return this.connects.map((el) => children(el)).flat(); 9271 }, 9272 toggles: ({ toggle }, $el) => $$(toggle, $el), 9273 children(_, $el) { 9274 return children($el).filter( 9275 (child) => this.toggles.some((toggle) => child.contains(toggle)) 9276 ); 9277 } 9278 }, 9279 watch: { 9280 connects(connects) { 9281 if (this.swiping) { 9282 css(connects, "touchAction", "pan-y pinch-zoom"); 9283 } 9284 this.$emit(); 9285 }, 9286 connectChildren() { 9287 let index = Math.max(0, this.index()); 9288 for (const el of this.connects) { 9289 children(el).forEach((child, i) => toggleClass(child, this.cls, i === index)); 9290 } 9291 this.$emit(); 9292 }, 9293 toggles(toggles) { 9294 this.$emit(); 9295 const active = this.index(); 9296 this.show(~active ? active : toggles[this.active] || toggles[0]); 9297 } 9298 }, 9299 connected() { 9300 attr(this.$el, "role", "tablist"); 9301 }, 9302 observe: [ 9303 lazyload({ targets: ({ connectChildren }) => connectChildren }), 9304 swipe({ target: ({ connects }) => connects, filter: ({ swiping }) => swiping }) 9305 ], 9306 events: [ 9307 { 9308 name: "click keydown", 9309 delegate() { 9310 return this.toggle; 9311 }, 9312 handler(e) { 9313 if (!matches(e.current, selDisabled) && (e.type === "click" || e.keyCode === keyMap.SPACE)) { 9314 e.preventDefault(); 9315 this.show(e.current); 9316 } 9317 } 9318 }, 9319 { 9320 name: "keydown", 9321 delegate() { 9322 return this.toggle; 9323 }, 9324 handler(e) { 9325 const { current, keyCode } = e; 9326 const isVertical = matches(this.$el, this.selVertical); 9327 let i = keyCode === keyMap.HOME ? 0 : keyCode === keyMap.END ? "last" : keyCode === keyMap.LEFT && !isVertical || keyCode === keyMap.UP && isVertical ? "previous" : keyCode === keyMap.RIGHT && !isVertical || keyCode === keyMap.DOWN && isVertical ? "next" : -1; 9328 if (~i) { 9329 e.preventDefault(); 9330 const toggles = this.toggles.filter((el) => !matches(el, selDisabled)); 9331 const next = toggles[getIndex(i, toggles, toggles.indexOf(current))]; 9332 next.focus(); 9333 if (this.followFocus) { 9334 this.show(next); 9335 } 9336 } 9337 } 9338 }, 9339 { 9340 name: "click", 9341 el() { 9342 return this.connects.concat(this.itemNav ? queryAll(this.itemNav, this.$el) : []); 9343 }, 9344 delegate() { 9345 return `[${this.attrItem}],[data-${this.attrItem}]`; 9346 }, 9347 handler(e) { 9348 if (e.target.closest("a,button")) { 9349 e.preventDefault(); 9350 this.show(data(e.current, this.attrItem)); 9351 } 9352 } 9353 }, 9354 { 9355 name: "swipeRight swipeLeft", 9356 filter() { 9357 return this.swiping; 9358 }, 9359 el() { 9360 return this.connects; 9361 }, 9362 handler({ type }) { 9363 this.show(endsWith(type, "Left") ? "next" : "previous"); 9364 } 9365 } 9366 ], 9367 update() { 9368 var _a; 9369 attr(this.connects, "role", "presentation"); 9370 attr(children(this.$el), "role", "presentation"); 9371 for (const index in this.toggles) { 9372 const toggle = this.toggles[index]; 9373 const item = (_a = this.connects[0]) == null ? void 0 : _a.children[index]; 9374 attr(toggle, "role", "tab"); 9375 if (!item) { 9376 continue; 9377 } 9378 toggle.id = generateId(this, toggle); 9379 item.id = generateId(this, item); 9380 attr(toggle, "aria-controls", item.id); 9381 attr(item, { role: "tabpanel", "aria-labelledby": toggle.id }); 9382 } 9383 attr(this.$el, "aria-orientation", matches(this.$el, this.selVertical) ? "vertical" : null); 9384 }, 9385 methods: { 9386 index() { 9387 return findIndex(this.children, (el) => hasClass(el, this.cls)); 9388 }, 9389 show(item) { 9390 const toggles = this.toggles.filter((el) => !matches(el, selDisabled)); 9391 const prev = this.index(); 9392 const next = getIndex( 9393 !isNode(item) || includes(toggles, item) ? item : 0, 9394 toggles, 9395 getIndex(this.toggles[prev], toggles) 9396 ); 9397 const active = getIndex(toggles[next], this.toggles);
vendor: 6,918 bytes, lines 9398-9610
9398 this.children.forEach((child, i) => { 9399 toggleClass(child, this.cls, active === i); 9400 attr(this.toggles[i], { 9401 "aria-selected": active === i, 9402 tabindex: active === i ? null : -1 9403 }); 9404 }); 9405 const animate = prev >= 0 && prev !== next; 9406 this.connects.forEach(async ({ children: children2 }) => { 9407 const actives = toArray(children2).filter( 9408 (child, i) => i !== active && hasClass(child, this.cls) 9409 ); 9410 await this.toggleElement(actives, false, animate); 9411 await this.toggleElement(children2[active], true, animate); 9412 }); 9413 } 9414 } 9415 }; 9416 9417 var tab = { 9418 mixins: [Class], 9419 extends: Switcher, 9420 props: { 9421 media: Boolean 9422 }, 9423 data: { 9424 media: 960, 9425 attrItem: "uk-tab-item", 9426 selVertical: ".uk-tab-left,.uk-tab-right" 9427 }, 9428 connected() { 9429 const cls = hasClass(this.$el, "uk-tab-left") ? "uk-tab-left" : hasClass(this.$el, "uk-tab-right") ? "uk-tab-right" : false; 9430 if (cls) { 9431 this.$create("toggle", this.$el, { cls, mode: "media", media: this.media }); 9432 } 9433 } 9434 }; 9435 9436 const KEY_SPACE = 32; 9437 var toggle = { 9438 mixins: [Media, Togglable], 9439 args: "target", 9440 props: { 9441 href: String, 9442 target: null, 9443 mode: "list", 9444 queued: Boolean 9445 }, 9446 data: { 9447 href: false, 9448 target: false, 9449 mode: "click", 9450 queued: true 9451 }, 9452 computed: { 9453 target({ target }, $el) { 9454 target = queryAll(target || $el.hash, $el); 9455 return target.length ? target : [$el]; 9456 } 9457 }, 9458 connected() { 9459 if (!includes(this.mode, "media")) { 9460 if (!isFocusable(this.$el)) { 9461 attr(this.$el, "tabindex", "0"); 9462 } 9463 if (!this.cls && isTag(this.$el, "a")) { 9464 attr(this.$el, "role", "button"); 9465 } 9466 } 9467 }, 9468 observe: lazyload({ target: ({ target }) => target }), 9469 events: [ 9470 { 9471 name: pointerDown$1, 9472 filter() { 9473 return includes(this.mode, "hover"); 9474 }, 9475 handler(e) { 9476 this._preventClick = null; 9477 if (!isTouch(e) || isBoolean(this._showState) || this.$el.disabled) { 9478 return; 9479 } 9480 trigger(this.$el, "focus"); 9481 once( 9482 document, 9483 pointerDown$1, 9484 () => trigger(this.$el, "blur"), 9485 true, 9486 (e2) => !this.$el.contains(e2.target) 9487 ); 9488 if (includes(this.mode, "click")) { 9489 this._preventClick = true; 9490 } 9491 } 9492 }, 9493 { 9494 // mouseenter mouseleave are added because of Firefox bug, 9495 // where pointerleave is triggered immediately after pointerenter on scroll 9496 name: `mouseenter mouseleave ${pointerEnter} ${pointerLeave} focus blur`, 9497 filter() { 9498 return includes(this.mode, "hover"); 9499 }, 9500 handler(e) { 9501 if (isTouch(e) || this.$el.disabled) { 9502 return; 9503 } 9504 const show = includes(["mouseenter", pointerEnter, "focus"], e.type); 9505 const expanded = this.isToggled(this.target); 9506 if (!show && (!isBoolean(this._showState) || e.type !== "blur" && matches(this.$el, ":focus") || e.type === "blur" && matches(this.$el, ":hover"))) { 9507 if (expanded === this._showState) { 9508 this._showState = null; 9509 } 9510 return; 9511 } 9512 if (show && isBoolean(this._showState) && expanded !== this._showState) { 9513 return; 9514 } 9515 this._showState = show ? expanded : null; 9516 this.toggle(`toggle${show ? "show" : "hide"}`); 9517 } 9518 }, 9519 { 9520 name: "keydown", 9521 filter() { 9522 return includes(this.mode, "click") && !isTag(this.$el, "input"); 9523 }, 9524 handler(e) { 9525 if (e.keyCode === KEY_SPACE) { 9526 e.preventDefault(); 9527 this.$el.click(); 9528 } 9529 } 9530 }, 9531 { 9532 name: "click", 9533 filter() { 9534 return ["click", "hover"].some((mode) => includes(this.mode, mode)); 9535 }, 9536 handler(e) { 9537 let link; 9538 if (this._preventClick || e.target.closest('a[href="#"], a[href=""]') || (link = e.target.closest("a[href]")) && (!this.isToggled(this.target) || link.hash && matches(this.target, link.hash))) { 9539 e.preventDefault(); 9540 } 9541 if (!this._preventClick && includes(this.mode, "click")) { 9542 this.toggle(); 9543 } 9544 } 9545 }, 9546 { 9547 name: "mediachange", 9548 filter() { 9549 return includes(this.mode, "media"); 9550 }, 9551 el() { 9552 return this.target; 9553 }, 9554 handler(e, mediaObj) { 9555 if (mediaObj.matches ^ this.isToggled(this.target)) { 9556 this.toggle(); 9557 } 9558 } 9559 } 9560 ], 9561 methods: { 9562 async toggle(type) { 9563 if (!trigger(this.target, type || "toggle", [this])) { 9564 return; 9565 } 9566 if (hasAttr(this.$el, "aria-expanded")) { 9567 attr(this.$el, "aria-expanded", !this.isToggled(this.target)); 9568 } 9569 if (!this.queued) { 9570 return this.toggleElement(this.target); 9571 } 9572 const leaving = this.target.filter((el) => hasClass(el, this.clsLeave)); 9573 if (leaving.length) { 9574 for (const el of this.target) { 9575 const isLeaving = includes(leaving, el); 9576 this.toggleElement(el, isLeaving, isLeaving); 9577 } 9578 return; 9579 } 9580 const toggled = this.target.filter(this.isToggled); 9581 if (await this.toggleElement(toggled, false)) { 9582 await this.toggleElement( 9583 this.target.filter((el) => !includes(toggled, el)), 9584 true 9585 ); 9586 } 9587 } 9588 } 9589 }; 9590 9591 var components = /*#__PURE__*/Object.freeze({ 9592 __proto__: null, 9593 Accordion: Accordion, 9594 Alert: alert, 9595 Close: Close, 9596 Cover: cover, 9597 Drop: drop, 9598 DropParentIcon: IconComponent, 9599 Dropdown: drop, 9600 Dropnav: Dropnav, 9601 FormCustom: formCustom, 9602 Grid: grid, 9603 HeightMatch: heightMatch, 9604 HeightViewport: heightViewport, 9605 Icon: Icon, 9606 Img: img, 9607 Leader: leader, 9608 Margin: Margin, 9609 Marker: Marker, 9610 Modal: modal,
9611 Nav: nav, 9612 NavParentIcon: NavParentIcon, 9613 Navbar: navbar, 9614 NavbarParentIcon: IconComponent, 9615 NavbarToggleIcon: NavbarToggleIcon, 9616 Offcanvas: offcanvas, 9617 OverflowAuto: overflowAuto, 9618 OverlayIcon: IconComponent, 9619 PaginationNext: PaginationNext, 9620 PaginationPrevious: PaginationPrevious, 9621 Responsive: responsive, 9622 Scroll: scroll, 9623 Scrollspy: scrollspy, 9624 ScrollspyNav: scrollspyNav, 9625 SearchIcon: Search, 9626 SlidenavNext: Slidenav, 9627 SlidenavPrevious: Slidenav, 9628 Spinner: Spinner, 9629 Sticky: sticky, 9630 Svg: svg, 9631 Switcher: Switcher, 9632 Tab: tab, 9633 Toggle: toggle, 9634 Totop: Totop, 9635 Video: Video 9636 }); 9637 9638 each(components, (component, name) => App.component(name, component)); 9639 boot(App); 9640 9641 each(components$1, (component, name) => App.component(name, component)); 9642 9643 return App; 9644 9645}));
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.