GPQAPP
1/**!2* @fileOverview Kickass library to create and place poppers near their reference elements.3* @version 1.16.14* @license5* Copyright (c) 2016 Federico Zivolo and contributors6*7* Permission is hereby granted, free of charge, to any person obtaining a copy8* of this software and associated documentation files (the "Software"), to deal9* in the Software without restriction, including without limitation the rights10* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell11* copies of the Software, and to permit persons to whom the Software is12* furnished to do so, subject to the following conditions:13*14* The above copyright notice and this permission notice shall be included in all15* copies or substantial portions of the Software.16*17* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR18* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,19* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE20* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER21* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,22* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE23* SOFTWARE.24*/25var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';26}50}63/**67* Create a debounced version of a method, that's asynchronously deferred68* but called in the minimum time possible.69*70* @method71* @memberof Popper.Utils72* @argument {Function} fn73* @returns {Function}74*/75var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;76/**78* Check if the given variable is a function79* @method80* @memberof Popper.Utils81* @argument {Any} functionToCheck - variable to check82* @returns {Boolean} answer to: is a function?83*/84function isFunction(functionToCheck) {85const getType = {};86return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';87}88/**90* Get CSS computed property of the given element91* @method92* @memberof Popper.Utils93* @argument {Eement} element94* @argument {String} property95*/96function getStyleComputedProperty(element, property) {97if (element.nodeType !== 1) {98return [];99}100// NOTE: 1 DOM access here101const window = element.ownerDocument.defaultView;102const css = window.getComputedStyle(element, null);103return property ? css[property] : css;104}105/**107* Returns the parentNode or the host of the element108* @method109* @memberof Popper.Utils110* @argument {Element} element111* @returns {Element} parent112*/113function getParentNode(element) {114if (element.nodeName === 'HTML') {115return element;116}117return element.parentNode || element.host;118}119/**121* Returns the scrolling parent of the given element122* @method123* @memberof Popper.Utils124* @argument {Element} element125* @returns {Element} scroll parent126*/127function getScrollParent(element) {128// Return body, `getScroll` will take care to get the correct `scrollTop` from it129if (!element) {130return document.body;131}132}149/**151* Returns the reference node of the reference object, or the reference object itself.152* @method153* @memberof Popper.Utils154* @param {Element|Object} reference - the reference element (the popper will be relative to this)155* @returns {Element} parent156*/157function getReferenceNode(reference) {158return reference && reference.referenceNode ? reference.referenceNode : reference;159}160/**165* Determines if the browser is Internet Explorer166* @method167* @memberof Popper.Utils168* @param {Number} version to check169* @returns {Boolean} isIE170*/171function isIE(version) {172if (version === 11) {173return isIE11;174}175if (version === 10) {176return isIE10;177}178return isIE11 || isIE10;179}180/**182* Returns the offset parent of the given element183* @method184* @memberof Popper.Utils185* @argument {Element} element186* @returns {Element} offset parent187*/188function getOffsetParent(element) {189if (!element) {190return document.documentElement;191}192}216}224/**226* Finds the root node (document, shadowDOM root) of the given element227* @method228* @memberof Popper.Utils229* @argument {Element} node230* @returns {Element} root node231*/232function getRoot(node) {233if (node.parentNode !== null) {234return getRoot(node.parentNode);235}236}239/**241* Finds the offset parent common to the two provided nodes242* @method243* @memberof Popper.Utils244* @argument {Element} element1245* @argument {Element} element2246* @returns {Element} common offset parent247*/248function findCommonOffsetParent(element1, element2) {249// This check is needed to avoid errors in case one of the elements isn't defined for any reason250if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {251return document.documentElement;252}253}282/**284* Gets the scroll value of the given element in the given side (top and left)285* @method286* @memberof Popper.Utils287* @argument {Element} element288* @argument {String} side `top` or `left`289* @returns {number} amount of scrolled pixels290*/291function getScroll(element, side = 'top') {292const upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';293const nodeName = element.nodeName;294}303/*305* Sum or subtract the element scroll values (left and top) from a given rect object306* @method307* @memberof Popper.Utils308* @param {Object} rect - Rect object you want to change309* @param {HTMLElement} element - The element from the function reads the scroll values310* @param {Boolean} subtract - set to true if you want to subtract the scroll values311* @return {Object} rect - The modifier rect object312*/313function includeScroll(rect, element, subtract = false) {314const scrollTop = getScroll(element, 'top');315const scrollLeft = getScroll(element, 'left');316const modifier = subtract ? -1 : 1;317rect.top += scrollTop * modifier;318rect.bottom += scrollTop * modifier;319rect.left += scrollLeft * modifier;320rect.right += scrollLeft * modifier;321return rect;322}323/*325* Helper to detect borders of a given element326* @method327* @memberof Popper.Utils328* @param {CSSStyleDeclaration} styles329* Result of `getStyleComputedProperty` on the given element330* @param {String} axis - `x` or `y`331* @return {number} borders - The borders size of the given axis332*/333}340}344}355/**371* Given element offsets, generate an output similar to getBoundingClientRect372* @method373* @memberof Popper.Utils374* @argument {Object} offsets375* @returns {Object} ClientRect like output376*/377function getClientRect(offsets) {378return _extends({}, offsets, {379right: offsets.left + offsets.width,380bottom: offsets.top + offsets.height381});382}383/**385* Get bounding client rect of given element386* @method387* @memberof Popper.Utils388* @param {HTMLElement} element389* @return {Object} client rect390*/391function getBoundingClientRect(element) {392let rect = {};393}439}489height504};505}508/**510* Check if the given element is fixed or is inside a fixed parent511* @method512* @memberof Popper.Utils513* @argument {Element} element514* @argument {Element} customContainer515* @returns {Boolean} answer to "isFixed?"516*/517function isFixed(element) {518const nodeName = element.nodeName;519if (nodeName === 'BODY' || nodeName === 'HTML') {520return false;521}522if (getStyleComputedProperty(element, 'position') === 'fixed') {523return true;524}525const parentNode = getParentNode(element);526if (!parentNode) {527return false;528}529return isFixed(parentNode);530}531/**533* Finds the first parent of an element that has a transformed property defined534* @method535* @memberof Popper.Utils536* @argument {Element} element537* @returns {Element} first transformed parent or documentElement538*/539}551/**553* Computed the boundaries limits and return them554* @method555* @memberof Popper.Utils556* @param {HTMLElement} popper557* @param {HTMLElement} reference558* @param {number} padding559* @param {HTMLElement} boundariesElement - Element used to define the boundaries560* @param {Boolean} fixedPosition - Is in fixed position mode561* @returns {Object} Coordinates of the boundaries562*/563function getBoundaries(popper, reference, padding, boundariesElement, fixedPosition = false) {564// NOTE: 1 DOM access here565}611}615/**617* Utility used to transform the `auto` placement to the placement with more618* available space.619* @method620* @memberof Popper.Utils621* @argument {Object} data - The data object generated by update method622* @argument {Object} options - Modifiers configuration and options623* @returns {Object} The data object, properly modified624*/625function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement, padding = 0) {626if (placement.indexOf('auto') === -1) {627return placement;628}629key653}, rects[key], {654area: getArea(rects[key])655})).sort((a, b) => b.area - a.area);656}665/**667* Get offsets to the reference element668* @method669* @memberof Popper.Utils670* @param {Object} state671* @param {Element} popper - the popper element672* @param {Element} reference - the reference element (the popper will be relative to this)673* @param {Element} fixedPosition - is in fixed position mode674* @returns {Object} An object containing the offsets which will be applied to the popper675*/676function getReferenceOffsets(state, popper, reference, fixedPosition = null) {677const commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));678return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);679}680/**682* Get the outer sizes of the given element (offset size + margins)683* @method684* @memberof Popper.Utils685* @argument {Element} element686* @returns {Object} object containing width and height properties687*/688function getOuterSizes(element) {689const window = element.ownerDocument.defaultView;690const styles = window.getComputedStyle(element);691const x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);692const y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);693const result = {694width: element.offsetWidth + y,695height: element.offsetHeight + x696};697return result;698}699/**701* Get the opposite placement of the given one702* @method703* @memberof Popper.Utils704* @argument {String} placement705* @returns {String} flipped placement706*/707function getOppositePlacement(placement) {708const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };709return placement.replace(/left|right|bottom|top/g, matched => hash[matched]);710}711/**713* Get offsets to the popper714* @method715* @memberof Popper.Utils716* @param {Object} position - CSS position the Popper will get applied717* @param {HTMLElement} popper - the popper element718* @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)719* @param {String} placement - one of the valid placement options720* @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper721*/722function getPopperOffsets(popper, referenceOffsets, placement) {723placement = placement.split('-')[0];724}750/**752* Mimics the `find` method of Array753* @method754* @memberof Popper.Utils755* @argument {Array} arr756* @argument prop757* @argument value758* @returns index or -1759*/760function find(arr, check) {761// use native find if supported762if (Array.prototype.find) {763return arr.find(check);764}765}769/**771* Return the index of the matching object772* @method773* @memberof Popper.Utils774* @argument {Array} arr775* @argument prop776* @argument value777* @returns index or -1778*/779function findIndex(arr, prop, value) {780// use native findIndex if supported781if (Array.prototype.findIndex) {782return arr.findIndex(cur => cur[prop] === value);783}784}789/**791* Loop trough the list of modifiers and run them in order,792* each of them will then edit the data object.793* @method794* @memberof Popper.Utils795* @param {dataObject} data796* @param {Array} modifiers797* @param {String} ends - Optional modifier name used as stopper798* @returns {dataObject}799*/800function runModifiers(modifiers, data, ends) {801const modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));802}822/**824* Updates the position of the popper, computing the new offsets and applying825* the new style.<br />826* Prefer `scheduleUpdate` over `update` because of performance reasons.827* @method828* @memberof Popper829*/830function update() {831// if popper is destroyed, don't perform any further update832if (this.state.isDestroyed) {833return;834}835}875/**877* Helper used to know if the given modifier is enabled.878* @method879* @memberof Popper.Utils880* @returns {Boolean}881*/882function isModifierEnabled(modifiers, modifierName) {883return modifiers.some(({ name, enabled }) => enabled && name === modifierName);884}885/**887* Get the prefixed supported property name888* @method889* @memberof Popper.Utils890* @argument {String} property (camelCase)891* @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)892*/893function getSupportedPropertyName(property) {894const prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];895const upperProp = property.charAt(0).toUpperCase() + property.slice(1);896}906/**908* Destroys the popper.909* @method910* @memberof Popper911*/912function destroy() {913this.state.isDestroyed = true;914}936/**938* Get the window associated with the element939* @argument {Element} element940* @returns {Window}941*/942function getWindow(element) {943const ownerDocument = element.ownerDocument;944return ownerDocument ? ownerDocument.defaultView : window;945}946}957/**959* Setup needed event listeners used to update the popper position960* @method961* @memberof Popper.Utils962* @private963*/964function setupEventListeners(reference, options, state, updateBound) {965// Resize event listener on window966state.updateBound = updateBound;967getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });968}977/**979* It will add resize/scroll events and start recalculating980* position of the popper element when they are triggered.981* @method982* @memberof Popper983*/984function enableEventListeners() {985if (!this.state.eventsEnabled) {986this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);987}988}989/**991* Remove event listeners used to update the popper position992* @method993* @memberof Popper.Utils994* @private995*/996function removeEventListeners(reference, state) {997// Remove resize event listener on window998getWindow(reference).removeEventListener('resize', state.updateBound);999}1012/**1014* It will remove resize/scroll events and won't recalculate popper position1015* when they are triggered. It also won't trigger `onUpdate` callback anymore,1016* unless you call `update` method manually.1017* @method1018* @memberof Popper1019*/1020function disableEventListeners() {1021if (this.state.eventsEnabled) {1022cancelAnimationFrame(this.scheduleUpdate);1023this.state = removeEventListeners(this.reference, this.state);1024}1025}1026/**1028* Tells if a given input is a number1029* @method1030* @memberof Popper.Utils1031* @param {*} input to check1032* @return {Boolean}1033*/1034function isNumeric(n) {1035return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);1036}1037/**1039* Set the style to the given popper1040* @method1041* @memberof Popper.Utils1042* @argument {Element} element - Element to apply the style to1043* @argument {Object} styles1044* Object with a list of properties and values which will be applied to the element1045*/1046function setStyles(element, styles) {1047Object.keys(styles).forEach(prop => {1048let unit = '';1049// add unit if the value is numeric and is one of the following1050if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {1051unit = 'px';1052}1053element.style[prop] = styles[prop] + unit;1054});1055}1056/**1058* Set the attributes to the given popper1059* @method1060* @memberof Popper.Utils1061* @argument {Element} element - Element to apply the attributes to1062* @argument {Object} styles1063* Object with a list of properties and values which will be applied to the element1064*/1065function setAttributes(element, attributes) {1066Object.keys(attributes).forEach(function (prop) {1067const value = attributes[prop];1068if (value !== false) {1069element.setAttribute(prop, attributes[prop]);1070} else {1071element.removeAttribute(prop);1072}1073});1074}1075/**1077* @function1078* @memberof Modifiers1079* @argument {Object} data - The data object generated by `update` method1080* @argument {Object} data.styles - List of style properties - values to apply to popper element1081* @argument {Object} data.attributes - List of attribute properties - values to apply to popper element1082* @argument {Object} options - Modifiers configuration and options1083* @returns {Object} The same data object1084*/1085function applyStyle(data) {1086// any property present in `data.styles` will be applied to the popper,1087// in this way we can make the 3rd party modifiers add custom styles to it1088// Be aware, modifiers could override the properties defined in the previous1089// lines of this modifier!1090setStyles(data.instance.popper, data.styles);1091}1103/**1105* Set the x-placement attribute before everything else because it could be used1106* to add margins to the popper margins needs to be calculated to get the1107* correct popper offsets.1108* @method1109* @memberof Popper.modifiers1110* @param {HTMLElement} reference - The reference element used to position the popper1111* @param {HTMLElement} popper - The HTML element used as popper1112* @param {Object} options - Popper.js options1113*/1114function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {1115// compute reference element offsets1116const referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);1117}1131/**1133* @function1134* @memberof Popper.Utils1135* @argument {Object} data - The data object generated by `update` method1136* @argument {Boolean} shouldRound - If the offsets should be rounded at all1137* @returns {Object} The popper's position offsets rounded1138*1139* The tale of pixel-perfect positioning. It's still not 100% perfect, but as1140* good as it can be within reason.1141* Discussion here: https://github.com/FezVrasta/popper.js/pull/7151142*1143* Low DPI screens cause a popper to be blurry if not using full pixels (Safari1144* as well on High DPI screens).1145*1146* Firefox prefers no rounding for positioning and does not have blurriness on1147* high DPI screens.1148*1149* Only horizontal placement and left/right values need to be considered.1150*/1151function getRoundedOffsets(data, shouldRound) {1152const { popper, reference } = data.offsets;1153const { round, floor } = Math;1154const noRound = v => v;1155}1174/**1178* @function1179* @memberof Modifiers1180* @argument {Object} data - The data object generated by `update` method1181* @argument {Object} options - Modifiers configuration and options1182* @returns {Object} The data object, properly modified1183*/1184function computeStyle(data, options) {1185const { x, y } = options;1186const { popper } = data.offsets;1187}1269/**1271* Helper used to know if the given modifier depends from another one.<br />1272* It checks if the needed modifier is listed and enabled.1273* @method1274* @memberof Popper.Utils1275* @param {Array} modifiers - list of modifiers1276* @param {String} requestingName - name of requesting modifier1277* @param {String} requestedName - name of requested modifier1278* @returns {Boolean}1279*/1280function isModifierRequired(modifiers, requestingName, requestedName) {1281const requesting = find(modifiers, ({ name }) => name === requestingName);1282}1294/**1296* @function1297* @memberof Modifiers1298* @argument {Object} data - The data object generated by update method1299* @argument {Object} options - Modifiers configuration and options1300* @returns {Object} The data object, properly modified1301*/1302function arrow(data, options) {1303// arrow depends on keepTogether in order to work1304if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {1305return data;1306}1307}1374/**1376* Get the opposite placement variation of the given one1377* @method1378* @memberof Popper.Utils1379* @argument {String} placement variation1380* @returns {String} flipped placement variation1381*/1382function getOppositeVariation(variation) {1383if (variation === 'end') {1384return 'start';1385} else if (variation === 'start') {1386return 'end';1387}1388return variation;1389}1390/**1392* List of accepted placements to use as values of the `placement` option.<br />1393* Valid placements are:1394* - `auto`1395* - `top`1396* - `right`1397* - `bottom`1398* - `left`1399*1400* Each placement can have a variation from this list:1401* - `-start`1402* - `-end`1403*1404* Variations are interpreted easily if you think of them as the left to right1405* written languages. Horizontally (`top` and `bottom`), `start` is left and `end`1406* is right.<br />1407* Vertically (`left` and `right`), `start` is top and `end` is bottom.1408*1409* Some valid examples are:1410* - `top-end` (on top of reference, right aligned)1411* - `right-start` (on right of reference, top aligned)1412* - `bottom` (on bottom, centered)1413* - `auto-end` (on the side with more space available, alignment depends by placement)1414*1415* @static1416* @type {Array}1417* @enum {String}1418* @readonly1419* @method placements1420* @memberof Popper1421*/1422var 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'];1423// Get rid of `auto` `auto-start` and `auto-end`1425const validPlacements = placements.slice(3);1426/**1428* Given an initial placement, returns all the subsequent placements1429* clockwise (or counter-clockwise).1430*1431* @method1432* @memberof Popper.Utils1433* @argument {String} placement - A valid placement (it accepts variations)1434* @argument {Boolean} counter - Set to true to walk the placements counterclockwise1435* @returns {Array} placements including their variations1436*/1437function clockwise(placement, counter = false) {1438const index = validPlacements.indexOf(placement);1439const arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));1440return counter ? arr.reverse() : arr;1441}1442/**1450* @function1451* @memberof Modifiers1452* @argument {Object} data - The data object generated by update method1453* @argument {Object} options - Modifiers configuration and options1454* @returns {Object} The data object, properly modified1455*/1456function flip(data, options) {1457// if `inner` modifier is enabled, we can't use the `flip` modifier1458if (isModifierEnabled(data.instance.modifiers, 'inner')) {1459return data;1460}1461}1545/**1547* @function1548* @memberof Modifiers1549* @argument {Object} data - The data object generated by update method1550* @argument {Object} options - Modifiers configuration and options1551* @returns {Object} The data object, properly modified1552*/1553function keepTogether(data) {1554const { popper, reference } = data.offsets;1555const placement = data.placement.split('-')[0];1556const floor = Math.floor;1557const isVertical = ['top', 'bottom'].indexOf(placement) !== -1;1558const side = isVertical ? 'right' : 'bottom';1559const opSide = isVertical ? 'left' : 'top';1560const measurement = isVertical ? 'width' : 'height';1561}1571/**1573* Converts a string containing value + unit into a px value number1574* @function1575* @memberof {modifiers~offset}1576* @private1577* @argument {String} str - Value + unit string1578* @argument {String} measurement - `height` or `width`1579* @argument {Object} popperOffsets1580* @argument {Object} referenceOffsets1581* @returns {Number|String}1582* Value in pixels, or original string if no values were extracted1583*/1584function toValue(str, measurement, popperOffsets, referenceOffsets) {1585// separate value from unit1586const split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);1587const value = +split[1];1588const unit = split[2];1589}1624/**1626* Parse an `offset` string to extrapolate `x` and `y` numeric offsets.1627* @function1628* @memberof {modifiers~offset}1629* @private1630* @argument {String} offset1631* @argument {Object} popperOffsets1632* @argument {Object} referenceOffsets1633* @argument {String} basePlacement1634* @returns {Array} a two cells array with x and y offsets in numbers1635*/1636function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {1637const offsets = [0, 0];1638}1696/**1698* @function1699* @memberof Modifiers1700* @argument {Object} data - The data object generated by update method1701* @argument {Object} options - Modifiers configuration and options1702* @argument {Number|String} options.offset=01703* The offset value as described in the modifier description1704* @returns {Object} The data object, properly modified1705*/1706function offset(data, { offset }) {1707const { placement, offsets: { popper, reference } } = data;1708const basePlacement = placement.split('-')[0];1709}1734/**1736* @function1737* @memberof Modifiers1738* @argument {Object} data - The data object generated by `update` method1739* @argument {Object} options - Modifiers configuration and options1740* @returns {Object} The data object, properly modified1741*/1742function preventOverflow(data, options) {1743let boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);1744}1802/**1804* @function1805* @memberof Modifiers1806* @argument {Object} data - The data object generated by `update` method1807* @argument {Object} options - Modifiers configuration and options1808* @returns {Object} The data object, properly modified1809*/1810function shift(data) {1811const placement = data.placement;1812const basePlacement = placement.split('-')[0];1813const shiftvariation = placement.split('-')[1];1814}1834/**1836* @function1837* @memberof Modifiers1838* @argument {Object} data - The data object generated by update method1839* @argument {Object} options - Modifiers configuration and options1840* @returns {Object} The data object, properly modified1841*/1842function hide(data) {1843if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {1844return data;1845}1846}1870/**1872* @function1873* @memberof Modifiers1874* @argument {Object} data - The data object generated by `update` method1875* @argument {Object} options - Modifiers configuration and options1876* @returns {Object} The data object, properly modified1877*/1878function inner(data) {1879const placement = data.placement;1880const basePlacement = placement.split('-')[0];1881const { popper, reference } = data.offsets;1882const isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;1883}1893/**1895* Modifier function, each modifier can have a function of this type assigned1896* to its `fn` property.<br />1897* These functions will be called on each update, this means that you must1898* make sure they are performant enough to avoid performance bottlenecks.1899*1900* @function ModifierFn1901* @argument {dataObject} data - The data object generated by `update` method1902* @argument {Object} options - Modifiers configuration and options1903* @returns {dataObject} The data object, properly modified1904*/1905/**1907* Modifiers are plugins used to alter the behavior of your poppers.<br />1908* Popper.js uses a set of 9 modifiers to provide all the basic functionalities1909* needed by the library.1910*1911* Usually you don't want to override the `order`, `fn` and `onLoad` props.1912* All the other properties are configurations that could be tweaked.1913* @namespace modifiers1914*/1915var modifiers = {1916/**1917* Modifier used to shift the popper on the start or end of its reference1918* element.<br />1919* It will read the variation of the `placement` property.<br />1920* It can be one either `-end` or `-start`.1921* @memberof modifiers1922* @inner1923*/1924shift: {1925/** @prop {number} order=100 - Index used to define the order of execution */1926order: 100,1927/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */1928enabled: true,1929/** @prop {ModifierFn} */1930fn: shift1931},1932* The `offset` modifier can shift your popper on both its axis.1935*1936* It accepts the following units:1937* - `px` or unit-less, interpreted as pixels1938* - `%` or `%r`, percentage relative to the length of the reference element1939* - `%p`, percentage relative to the length of the popper element1940* - `vw`, CSS viewport width unit1941* - `vh`, CSS viewport height unit1942*1943* For length is intended the main axis relative to the placement of the popper.<br />1944* This means that if the placement is `top` or `bottom`, the length will be the1945* `width`. In case of `left` or `right`, it will be the `height`.1946*1947* You can provide a single value (as `Number` or `String`), or a pair of values1948* as `String` divided by a comma or one (or more) white spaces.<br />1949* The latter is a deprecated method because it leads to confusion and will be1950* removed in v2.<br />1951* Additionally, it accepts additions and subtractions between different units.1952* Note that multiplications and divisions aren't supported.1953*1954* Valid examples are:1955* ```1956* 101957* '10%'1958* '10, 10'1959* '10%, 10'1960* '10 + 10%'1961* '10 - 5vh + 3%'1962* '-10px + 5vh, 5px - 6%'1963* ```1964* > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap1965* > with their reference element, unfortunately, you will have to disable the `flip` modifier.1966* > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).1967*1968* @memberof modifiers1969* @inner1970*/1971offset: {1972/** @prop {number} order=200 - Index used to define the order of execution */1973order: 200,1974/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */1975enabled: true,1976/** @prop {ModifierFn} */1977fn: offset,1978/** @prop {Number|String} offset=01979* The offset value as described in the modifier description1980*/1981offset: 01982},1983* Modifier used to prevent the popper from being positioned outside the boundary.1986*1987* A scenario exists where the reference itself is not within the boundaries.<br />1988* We can say it has "escaped the boundaries" — or just "escaped".<br />1989* In this case we need to decide whether the popper should either:1990*1991* - detach from the reference and remain "trapped" in the boundaries, or1992* - if it should ignore the boundary and "escape with its reference"1993*1994* When `escapeWithReference` is set to`true` and reference is completely1995* outside its boundaries, the popper will overflow (or completely leave)1996* the boundaries in order to remain attached to the edge of the reference.1997*1998* @memberof modifiers1999* @inner2000*/2001preventOverflow: {2002/** @prop {number} order=300 - Index used to define the order of execution */2003order: 300,2004/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2005enabled: true,2006/** @prop {ModifierFn} */2007fn: preventOverflow,2008/**2009* @prop {Array} [priority=['left','right','top','bottom']]2010* Popper will try to prevent overflow following these priorities by default,2011* then, it could overflow on the left and on top of the `boundariesElement`2012*/2013priority: ['left', 'right', 'top', 'bottom'],2014/**2015* @prop {number} padding=52016* Amount of pixel used to define a minimum distance between the boundaries2017* and the popper. This makes sure the popper always has a little padding2018* between the edges of its container2019*/2020padding: 5,2021/**2022* @prop {String|HTMLElement} boundariesElement='scrollParent'2023* Boundaries used by the modifier. Can be `scrollParent`, `window`,2024* `viewport` or any DOM element.2025*/2026boundariesElement: 'scrollParent'2027},2028* Modifier used to make sure the reference and its popper stay near each other2031* without leaving any gap between the two. Especially useful when the arrow is2032* enabled and you want to ensure that it points to its reference element.2033* It cares only about the first axis. You can still have poppers with margin2034* between the popper and its reference element.2035* @memberof modifiers2036* @inner2037*/2038keepTogether: {2039/** @prop {number} order=400 - Index used to define the order of execution */2040order: 400,2041/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2042enabled: true,2043/** @prop {ModifierFn} */2044fn: keepTogether2045},2046* This modifier is used to move the `arrowElement` of the popper to make2049* sure it is positioned between the reference element and its popper element.2050* It will read the outer size of the `arrowElement` node to detect how many2051* pixels of conjunction are needed.2052*2053* It has no effect if no `arrowElement` is provided.2054* @memberof modifiers2055* @inner2056*/2057arrow: {2058/** @prop {number} order=500 - Index used to define the order of execution */2059order: 500,2060/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2061enabled: true,2062/** @prop {ModifierFn} */2063fn: arrow,2064/** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */2065element: '[x-arrow]'2066},2067* Modifier used to flip the popper's placement when it starts to overlap its2070* reference element.2071*2072* Requires the `preventOverflow` modifier before it in order to work.2073*2074* **NOTE:** this modifier will interrupt the current update cycle and will2075* restart it if it detects the need to flip the placement.2076* @memberof modifiers2077* @inner2078*/2079flip: {2080/** @prop {number} order=600 - Index used to define the order of execution */2081order: 600,2082/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2083enabled: true,2084/** @prop {ModifierFn} */2085fn: flip,2086/**2087* @prop {String|Array} behavior='flip'2088* The behavior used to change the popper's placement. It can be one of2089* `flip`, `clockwise`, `counterclockwise` or an array with a list of valid2090* placements (with optional variations)2091*/2092behavior: 'flip',2093/**2094* @prop {number} padding=52095* The popper will flip if it hits the edges of the `boundariesElement`2096*/2097padding: 5,2098/**2099* @prop {String|HTMLElement} boundariesElement='viewport'2100* The element which will define the boundaries of the popper position.2101* The popper will never be placed outside of the defined boundaries2102* (except if `keepTogether` is enabled)2103*/2104boundariesElement: 'viewport',2105/**2106* @prop {Boolean} flipVariations=false2107* The popper will switch placement variation between `-start` and `-end` when2108* the reference element overlaps its boundaries.2109*2110* The original placement should have a set variation.2111*/2112flipVariations: false,2113/**2114* @prop {Boolean} flipVariationsByContent=false2115* The popper will switch placement variation between `-start` and `-end` when2116* the popper element overlaps its reference boundaries.2117*2118* The original placement should have a set variation.2119*/2120flipVariationsByContent: false2121},2122* Modifier used to make the popper flow toward the inner of the reference element.2125* By default, when this modifier is disabled, the popper will be placed outside2126* the reference element.2127* @memberof modifiers2128* @inner2129*/2130inner: {2131/** @prop {number} order=700 - Index used to define the order of execution */2132order: 700,2133/** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */2134enabled: false,2135/** @prop {ModifierFn} */2136fn: inner2137},2138* Modifier used to hide the popper when its reference element is outside of the2141* popper boundaries. It will set a `x-out-of-boundaries` attribute which can2142* be used to hide with a CSS selector the popper when its reference is2143* out of boundaries.2144*2145* Requires the `preventOverflow` modifier before it in order to work.2146* @memberof modifiers2147* @inner2148*/2149hide: {2150/** @prop {number} order=800 - Index used to define the order of execution */2151order: 800,2152/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2153enabled: true,2154/** @prop {ModifierFn} */2155fn: hide2156},2157* Computes the style that will be applied to the popper element to gets2160* properly positioned.2161*2162* Note that this modifier will not touch the DOM, it just prepares the styles2163* so that `applyStyle` modifier can apply it. This separation is useful2164* in case you need to replace `applyStyle` with a custom implementation.2165*2166* This modifier has `850` as `order` value to maintain backward compatibility2167* with previous versions of Popper.js. Expect the modifiers ordering method2168* to change in future major versions of the library.2169*2170* @memberof modifiers2171* @inner2172*/2173computeStyle: {2174/** @prop {number} order=850 - Index used to define the order of execution */2175order: 850,2176/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2177enabled: true,2178/** @prop {ModifierFn} */2179fn: computeStyle,2180/**2181* @prop {Boolean} gpuAcceleration=true2182* If true, it uses the CSS 3D transformation to position the popper.2183* Otherwise, it will use the `top` and `left` properties2184*/2185gpuAcceleration: true,2186/**2187* @prop {string} [x='bottom']2188* Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.2189* Change this if your popper should grow in a direction different from `bottom`2190*/2191x: 'bottom',2192/**2193* @prop {string} [x='left']2194* Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.2195* Change this if your popper should grow in a direction different from `right`2196*/2197y: 'right'2198},2199* Applies the computed styles to the popper element.2202*2203* All the DOM manipulations are limited to this modifier. This is useful in case2204* you want to integrate Popper.js inside a framework or view library and you2205* want to delegate all the DOM manipulations to it.2206*2207* Note that if you disable this modifier, you must make sure the popper element2208* has its position set to `absolute` before Popper.js can do its work!2209*2210* Just disable this modifier and define your own to achieve the desired effect.2211*2212* @memberof modifiers2213* @inner2214*/2215applyStyle: {2216/** @prop {number} order=900 - Index used to define the order of execution */2217order: 900,2218/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2219enabled: true,2220/** @prop {ModifierFn} */2221fn: applyStyle,2222/** @prop {Function} */2223onLoad: applyStyleOnLoad,2224/**2225* @deprecated since version 1.10.0, the property moved to `computeStyle` modifier2226* @prop {Boolean} gpuAcceleration=true2227* If true, it uses the CSS 3D transformation to position the popper.2228* Otherwise, it will use the `top` and `left` properties2229*/2230gpuAcceleration: undefined2231}2232};2233/**2235* The `dataObject` is an object containing all the information used by Popper.js.2236* This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.2237* @name dataObject2238* @property {Object} data.instance The Popper.js instance2239* @property {String} data.placement Placement applied to popper2240* @property {String} data.originalPlacement Placement originally defined on init2241* @property {Boolean} data.flipped True if popper has been flipped by flip modifier2242* @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper2243* @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier2244* @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)2245* @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)2246* @property {Object} data.boundaries Offsets of the popper boundaries2247* @property {Object} data.offsets The measurements of popper, reference and arrow elements2248* @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values2249* @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values2250* @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 02251*/2252/**2254* Default options provided to Popper.js constructor.<br />2255* These can be overridden using the `options` argument of Popper.js.<br />2256* To override an option, simply pass an object with the same2257* structure of the `options` object, as the 3rd argument. For example:2258* ```2259* new Popper(ref, pop, {2260* modifiers: {2261* preventOverflow: { enabled: false }2262* }2263* })2264* ```2265* @type {Object}2266* @static2267* @memberof Popper2268*/2269var Defaults = {2270/**2271* Popper's placement.2272* @prop {Popper.placements} placement='bottom'2273*/2274placement: 'bottom',2275* Set this to true if you want popper to position it self in 'fixed' mode2278* @prop {Boolean} positionFixed=false2279*/2280positionFixed: false,2281* Whether events (resize, scroll) are initially enabled.2284* @prop {Boolean} eventsEnabled=true2285*/2286eventsEnabled: true,2287* Set to true if you want to automatically remove the popper when2290* you call the `destroy` method.2291* @prop {Boolean} removeOnDestroy=false2292*/2293removeOnDestroy: false,2294* Callback called when the popper is created.<br />2297* By default, it is set to no-op.<br />2298* Access Popper.js instance with `data.instance`.2299* @prop {onCreate}2300*/2301onCreate: () => {},2302* Callback called when the popper is updated. This callback is not called2305* on the initialization/creation of the popper, but only on subsequent2306* updates.<br />2307* By default, it is set to no-op.<br />2308* Access Popper.js instance with `data.instance`.2309* @prop {onUpdate}2310*/2311onUpdate: () => {},2312* List of modifiers used to modify the offsets before they are applied to the popper.2315* They provide most of the functionalities of Popper.js.2316* @prop {modifiers}2317*/2318modifiers2319};2320/**2322* @callback onCreate2323* @param {dataObject} data2324*/2325/**2327* @callback onUpdate2328* @param {dataObject} data2329*/2330// Utils2332// Methods2333class Popper {2334/**2335* Creates a new Popper.js instance.2336* @class Popper2337* @param {Element|referenceObject} reference - The reference element used to position the popper2338* @param {Element} popper - The HTML / XML element used as the popper2339* @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)2340* @return {Object} instance - The generated Popper.js instance2341*/2342constructor(reference, popper, options = {}) {2343this.scheduleUpdate = () => requestAnimationFrame(this.update);2344name2371}, this.options.modifiers[name]))2372// sort the modifiers by order2373.sort((a, b) => a.order - b.order);2374* Schedules an update. It will run on the next UI update available.2414* @method scheduleUpdate2415* @memberof Popper2416*/2417* Collection of utilities useful when writing custom modifiers.2421* Starting from version 1.7, this method is available only if you2422* include `popper-utils.js` before `popper.js`.2423*2424* **DEPRECATION**: This way to access PopperUtils is deprecated2425* and will be removed in v2! Use the PopperUtils module directly instead.2426* Due to the high instability of the methods contained in Utils, we can't2427* guarantee them to follow semver. Use them at your own risk!2428* @static2429* @private2430* @type {Object}2431* @deprecated since version 1.82432* @member Utils2433* @memberof Popper2434*/2435}2436/**2438* The `referenceObject` is an object that provides an interface compatible with Popper.js2439* and lets you use it as replacement of a real DOM node.<br />2440* You can use this method to position a popper relatively to a set of coordinates2441* in case you don't have a DOM node to use as reference.2442*2443* ```2444* new Popper(referenceObject, popperNode);2445* ```2446*2447* NB: This feature isn't supported in Internet Explorer 10.2448* @name referenceObject2449* @property {Function} data.getBoundingClientRect2450* A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.2451* @property {number} data.clientWidth2452* An ES6 getter that will return the width of the virtual reference element.2453* @property {number} data.clientHeight2454* An ES6 getter that will return the height of the virtual reference element.2455*/2456//# sourceMappingURL=popper.js.map2463