LaravelTest
6972 строки · 225.1 Кб
1/*!2* Bootstrap v4.6.1 (https://getbootstrap.com/)3* Copyright 2011-2021 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* --------------------------------------------------------------------------68* Bootstrap (v4.6.1): util.js69* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)70* --------------------------------------------------------------------------71*/72/**73* Private TransitionEnd Helpers74*/75* Public Util API123*/124* Constants239*/240* Class definition256*/257* Data API implementation369*/370* jQuery375*/376* Constants387*/388* Class definition410*/411* Data API implementation505*/506* jQuery566*/567* Constants578*/579* Class definition648*/649* Data API implementation1138*/1139* jQuery1153*/1154* Constants1165*/1166* Class definition1196*/1197* Data API implementation1472*/1473* jQuery1494*/1495* @fileOverview Kickass library to create and place poppers near their reference elements.1506* @version 1.16.11507* @license1508* Copyright (c) 2016 Federico Zivolo and contributors1509*1510* Permission is hereby granted, free of charge, to any person obtaining a copy1511* of this software and associated documentation files (the "Software"), to deal1512* in the Software without restriction, including without limitation the rights1513* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell1514* copies of the Software, and to permit persons to whom the Software is1515* furnished to do so, subject to the following conditions:1516*1517* The above copyright notice and this permission notice shall be included in all1518* copies or substantial portions of the Software.1519*1520* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR1521* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,1522* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE1523* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER1524* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,1525* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE1526* SOFTWARE.1527*/1528var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';1529* Create a debounced version of a method, that's asynchronously deferred1571* but called in the minimum time possible.1572*1573* @method1574* @memberof Popper.Utils1575* @argument {Function} fn1576* @returns {Function}1577*/1578var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;1579* Check if the given variable is a function1582* @method1583* @memberof Popper.Utils1584* @argument {Any} functionToCheck - variable to check1585* @returns {Boolean} answer to: is a function?1586*/1587function isFunction(functionToCheck) {1588var getType = {};1589return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';1590}1591* Get CSS computed property of the given element1594* @method1595* @memberof Popper.Utils1596* @argument {Eement} element1597* @argument {String} property1598*/1599function getStyleComputedProperty(element, property) {1600if (element.nodeType !== 1) {1601return [];1602}1603// NOTE: 1 DOM access here1604var window = element.ownerDocument.defaultView;1605var css = window.getComputedStyle(element, null);1606return property ? css[property] : css;1607}1608* Returns the parentNode or the host of the element1611* @method1612* @memberof Popper.Utils1613* @argument {Element} element1614* @returns {Element} parent1615*/1616function getParentNode(element) {1617if (element.nodeName === 'HTML') {1618return element;1619}1620return element.parentNode || element.host;1621}1622* Returns the scrolling parent of the given element1625* @method1626* @memberof Popper.Utils1627* @argument {Element} element1628* @returns {Element} scroll parent1629*/1630function getScrollParent(element) {1631// Return body, `getScroll` will take care to get the correct `scrollTop` from it1632if (!element) {1633return document.body;1634}1635* Returns the reference node of the reference object, or the reference object itself.1660* @method1661* @memberof Popper.Utils1662* @param {Element|Object} reference - the reference element (the popper will be relative to this)1663* @returns {Element} parent1664*/1665function getReferenceNode(reference) {1666return reference && reference.referenceNode ? reference.referenceNode : reference;1667}1668* Determines if the browser is Internet Explorer1674* @method1675* @memberof Popper.Utils1676* @param {Number} version to check1677* @returns {Boolean} isIE1678*/1679function isIE(version) {1680if (version === 11) {1681return isIE11;1682}1683if (version === 10) {1684return isIE10;1685}1686return isIE11 || isIE10;1687}1688* Returns the offset parent of the given element1691* @method1692* @memberof Popper.Utils1693* @argument {Element} element1694* @returns {Element} offset parent1695*/1696function getOffsetParent(element) {1697if (!element) {1698return document.documentElement;1699}1700* Finds the root node (document, shadowDOM root) of the given element1736* @method1737* @memberof Popper.Utils1738* @argument {Element} node1739* @returns {Element} root node1740*/1741function getRoot(node) {1742if (node.parentNode !== null) {1743return getRoot(node.parentNode);1744}1745* Finds the offset parent common to the two provided nodes1751* @method1752* @memberof Popper.Utils1753* @argument {Element} element11754* @argument {Element} element21755* @returns {Element} common offset parent1756*/1757function findCommonOffsetParent(element1, element2) {1758// This check is needed to avoid errors in case one of the elements isn't defined for any reason1759if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {1760return document.documentElement;1761}1762* Gets the scroll value of the given element in the given side (top and left)1795* @method1796* @memberof Popper.Utils1797* @argument {Element} element1798* @argument {String} side `top` or `left`1799* @returns {number} amount of scrolled pixels1800*/1801function getScroll(element) {1802var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';1803* Sum or subtract the element scroll values (left and top) from a given rect object1818* @method1819* @memberof Popper.Utils1820* @param {Object} rect - Rect object you want to change1821* @param {HTMLElement} element - The element from the function reads the scroll values1822* @param {Boolean} subtract - set to true if you want to subtract the scroll values1823* @return {Object} rect - The modifier rect object1824*/1825function includeScroll(rect, element) {1826var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;1827* Helper to detect borders of a given element1840* @method1841* @memberof Popper.Utils1842* @param {CSSStyleDeclaration} styles1843* Result of `getStyleComputedProperty` on the given element1844* @param {String} axis - `x` or `y`1845* @return {number} borders - The borders size of the given axis1846*/1847* Given element offsets, generate an output similar to getBoundingClientRect1929* @method1930* @memberof Popper.Utils1931* @argument {Object} offsets1932* @returns {Object} ClientRect like output1933*/1934function getClientRect(offsets) {1935return _extends({}, offsets, {1936right: offsets.left + offsets.width,1937bottom: offsets.top + offsets.height1938});1939}1940* Get bounding client rect of given element1943* @method1944* @memberof Popper.Utils1945* @param {HTMLElement} element1946* @return {Object} client rect1947*/1948function getBoundingClientRect(element) {1949var rect = {};1950* Check if the given element is fixed or is inside a fixed parent2072* @method2073* @memberof Popper.Utils2074* @argument {Element} element2075* @argument {Element} customContainer2076* @returns {Boolean} answer to "isFixed?"2077*/2078function isFixed(element) {2079var nodeName = element.nodeName;2080if (nodeName === 'BODY' || nodeName === 'HTML') {2081return false;2082}2083if (getStyleComputedProperty(element, 'position') === 'fixed') {2084return true;2085}2086var parentNode = getParentNode(element);2087if (!parentNode) {2088return false;2089}2090return isFixed(parentNode);2091}2092* Finds the first parent of an element that has a transformed property defined2095* @method2096* @memberof Popper.Utils2097* @argument {Element} element2098* @returns {Element} first transformed parent or documentElement2099*/2100* Computed the boundaries limits and return them2115* @method2116* @memberof Popper.Utils2117* @param {HTMLElement} popper2118* @param {HTMLElement} reference2119* @param {number} padding2120* @param {HTMLElement} boundariesElement - Element used to define the boundaries2121* @param {Boolean} fixedPosition - Is in fixed position mode2122* @returns {Object} Coordinates of the boundaries2123*/2124function getBoundaries(popper, reference, padding, boundariesElement) {2125var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;2126* Utility used to transform the `auto` placement to the placement with more2187* available space.2188* @method2189* @memberof Popper.Utils2190* @argument {Object} data - The data object generated by update method2191* @argument {Object} options - Modifiers configuration and options2192* @returns {Object} The data object, properly modified2193*/2194function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {2195var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;2196* Get offsets to the reference element2247* @method2248* @memberof Popper.Utils2249* @param {Object} state2250* @param {Element} popper - the popper element2251* @param {Element} reference - the reference element (the popper will be relative to this)2252* @param {Element} fixedPosition - is in fixed position mode2253* @returns {Object} An object containing the offsets which will be applied to the popper2254*/2255function getReferenceOffsets(state, popper, reference) {2256var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;2257* Get the outer sizes of the given element (offset size + margins)2264* @method2265* @memberof Popper.Utils2266* @argument {Element} element2267* @returns {Object} object containing width and height properties2268*/2269function getOuterSizes(element) {2270var window = element.ownerDocument.defaultView;2271var styles = window.getComputedStyle(element);2272var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);2273var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);2274var result = {2275width: element.offsetWidth + y,2276height: element.offsetHeight + x2277};2278return result;2279}2280* Get the opposite placement of the given one2283* @method2284* @memberof Popper.Utils2285* @argument {String} placement2286* @returns {String} flipped placement2287*/2288function getOppositePlacement(placement) {2289var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };2290return placement.replace(/left|right|bottom|top/g, function (matched) {2291return hash[matched];2292});2293}2294* Get offsets to the popper2297* @method2298* @memberof Popper.Utils2299* @param {Object} position - CSS position the Popper will get applied2300* @param {HTMLElement} popper - the popper element2301* @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)2302* @param {String} placement - one of the valid placement options2303* @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper2304*/2305function getPopperOffsets(popper, referenceOffsets, placement) {2306placement = placement.split('-')[0];2307* Mimics the `find` method of Array2336* @method2337* @memberof Popper.Utils2338* @argument {Array} arr2339* @argument prop2340* @argument value2341* @returns index or -12342*/2343function find(arr, check) {2344// use native find if supported2345if (Array.prototype.find) {2346return arr.find(check);2347}2348* Return the index of the matching object2355* @method2356* @memberof Popper.Utils2357* @argument {Array} arr2358* @argument prop2359* @argument value2360* @returns index or -12361*/2362function findIndex(arr, prop, value) {2363// use native findIndex if supported2364if (Array.prototype.findIndex) {2365return arr.findIndex(function (cur) {2366return cur[prop] === value;2367});2368}2369* Loop trough the list of modifiers and run them in order,2379* each of them will then edit the data object.2380* @method2381* @memberof Popper.Utils2382* @param {dataObject} data2383* @param {Array} modifiers2384* @param {String} ends - Optional modifier name used as stopper2385* @returns {dataObject}2386*/2387function runModifiers(modifiers, data, ends) {2388var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));2389* Updates the position of the popper, computing the new offsets and applying2412* the new style.<br />2413* Prefer `scheduleUpdate` over `update` because of performance reasons.2414* @method2415* @memberof Popper2416*/2417function update() {2418// if popper is destroyed, don't perform any further update2419if (this.state.isDestroyed) {2420return;2421}2422* Helper used to know if the given modifier is enabled.2465* @method2466* @memberof Popper.Utils2467* @returns {Boolean}2468*/2469function isModifierEnabled(modifiers, modifierName) {2470return modifiers.some(function (_ref) {2471var name = _ref.name,2472enabled = _ref.enabled;2473return enabled && name === modifierName;2474});2475}2476* Get the prefixed supported property name2479* @method2480* @memberof Popper.Utils2481* @argument {String} property (camelCase)2482* @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)2483*/2484function getSupportedPropertyName(property) {2485var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];2486var upperProp = property.charAt(0).toUpperCase() + property.slice(1);2487* Destroys the popper.2500* @method2501* @memberof Popper2502*/2503function destroy() {2504this.state.isDestroyed = true;2505* Get the window associated with the element2530* @argument {Element} element2531* @returns {Window}2532*/2533function getWindow(element) {2534var ownerDocument = element.ownerDocument;2535return ownerDocument ? ownerDocument.defaultView : window;2536}2537* Setup needed event listeners used to update the popper position2551* @method2552* @memberof Popper.Utils2553* @private2554*/2555function setupEventListeners(reference, options, state, updateBound) {2556// Resize event listener on window2557state.updateBound = updateBound;2558getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });2559* It will add resize/scroll events and start recalculating2571* position of the popper element when they are triggered.2572* @method2573* @memberof Popper2574*/2575function enableEventListeners() {2576if (!this.state.eventsEnabled) {2577this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);2578}2579}2580* Remove event listeners used to update the popper position2583* @method2584* @memberof Popper.Utils2585* @private2586*/2587function removeEventListeners(reference, state) {2588// Remove resize event listener on window2589getWindow(reference).removeEventListener('resize', state.updateBound);2590* It will remove resize/scroll events and won't recalculate popper position2606* when they are triggered. It also won't trigger `onUpdate` callback anymore,2607* unless you call `update` method manually.2608* @method2609* @memberof Popper2610*/2611function disableEventListeners() {2612if (this.state.eventsEnabled) {2613cancelAnimationFrame(this.scheduleUpdate);2614this.state = removeEventListeners(this.reference, this.state);2615}2616}2617* Tells if a given input is a number2620* @method2621* @memberof Popper.Utils2622* @param {*} input to check2623* @return {Boolean}2624*/2625function isNumeric(n) {2626return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);2627}2628* Set the style to the given popper2631* @method2632* @memberof Popper.Utils2633* @argument {Element} element - Element to apply the style to2634* @argument {Object} styles2635* Object with a list of properties and values which will be applied to the element2636*/2637function setStyles(element, styles) {2638Object.keys(styles).forEach(function (prop) {2639var unit = '';2640// add unit if the value is numeric and is one of the following2641if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {2642unit = 'px';2643}2644element.style[prop] = styles[prop] + unit;2645});2646}2647* Set the attributes to the given popper2650* @method2651* @memberof Popper.Utils2652* @argument {Element} element - Element to apply the attributes to2653* @argument {Object} styles2654* Object with a list of properties and values which will be applied to the element2655*/2656function setAttributes(element, attributes) {2657Object.keys(attributes).forEach(function (prop) {2658var value = attributes[prop];2659if (value !== false) {2660element.setAttribute(prop, attributes[prop]);2661} else {2662element.removeAttribute(prop);2663}2664});2665}2666* @function2669* @memberof Modifiers2670* @argument {Object} data - The data object generated by `update` method2671* @argument {Object} data.styles - List of style properties - values to apply to popper element2672* @argument {Object} data.attributes - List of attribute properties - values to apply to popper element2673* @argument {Object} options - Modifiers configuration and options2674* @returns {Object} The same data object2675*/2676function applyStyle(data) {2677// any property present in `data.styles` will be applied to the popper,2678// in this way we can make the 3rd party modifiers add custom styles to it2679// Be aware, modifiers could override the properties defined in the previous2680// lines of this modifier!2681setStyles(data.instance.popper, data.styles);2682* Set the x-placement attribute before everything else because it could be used2697* to add margins to the popper margins needs to be calculated to get the2698* correct popper offsets.2699* @method2700* @memberof Popper.modifiers2701* @param {HTMLElement} reference - The reference element used to position the popper2702* @param {HTMLElement} popper - The HTML element used as popper2703* @param {Object} options - Popper.js options2704*/2705function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {2706// compute reference element offsets2707var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);2708* @function2725* @memberof Popper.Utils2726* @argument {Object} data - The data object generated by `update` method2727* @argument {Boolean} shouldRound - If the offsets should be rounded at all2728* @returns {Object} The popper's position offsets rounded2729*2730* The tale of pixel-perfect positioning. It's still not 100% perfect, but as2731* good as it can be within reason.2732* Discussion here: https://github.com/FezVrasta/popper.js/pull/7152733*2734* Low DPI screens cause a popper to be blurry if not using full pixels (Safari2735* as well on High DPI screens).2736*2737* Firefox prefers no rounding for positioning and does not have blurriness on2738* high DPI screens.2739*2740* Only horizontal placement and left/right values need to be considered.2741*/2742function getRoundedOffsets(data, shouldRound) {2743var _data$offsets = data.offsets,2744popper = _data$offsets.popper,2745reference = _data$offsets.reference;2746var round = Math.round,2747floor = Math.floor;2748* @function2776* @memberof Modifiers2777* @argument {Object} data - The data object generated by `update` method2778* @argument {Object} options - Modifiers configuration and options2779* @returns {Object} The data object, properly modified2780*/2781function computeStyle(data, options) {2782var x = options.x,2783y = options.y;2784var popper = data.offsets.popper;2785* Helper used to know if the given modifier depends from another one.<br />2874* It checks if the needed modifier is listed and enabled.2875* @method2876* @memberof Popper.Utils2877* @param {Array} modifiers - list of modifiers2878* @param {String} requestingName - name of requesting modifier2879* @param {String} requestedName - name of requested modifier2880* @returns {Boolean}2881*/2882function isModifierRequired(modifiers, requestingName, requestedName) {2883var requesting = find(modifiers, function (_ref) {2884var name = _ref.name;2885return name === requestingName;2886});2887* @function2902* @memberof Modifiers2903* @argument {Object} data - The data object generated by update method2904* @argument {Object} options - Modifiers configuration and options2905* @returns {Object} The data object, properly modified2906*/2907function arrow(data, options) {2908var _data$offsets$arrow;2909* Get the opposite placement variation of the given one2984* @method2985* @memberof Popper.Utils2986* @argument {String} placement variation2987* @returns {String} flipped placement variation2988*/2989function getOppositeVariation(variation) {2990if (variation === 'end') {2991return 'start';2992} else if (variation === 'start') {2993return 'end';2994}2995return variation;2996}2997* List of accepted placements to use as values of the `placement` option.<br />3000* Valid placements are:3001* - `auto`3002* - `top`3003* - `right`3004* - `bottom`3005* - `left`3006*3007* Each placement can have a variation from this list:3008* - `-start`3009* - `-end`3010*3011* Variations are interpreted easily if you think of them as the left to right3012* written languages. Horizontally (`top` and `bottom`), `start` is left and `end`3013* is right.<br />3014* Vertically (`left` and `right`), `start` is top and `end` is bottom.3015*3016* Some valid examples are:3017* - `top-end` (on top of reference, right aligned)3018* - `right-start` (on right of reference, top aligned)3019* - `bottom` (on bottom, centered)3020* - `auto-end` (on the side with more space available, alignment depends by placement)3021*3022* @static3023* @type {Array}3024* @enum {String}3025* @readonly3026* @method placements3027* @memberof Popper3028*/3029var 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'];3030* Given an initial placement, returns all the subsequent placements3036* clockwise (or counter-clockwise).3037*3038* @method3039* @memberof Popper.Utils3040* @argument {String} placement - A valid placement (it accepts variations)3041* @argument {Boolean} counter - Set to true to walk the placements counterclockwise3042* @returns {Array} placements including their variations3043*/3044function clockwise(placement) {3045var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;3046* @function3060* @memberof Modifiers3061* @argument {Object} data - The data object generated by update method3062* @argument {Object} options - Modifiers configuration and options3063* @returns {Object} The data object, properly modified3064*/3065function flip(data, options) {3066// if `inner` modifier is enabled, we can't use the `flip` modifier3067if (isModifierEnabled(data.instance.modifiers, 'inner')) {3068return data;3069}3070* @function3157* @memberof Modifiers3158* @argument {Object} data - The data object generated by update method3159* @argument {Object} options - Modifiers configuration and options3160* @returns {Object} The data object, properly modified3161*/3162function keepTogether(data) {3163var _data$offsets = data.offsets,3164popper = _data$offsets.popper,3165reference = _data$offsets.reference;3166* Converts a string containing value + unit into a px value number3186* @function3187* @memberof {modifiers~offset}3188* @private3189* @argument {String} str - Value + unit string3190* @argument {String} measurement - `height` or `width`3191* @argument {Object} popperOffsets3192* @argument {Object} referenceOffsets3193* @returns {Number|String}3194* Value in pixels, or original string if no values were extracted3195*/3196function toValue(str, measurement, popperOffsets, referenceOffsets) {3197// separate value from unit3198var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);3199var value = +split[1];3200var unit = split[2];3201* Parse an `offset` string to extrapolate `x` and `y` numeric offsets.3239* @function3240* @memberof {modifiers~offset}3241* @private3242* @argument {String} offset3243* @argument {Object} popperOffsets3244* @argument {Object} referenceOffsets3245* @argument {String} basePlacement3246* @returns {Array} a two cells array with x and y offsets in numbers3247*/3248function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {3249var offsets = [0, 0];3250* @function3317* @memberof Modifiers3318* @argument {Object} data - The data object generated by update method3319* @argument {Object} options - Modifiers configuration and options3320* @argument {Number|String} options.offset=03321* The offset value as described in the modifier description3322* @returns {Object} The data object, properly modified3323*/3324function offset(data, _ref) {3325var offset = _ref.offset;3326var placement = data.placement,3327_data$offsets = data.offsets,3328popper = _data$offsets.popper,3329reference = _data$offsets.reference;3330* @function3360* @memberof Modifiers3361* @argument {Object} data - The data object generated by `update` method3362* @argument {Object} options - Modifiers configuration and options3363* @returns {Object} The data object, properly modified3364*/3365function preventOverflow(data, options) {3366var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);3367* @function3431* @memberof Modifiers3432* @argument {Object} data - The data object generated by `update` method3433* @argument {Object} options - Modifiers configuration and options3434* @returns {Object} The data object, properly modified3435*/3436function shift(data) {3437var placement = data.placement;3438var basePlacement = placement.split('-')[0];3439var shiftvariation = placement.split('-')[1];3440* @function3464* @memberof Modifiers3465* @argument {Object} data - The data object generated by update method3466* @argument {Object} options - Modifiers configuration and options3467* @returns {Object} The data object, properly modified3468*/3469function hide(data) {3470if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {3471return data;3472}3473* @function3502* @memberof Modifiers3503* @argument {Object} data - The data object generated by `update` method3504* @argument {Object} options - Modifiers configuration and options3505* @returns {Object} The data object, properly modified3506*/3507function inner(data) {3508var placement = data.placement;3509var basePlacement = placement.split('-')[0];3510var _data$offsets = data.offsets,3511popper = _data$offsets.popper,3512reference = _data$offsets.reference;3513* Modifier function, each modifier can have a function of this type assigned3528* to its `fn` property.<br />3529* These functions will be called on each update, this means that you must3530* make sure they are performant enough to avoid performance bottlenecks.3531*3532* @function ModifierFn3533* @argument {dataObject} data - The data object generated by `update` method3534* @argument {Object} options - Modifiers configuration and options3535* @returns {dataObject} The data object, properly modified3536*/3537* Modifiers are plugins used to alter the behavior of your poppers.<br />3540* Popper.js uses a set of 9 modifiers to provide all the basic functionalities3541* needed by the library.3542*3543* Usually you don't want to override the `order`, `fn` and `onLoad` props.3544* All the other properties are configurations that could be tweaked.3545* @namespace modifiers3546*/3547var modifiers = {3548/**3549* Modifier used to shift the popper on the start or end of its reference3550* element.<br />3551* It will read the variation of the `placement` property.<br />3552* It can be one either `-end` or `-start`.3553* @memberof modifiers3554* @inner3555*/3556shift: {3557/** @prop {number} order=100 - Index used to define the order of execution */3558order: 100,3559/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3560enabled: true,3561/** @prop {ModifierFn} */3562fn: shift3563},3564* The `offset` modifier can shift your popper on both its axis.3567*3568* It accepts the following units:3569* - `px` or unit-less, interpreted as pixels3570* - `%` or `%r`, percentage relative to the length of the reference element3571* - `%p`, percentage relative to the length of the popper element3572* - `vw`, CSS viewport width unit3573* - `vh`, CSS viewport height unit3574*3575* For length is intended the main axis relative to the placement of the popper.<br />3576* This means that if the placement is `top` or `bottom`, the length will be the3577* `width`. In case of `left` or `right`, it will be the `height`.3578*3579* You can provide a single value (as `Number` or `String`), or a pair of values3580* as `String` divided by a comma or one (or more) white spaces.<br />3581* The latter is a deprecated method because it leads to confusion and will be3582* removed in v2.<br />3583* Additionally, it accepts additions and subtractions between different units.3584* Note that multiplications and divisions aren't supported.3585*3586* Valid examples are:3587* ```3588* 103589* '10%'3590* '10, 10'3591* '10%, 10'3592* '10 + 10%'3593* '10 - 5vh + 3%'3594* '-10px + 5vh, 5px - 6%'3595* ```3596* > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap3597* > with their reference element, unfortunately, you will have to disable the `flip` modifier.3598* > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).3599*3600* @memberof modifiers3601* @inner3602*/3603offset: {3604/** @prop {number} order=200 - Index used to define the order of execution */3605order: 200,3606/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3607enabled: true,3608/** @prop {ModifierFn} */3609fn: offset,3610/** @prop {Number|String} offset=03611* The offset value as described in the modifier description3612*/3613offset: 03614},3615* Modifier used to prevent the popper from being positioned outside the boundary.3618*3619* A scenario exists where the reference itself is not within the boundaries.<br />3620* We can say it has "escaped the boundaries" — or just "escaped".<br />3621* In this case we need to decide whether the popper should either:3622*3623* - detach from the reference and remain "trapped" in the boundaries, or3624* - if it should ignore the boundary and "escape with its reference"3625*3626* When `escapeWithReference` is set to`true` and reference is completely3627* outside its boundaries, the popper will overflow (or completely leave)3628* the boundaries in order to remain attached to the edge of the reference.3629*3630* @memberof modifiers3631* @inner3632*/3633preventOverflow: {3634/** @prop {number} order=300 - Index used to define the order of execution */3635order: 300,3636/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3637enabled: true,3638/** @prop {ModifierFn} */3639fn: preventOverflow,3640/**3641* @prop {Array} [priority=['left','right','top','bottom']]3642* Popper will try to prevent overflow following these priorities by default,3643* then, it could overflow on the left and on top of the `boundariesElement`3644*/3645priority: ['left', 'right', 'top', 'bottom'],3646/**3647* @prop {number} padding=53648* Amount of pixel used to define a minimum distance between the boundaries3649* and the popper. This makes sure the popper always has a little padding3650* between the edges of its container3651*/3652padding: 5,3653/**3654* @prop {String|HTMLElement} boundariesElement='scrollParent'3655* Boundaries used by the modifier. Can be `scrollParent`, `window`,3656* `viewport` or any DOM element.3657*/3658boundariesElement: 'scrollParent'3659},3660* Modifier used to make sure the reference and its popper stay near each other3663* without leaving any gap between the two. Especially useful when the arrow is3664* enabled and you want to ensure that it points to its reference element.3665* It cares only about the first axis. You can still have poppers with margin3666* between the popper and its reference element.3667* @memberof modifiers3668* @inner3669*/3670keepTogether: {3671/** @prop {number} order=400 - Index used to define the order of execution */3672order: 400,3673/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3674enabled: true,3675/** @prop {ModifierFn} */3676fn: keepTogether3677},3678* This modifier is used to move the `arrowElement` of the popper to make3681* sure it is positioned between the reference element and its popper element.3682* It will read the outer size of the `arrowElement` node to detect how many3683* pixels of conjunction are needed.3684*3685* It has no effect if no `arrowElement` is provided.3686* @memberof modifiers3687* @inner3688*/3689arrow: {3690/** @prop {number} order=500 - Index used to define the order of execution */3691order: 500,3692/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3693enabled: true,3694/** @prop {ModifierFn} */3695fn: arrow,3696/** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */3697element: '[x-arrow]'3698},3699* Modifier used to flip the popper's placement when it starts to overlap its3702* reference element.3703*3704* Requires the `preventOverflow` modifier before it in order to work.3705*3706* **NOTE:** this modifier will interrupt the current update cycle and will3707* restart it if it detects the need to flip the placement.3708* @memberof modifiers3709* @inner3710*/3711flip: {3712/** @prop {number} order=600 - Index used to define the order of execution */3713order: 600,3714/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3715enabled: true,3716/** @prop {ModifierFn} */3717fn: flip,3718/**3719* @prop {String|Array} behavior='flip'3720* The behavior used to change the popper's placement. It can be one of3721* `flip`, `clockwise`, `counterclockwise` or an array with a list of valid3722* placements (with optional variations)3723*/3724behavior: 'flip',3725/**3726* @prop {number} padding=53727* The popper will flip if it hits the edges of the `boundariesElement`3728*/3729padding: 5,3730/**3731* @prop {String|HTMLElement} boundariesElement='viewport'3732* The element which will define the boundaries of the popper position.3733* The popper will never be placed outside of the defined boundaries3734* (except if `keepTogether` is enabled)3735*/3736boundariesElement: 'viewport',3737/**3738* @prop {Boolean} flipVariations=false3739* The popper will switch placement variation between `-start` and `-end` when3740* the reference element overlaps its boundaries.3741*3742* The original placement should have a set variation.3743*/3744flipVariations: false,3745/**3746* @prop {Boolean} flipVariationsByContent=false3747* The popper will switch placement variation between `-start` and `-end` when3748* the popper element overlaps its reference boundaries.3749*3750* The original placement should have a set variation.3751*/3752flipVariationsByContent: false3753},3754* Modifier used to make the popper flow toward the inner of the reference element.3757* By default, when this modifier is disabled, the popper will be placed outside3758* the reference element.3759* @memberof modifiers3760* @inner3761*/3762inner: {3763/** @prop {number} order=700 - Index used to define the order of execution */3764order: 700,3765/** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */3766enabled: false,3767/** @prop {ModifierFn} */3768fn: inner3769},3770* Modifier used to hide the popper when its reference element is outside of the3773* popper boundaries. It will set a `x-out-of-boundaries` attribute which can3774* be used to hide with a CSS selector the popper when its reference is3775* out of boundaries.3776*3777* Requires the `preventOverflow` modifier before it in order to work.3778* @memberof modifiers3779* @inner3780*/3781hide: {3782/** @prop {number} order=800 - Index used to define the order of execution */3783order: 800,3784/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3785enabled: true,3786/** @prop {ModifierFn} */3787fn: hide3788},3789* Computes the style that will be applied to the popper element to gets3792* properly positioned.3793*3794* Note that this modifier will not touch the DOM, it just prepares the styles3795* so that `applyStyle` modifier can apply it. This separation is useful3796* in case you need to replace `applyStyle` with a custom implementation.3797*3798* This modifier has `850` as `order` value to maintain backward compatibility3799* with previous versions of Popper.js. Expect the modifiers ordering method3800* to change in future major versions of the library.3801*3802* @memberof modifiers3803* @inner3804*/3805computeStyle: {3806/** @prop {number} order=850 - Index used to define the order of execution */3807order: 850,3808/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3809enabled: true,3810/** @prop {ModifierFn} */3811fn: computeStyle,3812/**3813* @prop {Boolean} gpuAcceleration=true3814* If true, it uses the CSS 3D transformation to position the popper.3815* Otherwise, it will use the `top` and `left` properties3816*/3817gpuAcceleration: true,3818/**3819* @prop {string} [x='bottom']3820* Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.3821* Change this if your popper should grow in a direction different from `bottom`3822*/3823x: 'bottom',3824/**3825* @prop {string} [x='left']3826* Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.3827* Change this if your popper should grow in a direction different from `right`3828*/3829y: 'right'3830},3831* Applies the computed styles to the popper element.3834*3835* All the DOM manipulations are limited to this modifier. This is useful in case3836* you want to integrate Popper.js inside a framework or view library and you3837* want to delegate all the DOM manipulations to it.3838*3839* Note that if you disable this modifier, you must make sure the popper element3840* has its position set to `absolute` before Popper.js can do its work!3841*3842* Just disable this modifier and define your own to achieve the desired effect.3843*3844* @memberof modifiers3845* @inner3846*/3847applyStyle: {3848/** @prop {number} order=900 - Index used to define the order of execution */3849order: 900,3850/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */3851enabled: true,3852/** @prop {ModifierFn} */3853fn: applyStyle,3854/** @prop {Function} */3855onLoad: applyStyleOnLoad,3856/**3857* @deprecated since version 1.10.0, the property moved to `computeStyle` modifier3858* @prop {Boolean} gpuAcceleration=true3859* If true, it uses the CSS 3D transformation to position the popper.3860* Otherwise, it will use the `top` and `left` properties3861*/3862gpuAcceleration: undefined3863}3864};3865* The `dataObject` is an object containing all the information used by Popper.js.3868* This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.3869* @name dataObject3870* @property {Object} data.instance The Popper.js instance3871* @property {String} data.placement Placement applied to popper3872* @property {String} data.originalPlacement Placement originally defined on init3873* @property {Boolean} data.flipped True if popper has been flipped by flip modifier3874* @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper3875* @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier3876* @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)3877* @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)3878* @property {Object} data.boundaries Offsets of the popper boundaries3879* @property {Object} data.offsets The measurements of popper, reference and arrow elements3880* @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values3881* @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values3882* @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 03883*/3884* Default options provided to Popper.js constructor.<br />3887* These can be overridden using the `options` argument of Popper.js.<br />3888* To override an option, simply pass an object with the same3889* structure of the `options` object, as the 3rd argument. For example:3890* ```3891* new Popper(ref, pop, {3892* modifiers: {3893* preventOverflow: { enabled: false }3894* }3895* })3896* ```3897* @type {Object}3898* @static3899* @memberof Popper3900*/3901var Defaults = {3902/**3903* Popper's placement.3904* @prop {Popper.placements} placement='bottom'3905*/3906placement: 'bottom',3907* Set this to true if you want popper to position it self in 'fixed' mode3910* @prop {Boolean} positionFixed=false3911*/3912positionFixed: false,3913* Whether events (resize, scroll) are initially enabled.3916* @prop {Boolean} eventsEnabled=true3917*/3918eventsEnabled: true,3919* Set to true if you want to automatically remove the popper when3922* you call the `destroy` method.3923* @prop {Boolean} removeOnDestroy=false3924*/3925removeOnDestroy: false,3926* Callback called when the popper is created.<br />3929* By default, it is set to no-op.<br />3930* Access Popper.js instance with `data.instance`.3931* @prop {onCreate}3932*/3933onCreate: function onCreate() {},3934* Callback called when the popper is updated. This callback is not called3937* on the initialization/creation of the popper, but only on subsequent3938* updates.<br />3939* By default, it is set to no-op.<br />3940* Access Popper.js instance with `data.instance`.3941* @prop {onUpdate}3942*/3943onUpdate: function onUpdate() {},3944* List of modifiers used to modify the offsets before they are applied to the popper.3947* They provide most of the functionalities of Popper.js.3948* @prop {modifiers}3949*/3950modifiers: modifiers3951};3952* @callback onCreate3955* @param {dataObject} data3956*/3957* @callback onUpdate3960* @param {dataObject} data3961*/3962* Creates a new Popper.js instance.3968* @class Popper3969* @param {Element|referenceObject} reference - The reference element used to position the popper3970* @param {Element} popper - The HTML / XML element used as the popper3971* @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)3972* @return {Object} instance - The generated Popper.js instance3973*/3974function Popper(reference, popper) {3975var _this = this;3976* Schedules an update. It will run on the next UI update available.4067* @method scheduleUpdate4068* @memberof Popper4069*/4070* Collection of utilities useful when writing custom modifiers.4074* Starting from version 1.7, this method is available only if you4075* include `popper-utils.js` before `popper.js`.4076*4077* **DEPRECATION**: This way to access PopperUtils is deprecated4078* and will be removed in v2! Use the PopperUtils module directly instead.4079* Due to the high instability of the methods contained in Utils, we can't4080* guarantee them to follow semver. Use them at your own risk!4081* @static4082* @private4083* @type {Object}4084* @deprecated since version 1.84085* @member Utils4086* @memberof Popper4087*/4088* The `referenceObject` is an object that provides an interface compatible with Popper.js4095* and lets you use it as replacement of a real DOM node.<br />4096* You can use this method to position a popper relatively to a set of coordinates4097* in case you don't have a DOM node to use as reference.4098*4099* ```4100* new Popper(referenceObject, popperNode);4101* ```4102*4103* NB: This feature isn't supported in Internet Explorer 10.4104* @name referenceObject4105* @property {Function} data.getBoundingClientRect4106* A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.4107* @property {number} data.clientWidth4108* An ES6 getter that will return the width of the virtual reference element.4109* @property {number} data.clientHeight4110* An ES6 getter that will return the height of the virtual reference element.4111*/4112* Constants4122*/4123* Class definition4187*/4188* Data API implementation4600*/4601* jQuery4613*/4614* Constants4625*/4626* Class definition4674*/4675* `document` has 2 events `EVENT_FOCUSIN` and `EVENT_CLICK_DATA_API`4795* Do not move `document` in `htmlElements` array4796* It will remove `EVENT_CLICK_DATA_API` event that should remain4797*/4798* Data API implementation5184*/5185* jQuery5220*/5221* --------------------------------------------------------------------------5232* Bootstrap (v4.6.1): tools/sanitizer.js5233* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)5234* --------------------------------------------------------------------------5235*/5236var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href'];5237var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;5238var DefaultWhitelist = {5239// Global attributes allowed on any supplied element below.5240'*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],5241a: ['target', 'href', 'title', 'rel'],5242area: [],5243b: [],5244br: [],5245col: [],5246code: [],5247div: [],5248em: [],5249hr: [],5250h1: [],5251h2: [],5252h3: [],5253h4: [],5254h5: [],5255h6: [],5256i: [],5257img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],5258li: [],5259ol: [],5260p: [],5261pre: [],5262s: [],5263small: [],5264span: [],5265sub: [],5266sup: [],5267strong: [],5268u: [],5269ul: []5270};5271/**5272* A pattern that recognizes a commonly useful subset of URLs that are safe.5273*5274* Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts5275*/5276* A pattern that matches safe data URLs. Only matches image, video and audio types.5280*5281* Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts5282*/5283* Constants5354*/5355* Class definition5433*/5434* jQuery6051*/6052* Constants6064*/6065* Class definition6103*/6104* jQuery6225*/6226* Constants6238*/6239* Class definition6273*/6274* Data API implementation6495*/6496* jQuery6510*/6511* Constants6522*/6523* Class definition6549*/6550* Data API implementation6724*/6725* jQuery6734*/6735* Constants6746*/6747* Class definition6775*/6776* jQuery6945*/6946//# sourceMappingURL=bootstrap.bundle.js.map6973