prometheus
7023 строки · 223.1 Кб
1/*!2* Bootstrap v4.5.2 (https://getbootstrap.com/)3* Copyright 2011-2020 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)4* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)5*/6(function (global, factory) {7typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery')) :8typeof define === 'function' && define.amd ? define(['exports', 'jquery'], factory) :9(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.bootstrap = {}, global.jQuery));10}(this, (function (exports, $) { 'use strict';11* --------------------------------------------------------------------------56* Bootstrap (v4.5.2): util.js57* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)58* --------------------------------------------------------------------------59*/60/**61* ------------------------------------------------------------------------62* Private TransitionEnd Helpers63* ------------------------------------------------------------------------64*/65* --------------------------------------------------------------------------113* Public Util Api114* --------------------------------------------------------------------------115*/116* ------------------------------------------------------------------------232* Constants233* ------------------------------------------------------------------------234*/235* ------------------------------------------------------------------------251* Class Definition252* ------------------------------------------------------------------------253*/254* ------------------------------------------------------------------------366* Data Api implementation367* ------------------------------------------------------------------------368*/369* ------------------------------------------------------------------------374* jQuery375* ------------------------------------------------------------------------376*/377* ------------------------------------------------------------------------388* Constants389* ------------------------------------------------------------------------390*/391* ------------------------------------------------------------------------413* Class Definition414* ------------------------------------------------------------------------415*/416* ------------------------------------------------------------------------504* Data Api implementation505* ------------------------------------------------------------------------506*/507* ------------------------------------------------------------------------567* jQuery568* ------------------------------------------------------------------------569*/570* ------------------------------------------------------------------------581* Constants582* ------------------------------------------------------------------------583*/584* ------------------------------------------------------------------------653* Class Definition654* ------------------------------------------------------------------------655*/656* ------------------------------------------------------------------------1137* Data Api implementation1138* ------------------------------------------------------------------------1139*/1140* ------------------------------------------------------------------------1154* jQuery1155* ------------------------------------------------------------------------1156*/1157* ------------------------------------------------------------------------1168* Constants1169* ------------------------------------------------------------------------1170*/1171* ------------------------------------------------------------------------1201* Class Definition1202* ------------------------------------------------------------------------1203*/1204* ------------------------------------------------------------------------1479* Data Api implementation1480* ------------------------------------------------------------------------1481*/1482* ------------------------------------------------------------------------1503* jQuery1504* ------------------------------------------------------------------------1505*/1506* @fileOverview Kickass library to create and place poppers near their reference elements.1517* @version 1.16.11518* @license1519* Copyright (c) 2016 Federico Zivolo and contributors1520*1521* Permission is hereby granted, free of charge, to any person obtaining a copy1522* of this software and associated documentation files (the "Software"), to deal1523* in the Software without restriction, including without limitation the rights1524* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell1525* copies of the Software, and to permit persons to whom the Software is1526* furnished to do so, subject to the following conditions:1527*1528* The above copyright notice and this permission notice shall be included in all1529* copies or substantial portions of the Software.1530*1531* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR1532* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,1533* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE1534* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER1535* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,1536* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE1537* SOFTWARE.1538*/1539var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';1540* Create a debounced version of a method, that's asynchronously deferred1582* but called in the minimum time possible.1583*1584* @method1585* @memberof Popper.Utils1586* @argument {Function} fn1587* @returns {Function}1588*/1589var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;1590* Check if the given variable is a function1593* @method1594* @memberof Popper.Utils1595* @argument {Any} functionToCheck - variable to check1596* @returns {Boolean} answer to: is a function?1597*/1598function isFunction(functionToCheck) {1599var getType = {};1600return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';1601}1602* Get CSS computed property of the given element1605* @method1606* @memberof Popper.Utils1607* @argument {Eement} element1608* @argument {String} property1609*/1610function getStyleComputedProperty(element, property) {1611if (element.nodeType !== 1) {1612return [];1613}1614// NOTE: 1 DOM access here1615var window = element.ownerDocument.defaultView;1616var css = window.getComputedStyle(element, null);1617return property ? css[property] : css;1618}1619* Returns the parentNode or the host of the element1622* @method1623* @memberof Popper.Utils1624* @argument {Element} element1625* @returns {Element} parent1626*/1627function getParentNode(element) {1628if (element.nodeName === 'HTML') {1629return element;1630}1631return element.parentNode || element.host;1632}1633* Returns the scrolling parent of the given element1636* @method1637* @memberof Popper.Utils1638* @argument {Element} element1639* @returns {Element} scroll parent1640*/1641function getScrollParent(element) {1642// Return body, `getScroll` will take care to get the correct `scrollTop` from it1643if (!element) {1644return document.body;1645}1646* Returns the reference node of the reference object, or the reference object itself.1671* @method1672* @memberof Popper.Utils1673* @param {Element|Object} reference - the reference element (the popper will be relative to this)1674* @returns {Element} parent1675*/1676function getReferenceNode(reference) {1677return reference && reference.referenceNode ? reference.referenceNode : reference;1678}1679* Determines if the browser is Internet Explorer1685* @method1686* @memberof Popper.Utils1687* @param {Number} version to check1688* @returns {Boolean} isIE1689*/1690function isIE(version) {1691if (version === 11) {1692return isIE11;1693}1694if (version === 10) {1695return isIE10;1696}1697return isIE11 || isIE10;1698}1699* Returns the offset parent of the given element1702* @method1703* @memberof Popper.Utils1704* @argument {Element} element1705* @returns {Element} offset parent1706*/1707function getOffsetParent(element) {1708if (!element) {1709return document.documentElement;1710}1711* Finds the root node (document, shadowDOM root) of the given element1747* @method1748* @memberof Popper.Utils1749* @argument {Element} node1750* @returns {Element} root node1751*/1752function getRoot(node) {1753if (node.parentNode !== null) {1754return getRoot(node.parentNode);1755}1756* Finds the offset parent common to the two provided nodes1762* @method1763* @memberof Popper.Utils1764* @argument {Element} element11765* @argument {Element} element21766* @returns {Element} common offset parent1767*/1768function findCommonOffsetParent(element1, element2) {1769// This check is needed to avoid errors in case one of the elements isn't defined for any reason1770if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {1771return document.documentElement;1772}1773* Gets the scroll value of the given element in the given side (top and left)1806* @method1807* @memberof Popper.Utils1808* @argument {Element} element1809* @argument {String} side `top` or `left`1810* @returns {number} amount of scrolled pixels1811*/1812function getScroll(element) {1813var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';1814* Sum or subtract the element scroll values (left and top) from a given rect object1829* @method1830* @memberof Popper.Utils1831* @param {Object} rect - Rect object you want to change1832* @param {HTMLElement} element - The element from the function reads the scroll values1833* @param {Boolean} subtract - set to true if you want to subtract the scroll values1834* @return {Object} rect - The modifier rect object1835*/1836function includeScroll(rect, element) {1837var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;1838* Helper to detect borders of a given element1851* @method1852* @memberof Popper.Utils1853* @param {CSSStyleDeclaration} styles1854* Result of `getStyleComputedProperty` on the given element1855* @param {String} axis - `x` or `y`1856* @return {number} borders - The borders size of the given axis1857*/1858* Given element offsets, generate an output similar to getBoundingClientRect1940* @method1941* @memberof Popper.Utils1942* @argument {Object} offsets1943* @returns {Object} ClientRect like output1944*/1945function getClientRect(offsets) {1946return _extends$1({}, offsets, {1947right: offsets.left + offsets.width,1948bottom: offsets.top + offsets.height1949});1950}1951* Get bounding client rect of given element1954* @method1955* @memberof Popper.Utils1956* @param {HTMLElement} element1957* @return {Object} client rect1958*/1959function getBoundingClientRect(element) {1960var rect = {};1961* Check if the given element is fixed or is inside a fixed parent2083* @method2084* @memberof Popper.Utils2085* @argument {Element} element2086* @argument {Element} customContainer2087* @returns {Boolean} answer to "isFixed?"2088*/2089function isFixed(element) {2090var nodeName = element.nodeName;2091if (nodeName === 'BODY' || nodeName === 'HTML') {2092return false;2093}2094if (getStyleComputedProperty(element, 'position') === 'fixed') {2095return true;2096}2097var parentNode = getParentNode(element);2098if (!parentNode) {2099return false;2100}2101return isFixed(parentNode);2102}2103* Finds the first parent of an element that has a transformed property defined2106* @method2107* @memberof Popper.Utils2108* @argument {Element} element2109* @returns {Element} first transformed parent or documentElement2110*/2111* Computed the boundaries limits and return them2126* @method2127* @memberof Popper.Utils2128* @param {HTMLElement} popper2129* @param {HTMLElement} reference2130* @param {number} padding2131* @param {HTMLElement} boundariesElement - Element used to define the boundaries2132* @param {Boolean} fixedPosition - Is in fixed position mode2133* @returns {Object} Coordinates of the boundaries2134*/2135function getBoundaries(popper, reference, padding, boundariesElement) {2136var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;2137* Utility used to transform the `auto` placement to the placement with more2198* available space.2199* @method2200* @memberof Popper.Utils2201* @argument {Object} data - The data object generated by update method2202* @argument {Object} options - Modifiers configuration and options2203* @returns {Object} The data object, properly modified2204*/2205function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {2206var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;2207* Get offsets to the reference element2258* @method2259* @memberof Popper.Utils2260* @param {Object} state2261* @param {Element} popper - the popper element2262* @param {Element} reference - the reference element (the popper will be relative to this)2263* @param {Element} fixedPosition - is in fixed position mode2264* @returns {Object} An object containing the offsets which will be applied to the popper2265*/2266function getReferenceOffsets(state, popper, reference) {2267var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;2268* Get the outer sizes of the given element (offset size + margins)2275* @method2276* @memberof Popper.Utils2277* @argument {Element} element2278* @returns {Object} object containing width and height properties2279*/2280function getOuterSizes(element) {2281var window = element.ownerDocument.defaultView;2282var styles = window.getComputedStyle(element);2283var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);2284var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);2285var result = {2286width: element.offsetWidth + y,2287height: element.offsetHeight + x2288};2289return result;2290}2291* Get the opposite placement of the given one2294* @method2295* @memberof Popper.Utils2296* @argument {String} placement2297* @returns {String} flipped placement2298*/2299function getOppositePlacement(placement) {2300var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };2301return placement.replace(/left|right|bottom|top/g, function (matched) {2302return hash[matched];2303});2304}2305* Get offsets to the popper2308* @method2309* @memberof Popper.Utils2310* @param {Object} position - CSS position the Popper will get applied2311* @param {HTMLElement} popper - the popper element2312* @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)2313* @param {String} placement - one of the valid placement options2314* @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper2315*/2316function getPopperOffsets(popper, referenceOffsets, placement) {2317placement = placement.split('-')[0];2318* Mimics the `find` method of Array2347* @method2348* @memberof Popper.Utils2349* @argument {Array} arr2350* @argument prop2351* @argument value2352* @returns index or -12353*/2354function find(arr, check) {2355// use native find if supported2356if (Array.prototype.find) {2357return arr.find(check);2358}2359* Return the index of the matching object2366* @method2367* @memberof Popper.Utils2368* @argument {Array} arr2369* @argument prop2370* @argument value2371* @returns index or -12372*/2373function findIndex(arr, prop, value) {2374// use native findIndex if supported2375if (Array.prototype.findIndex) {2376return arr.findIndex(function (cur) {2377return cur[prop] === value;2378});2379}2380* Loop trough the list of modifiers and run them in order,2390* each of them will then edit the data object.2391* @method2392* @memberof Popper.Utils2393* @param {dataObject} data2394* @param {Array} modifiers2395* @param {String} ends - Optional modifier name used as stopper2396* @returns {dataObject}2397*/2398function runModifiers(modifiers, data, ends) {2399var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));2400* Updates the position of the popper, computing the new offsets and applying2423* the new style.<br />2424* Prefer `scheduleUpdate` over `update` because of performance reasons.2425* @method2426* @memberof Popper2427*/2428function update() {2429// if popper is destroyed, don't perform any further update2430if (this.state.isDestroyed) {2431return;2432}2433* Helper used to know if the given modifier is enabled.2476* @method2477* @memberof Popper.Utils2478* @returns {Boolean}2479*/2480function isModifierEnabled(modifiers, modifierName) {2481return modifiers.some(function (_ref) {2482var name = _ref.name,2483enabled = _ref.enabled;2484return enabled && name === modifierName;2485});2486}2487* Get the prefixed supported property name2490* @method2491* @memberof Popper.Utils2492* @argument {String} property (camelCase)2493* @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)2494*/2495function getSupportedPropertyName(property) {2496var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];2497var upperProp = property.charAt(0).toUpperCase() + property.slice(1);2498* Destroys the popper.2511* @method2512* @memberof Popper2513*/2514function destroy() {2515this.state.isDestroyed = true;2516* Get the window associated with the element2541* @argument {Element} element2542* @returns {Window}2543*/2544function getWindow(element) {2545var ownerDocument = element.ownerDocument;2546return ownerDocument ? ownerDocument.defaultView : window;2547}2548* Setup needed event listeners used to update the popper position2562* @method2563* @memberof Popper.Utils2564* @private2565*/2566function setupEventListeners(reference, options, state, updateBound) {2567// Resize event listener on window2568state.updateBound = updateBound;2569getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });2570* It will add resize/scroll events and start recalculating2582* position of the popper element when they are triggered.2583* @method2584* @memberof Popper2585*/2586function enableEventListeners() {2587if (!this.state.eventsEnabled) {2588this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);2589}2590}2591* Remove event listeners used to update the popper position2594* @method2595* @memberof Popper.Utils2596* @private2597*/2598function removeEventListeners(reference, state) {2599// Remove resize event listener on window2600getWindow(reference).removeEventListener('resize', state.updateBound);2601* It will remove resize/scroll events and won't recalculate popper position2617* when they are triggered. It also won't trigger `onUpdate` callback anymore,2618* unless you call `update` method manually.2619* @method2620* @memberof Popper2621*/2622function disableEventListeners() {2623if (this.state.eventsEnabled) {2624cancelAnimationFrame(this.scheduleUpdate);2625this.state = removeEventListeners(this.reference, this.state);2626}2627}2628* Tells if a given input is a number2631* @method2632* @memberof Popper.Utils2633* @param {*} input to check2634* @return {Boolean}2635*/2636function isNumeric(n) {2637return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);2638}2639* Set the style to the given popper2642* @method2643* @memberof Popper.Utils2644* @argument {Element} element - Element to apply the style to2645* @argument {Object} styles2646* Object with a list of properties and values which will be applied to the element2647*/2648function setStyles(element, styles) {2649Object.keys(styles).forEach(function (prop) {2650var unit = '';2651// add unit if the value is numeric and is one of the following2652if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {2653unit = 'px';2654}2655element.style[prop] = styles[prop] + unit;2656});2657}2658* Set the attributes to the given popper2661* @method2662* @memberof Popper.Utils2663* @argument {Element} element - Element to apply the attributes to2664* @argument {Object} styles2665* Object with a list of properties and values which will be applied to the element2666*/2667function setAttributes(element, attributes) {2668Object.keys(attributes).forEach(function (prop) {2669var value = attributes[prop];2670if (value !== false) {2671element.setAttribute(prop, attributes[prop]);2672} else {2673element.removeAttribute(prop);2674}2675});2676}2677* @function2680* @memberof Modifiers2681* @argument {Object} data - The data object generated by `update` method2682* @argument {Object} data.styles - List of style properties - values to apply to popper element2683* @argument {Object} data.attributes - List of attribute properties - values to apply to popper element2684* @argument {Object} options - Modifiers configuration and options2685* @returns {Object} The same data object2686*/2687function applyStyle(data) {2688// any property present in `data.styles` will be applied to the popper,2689// in this way we can make the 3rd party modifiers add custom styles to it2690// Be aware, modifiers could override the properties defined in the previous2691// lines of this modifier!2692setStyles(data.instance.popper, data.styles);2693* Set the x-placement attribute before everything else because it could be used2708* to add margins to the popper margins needs to be calculated to get the2709* correct popper offsets.2710* @method2711* @memberof Popper.modifiers2712* @param {HTMLElement} reference - The reference element used to position the popper2713* @param {HTMLElement} popper - The HTML element used as popper2714* @param {Object} options - Popper.js options2715*/2716function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {2717// compute reference element offsets2718var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);2719* @function2736* @memberof Popper.Utils2737* @argument {Object} data - The data object generated by `update` method2738* @argument {Boolean} shouldRound - If the offsets should be rounded at all2739* @returns {Object} The popper's position offsets rounded2740*2741* The tale of pixel-perfect positioning. It's still not 100% perfect, but as2742* good as it can be within reason.2743* Discussion here: https://github.com/FezVrasta/popper.js/pull/7152744*2745* Low DPI screens cause a popper to be blurry if not using full pixels (Safari2746* as well on High DPI screens).2747*2748* Firefox prefers no rounding for positioning and does not have blurriness on2749* high DPI screens.2750*2751* Only horizontal placement and left/right values need to be considered.2752*/2753function getRoundedOffsets(data, shouldRound) {2754var _data$offsets = data.offsets,2755popper = _data$offsets.popper,2756reference = _data$offsets.reference;2757var round = Math.round,2758floor = Math.floor;2759* @function2787* @memberof Modifiers2788* @argument {Object} data - The data object generated by `update` method2789* @argument {Object} options - Modifiers configuration and options2790* @returns {Object} The data object, properly modified2791*/2792function computeStyle(data, options) {2793var x = options.x,2794y = options.y;2795var popper = data.offsets.popper;2796* Helper used to know if the given modifier depends from another one.<br />2885* It checks if the needed modifier is listed and enabled.2886* @method2887* @memberof Popper.Utils2888* @param {Array} modifiers - list of modifiers2889* @param {String} requestingName - name of requesting modifier2890* @param {String} requestedName - name of requested modifier2891* @returns {Boolean}2892*/2893function isModifierRequired(modifiers, requestingName, requestedName) {2894var requesting = find(modifiers, function (_ref) {2895var name = _ref.name;2896return name === requestingName;2897});2898* @function2913* @memberof Modifiers2914* @argument {Object} data - The data object generated by update method2915* @argument {Object} options - Modifiers configuration and options2916* @returns {Object} The data object, properly modified2917*/2918function arrow(data, options) {2919var _data$offsets$arrow;2920* Get the opposite placement variation of the given one2995* @method2996* @memberof Popper.Utils2997* @argument {String} placement variation2998* @returns {String} flipped placement variation2999*/3000function getOppositeVariation(variation) {3001if (variation === 'end') {3002return 'start';3003} else if (variation === 'start') {3004return 'end';3005}3006return variation;3007}3008* List of accepted placements to use as values of the `placement` option.<br />3011* Valid placements are:3012* - `auto`3013* - `top`3014* - `right`3015* - `bottom`3016* - `left`3017*3018* Each placement can have a variation from this list:3019* - `-start`3020* - `-end`3021*3022* Variations are interpreted easily if you think of them as the left to right3023* written languages. Horizontally (`top` and `bottom`), `start` is left and `end`3024* is right.<br />3025* Vertically (`left` and `right`), `start` is top and `end` is bottom.3026*3027* Some valid examples are:3028* - `top-end` (on top of reference, right aligned)3029* - `right-start` (on right of reference, top aligned)3030* - `bottom` (on bottom, centered)3031* - `auto-end` (on the side with more space available, alignment depends by placement)3032*3033* @static3034* @type {Array}3035* @enum {String}3036* @readonly3037* @method placements3038* @memberof Popper3039*/3040var placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];3041* Given an initial placement, returns all the subsequent placements3047* clockwise (or counter-clockwise).3048*3049* @method3050* @memberof Popper.Utils3051* @argument {String} placement - A valid placement (it accepts variations)3052* @argument {Boolean} counter - Set to true to walk the placements counterclockwise3053* @returns {Array} placements including their variations3054*/3055function clockwise(placement) {3056var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;3057* @function3071* @memberof Modifiers3072* @argument {Object} data - The data object generated by update method3073* @argument {Object} options - Modifiers configuration and options3074* @returns {Object} The data object, properly modified3075*/3076function flip(data, options) {3077// if `inner` modifier is enabled, we can't use the `flip` modifier3078if (isModifierEnabled(data.instance.modifiers, 'inner')) {3079return data;3080}3081* @function3168* @memberof Modifiers3169* @argument {Object} data - The data object generated by update method3170* @argument {Object} options - Modifiers configuration and options3171* @returns {Object} The data object, properly modified3172*/3173function keepTogether(data) {3174var _data$offsets = data.offsets,3175popper = _data$offsets.popper,3176reference = _data$offsets.reference;3177* Converts a string containing value + unit into a px value number3197* @function3198* @memberof {modifiers~offset}3199* @private3200* @argument {String} str - Value + unit string3201* @argument {String} measurement - `height` or `width`3202* @argument {Object} popperOffsets3203* @argument {Object} referenceOffsets3204* @returns {Number|String}3205* Value in pixels, or original string if no values were extracted3206*/3207function toValue(str, measurement, popperOffsets, referenceOffsets) {3208// separate value from unit3209var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);3210var value = +split[1];3211var unit = split[2];3212* Parse an `offset` string to extrapolate `x` and `y` numeric offsets.3250* @function3251* @memberof {modifiers~offset}3252* @private3253* @argument {String} offset3254* @argument {Object} popperOffsets3255* @argument {Object} referenceOffsets3256* @argument {String} basePlacement3257* @returns {Array} a two cells array with x and y offsets in numbers3258*/3259function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {3260var offsets = [0, 0];3261* @function3328* @memberof Modifiers3329* @argument {Object} data - The data object generated by update method3330* @argument {Object} options - Modifiers configuration and options3331* @argument {Number|String} options.offset=03332* The offset value as described in the modifier description3333* @returns {Object} The data object, properly modified3334*/3335function offset(data, _ref) {3336var offset = _ref.offset;3337var placement = data.placement,3338_data$offsets = data.offsets,3339popper = _data$offsets.popper,3340reference = _data$offsets.reference;3341* @function3371* @memberof Modifiers3372* @argument {Object} data - The data object generated by `update` method3373* @argument {Object} options - Modifiers configuration and options3374* @returns {Object} The data object, properly modified3375*/3376function preventOverflow(data, options) {3377var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);3378* @function3442* @memberof Modifiers3443* @argument {Object} data - The data object generated by `update` method3444* @argument {Object} options - Modifiers configuration and options3445* @returns {Object} The data object, properly modified3446*/3447function shift(data) {3448var placement = data.placement;3449var basePlacement = placement.split('-')[0];3450var shiftvariation = placement.split('-')[1];3451* @function3475* @memberof Modifiers3476* @argument {Object} data - The data object generated by update method3477* @argument {Object} options - Modifiers configuration and options3478* @returns {Object} The data object, properly modified3479*/3480function hide(data) {3481if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {3482return data;3483}3484* @function3513* @memberof Modifiers3514* @argument {Object} data - The data object generated by `update` method3515* @argument {Object} options - Modifiers configuration and options3516* @returns {Object} The data object, properly modified3517*/3518function inner(data) {3519var placement = data.placement;3520var basePlacement = placement.split('-')[0];3521var _data$offsets = data.offsets,3522popper = _data$offsets.popper,3523reference = _data$offsets.reference;3524* Modifier function, each modifier can have a function of this type assigned3539* to its `fn` property.<br />3540* These functions will be called on each update, this means that you must3541* make sure they are performant enough to avoid performance bottlenecks.3542*3543* @function ModifierFn3544* @argument {dataObject} data - The data object generated by `update` method3545* @argument {Object} options - Modifiers configuration and options3546* @returns {dataObject} The data object, properly modified3547*/3548* Modifiers are plugins used to alter the behavior of your poppers.<br />3551* Popper.js uses a set of 9 modifiers to provide all the basic functionalities3552* needed by the library.3553*3554* Usually you don't want to override the `order`, `fn` and `onLoad` props.3555* All the other properties are configurations that could be tweaked.3556* @namespace modifiers3557*/3558var modifiers = {3559/**3560* Modifier used to shift the popper on the start or end of its reference3561* element.<br />3562* It will read the variation of the `placement` property.<br />3563* It can be one either `-end` or `-start`.3564* @memberof modifiers3565* @inner3566*/3567shift: {3568/** @prop {number} order=100 - Index used to define the order of execution */3569order: 100,3570/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3571enabled: true,3572/** @prop {ModifierFn} */3573fn: shift3574},3575* The `offset` modifier can shift your popper on both its axis.3578*3579* It accepts the following units:3580* - `px` or unit-less, interpreted as pixels3581* - `%` or `%r`, percentage relative to the length of the reference element3582* - `%p`, percentage relative to the length of the popper element3583* - `vw`, CSS viewport width unit3584* - `vh`, CSS viewport height unit3585*3586* For length is intended the main axis relative to the placement of the popper.<br />3587* This means that if the placement is `top` or `bottom`, the length will be the3588* `width`. In case of `left` or `right`, it will be the `height`.3589*3590* You can provide a single value (as `Number` or `String`), or a pair of values3591* as `String` divided by a comma or one (or more) white spaces.<br />3592* The latter is a deprecated method because it leads to confusion and will be3593* removed in v2.<br />3594* Additionally, it accepts additions and subtractions between different units.3595* Note that multiplications and divisions aren't supported.3596*3597* Valid examples are:3598* ```3599* 103600* '10%'3601* '10, 10'3602* '10%, 10'3603* '10 + 10%'3604* '10 - 5vh + 3%'3605* '-10px + 5vh, 5px - 6%'3606* ```3607* > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap3608* > with their reference element, unfortunately, you will have to disable the `flip` modifier.3609* > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).3610*3611* @memberof modifiers3612* @inner3613*/3614offset: {3615/** @prop {number} order=200 - Index used to define the order of execution */3616order: 200,3617/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3618enabled: true,3619/** @prop {ModifierFn} */3620fn: offset,3621/** @prop {Number|String} offset=03622* The offset value as described in the modifier description3623*/3624offset: 03625},3626* Modifier used to prevent the popper from being positioned outside the boundary.3629*3630* A scenario exists where the reference itself is not within the boundaries.<br />3631* We can say it has "escaped the boundaries" — or just "escaped".<br />3632* In this case we need to decide whether the popper should either:3633*3634* - detach from the reference and remain "trapped" in the boundaries, or3635* - if it should ignore the boundary and "escape with its reference"3636*3637* When `escapeWithReference` is set to`true` and reference is completely3638* outside its boundaries, the popper will overflow (or completely leave)3639* the boundaries in order to remain attached to the edge of the reference.3640*3641* @memberof modifiers3642* @inner3643*/3644preventOverflow: {3645/** @prop {number} order=300 - Index used to define the order of execution */3646order: 300,3647/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3648enabled: true,3649/** @prop {ModifierFn} */3650fn: preventOverflow,3651/**3652* @prop {Array} [priority=['left','right','top','bottom']]3653* Popper will try to prevent overflow following these priorities by default,3654* then, it could overflow on the left and on top of the `boundariesElement`3655*/3656priority: ['left', 'right', 'top', 'bottom'],3657/**3658* @prop {number} padding=53659* Amount of pixel used to define a minimum distance between the boundaries3660* and the popper. This makes sure the popper always has a little padding3661* between the edges of its container3662*/3663padding: 5,3664/**3665* @prop {String|HTMLElement} boundariesElement='scrollParent'3666* Boundaries used by the modifier. Can be `scrollParent`, `window`,3667* `viewport` or any DOM element.3668*/3669boundariesElement: 'scrollParent'3670},3671* Modifier used to make sure the reference and its popper stay near each other3674* without leaving any gap between the two. Especially useful when the arrow is3675* enabled and you want to ensure that it points to its reference element.3676* It cares only about the first axis. You can still have poppers with margin3677* between the popper and its reference element.3678* @memberof modifiers3679* @inner3680*/3681keepTogether: {3682/** @prop {number} order=400 - Index used to define the order of execution */3683order: 400,3684/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3685enabled: true,3686/** @prop {ModifierFn} */3687fn: keepTogether3688},3689* This modifier is used to move the `arrowElement` of the popper to make3692* sure it is positioned between the reference element and its popper element.3693* It will read the outer size of the `arrowElement` node to detect how many3694* pixels of conjunction are needed.3695*3696* It has no effect if no `arrowElement` is provided.3697* @memberof modifiers3698* @inner3699*/3700arrow: {3701/** @prop {number} order=500 - Index used to define the order of execution */3702order: 500,3703/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3704enabled: true,3705/** @prop {ModifierFn} */3706fn: arrow,3707/** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */3708element: '[x-arrow]'3709},3710* Modifier used to flip the popper's placement when it starts to overlap its3713* reference element.3714*3715* Requires the `preventOverflow` modifier before it in order to work.3716*3717* **NOTE:** this modifier will interrupt the current update cycle and will3718* restart it if it detects the need to flip the placement.3719* @memberof modifiers3720* @inner3721*/3722flip: {3723/** @prop {number} order=600 - Index used to define the order of execution */3724order: 600,3725/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3726enabled: true,3727/** @prop {ModifierFn} */3728fn: flip,3729/**3730* @prop {String|Array} behavior='flip'3731* The behavior used to change the popper's placement. It can be one of3732* `flip`, `clockwise`, `counterclockwise` or an array with a list of valid3733* placements (with optional variations)3734*/3735behavior: 'flip',3736/**3737* @prop {number} padding=53738* The popper will flip if it hits the edges of the `boundariesElement`3739*/3740padding: 5,3741/**3742* @prop {String|HTMLElement} boundariesElement='viewport'3743* The element which will define the boundaries of the popper position.3744* The popper will never be placed outside of the defined boundaries3745* (except if `keepTogether` is enabled)3746*/3747boundariesElement: 'viewport',3748/**3749* @prop {Boolean} flipVariations=false3750* The popper will switch placement variation between `-start` and `-end` when3751* the reference element overlaps its boundaries.3752*3753* The original placement should have a set variation.3754*/3755flipVariations: false,3756/**3757* @prop {Boolean} flipVariationsByContent=false3758* The popper will switch placement variation between `-start` and `-end` when3759* the popper element overlaps its reference boundaries.3760*3761* The original placement should have a set variation.3762*/3763flipVariationsByContent: false3764},3765* Modifier used to make the popper flow toward the inner of the reference element.3768* By default, when this modifier is disabled, the popper will be placed outside3769* the reference element.3770* @memberof modifiers3771* @inner3772*/3773inner: {3774/** @prop {number} order=700 - Index used to define the order of execution */3775order: 700,3776/** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */3777enabled: false,3778/** @prop {ModifierFn} */3779fn: inner3780},3781* Modifier used to hide the popper when its reference element is outside of the3784* popper boundaries. It will set a `x-out-of-boundaries` attribute which can3785* be used to hide with a CSS selector the popper when its reference is3786* out of boundaries.3787*3788* Requires the `preventOverflow` modifier before it in order to work.3789* @memberof modifiers3790* @inner3791*/3792hide: {3793/** @prop {number} order=800 - Index used to define the order of execution */3794order: 800,3795/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3796enabled: true,3797/** @prop {ModifierFn} */3798fn: hide3799},3800* Computes the style that will be applied to the popper element to gets3803* properly positioned.3804*3805* Note that this modifier will not touch the DOM, it just prepares the styles3806* so that `applyStyle` modifier can apply it. This separation is useful3807* in case you need to replace `applyStyle` with a custom implementation.3808*3809* This modifier has `850` as `order` value to maintain backward compatibility3810* with previous versions of Popper.js. Expect the modifiers ordering method3811* to change in future major versions of the library.3812*3813* @memberof modifiers3814* @inner3815*/3816computeStyle: {3817/** @prop {number} order=850 - Index used to define the order of execution */3818order: 850,3819/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3820enabled: true,3821/** @prop {ModifierFn} */3822fn: computeStyle,3823/**3824* @prop {Boolean} gpuAcceleration=true3825* If true, it uses the CSS 3D transformation to position the popper.3826* Otherwise, it will use the `top` and `left` properties3827*/3828gpuAcceleration: true,3829/**3830* @prop {string} [x='bottom']3831* Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.3832* Change this if your popper should grow in a direction different from `bottom`3833*/3834x: 'bottom',3835/**3836* @prop {string} [x='left']3837* Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.3838* Change this if your popper should grow in a direction different from `right`3839*/3840y: 'right'3841},3842* Applies the computed styles to the popper element.3845*3846* All the DOM manipulations are limited to this modifier. This is useful in case3847* you want to integrate Popper.js inside a framework or view library and you3848* want to delegate all the DOM manipulations to it.3849*3850* Note that if you disable this modifier, you must make sure the popper element3851* has its position set to `absolute` before Popper.js can do its work!3852*3853* Just disable this modifier and define your own to achieve the desired effect.3854*3855* @memberof modifiers3856* @inner3857*/3858applyStyle: {3859/** @prop {number} order=900 - Index used to define the order of execution */3860order: 900,3861/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3862enabled: true,3863/** @prop {ModifierFn} */3864fn: applyStyle,3865/** @prop {Function} */3866onLoad: applyStyleOnLoad,3867/**3868* @deprecated since version 1.10.0, the property moved to `computeStyle` modifier3869* @prop {Boolean} gpuAcceleration=true3870* If true, it uses the CSS 3D transformation to position the popper.3871* Otherwise, it will use the `top` and `left` properties3872*/3873gpuAcceleration: undefined3874}3875};3876* The `dataObject` is an object containing all the information used by Popper.js.3879* This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.3880* @name dataObject3881* @property {Object} data.instance The Popper.js instance3882* @property {String} data.placement Placement applied to popper3883* @property {String} data.originalPlacement Placement originally defined on init3884* @property {Boolean} data.flipped True if popper has been flipped by flip modifier3885* @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper3886* @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier3887* @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)3888* @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)3889* @property {Object} data.boundaries Offsets of the popper boundaries3890* @property {Object} data.offsets The measurements of popper, reference and arrow elements3891* @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values3892* @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values3893* @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 03894*/3895* Default options provided to Popper.js constructor.<br />3898* These can be overridden using the `options` argument of Popper.js.<br />3899* To override an option, simply pass an object with the same3900* structure of the `options` object, as the 3rd argument. For example:3901* ```3902* new Popper(ref, pop, {3903* modifiers: {3904* preventOverflow: { enabled: false }3905* }3906* })3907* ```3908* @type {Object}3909* @static3910* @memberof Popper3911*/3912var Defaults = {3913/**3914* Popper's placement.3915* @prop {Popper.placements} placement='bottom'3916*/3917placement: 'bottom',3918* Set this to true if you want popper to position it self in 'fixed' mode3921* @prop {Boolean} positionFixed=false3922*/3923positionFixed: false,3924* Whether events (resize, scroll) are initially enabled.3927* @prop {Boolean} eventsEnabled=true3928*/3929eventsEnabled: true,3930* Set to true if you want to automatically remove the popper when3933* you call the `destroy` method.3934* @prop {Boolean} removeOnDestroy=false3935*/3936removeOnDestroy: false,3937* Callback called when the popper is created.<br />3940* By default, it is set to no-op.<br />3941* Access Popper.js instance with `data.instance`.3942* @prop {onCreate}3943*/3944onCreate: function onCreate() {},3945* Callback called when the popper is updated. This callback is not called3948* on the initialization/creation of the popper, but only on subsequent3949* updates.<br />3950* By default, it is set to no-op.<br />3951* Access Popper.js instance with `data.instance`.3952* @prop {onUpdate}3953*/3954onUpdate: function onUpdate() {},3955* List of modifiers used to modify the offsets before they are applied to the popper.3958* They provide most of the functionalities of Popper.js.3959* @prop {modifiers}3960*/3961modifiers: modifiers3962};3963* @callback onCreate3966* @param {dataObject} data3967*/3968* @callback onUpdate3971* @param {dataObject} data3972*/3973* Creates a new Popper.js instance.3979* @class Popper3980* @param {Element|referenceObject} reference - The reference element used to position the popper3981* @param {Element} popper - The HTML / XML element used as the popper3982* @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)3983* @return {Object} instance - The generated Popper.js instance3984*/3985function Popper(reference, popper) {3986var _this = this;3987* Schedules an update. It will run on the next UI update available.4078* @method scheduleUpdate4079* @memberof Popper4080*/4081* Collection of utilities useful when writing custom modifiers.4085* Starting from version 1.7, this method is available only if you4086* include `popper-utils.js` before `popper.js`.4087*4088* **DEPRECATION**: This way to access PopperUtils is deprecated4089* and will be removed in v2! Use the PopperUtils module directly instead.4090* Due to the high instability of the methods contained in Utils, we can't4091* guarantee them to follow semver. Use them at your own risk!4092* @static4093* @private4094* @type {Object}4095* @deprecated since version 1.84096* @member Utils4097* @memberof Popper4098*/4099* The `referenceObject` is an object that provides an interface compatible with Popper.js4106* and lets you use it as replacement of a real DOM node.<br />4107* You can use this method to position a popper relatively to a set of coordinates4108* in case you don't have a DOM node to use as reference.4109*4110* ```4111* new Popper(referenceObject, popperNode);4112* ```4113*4114* NB: This feature isn't supported in Internet Explorer 10.4115* @name referenceObject4116* @property {Function} data.getBoundingClientRect4117* A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.4118* @property {number} data.clientWidth4119* An ES6 getter that will return the width of the virtual reference element.4120* @property {number} data.clientHeight4121* An ES6 getter that will return the height of the virtual reference element.4122*/4123* ------------------------------------------------------------------------4131* Constants4132* ------------------------------------------------------------------------4133*/4134* ------------------------------------------------------------------------4198* Class Definition4199* ------------------------------------------------------------------------4200*/4201* Check for Popper dependency4259* Popper - https://popper.js.org4260*/4261if (typeof Popper === 'undefined') {4262throw new TypeError('Bootstrap\'s dropdowns require Popper.js (https://popper.js.org/)');4263}4264* ------------------------------------------------------------------------4616* Data Api implementation4617* ------------------------------------------------------------------------4618*/4619* ------------------------------------------------------------------------4631* jQuery4632* ------------------------------------------------------------------------4633*/4634* ------------------------------------------------------------------------4645* Constants4646* ------------------------------------------------------------------------4647*/4648* ------------------------------------------------------------------------4696* Class Definition4697* ------------------------------------------------------------------------4698*/4699* `document` has 2 events `EVENT_FOCUSIN` and `EVENT_CLICK_DATA_API`4819* Do not move `document` in `htmlElements` array4820* It will remove `EVENT_CLICK_DATA_API` event that should remain4821*/4822* ------------------------------------------------------------------------5208* Data Api implementation5209* ------------------------------------------------------------------------5210*/5211* ------------------------------------------------------------------------5246* jQuery5247* ------------------------------------------------------------------------5248*/5249* --------------------------------------------------------------------------5260* Bootstrap (v4.5.2): tools/sanitizer.js5261* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)5262* --------------------------------------------------------------------------5263*/5264var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href'];5265var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;5266var DefaultWhitelist = {5267// Global attributes allowed on any supplied element below.5268'*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],5269a: ['target', 'href', 'title', 'rel'],5270area: [],5271b: [],5272br: [],5273col: [],5274code: [],5275div: [],5276em: [],5277hr: [],5278h1: [],5279h2: [],5280h3: [],5281h4: [],5282h5: [],5283h6: [],5284i: [],5285img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],5286li: [],5287ol: [],5288p: [],5289pre: [],5290s: [],5291small: [],5292span: [],5293sub: [],5294sup: [],5295strong: [],5296u: [],5297ul: []5298};5299/**5300* A pattern that recognizes a commonly useful subset of URLs that are safe.5301*5302* Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts5303*/5304* A pattern that matches safe data URLs. Only matches image, video and audio types.5308*5309* Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts5310*/5311* ------------------------------------------------------------------------5381* Constants5382* ------------------------------------------------------------------------5383*/5384* ------------------------------------------------------------------------5460* Class Definition5461* ------------------------------------------------------------------------5462*/5463* ------------------------------------------------------------------------6078* jQuery6079* ------------------------------------------------------------------------6080*/6081* ------------------------------------------------------------------------6093* Constants6094* ------------------------------------------------------------------------6095*/6096* ------------------------------------------------------------------------6134* Class Definition6135* ------------------------------------------------------------------------6136*/6137* ------------------------------------------------------------------------6258* jQuery6259* ------------------------------------------------------------------------6260*/6261* ------------------------------------------------------------------------6273* Constants6274* ------------------------------------------------------------------------6275*/6276* ------------------------------------------------------------------------6310* Class Definition6311* ------------------------------------------------------------------------6312*/6313* ------------------------------------------------------------------------6534* Data Api implementation6535* ------------------------------------------------------------------------6536*/6537* ------------------------------------------------------------------------6551* jQuery6552* ------------------------------------------------------------------------6553*/6554* ------------------------------------------------------------------------6565* Constants6566* ------------------------------------------------------------------------6567*/6568* ------------------------------------------------------------------------6594* Class Definition6595* ------------------------------------------------------------------------6596*/6597* ------------------------------------------------------------------------6765* Data Api implementation6766* ------------------------------------------------------------------------6767*/6768* ------------------------------------------------------------------------6777* jQuery6778* ------------------------------------------------------------------------6779*/6780* ------------------------------------------------------------------------6791* Constants6792* ------------------------------------------------------------------------6793*/6794* ------------------------------------------------------------------------6822* Class Definition6823* ------------------------------------------------------------------------6824*/6825* ------------------------------------------------------------------------6994* jQuery6995* ------------------------------------------------------------------------6996*/6997//# sourceMappingURL=bootstrap.bundle.js.map7024