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) {85var 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 here101var window = element.ownerDocument.defaultView;102var 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}154/**156* Returns the reference node of the reference object, or the reference object itself.157* @method158* @memberof Popper.Utils159* @param {Element|Object} reference - the reference element (the popper will be relative to this)160* @returns {Element} parent161*/162function getReferenceNode(reference) {163return reference && reference.referenceNode ? reference.referenceNode : reference;164}165/**170* Determines if the browser is Internet Explorer171* @method172* @memberof Popper.Utils173* @param {Number} version to check174* @returns {Boolean} isIE175*/176function isIE(version) {177if (version === 11) {178return isIE11;179}180if (version === 10) {181return isIE10;182}183return isIE11 || isIE10;184}185/**187* Returns the offset parent of the given element188* @method189* @memberof Popper.Utils190* @argument {Element} element191* @returns {Element} offset parent192*/193function getOffsetParent(element) {194if (!element) {195return document.documentElement;196}197}221}230/**232* Finds the root node (document, shadowDOM root) of the given element233* @method234* @memberof Popper.Utils235* @argument {Element} node236* @returns {Element} root node237*/238function getRoot(node) {239if (node.parentNode !== null) {240return getRoot(node.parentNode);241}242}245/**247* Finds the offset parent common to the two provided nodes248* @method249* @memberof Popper.Utils250* @argument {Element} element1251* @argument {Element} element2252* @returns {Element} common offset parent253*/254function findCommonOffsetParent(element1, element2) {255// This check is needed to avoid errors in case one of the elements isn't defined for any reason256if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {257return document.documentElement;258}259}289/**291* Gets the scroll value of the given element in the given side (top and left)292* @method293* @memberof Popper.Utils294* @argument {Element} element295* @argument {String} side `top` or `left`296* @returns {number} amount of scrolled pixels297*/298function getScroll(element) {299var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';300}312/*314* Sum or subtract the element scroll values (left and top) from a given rect object315* @method316* @memberof Popper.Utils317* @param {Object} rect - Rect object you want to change318* @param {HTMLElement} element - The element from the function reads the scroll values319* @param {Boolean} subtract - set to true if you want to subtract the scroll values320* @return {Object} rect - The modifier rect object321*/322function includeScroll(rect, element) {323var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;324}334/*336* Helper to detect borders of a given element337* @method338* @memberof Popper.Utils339* @param {CSSStyleDeclaration} styles340* Result of `getStyleComputedProperty` on the given element341* @param {String} axis - `x` or `y`342* @return {number} borders - The borders size of the given axis343*/344}351}355}366/**425* Given element offsets, generate an output similar to getBoundingClientRect426* @method427* @memberof Popper.Utils428* @argument {Object} offsets429* @returns {Object} ClientRect like output430*/431function getClientRect(offsets) {432return _extends({}, offsets, {433right: offsets.left + offsets.width,434bottom: offsets.top + offsets.height435});436}437/**439* Get bounding client rect of given element440* @method441* @memberof Popper.Utils442* @param {HTMLElement} element443* @return {Object} client rect444*/445function getBoundingClientRect(element) {446var rect = {};447}493}545}566/**568* Check if the given element is fixed or is inside a fixed parent569* @method570* @memberof Popper.Utils571* @argument {Element} element572* @argument {Element} customContainer573* @returns {Boolean} answer to "isFixed?"574*/575function isFixed(element) {576var nodeName = element.nodeName;577if (nodeName === 'BODY' || nodeName === 'HTML') {578return false;579}580if (getStyleComputedProperty(element, 'position') === 'fixed') {581return true;582}583var parentNode = getParentNode(element);584if (!parentNode) {585return false;586}587return isFixed(parentNode);588}589/**591* Finds the first parent of an element that has a transformed property defined592* @method593* @memberof Popper.Utils594* @argument {Element} element595* @returns {Element} first transformed parent or documentElement596*/597}609/**611* Computed the boundaries limits and return them612* @method613* @memberof Popper.Utils614* @param {HTMLElement} popper615* @param {HTMLElement} reference616* @param {number} padding617* @param {HTMLElement} boundariesElement - Element used to define the boundaries618* @param {Boolean} fixedPosition - Is in fixed position mode619* @returns {Object} Coordinates of the boundaries620*/621function getBoundaries(popper, reference, padding, boundariesElement) {622var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;623}674}681/**683* Utility used to transform the `auto` placement to the placement with more684* available space.685* @method686* @memberof Popper.Utils687* @argument {Object} data - The data object generated by update method688* @argument {Object} options - Modifiers configuration and options689* @returns {Object} The data object, properly modified690*/691function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {692var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;693}741/**743* Get offsets to the reference element744* @method745* @memberof Popper.Utils746* @param {Object} state747* @param {Element} popper - the popper element748* @param {Element} reference - the reference element (the popper will be relative to this)749* @param {Element} fixedPosition - is in fixed position mode750* @returns {Object} An object containing the offsets which will be applied to the popper751*/752function getReferenceOffsets(state, popper, reference) {753var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;754}758/**760* Get the outer sizes of the given element (offset size + margins)761* @method762* @memberof Popper.Utils763* @argument {Element} element764* @returns {Object} object containing width and height properties765*/766function getOuterSizes(element) {767var window = element.ownerDocument.defaultView;768var styles = window.getComputedStyle(element);769var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);770var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);771var result = {772width: element.offsetWidth + y,773height: element.offsetHeight + x774};775return result;776}777/**779* Get the opposite placement of the given one780* @method781* @memberof Popper.Utils782* @argument {String} placement783* @returns {String} flipped placement784*/785function getOppositePlacement(placement) {786var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };787return placement.replace(/left|right|bottom|top/g, function (matched) {788return hash[matched];789});790}791/**793* Get offsets to the popper794* @method795* @memberof Popper.Utils796* @param {Object} position - CSS position the Popper will get applied797* @param {HTMLElement} popper - the popper element798* @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)799* @param {String} placement - one of the valid placement options800* @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper801*/802function getPopperOffsets(popper, referenceOffsets, placement) {803placement = placement.split('-')[0];804}830/**832* Mimics the `find` method of Array833* @method834* @memberof Popper.Utils835* @argument {Array} arr836* @argument prop837* @argument value838* @returns index or -1839*/840function find(arr, check) {841// use native find if supported842if (Array.prototype.find) {843return arr.find(check);844}845}849/**851* Return the index of the matching object852* @method853* @memberof Popper.Utils854* @argument {Array} arr855* @argument prop856* @argument value857* @returns index or -1858*/859function findIndex(arr, prop, value) {860// use native findIndex if supported861if (Array.prototype.findIndex) {862return arr.findIndex(function (cur) {863return cur[prop] === value;864});865}866}873/**875* Loop trough the list of modifiers and run them in order,876* each of them will then edit the data object.877* @method878* @memberof Popper.Utils879* @param {dataObject} data880* @param {Array} modifiers881* @param {String} ends - Optional modifier name used as stopper882* @returns {dataObject}883*/884function runModifiers(modifiers, data, ends) {885var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));886}906/**908* Updates the position of the popper, computing the new offsets and applying909* the new style.<br />910* Prefer `scheduleUpdate` over `update` because of performance reasons.911* @method912* @memberof Popper913*/914function update() {915// if popper is destroyed, don't perform any further update916if (this.state.isDestroyed) {917return;918}919}959/**961* Helper used to know if the given modifier is enabled.962* @method963* @memberof Popper.Utils964* @returns {Boolean}965*/966function isModifierEnabled(modifiers, modifierName) {967return modifiers.some(function (_ref) {968var name = _ref.name,969enabled = _ref.enabled;970return enabled && name === modifierName;971});972}973/**975* Get the prefixed supported property name976* @method977* @memberof Popper.Utils978* @argument {String} property (camelCase)979* @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)980*/981function getSupportedPropertyName(property) {982var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];983var upperProp = property.charAt(0).toUpperCase() + property.slice(1);984}994/**996* Destroys the popper.997* @method998* @memberof Popper999*/1000function destroy() {1001this.state.isDestroyed = true;1002}1024/**1026* Get the window associated with the element1027* @argument {Element} element1028* @returns {Window}1029*/1030function getWindow(element) {1031var ownerDocument = element.ownerDocument;1032return ownerDocument ? ownerDocument.defaultView : window;1033}1034}1045/**1047* Setup needed event listeners used to update the popper position1048* @method1049* @memberof Popper.Utils1050* @private1051*/1052function setupEventListeners(reference, options, state, updateBound) {1053// Resize event listener on window1054state.updateBound = updateBound;1055getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });1056}1065/**1067* It will add resize/scroll events and start recalculating1068* position of the popper element when they are triggered.1069* @method1070* @memberof Popper1071*/1072function enableEventListeners() {1073if (!this.state.eventsEnabled) {1074this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);1075}1076}1077/**1079* Remove event listeners used to update the popper position1080* @method1081* @memberof Popper.Utils1082* @private1083*/1084function removeEventListeners(reference, state) {1085// Remove resize event listener on window1086getWindow(reference).removeEventListener('resize', state.updateBound);1087}1100/**1102* It will remove resize/scroll events and won't recalculate popper position1103* when they are triggered. It also won't trigger `onUpdate` callback anymore,1104* unless you call `update` method manually.1105* @method1106* @memberof Popper1107*/1108function disableEventListeners() {1109if (this.state.eventsEnabled) {1110cancelAnimationFrame(this.scheduleUpdate);1111this.state = removeEventListeners(this.reference, this.state);1112}1113}1114/**1116* Tells if a given input is a number1117* @method1118* @memberof Popper.Utils1119* @param {*} input to check1120* @return {Boolean}1121*/1122function isNumeric(n) {1123return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);1124}1125/**1127* Set the style to the given popper1128* @method1129* @memberof Popper.Utils1130* @argument {Element} element - Element to apply the style to1131* @argument {Object} styles1132* Object with a list of properties and values which will be applied to the element1133*/1134function setStyles(element, styles) {1135Object.keys(styles).forEach(function (prop) {1136var unit = '';1137// add unit if the value is numeric and is one of the following1138if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {1139unit = 'px';1140}1141element.style[prop] = styles[prop] + unit;1142});1143}1144/**1146* Set the attributes to the given popper1147* @method1148* @memberof Popper.Utils1149* @argument {Element} element - Element to apply the attributes to1150* @argument {Object} styles1151* Object with a list of properties and values which will be applied to the element1152*/1153function setAttributes(element, attributes) {1154Object.keys(attributes).forEach(function (prop) {1155var value = attributes[prop];1156if (value !== false) {1157element.setAttribute(prop, attributes[prop]);1158} else {1159element.removeAttribute(prop);1160}1161});1162}1163/**1165* @function1166* @memberof Modifiers1167* @argument {Object} data - The data object generated by `update` method1168* @argument {Object} data.styles - List of style properties - values to apply to popper element1169* @argument {Object} data.attributes - List of attribute properties - values to apply to popper element1170* @argument {Object} options - Modifiers configuration and options1171* @returns {Object} The same data object1172*/1173function applyStyle(data) {1174// any property present in `data.styles` will be applied to the popper,1175// in this way we can make the 3rd party modifiers add custom styles to it1176// Be aware, modifiers could override the properties defined in the previous1177// lines of this modifier!1178setStyles(data.instance.popper, data.styles);1179}1191/**1193* Set the x-placement attribute before everything else because it could be used1194* to add margins to the popper margins needs to be calculated to get the1195* correct popper offsets.1196* @method1197* @memberof Popper.modifiers1198* @param {HTMLElement} reference - The reference element used to position the popper1199* @param {HTMLElement} popper - The HTML element used as popper1200* @param {Object} options - Popper.js options1201*/1202function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {1203// compute reference element offsets1204var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);1205}1219/**1221* @function1222* @memberof Popper.Utils1223* @argument {Object} data - The data object generated by `update` method1224* @argument {Boolean} shouldRound - If the offsets should be rounded at all1225* @returns {Object} The popper's position offsets rounded1226*1227* The tale of pixel-perfect positioning. It's still not 100% perfect, but as1228* good as it can be within reason.1229* Discussion here: https://github.com/FezVrasta/popper.js/pull/7151230*1231* Low DPI screens cause a popper to be blurry if not using full pixels (Safari1232* as well on High DPI screens).1233*1234* Firefox prefers no rounding for positioning and does not have blurriness on1235* high DPI screens.1236*1237* Only horizontal placement and left/right values need to be considered.1238*/1239function getRoundedOffsets(data, shouldRound) {1240var _data$offsets = data.offsets,1241popper = _data$offsets.popper,1242reference = _data$offsets.reference;1243var round = Math.round,1244floor = Math.floor;1245}1268/**1272* @function1273* @memberof Modifiers1274* @argument {Object} data - The data object generated by `update` method1275* @argument {Object} options - Modifiers configuration and options1276* @returns {Object} The data object, properly modified1277*/1278function computeStyle(data, options) {1279var x = options.x,1280y = options.y;1281var popper = data.offsets.popper;1282}1368/**1370* Helper used to know if the given modifier depends from another one.<br />1371* It checks if the needed modifier is listed and enabled.1372* @method1373* @memberof Popper.Utils1374* @param {Array} modifiers - list of modifiers1375* @param {String} requestingName - name of requesting modifier1376* @param {String} requestedName - name of requested modifier1377* @returns {Boolean}1378*/1379function isModifierRequired(modifiers, requestingName, requestedName) {1380var requesting = find(modifiers, function (_ref) {1381var name = _ref.name;1382return name === requestingName;1383});1384}1396/**1398* @function1399* @memberof Modifiers1400* @argument {Object} data - The data object generated by update method1401* @argument {Object} options - Modifiers configuration and options1402* @returns {Object} The data object, properly modified1403*/1404function arrow(data, options) {1405var _data$offsets$arrow;1406}1478/**1480* Get the opposite placement variation of the given one1481* @method1482* @memberof Popper.Utils1483* @argument {String} placement variation1484* @returns {String} flipped placement variation1485*/1486function getOppositeVariation(variation) {1487if (variation === 'end') {1488return 'start';1489} else if (variation === 'start') {1490return 'end';1491}1492return variation;1493}1494/**1496* List of accepted placements to use as values of the `placement` option.<br />1497* Valid placements are:1498* - `auto`1499* - `top`1500* - `right`1501* - `bottom`1502* - `left`1503*1504* Each placement can have a variation from this list:1505* - `-start`1506* - `-end`1507*1508* Variations are interpreted easily if you think of them as the left to right1509* written languages. Horizontally (`top` and `bottom`), `start` is left and `end`1510* is right.<br />1511* Vertically (`left` and `right`), `start` is top and `end` is bottom.1512*1513* Some valid examples are:1514* - `top-end` (on top of reference, right aligned)1515* - `right-start` (on right of reference, top aligned)1516* - `bottom` (on bottom, centered)1517* - `auto-end` (on the side with more space available, alignment depends by placement)1518*1519* @static1520* @type {Array}1521* @enum {String}1522* @readonly1523* @method placements1524* @memberof Popper1525*/1526var 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'];1527// Get rid of `auto` `auto-start` and `auto-end`1529var validPlacements = placements.slice(3);1530/**1532* Given an initial placement, returns all the subsequent placements1533* clockwise (or counter-clockwise).1534*1535* @method1536* @memberof Popper.Utils1537* @argument {String} placement - A valid placement (it accepts variations)1538* @argument {Boolean} counter - Set to true to walk the placements counterclockwise1539* @returns {Array} placements including their variations1540*/1541function clockwise(placement) {1542var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;1543}1548/**1556* @function1557* @memberof Modifiers1558* @argument {Object} data - The data object generated by update method1559* @argument {Object} options - Modifiers configuration and options1560* @returns {Object} The data object, properly modified1561*/1562function flip(data, options) {1563// if `inner` modifier is enabled, we can't use the `flip` modifier1564if (isModifierEnabled(data.instance.modifiers, 'inner')) {1565return data;1566}1567}1651/**1653* @function1654* @memberof Modifiers1655* @argument {Object} data - The data object generated by update method1656* @argument {Object} options - Modifiers configuration and options1657* @returns {Object} The data object, properly modified1658*/1659function keepTogether(data) {1660var _data$offsets = data.offsets,1661popper = _data$offsets.popper,1662reference = _data$offsets.reference;1663}1680/**1682* Converts a string containing value + unit into a px value number1683* @function1684* @memberof {modifiers~offset}1685* @private1686* @argument {String} str - Value + unit string1687* @argument {String} measurement - `height` or `width`1688* @argument {Object} popperOffsets1689* @argument {Object} referenceOffsets1690* @returns {Number|String}1691* Value in pixels, or original string if no values were extracted1692*/1693function toValue(str, measurement, popperOffsets, referenceOffsets) {1694// separate value from unit1695var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);1696var value = +split[1];1697var unit = split[2];1698}1733/**1735* Parse an `offset` string to extrapolate `x` and `y` numeric offsets.1736* @function1737* @memberof {modifiers~offset}1738* @private1739* @argument {String} offset1740* @argument {Object} popperOffsets1741* @argument {Object} referenceOffsets1742* @argument {String} basePlacement1743* @returns {Array} a two cells array with x and y offsets in numbers1744*/1745function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {1746var offsets = [0, 0];1747}1811/**1813* @function1814* @memberof Modifiers1815* @argument {Object} data - The data object generated by update method1816* @argument {Object} options - Modifiers configuration and options1817* @argument {Number|String} options.offset=01818* The offset value as described in the modifier description1819* @returns {Object} The data object, properly modified1820*/1821function offset(data, _ref) {1822var offset = _ref.offset;1823var placement = data.placement,1824_data$offsets = data.offsets,1825popper = _data$offsets.popper,1826reference = _data$offsets.reference;1827}1854/**1856* @function1857* @memberof Modifiers1858* @argument {Object} data - The data object generated by `update` method1859* @argument {Object} options - Modifiers configuration and options1860* @returns {Object} The data object, properly modified1861*/1862function preventOverflow(data, options) {1863var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);1864}1925/**1927* @function1928* @memberof Modifiers1929* @argument {Object} data - The data object generated by `update` method1930* @argument {Object} options - Modifiers configuration and options1931* @returns {Object} The data object, properly modified1932*/1933function shift(data) {1934var placement = data.placement;1935var basePlacement = placement.split('-')[0];1936var shiftvariation = placement.split('-')[1];1937}1958/**1960* @function1961* @memberof Modifiers1962* @argument {Object} data - The data object generated by update method1963* @argument {Object} options - Modifiers configuration and options1964* @returns {Object} The data object, properly modified1965*/1966function hide(data) {1967if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {1968return data;1969}1970}1996/**1998* @function1999* @memberof Modifiers2000* @argument {Object} data - The data object generated by `update` method2001* @argument {Object} options - Modifiers configuration and options2002* @returns {Object} The data object, properly modified2003*/2004function inner(data) {2005var placement = data.placement;2006var basePlacement = placement.split('-')[0];2007var _data$offsets = data.offsets,2008popper = _data$offsets.popper,2009reference = _data$offsets.reference;2010}2022/**2024* Modifier function, each modifier can have a function of this type assigned2025* to its `fn` property.<br />2026* These functions will be called on each update, this means that you must2027* make sure they are performant enough to avoid performance bottlenecks.2028*2029* @function ModifierFn2030* @argument {dataObject} data - The data object generated by `update` method2031* @argument {Object} options - Modifiers configuration and options2032* @returns {dataObject} The data object, properly modified2033*/2034/**2036* Modifiers are plugins used to alter the behavior of your poppers.<br />2037* Popper.js uses a set of 9 modifiers to provide all the basic functionalities2038* needed by the library.2039*2040* Usually you don't want to override the `order`, `fn` and `onLoad` props.2041* All the other properties are configurations that could be tweaked.2042* @namespace modifiers2043*/2044var modifiers = {2045/**2046* Modifier used to shift the popper on the start or end of its reference2047* element.<br />2048* It will read the variation of the `placement` property.<br />2049* It can be one either `-end` or `-start`.2050* @memberof modifiers2051* @inner2052*/2053shift: {2054/** @prop {number} order=100 - Index used to define the order of execution */2055order: 100,2056/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2057enabled: true,2058/** @prop {ModifierFn} */2059fn: shift2060},2061* The `offset` modifier can shift your popper on both its axis.2064*2065* It accepts the following units:2066* - `px` or unit-less, interpreted as pixels2067* - `%` or `%r`, percentage relative to the length of the reference element2068* - `%p`, percentage relative to the length of the popper element2069* - `vw`, CSS viewport width unit2070* - `vh`, CSS viewport height unit2071*2072* For length is intended the main axis relative to the placement of the popper.<br />2073* This means that if the placement is `top` or `bottom`, the length will be the2074* `width`. In case of `left` or `right`, it will be the `height`.2075*2076* You can provide a single value (as `Number` or `String`), or a pair of values2077* as `String` divided by a comma or one (or more) white spaces.<br />2078* The latter is a deprecated method because it leads to confusion and will be2079* removed in v2.<br />2080* Additionally, it accepts additions and subtractions between different units.2081* Note that multiplications and divisions aren't supported.2082*2083* Valid examples are:2084* ```2085* 102086* '10%'2087* '10, 10'2088* '10%, 10'2089* '10 + 10%'2090* '10 - 5vh + 3%'2091* '-10px + 5vh, 5px - 6%'2092* ```2093* > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap2094* > with their reference element, unfortunately, you will have to disable the `flip` modifier.2095* > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).2096*2097* @memberof modifiers2098* @inner2099*/2100offset: {2101/** @prop {number} order=200 - Index used to define the order of execution */2102order: 200,2103/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2104enabled: true,2105/** @prop {ModifierFn} */2106fn: offset,2107/** @prop {Number|String} offset=02108* The offset value as described in the modifier description2109*/2110offset: 02111},2112* Modifier used to prevent the popper from being positioned outside the boundary.2115*2116* A scenario exists where the reference itself is not within the boundaries.<br />2117* We can say it has "escaped the boundaries" — or just "escaped".<br />2118* In this case we need to decide whether the popper should either:2119*2120* - detach from the reference and remain "trapped" in the boundaries, or2121* - if it should ignore the boundary and "escape with its reference"2122*2123* When `escapeWithReference` is set to`true` and reference is completely2124* outside its boundaries, the popper will overflow (or completely leave)2125* the boundaries in order to remain attached to the edge of the reference.2126*2127* @memberof modifiers2128* @inner2129*/2130preventOverflow: {2131/** @prop {number} order=300 - Index used to define the order of execution */2132order: 300,2133/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2134enabled: true,2135/** @prop {ModifierFn} */2136fn: preventOverflow,2137/**2138* @prop {Array} [priority=['left','right','top','bottom']]2139* Popper will try to prevent overflow following these priorities by default,2140* then, it could overflow on the left and on top of the `boundariesElement`2141*/2142priority: ['left', 'right', 'top', 'bottom'],2143/**2144* @prop {number} padding=52145* Amount of pixel used to define a minimum distance between the boundaries2146* and the popper. This makes sure the popper always has a little padding2147* between the edges of its container2148*/2149padding: 5,2150/**2151* @prop {String|HTMLElement} boundariesElement='scrollParent'2152* Boundaries used by the modifier. Can be `scrollParent`, `window`,2153* `viewport` or any DOM element.2154*/2155boundariesElement: 'scrollParent'2156},2157* Modifier used to make sure the reference and its popper stay near each other2160* without leaving any gap between the two. Especially useful when the arrow is2161* enabled and you want to ensure that it points to its reference element.2162* It cares only about the first axis. You can still have poppers with margin2163* between the popper and its reference element.2164* @memberof modifiers2165* @inner2166*/2167keepTogether: {2168/** @prop {number} order=400 - Index used to define the order of execution */2169order: 400,2170/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2171enabled: true,2172/** @prop {ModifierFn} */2173fn: keepTogether2174},2175* This modifier is used to move the `arrowElement` of the popper to make2178* sure it is positioned between the reference element and its popper element.2179* It will read the outer size of the `arrowElement` node to detect how many2180* pixels of conjunction are needed.2181*2182* It has no effect if no `arrowElement` is provided.2183* @memberof modifiers2184* @inner2185*/2186arrow: {2187/** @prop {number} order=500 - Index used to define the order of execution */2188order: 500,2189/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2190enabled: true,2191/** @prop {ModifierFn} */2192fn: arrow,2193/** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */2194element: '[x-arrow]'2195},2196* Modifier used to flip the popper's placement when it starts to overlap its2199* reference element.2200*2201* Requires the `preventOverflow` modifier before it in order to work.2202*2203* **NOTE:** this modifier will interrupt the current update cycle and will2204* restart it if it detects the need to flip the placement.2205* @memberof modifiers2206* @inner2207*/2208flip: {2209/** @prop {number} order=600 - Index used to define the order of execution */2210order: 600,2211/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2212enabled: true,2213/** @prop {ModifierFn} */2214fn: flip,2215/**2216* @prop {String|Array} behavior='flip'2217* The behavior used to change the popper's placement. It can be one of2218* `flip`, `clockwise`, `counterclockwise` or an array with a list of valid2219* placements (with optional variations)2220*/2221behavior: 'flip',2222/**2223* @prop {number} padding=52224* The popper will flip if it hits the edges of the `boundariesElement`2225*/2226padding: 5,2227/**2228* @prop {String|HTMLElement} boundariesElement='viewport'2229* The element which will define the boundaries of the popper position.2230* The popper will never be placed outside of the defined boundaries2231* (except if `keepTogether` is enabled)2232*/2233boundariesElement: 'viewport',2234/**2235* @prop {Boolean} flipVariations=false2236* The popper will switch placement variation between `-start` and `-end` when2237* the reference element overlaps its boundaries.2238*2239* The original placement should have a set variation.2240*/2241flipVariations: false,2242/**2243* @prop {Boolean} flipVariationsByContent=false2244* The popper will switch placement variation between `-start` and `-end` when2245* the popper element overlaps its reference boundaries.2246*2247* The original placement should have a set variation.2248*/2249flipVariationsByContent: false2250},2251* Modifier used to make the popper flow toward the inner of the reference element.2254* By default, when this modifier is disabled, the popper will be placed outside2255* the reference element.2256* @memberof modifiers2257* @inner2258*/2259inner: {2260/** @prop {number} order=700 - Index used to define the order of execution */2261order: 700,2262/** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */2263enabled: false,2264/** @prop {ModifierFn} */2265fn: inner2266},2267* Modifier used to hide the popper when its reference element is outside of the2270* popper boundaries. It will set a `x-out-of-boundaries` attribute which can2271* be used to hide with a CSS selector the popper when its reference is2272* out of boundaries.2273*2274* Requires the `preventOverflow` modifier before it in order to work.2275* @memberof modifiers2276* @inner2277*/2278hide: {2279/** @prop {number} order=800 - Index used to define the order of execution */2280order: 800,2281/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2282enabled: true,2283/** @prop {ModifierFn} */2284fn: hide2285},2286* Computes the style that will be applied to the popper element to gets2289* properly positioned.2290*2291* Note that this modifier will not touch the DOM, it just prepares the styles2292* so that `applyStyle` modifier can apply it. This separation is useful2293* in case you need to replace `applyStyle` with a custom implementation.2294*2295* This modifier has `850` as `order` value to maintain backward compatibility2296* with previous versions of Popper.js. Expect the modifiers ordering method2297* to change in future major versions of the library.2298*2299* @memberof modifiers2300* @inner2301*/2302computeStyle: {2303/** @prop {number} order=850 - Index used to define the order of execution */2304order: 850,2305/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2306enabled: true,2307/** @prop {ModifierFn} */2308fn: computeStyle,2309/**2310* @prop {Boolean} gpuAcceleration=true2311* If true, it uses the CSS 3D transformation to position the popper.2312* Otherwise, it will use the `top` and `left` properties2313*/2314gpuAcceleration: true,2315/**2316* @prop {string} [x='bottom']2317* Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.2318* Change this if your popper should grow in a direction different from `bottom`2319*/2320x: 'bottom',2321/**2322* @prop {string} [x='left']2323* Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.2324* Change this if your popper should grow in a direction different from `right`2325*/2326y: 'right'2327},2328* Applies the computed styles to the popper element.2331*2332* All the DOM manipulations are limited to this modifier. This is useful in case2333* you want to integrate Popper.js inside a framework or view library and you2334* want to delegate all the DOM manipulations to it.2335*2336* Note that if you disable this modifier, you must make sure the popper element2337* has its position set to `absolute` before Popper.js can do its work!2338*2339* Just disable this modifier and define your own to achieve the desired effect.2340*2341* @memberof modifiers2342* @inner2343*/2344applyStyle: {2345/** @prop {number} order=900 - Index used to define the order of execution */2346order: 900,2347/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */2348enabled: true,2349/** @prop {ModifierFn} */2350fn: applyStyle,2351/** @prop {Function} */2352onLoad: applyStyleOnLoad,2353/**2354* @deprecated since version 1.10.0, the property moved to `computeStyle` modifier2355* @prop {Boolean} gpuAcceleration=true2356* If true, it uses the CSS 3D transformation to position the popper.2357* Otherwise, it will use the `top` and `left` properties2358*/2359gpuAcceleration: undefined2360}2361};2362/**2364* The `dataObject` is an object containing all the information used by Popper.js.2365* This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.2366* @name dataObject2367* @property {Object} data.instance The Popper.js instance2368* @property {String} data.placement Placement applied to popper2369* @property {String} data.originalPlacement Placement originally defined on init2370* @property {Boolean} data.flipped True if popper has been flipped by flip modifier2371* @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper2372* @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier2373* @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)2374* @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)2375* @property {Object} data.boundaries Offsets of the popper boundaries2376* @property {Object} data.offsets The measurements of popper, reference and arrow elements2377* @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values2378* @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values2379* @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 02380*/2381/**2383* Default options provided to Popper.js constructor.<br />2384* These can be overridden using the `options` argument of Popper.js.<br />2385* To override an option, simply pass an object with the same2386* structure of the `options` object, as the 3rd argument. For example:2387* ```2388* new Popper(ref, pop, {2389* modifiers: {2390* preventOverflow: { enabled: false }2391* }2392* })2393* ```2394* @type {Object}2395* @static2396* @memberof Popper2397*/2398var Defaults = {2399/**2400* Popper's placement.2401* @prop {Popper.placements} placement='bottom'2402*/2403placement: 'bottom',2404* Set this to true if you want popper to position it self in 'fixed' mode2407* @prop {Boolean} positionFixed=false2408*/2409positionFixed: false,2410* Whether events (resize, scroll) are initially enabled.2413* @prop {Boolean} eventsEnabled=true2414*/2415eventsEnabled: true,2416* Set to true if you want to automatically remove the popper when2419* you call the `destroy` method.2420* @prop {Boolean} removeOnDestroy=false2421*/2422removeOnDestroy: false,2423* Callback called when the popper is created.<br />2426* By default, it is set to no-op.<br />2427* Access Popper.js instance with `data.instance`.2428* @prop {onCreate}2429*/2430onCreate: function onCreate() {},2431* Callback called when the popper is updated. This callback is not called2434* on the initialization/creation of the popper, but only on subsequent2435* updates.<br />2436* By default, it is set to no-op.<br />2437* Access Popper.js instance with `data.instance`.2438* @prop {onUpdate}2439*/2440onUpdate: function onUpdate() {},2441* List of modifiers used to modify the offsets before they are applied to the popper.2444* They provide most of the functionalities of Popper.js.2445* @prop {modifiers}2446*/2447modifiers: modifiers2448};2449/**2451* @callback onCreate2452* @param {dataObject} data2453*/2454/**2456* @callback onUpdate2457* @param {dataObject} data2458*/2459// Utils2461// Methods2462var Popper = function () {2463/**2464* Creates a new Popper.js instance.2465* @class Popper2466* @param {Element|referenceObject} reference - The reference element used to position the popper2467* @param {Element} popper - The HTML / XML element used as the popper2468* @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)2469* @return {Object} instance - The generated Popper.js instance2470*/2471function Popper(reference, popper) {2472var _this = this;2473* Schedules an update. It will run on the next UI update available.2564* @method scheduleUpdate2565* @memberof Popper2566*/2567* Collection of utilities useful when writing custom modifiers.2571* Starting from version 1.7, this method is available only if you2572* include `popper-utils.js` before `popper.js`.2573*2574* **DEPRECATION**: This way to access PopperUtils is deprecated2575* and will be removed in v2! Use the PopperUtils module directly instead.2576* Due to the high instability of the methods contained in Utils, we can't2577* guarantee them to follow semver. Use them at your own risk!2578* @static2579* @private2580* @type {Object}2581* @deprecated since version 1.82582* @member Utils2583* @memberof Popper2584*/2585/**2591* The `referenceObject` is an object that provides an interface compatible with Popper.js2592* and lets you use it as replacement of a real DOM node.<br />2593* You can use this method to position a popper relatively to a set of coordinates2594* in case you don't have a DOM node to use as reference.2595*2596* ```2597* new Popper(referenceObject, popperNode);2598* ```2599*2600* NB: This feature isn't supported in Internet Explorer 10.2601* @name referenceObject2602* @property {Function} data.getBoundingClientRect2603* A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.2604* @property {number} data.clientWidth2605* An ES6 getter that will return the width of the virtual reference element.2606* @property {number} data.clientHeight2607* An ES6 getter that will return the height of the virtual reference element.2608*/2609//# sourceMappingURL=popper.js.map2617