| /*! |
| * Bootstrap index.js v5.2.1 (https://getbootstrap.com/) |
| * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) |
| * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) |
| */ |
| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : |
| (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Index = {})); |
| })(this, (function (exports) { 'use strict'; |
| |
| /** |
| * -------------------------------------------------------------------------- |
| * Bootstrap (v5.2.1): util/index.js |
| * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) |
| * -------------------------------------------------------------------------- |
| */ |
| const MAX_UID = 1000000; |
| const MILLISECONDS_MULTIPLIER = 1000; |
| const TRANSITION_END = 'transitionend'; // Shout-out Angus Croll (https://goo.gl/pxwQGp) |
| |
| const toType = object => { |
| if (object === null || object === undefined) { |
| return `${object}`; |
| } |
| |
| return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase(); |
| }; |
| /** |
| * Public Util API |
| */ |
| |
| |
| const getUID = prefix => { |
| do { |
| prefix += Math.floor(Math.random() * MAX_UID); |
| } while (document.getElementById(prefix)); |
| |
| return prefix; |
| }; |
| |
| const getSelector = element => { |
| let selector = element.getAttribute('data-bs-target'); |
| |
| if (!selector || selector === '#') { |
| let hrefAttribute = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, |
| // so everything starting with `#` or `.`. If a "real" URL is used as the selector, |
| // `document.querySelector` will rightfully complain it is invalid. |
| // See https://github.com/twbs/bootstrap/issues/32273 |
| |
| if (!hrefAttribute || !hrefAttribute.includes('#') && !hrefAttribute.startsWith('.')) { |
| return null; |
| } // Just in case some CMS puts out a full URL with the anchor appended |
| |
| |
| if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) { |
| hrefAttribute = `#${hrefAttribute.split('#')[1]}`; |
| } |
| |
| selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null; |
| } |
| |
| return selector; |
| }; |
| |
| const getSelectorFromElement = element => { |
| const selector = getSelector(element); |
| |
| if (selector) { |
| return document.querySelector(selector) ? selector : null; |
| } |
| |
| return null; |
| }; |
| |
| const getElementFromSelector = element => { |
| const selector = getSelector(element); |
| return selector ? document.querySelector(selector) : null; |
| }; |
| |
| const getTransitionDurationFromElement = element => { |
| if (!element) { |
| return 0; |
| } // Get transition-duration of the element |
| |
| |
| let { |
| transitionDuration, |
| transitionDelay |
| } = window.getComputedStyle(element); |
| const floatTransitionDuration = Number.parseFloat(transitionDuration); |
| const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found |
| |
| if (!floatTransitionDuration && !floatTransitionDelay) { |
| return 0; |
| } // If multiple durations are defined, take the first |
| |
| |
| transitionDuration = transitionDuration.split(',')[0]; |
| transitionDelay = transitionDelay.split(',')[0]; |
| return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; |
| }; |
| |
| const triggerTransitionEnd = element => { |
| element.dispatchEvent(new Event(TRANSITION_END)); |
| }; |
| |
| const isElement = object => { |
| if (!object || typeof object !== 'object') { |
| return false; |
| } |
| |
| if (typeof object.jquery !== 'undefined') { |
| object = object[0]; |
| } |
| |
| return typeof object.nodeType !== 'undefined'; |
| }; |
| |
| const getElement = object => { |
| // it's a jQuery object or a node element |
| if (isElement(object)) { |
| return object.jquery ? object[0] : object; |
| } |
| |
| if (typeof object === 'string' && object.length > 0) { |
| return document.querySelector(object); |
| } |
| |
| return null; |
| }; |
| |
| const isVisible = element => { |
| if (!isElement(element) || element.getClientRects().length === 0) { |
| return false; |
| } |
| |
| const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible'; // Handle `details` element as its content may falsie appear visible when it is closed |
| |
| const closedDetails = element.closest('details:not([open])'); |
| |
| if (!closedDetails) { |
| return elementIsVisible; |
| } |
| |
| if (closedDetails !== element) { |
| const summary = element.closest('summary'); |
| |
| if (summary && summary.parentNode !== closedDetails) { |
| return false; |
| } |
| |
| if (summary === null) { |
| return false; |
| } |
| } |
| |
| return elementIsVisible; |
| }; |
| |
| const isDisabled = element => { |
| if (!element || element.nodeType !== Node.ELEMENT_NODE) { |
| return true; |
| } |
| |
| if (element.classList.contains('disabled')) { |
| return true; |
| } |
| |
| if (typeof element.disabled !== 'undefined') { |
| return element.disabled; |
| } |
| |
| return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; |
| }; |
| |
| const findShadowRoot = element => { |
| if (!document.documentElement.attachShadow) { |
| return null; |
| } // Can find the shadow root otherwise it'll return the document |
| |
| |
| if (typeof element.getRootNode === 'function') { |
| const root = element.getRootNode(); |
| return root instanceof ShadowRoot ? root : null; |
| } |
| |
| if (element instanceof ShadowRoot) { |
| return element; |
| } // when we don't find a shadow root |
| |
| |
| if (!element.parentNode) { |
| return null; |
| } |
| |
| return findShadowRoot(element.parentNode); |
| }; |
| |
| const noop = () => {}; |
| /** |
| * Trick to restart an element's animation |
| * |
| * @param {HTMLElement} element |
| * @return void |
| * |
| * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation |
| */ |
| |
| |
| const reflow = element => { |
| element.offsetHeight; // eslint-disable-line no-unused-expressions |
| }; |
| |
| const getjQuery = () => { |
| if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { |
| return window.jQuery; |
| } |
| |
| return null; |
| }; |
| |
| const DOMContentLoadedCallbacks = []; |
| |
| const onDOMContentLoaded = callback => { |
| if (document.readyState === 'loading') { |
| // add listener on the first call when the document is in loading state |
| if (!DOMContentLoadedCallbacks.length) { |
| document.addEventListener('DOMContentLoaded', () => { |
| for (const callback of DOMContentLoadedCallbacks) { |
| callback(); |
| } |
| }); |
| } |
| |
| DOMContentLoadedCallbacks.push(callback); |
| } else { |
| callback(); |
| } |
| }; |
| |
| const isRTL = () => document.documentElement.dir === 'rtl'; |
| |
| const defineJQueryPlugin = plugin => { |
| onDOMContentLoaded(() => { |
| const $ = getjQuery(); |
| /* istanbul ignore if */ |
| |
| if ($) { |
| const name = plugin.NAME; |
| const JQUERY_NO_CONFLICT = $.fn[name]; |
| $.fn[name] = plugin.jQueryInterface; |
| $.fn[name].Constructor = plugin; |
| |
| $.fn[name].noConflict = () => { |
| $.fn[name] = JQUERY_NO_CONFLICT; |
| return plugin.jQueryInterface; |
| }; |
| } |
| }); |
| }; |
| |
| const execute = callback => { |
| if (typeof callback === 'function') { |
| callback(); |
| } |
| }; |
| |
| const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => { |
| if (!waitForTransition) { |
| execute(callback); |
| return; |
| } |
| |
| const durationPadding = 5; |
| const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding; |
| let called = false; |
| |
| const handler = ({ |
| target |
| }) => { |
| if (target !== transitionElement) { |
| return; |
| } |
| |
| called = true; |
| transitionElement.removeEventListener(TRANSITION_END, handler); |
| execute(callback); |
| }; |
| |
| transitionElement.addEventListener(TRANSITION_END, handler); |
| setTimeout(() => { |
| if (!called) { |
| triggerTransitionEnd(transitionElement); |
| } |
| }, emulatedDuration); |
| }; |
| /** |
| * Return the previous/next element of a list. |
| * |
| * @param {array} list The list of elements |
| * @param activeElement The active element |
| * @param shouldGetNext Choose to get next or previous element |
| * @param isCycleAllowed |
| * @return {Element|elem} The proper element |
| */ |
| |
| |
| const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => { |
| const listLength = list.length; |
| let index = list.indexOf(activeElement); // if the element does not exist in the list return an element |
| // depending on the direction and if cycle is allowed |
| |
| if (index === -1) { |
| return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0]; |
| } |
| |
| index += shouldGetNext ? 1 : -1; |
| |
| if (isCycleAllowed) { |
| index = (index + listLength) % listLength; |
| } |
| |
| return list[Math.max(0, Math.min(index, listLength - 1))]; |
| }; |
| |
| exports.defineJQueryPlugin = defineJQueryPlugin; |
| exports.execute = execute; |
| exports.executeAfterTransition = executeAfterTransition; |
| exports.findShadowRoot = findShadowRoot; |
| exports.getElement = getElement; |
| exports.getElementFromSelector = getElementFromSelector; |
| exports.getNextActiveElement = getNextActiveElement; |
| exports.getSelectorFromElement = getSelectorFromElement; |
| exports.getTransitionDurationFromElement = getTransitionDurationFromElement; |
| exports.getUID = getUID; |
| exports.getjQuery = getjQuery; |
| exports.isDisabled = isDisabled; |
| exports.isElement = isElement; |
| exports.isRTL = isRTL; |
| exports.isVisible = isVisible; |
| exports.noop = noop; |
| exports.onDOMContentLoaded = onDOMContentLoaded; |
| exports.reflow = reflow; |
| exports.toType = toType; |
| exports.triggerTransitionEnd = triggerTransitionEnd; |
| |
| Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } }); |
| |
| })); |
| //# sourceMappingURL=index.js.map |