{
version: 3,
file: "popper.min.js",
sources: [
"../../src/utils/debounce.js",
"../../src/utils/isNative.js",
"../../src/utils/isFunction.js",
"../../src/utils/getStyleComputedProperty.js",
"../../src/utils/getParentNode.js",
"../../src/utils/getScrollParent.js",
"../../src/utils/getOffsetParent.js",
"../../src/utils/isOffsetContainer.js",
"../../src/utils/getRoot.js",
"../../src/utils/findCommonOffsetParent.js",
"../../src/utils/getScroll.js",
"../../src/utils/includeScroll.js",
"../../src/utils/getBordersSize.js",
"../../src/utils/isIE10.js",
"../../src/utils/getWindowSizes.js",
"../../src/utils/getClientRect.js",
"../../src/utils/getBoundingClientRect.js",
"../../src/utils/getOffsetRectRelativeToArbitraryNode.js",
"../../src/utils/getViewportOffsetRectRelativeToArtbitraryNode.js",
"../../src/utils/isFixed.js",
"../../src/utils/getBoundaries.js",
"../../src/utils/computeAutoPlacement.js",
"../../src/utils/getReferenceOffsets.js",
"../../src/utils/getOuterSizes.js",
"../../src/utils/getOppositePlacement.js",
"../../src/utils/getPopperOffsets.js",
"../../src/utils/find.js",
"../../src/utils/findIndex.js",
"../../src/utils/runModifiers.js",
"../../src/methods/update.js",
"../../src/utils/isModifierEnabled.js",
"../../src/utils/getSupportedPropertyName.js",
"../../src/methods/destroy.js",
"../../src/utils/setupEventListeners.js",
"../../src/methods/enableEventListeners.js",
"../../src/utils/removeEventListeners.js",
"../../src/methods/disableEventListeners.js",
"../../src/utils/isNumeric.js",
"../../src/utils/setStyles.js",
"../../src/utils/setAttributes.js",
"../../src/modifiers/applyStyle.js",
"../../src/modifiers/computeStyle.js",
"../../src/utils/isModifierRequired.js",
"../../src/modifiers/arrow.js",
"../../src/utils/getOppositeVariation.js",
"../../src/methods/placements.js",
"../../src/utils/clockwise.js",
"../../src/modifiers/flip.js",
"../../src/modifiers/keepTogether.js",
"../../src/modifiers/offset.js",
"../../src/modifiers/preventOverflow.js",
"../../src/modifiers/shift.js",
"../../src/modifiers/hide.js",
"../../src/modifiers/inner.js",
"../../src/modifiers/index.js",
"../../src/methods/defaults.js",
"../../src/index.js",
],
sourcesContent: [
"import isNative from './isNative'; const isBrowser = typeof window !== 'undefined'; const longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox']; let timeoutDuration = 0; for (let i = 0; i < longerTimeoutBrowsers.length; i += 1) { if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) { timeoutDuration = 1; break; } } export function microtaskDebounce(fn) { let scheduled = false; let i = 0; const elem = document.createElement('span'); // MutationObserver provides a mechanism for scheduling microtasks, which // are scheduled *before* the next task. This gives us a way to debounce // a function but ensure it's called *before* the next paint. const observer = new MutationObserver(() => { fn(); scheduled = false; }); observer.observe(elem, { attributes: true }); return () => { if (!scheduled) { scheduled = true; elem.setAttribute('x-index', i); i = i + 1; // don't use compund (+=) because it doesn't get optimized in V8 } }; } export function taskDebounce(fn) { let scheduled = false; return () => { if (!scheduled) { scheduled = true; setTimeout(() => { scheduled = false; fn(); }, timeoutDuration); } }; } // It's common for MutationObserver polyfills to be seen in the wild, however // these rely on Mutation Events which only occur when an element is connected // to the DOM. The algorithm used in this module does not use a connected element, // and so we must ensure that a *native* MutationObserver is available. const supportsNativeMutationObserver = isBrowser && isNative(window.MutationObserver); /** * Create a debounced version of a method, that's asynchronously deferred * but called in the minimum time possible. * * @method * @memberof Popper.Utils * @argument {Function} fn * @returns {Function} */ export default (supportsNativeMutationObserver ? microtaskDebounce : taskDebounce); ",
"const nativeHints = [ 'native code', '[object MutationObserverConstructor]', // for mobile safari iOS 9.0 ]; /** * Determine if a function is implemented natively (as opposed to a polyfill). * @method * @memberof Popper.Utils * @argument {Function | undefined} fn the function to check * @returns {Boolean} */ export default fn => nativeHints.some(hint => (fn || '').toString().indexOf(hint) > -1); ",
"/** * Check if the given variable is a function * @method * @memberof Popper.Utils * @argument {Any} functionToCheck - variable to check * @returns {Boolean} answer to: is a function? */ export default function isFunction(functionToCheck) { const getType = {}; return ( functionToCheck && getType.toString.call(functionToCheck) === '[object Function]' ); } ",
"/** * Get CSS computed property of the given element * @method * @memberof Popper.Utils * @argument {Eement} element * @argument {String} property */ export default function getStyleComputedProperty(element, property) { if (element.nodeType !== 1) { return []; } // NOTE: 1 DOM access here const css = window.getComputedStyle(element, null); return property ? css[property] : css; } ",
"/** * Returns the parentNode or the host of the element * @method * @memberof Popper.Utils * @argument {Element} element * @returns {Element} parent */ export default function getParentNode(element) { if (element.nodeName === 'HTML') { return element; } return element.parentNode || element.host; } ",
"import getStyleComputedProperty from './getStyleComputedProperty'; import getParentNode from './getParentNode'; /** * Returns the scrolling parent of the given element * @method * @memberof Popper.Utils * @argument {Element} element * @returns {Element} scroll parent */ export default function getScrollParent(element) { // Return body, `getScroll` will take care to get the correct `scrollTop` from it if ( !element || ['HTML', 'BODY', '#document'].indexOf(element.nodeName) !== -1 ) { return window.document.body; } // Firefox want us to check `-x` and `-y` variations as well const { overflow, overflowX, overflowY } = getStyleComputedProperty(element); if (/(auto|scroll)/.test(overflow + overflowY + overflowX)) { return element; } return getScrollParent(getParentNode(element)); } ",
"import getStyleComputedProperty from './getStyleComputedProperty'; /** * Returns the offset parent of the given element * @method * @memberof Popper.Utils * @argument {Element} element * @returns {Element} offset parent */ export default function getOffsetParent(element) { // NOTE: 1 DOM access here const offsetParent = element && element.offsetParent; const nodeName = offsetParent && offsetParent.nodeName; if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') { return window.document.documentElement; } // .offsetParent will return the closest TD or TABLE in case // no offsetParent is present, I hate this job... if ( ['TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static' ) { return getOffsetParent(offsetParent); } return offsetParent; } ",
"import getOffsetParent from './getOffsetParent'; export default function isOffsetContainer(element) { const { nodeName } = element; if (nodeName === 'BODY') { return false; } return ( nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element ); } ",
"/** * Finds the root node (document, shadowDOM root) of the given element * @method * @memberof Popper.Utils * @argument {Element} node * @returns {Element} root node */ export default function getRoot(node) { if (node.parentNode !== null) { return getRoot(node.parentNode); } return node; } ",
"import isOffsetContainer from './isOffsetContainer'; import getRoot from './getRoot'; import getOffsetParent from './getOffsetParent'; /** * Finds the offset parent common to the two provided nodes * @method * @memberof Popper.Utils * @argument {Element} element1 * @argument {Element} element2 * @returns {Element} common offset parent */ export default function findCommonOffsetParent(element1, element2) { // This check is needed to avoid errors in case one of the elements isn't defined for any reason if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) { return window.document.documentElement; } // Here we make sure to give as "start" the element that comes first in the DOM const order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING; const start = order ? element1 : element2; const end = order ? element2 : element1; // Get common ancestor container const range = document.createRange(); range.setStart(start, 0); range.setEnd(end, 0); const { commonAncestorContainer } = range; // Both nodes are inside #document if ( (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer) || start.contains(end) ) { if (isOffsetContainer(commonAncestorContainer)) { return commonAncestorContainer; } return getOffsetParent(commonAncestorContainer); } // one of the nodes is inside shadowDOM, find which one const element1root = getRoot(element1); if (element1root.host) { return findCommonOffsetParent(element1root.host, element2); } else { return findCommonOffsetParent(element1, getRoot(element2).host); } } ",
"/** * Gets the scroll value of the given element in the given side (top and left) * @method * @memberof Popper.Utils * @argument {Element} element * @argument {String} side `top` or `left` * @returns {number} amount of scrolled pixels */ export default function getScroll(element, side = 'top') { const upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft'; const nodeName = element.nodeName; if (nodeName === 'BODY' || nodeName === 'HTML') { const html = window.document.documentElement; const scrollingElement = window.document.scrollingElement || html; return scrollingElement[upperSide]; } return element[upperSide]; } ",
"import getScroll from './getScroll'; /* * Sum or subtract the element scroll values (left and top) from a given rect object * @method * @memberof Popper.Utils * @param {Object} rect - Rect object you want to change * @param {HTMLElement} element - The element from the function reads the scroll values * @param {Boolean} subtract - set to true if you want to subtract the scroll values * @return {Object} rect - The modifier rect object */ export default function includeScroll(rect, element, subtract = false) { const scrollTop = getScroll(element, 'top'); const scrollLeft = getScroll(element, 'left'); const modifier = subtract ? -1 : 1; rect.top += scrollTop * modifier; rect.bottom += scrollTop * modifier; rect.left += scrollLeft * modifier; rect.right += scrollLeft * modifier; return rect; } ",
"/* * Helper to detect borders of a given element * @method * @memberof Popper.Utils * @param {CSSStyleDeclaration} styles * Result of `getStyleComputedProperty` on the given element * @param {String} axis - `x` or `y` * @return {number} borders - The borders size of the given axis */ export default function getBordersSize(styles, axis) { const sideA = axis === 'x' ? 'Left' : 'Top'; const sideB = sideA === 'Left' ? 'Right' : 'Bottom'; return ( +styles[`border${sideA}Width`].split('px')[0] + +styles[`border${sideB}Width`].split('px')[0] ); } ",
"/** * Tells if you are running Internet Explorer 10 * @method * @memberof Popper.Utils * @returns {Boolean} isIE10 */ let isIE10 = undefined; export default function() { if (isIE10 === undefined) { isIE10 = navigator.appVersion.indexOf('MSIE 10') !== -1; } return isIE10; } ",
"import isIE10 from './isIE10'; function getSize(axis, body, html, computedStyle) { return Math.max( body[`offset${axis}`], body[`scroll${axis}`], html[`client${axis}`], html[`offset${axis}`], html[`scroll${axis}`], isIE10() ? html[`offset${axis}`] + computedStyle[`margin${axis === 'Height' ? 'Top' : 'Left'}`] + computedStyle[`margin${axis === 'Height' ? 'Bottom' : 'Right'}`] : 0 ); } export default function getWindowSizes() { const body = window.document.body; const html = window.document.documentElement; const computedStyle = isIE10() && window.getComputedStyle(html); return { height: getSize('Height', body, html, computedStyle), width: getSize('Width', body, html, computedStyle), }; } ",
"/** * Given element offsets, generate an output similar to getBoundingClientRect * @method * @memberof Popper.Utils * @argument {Object} offsets * @returns {Object} ClientRect like output */ export default function getClientRect(offsets) { return { ...offsets, right: offsets.left + offsets.width, bottom: offsets.top + offsets.height, }; } ",
"import getStyleComputedProperty from './getStyleComputedProperty'; import getBordersSize from './getBordersSize'; import getWindowSizes from './getWindowSizes'; import getScroll from './getScroll'; import getClientRect from './getClientRect'; import isIE10 from './isIE10'; /** * Get bounding client rect of given element * @method * @memberof Popper.Utils * @param {HTMLElement} element * @return {Object} client rect */ export default function getBoundingClientRect(element) { let rect = {}; // IE10 10 FIX: Please, don't ask, the element isn't // considered in DOM in some circumstances... // This isn't reproducible in IE10 compatibility mode of IE11 if (isIE10()) { try { rect = element.getBoundingClientRect(); const scrollTop = getScroll(element, 'top'); const scrollLeft = getScroll(element, 'left'); rect.top += scrollTop; rect.left += scrollLeft; rect.bottom += scrollTop; rect.right += scrollLeft; } catch (err) {} } else { rect = element.getBoundingClientRect(); } const result = { left: rect.left, top: rect.top, width: rect.right - rect.left, height: rect.bottom - rect.top, }; // subtract scrollbar size from sizes const sizes = element.nodeName === 'HTML' ? getWindowSizes() : {}; const width = sizes.width || element.clientWidth || result.right - result.left; const height = sizes.height || element.clientHeight || result.bottom - result.top; let horizScrollbar = element.offsetWidth - width; let vertScrollbar = element.offsetHeight - height; // if an hypothetical scrollbar is detected, we must be sure it's not a `border` // we make this check conditional for performance reasons if (horizScrollbar || vertScrollbar) { const styles = getStyleComputedProperty(element); horizScrollbar -= getBordersSize(styles, 'x'); vertScrollbar -= getBordersSize(styles, 'y'); result.width -= horizScrollbar; result.height -= vertScrollbar; } return getClientRect(result); } ",
"import getStyleComputedProperty from './getStyleComputedProperty'; import includeScroll from './includeScroll'; import getScrollParent from './getScrollParent'; import getBoundingClientRect from './getBoundingClientRect'; import runIsIE10 from './isIE10'; import getClientRect from './getClientRect'; export default function getOffsetRectRelativeToArbitraryNode(children, parent) { const isIE10 = runIsIE10(); const isHTML = parent.nodeName === 'HTML'; const childrenRect = getBoundingClientRect(children); const parentRect = getBoundingClientRect(parent); const scrollParent = getScrollParent(children); const styles = getStyleComputedProperty(parent); const borderTopWidth = +styles.borderTopWidth.split('px')[0]; const borderLeftWidth = +styles.borderLeftWidth.split('px')[0]; let offsets = getClientRect({ top: childrenRect.top - parentRect.top - borderTopWidth, left: childrenRect.left - parentRect.left - borderLeftWidth, width: childrenRect.width, height: childrenRect.height, }); offsets.marginTop = 0; offsets.marginLeft = 0; // Subtract margins of documentElement in case it's being used as parent // we do this only on HTML because it's the only element that behaves // differently when margins are applied to it. The margins are included in // the box of the documentElement, in the other cases not. if (!isIE10 && isHTML) { const marginTop = +styles.marginTop.split('px')[0]; const marginLeft = +styles.marginLeft.split('px')[0]; offsets.top -= borderTopWidth - marginTop; offsets.bottom -= borderTopWidth - marginTop; offsets.left -= borderLeftWidth - marginLeft; offsets.right -= borderLeftWidth - marginLeft; // Attach marginTop and marginLeft because in some circumstances we may need them offsets.marginTop = marginTop; offsets.marginLeft = marginLeft; } if ( isIE10 ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY' ) { offsets = includeScroll(offsets, parent); } return offsets; } ",
"import getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode'; import getScroll from './getScroll'; import getClientRect from './getClientRect'; export default function getViewportOffsetRectRelativeToArtbitraryNode(element) { const html = window.document.documentElement; const relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html); const width = Math.max(html.clientWidth, window.innerWidth || 0); const height = Math.max(html.clientHeight, window.innerHeight || 0); const scrollTop = getScroll(html); const scrollLeft = getScroll(html, 'left'); const offset = { top: scrollTop - relativeOffset.top + relativeOffset.marginTop, left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft, width, height, }; return getClientRect(offset); } ",
"import getStyleComputedProperty from './getStyleComputedProperty'; import getParentNode from './getParentNode'; /** * Check if the given element is fixed or is inside a fixed parent * @method * @memberof Popper.Utils * @argument {Element} element * @argument {Element} customContainer * @returns {Boolean} answer to "isFixed?" */ export default function isFixed(element) { const nodeName = element.nodeName; if (nodeName === 'BODY' || nodeName === 'HTML') { return false; } if (getStyleComputedProperty(element, 'position') === 'fixed') { return true; } return isFixed(getParentNode(element)); } ",
"import getScrollParent from './getScrollParent'; import getParentNode from './getParentNode'; import findCommonOffsetParent from './findCommonOffsetParent'; import getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode'; import getViewportOffsetRectRelativeToArtbitraryNode from './getViewportOffsetRectRelativeToArtbitraryNode'; import getWindowSizes from './getWindowSizes'; import isFixed from './isFixed'; /** * Computed the boundaries limits and return them * @method * @memberof Popper.Utils * @param {HTMLElement} popper * @param {HTMLElement} reference * @param {number} padding * @param {HTMLElement} boundariesElement - Element used to define the boundaries * @returns {Object} Coordinates of the boundaries */ export default function getBoundaries( popper, reference, padding, boundariesElement ) { // NOTE: 1 DOM access here let boundaries = { top: 0, left: 0 }; const offsetParent = findCommonOffsetParent(popper, reference); // Handle viewport case if (boundariesElement === 'viewport') { boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent); } else { // Handle other cases based on DOM element used as boundaries let boundariesNode; if (boundariesElement === 'scrollParent') { boundariesNode = getScrollParent(getParentNode(popper)); if (boundariesNode.nodeName === 'BODY') { boundariesNode = window.document.documentElement; } } else if (boundariesElement === 'window') { boundariesNode = window.document.documentElement; } else { boundariesNode = boundariesElement; } const offsets = getOffsetRectRelativeToArbitraryNode( boundariesNode, offsetParent ); // In case of HTML, we need a different computation if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) { const { height, width } = getWindowSizes(); boundaries.top += offsets.top - offsets.marginTop; boundaries.bottom = height + offsets.top; boundaries.left += offsets.left - offsets.marginLeft; boundaries.right = width + offsets.left; } else { // for all the other DOM elements, this one is good boundaries = offsets; } } // Add paddings boundaries.left += padding; boundaries.top += padding; boundaries.right -= padding; boundaries.bottom -= padding; return boundaries; } ",
"import getBoundaries from '../utils/getBoundaries'; function getArea({ width, height }) { return width * height; } /** * Utility used to transform the `auto` placement to the placement with more * available space. * @method * @memberof Popper.Utils * @argument {Object} data - The data object generated by update method * @argument {Object} options - Modifiers configuration and options * @returns {Object} The data object, properly modified */ export default function computeAutoPlacement( placement, refRect, popper, reference, boundariesElement, padding = 0 ) { if (placement.indexOf('auto') === -1) { return placement; } const boundaries = getBoundaries( popper, reference, padding, boundariesElement ); const rects = { top: { width: boundaries.width, height: refRect.top - boundaries.top, }, right: { width: boundaries.right - refRect.right, height: boundaries.height, }, bottom: { width: boundaries.width, height: boundaries.bottom - refRect.bottom, }, left: { width: refRect.left - boundaries.left, height: boundaries.height, }, }; const sortedAreas = Object.keys(rects) .map(key => ({ key, ...rects[key], area: getArea(rects[key]), })) .sort((a, b) => b.area - a.area); const filteredAreas = sortedAreas.filter( ({ width, height }) => width >= popper.clientWidth && height >= popper.clientHeight ); const computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key; const variation = placement.split('-')[1]; return computedPlacement + (variation ? `-${variation}` : ''); } ",
"import findCommonOffsetParent from './findCommonOffsetParent'; import getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode'; /** * Get offsets to the reference element * @method * @memberof Popper.Utils * @param {Object} state * @param {Element} popper - the popper element * @param {Element} reference - the reference element (the popper will be relative to this) * @returns {Object} An object containing the offsets which will be applied to the popper */ export default function getReferenceOffsets(state, popper, reference) { const commonOffsetParent = findCommonOffsetParent(popper, reference); return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent); } ",
"/** * Get the outer sizes of the given element (offset size + margins) * @method * @memberof Popper.Utils * @argument {Element} element * @returns {Object} object containing width and height properties */ export default function getOuterSizes(element) { const styles = window.getComputedStyle(element); const x = parseFloat(styles.marginTop) + parseFloat(styles.marginBottom); const y = parseFloat(styles.marginLeft) + parseFloat(styles.marginRight); const result = { width: element.offsetWidth + y, height: element.offsetHeight + x, }; return result; } ",
"/** * Get the opposite placement of the given one * @method * @memberof Popper.Utils * @argument {String} placement * @returns {String} flipped placement */ export default function getOppositePlacement(placement) { const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' }; return placement.replace(/left|right|bottom|top/g, matched => hash[matched]); } ",
"import getOuterSizes from './getOuterSizes'; import getOppositePlacement from './getOppositePlacement'; /** * Get offsets to the popper * @method * @memberof Popper.Utils * @param {Object} position - CSS position the Popper will get applied * @param {HTMLElement} popper - the popper element * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this) * @param {String} placement - one of the valid placement options * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper */ export default function getPopperOffsets(popper, referenceOffsets, placement) { placement = placement.split('-')[0]; // Get popper node sizes const popperRect = getOuterSizes(popper); // Add position, width and height to our offsets object const popperOffsets = { width: popperRect.width, height: popperRect.height, }; // depending by the popper placement we have to compute its offsets slightly differently const isHoriz = ['right', 'left'].indexOf(placement) !== -1; const mainSide = isHoriz ? 'top' : 'left'; const secondarySide = isHoriz ? 'left' : 'top'; const measurement = isHoriz ? 'height' : 'width'; const secondaryMeasurement = !isHoriz ? 'height' : 'width'; popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2; if (placement === secondarySide) { popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement]; } else { popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)]; } return popperOffsets; } ",
"/** * Mimics the `find` method of Array * @method * @memberof Popper.Utils * @argument {Array} arr * @argument prop * @argument value * @returns index or -1 */ export default function find(arr, check) { // use native find if supported if (Array.prototype.find) { return arr.find(check); } // use `filter` to obtain the same behavior of `find` return arr.filter(check)[0]; } ",
"import find from './find'; /** * Return the index of the matching object * @method * @memberof Popper.Utils * @argument {Array} arr * @argument prop * @argument value * @returns index or -1 */ export default function findIndex(arr, prop, value) { // use native findIndex if supported if (Array.prototype.findIndex) { return arr.findIndex(cur => cur[prop] === value); } // use `find` + `indexOf` if `findIndex` isn't supported const match = find(arr, obj => obj[prop] === value); return arr.indexOf(match); } ",
"import isFunction from './isFunction'; import findIndex from './findIndex'; import getClientRect from '../utils/getClientRect'; /** * Loop trough the list of modifiers and run them in order, * each of them will then edit the data object. * @method * @memberof Popper.Utils * @param {dataObject} data * @param {Array} modifiers * @param {String} ends - Optional modifier name used as stopper * @returns {dataObject} */ export default function runModifiers(modifiers, data, ends) { const modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends)); modifiersToRun.forEach(modifier => { if (modifier.function) { console.warn('`modifier.function` is deprecated, use `modifier.fn`!'); } const fn = modifier.function || modifier.fn; if (modifier.enabled && isFunction(fn)) { // Add properties to offsets to make them a complete clientRect object // we do this before each modifier to make sure the previous one doesn't // mess with these values data.offsets.popper = getClientRect(data.offsets.popper); data.offsets.reference = getClientRect(data.offsets.reference); data = fn(data, modifier); } }); return data; } ",
"import computeAutoPlacement from '../utils/computeAutoPlacement'; import getReferenceOffsets from '../utils/getReferenceOffsets'; import getPopperOffsets from '../utils/getPopperOffsets'; import runModifiers from '../utils/runModifiers'; /** * Updates the position of the popper, computing the new offsets and applying * the new style.<br /> * Prefer `scheduleUpdate` over `update` because of performance reasons. * @method * @memberof Popper */ export default function update() { // if popper is destroyed, don't perform any further update if (this.state.isDestroyed) { return; } let data = { instance: this, styles: {}, arrowStyles: {}, attributes: {}, flipped: false, offsets: {}, }; // compute reference element offsets data.offsets.reference = getReferenceOffsets( this.state, this.popper, this.reference ); // compute auto placement, store placement inside the data object, // modifiers will be able to edit `placement` if needed // and refer to originalPlacement to know the original value data.placement = computeAutoPlacement( this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding ); // store the computed placement inside `originalPlacement` data.originalPlacement = data.placement; // compute the popper offsets data.offsets.popper = getPopperOffsets( this.popper, data.offsets.reference, data.placement ); data.offsets.popper.position = 'absolute'; // run the modifiers data = runModifiers(this.modifiers, data); // the first `update` will call `onCreate` callback // the other ones will call `onUpdate` callback if (!this.state.isCreated) { this.state.isCreated = true; this.options.onCreate(data); } else { this.options.onUpdate(data); } } ",
"/** * Helper used to know if the given modifier is enabled. * @method * @memberof Popper.Utils * @returns {Boolean} */ export default function isModifierEnabled(modifiers, modifierName) { return modifiers.some( ({ name, enabled }) => enabled && name === modifierName ); } ",
"/** * Get the prefixed supported property name * @method * @memberof Popper.Utils * @argument {String} property (camelCase) * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix) */ export default function getSupportedPropertyName(property) { const prefixes = [false, 'ms', 'Webkit', 'Moz', 'O']; const upperProp = property.charAt(0).toUpperCase() + property.slice(1); for (let i = 0; i < prefixes.length - 1; i++) { const prefix = prefixes[i]; const toCheck = prefix ? `${prefix}${upperProp}` : property; if (typeof window.document.body.style[toCheck] !== 'undefined') { return toCheck; } } return null; } ",
"import isModifierEnabled from '../utils/isModifierEnabled'; import getSupportedPropertyName from '../utils/getSupportedPropertyName'; /** * Destroy the popper * @method * @memberof Popper */ export default function destroy() { this.state.isDestroyed = true; // touch DOM only if `applyStyle` modifier is enabled if (isModifierEnabled(this.modifiers, 'applyStyle')) { this.popper.removeAttribute('x-placement'); this.popper.style.left = ''; this.popper.style.position = ''; this.popper.style.top = ''; this.popper.style[getSupportedPropertyName('transform')] = ''; } this.disableEventListeners(); // remove the popper if user explicity asked for the deletion on destroy // do not use `remove` because IE11 doesn't support it if (this.options.removeOnDestroy) { this.popper.parentNode.removeChild(this.popper); } return this; } ",
"import getScrollParent from './getScrollParent'; function attachToScrollParents(scrollParent, event, callback, scrollParents) { const isBody = scrollParent.nodeName === 'BODY'; const target = isBody ? window : scrollParent; target.addEventListener(event, callback, { passive: true }); if (!isBody) { attachToScrollParents( getScrollParent(target.parentNode), event, callback, scrollParents ); } scrollParents.push(target); } /** * Setup needed event listeners used to update the popper position * @method * @memberof Popper.Utils * @private */ export default function setupEventListeners( reference, options, state, updateBound ) { // Resize event listener on window state.updateBound = updateBound; window.addEventListener('resize', state.updateBound, { passive: true }); // Scroll event listener on scroll parents const scrollElement = getScrollParent(reference); attachToScrollParents( scrollElement, 'scroll', state.updateBound, state.scrollParents ); state.scrollElement = scrollElement; state.eventsEnabled = true; return state; } ",
"import setupEventListeners from '../utils/setupEventListeners'; /** * It will add resize/scroll events and start recalculating * position of the popper element when they are triggered. * @method * @memberof Popper */ export default function enableEventListeners() { if (!this.state.eventsEnabled) { this.state = setupEventListeners( this.reference, this.options, this.state, this.scheduleUpdate ); } } ",
"/** * Remove event listeners used to update the popper position * @method * @memberof Popper.Utils * @private */ export default function removeEventListeners(reference, state) { // Remove resize event listener on window window.removeEventListener('resize', state.updateBound); // Remove scroll event listener on scroll parents state.scrollParents.forEach(target => { target.removeEventListener('scroll', state.updateBound); }); // Reset state state.updateBound = null; state.scrollParents = []; state.scrollElement = null; state.eventsEnabled = false; return state; } ",
"import removeEventListeners from '../utils/removeEventListeners'; /** * It will remove resize/scroll events and won't recalculate popper position * when they are triggered. It also won't trigger onUpdate callback anymore, * unless you call `update` method manually. * @method * @memberof Popper */ export default function disableEventListeners() { if (this.state.eventsEnabled) { window.cancelAnimationFrame(this.scheduleUpdate); this.state = removeEventListeners(this.reference, this.state); } } ",
"/** * Tells if a given input is a number * @method * @memberof Popper.Utils * @param {*} input to check * @return {Boolean} */ export default function isNumeric(n) { return n !== '' && !isNaN(parseFloat(n)) && isFinite(n); } ",
"import isNumeric from './isNumeric'; /** * Set the style to the given popper * @method * @memberof Popper.Utils * @argument {Element} element - Element to apply the style to * @argument {Object} styles * Object with a list of properties and values which will be applied to the element */ export default function setStyles(element, styles) { Object.keys(styles).forEach(prop => { let unit = ''; // add unit if the value is numeric and is one of the following if ( ['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop]) ) { unit = 'px'; } element.style[prop] = styles[prop] + unit; }); } ",
"/** * Set the attributes to the given popper * @method * @memberof Popper.Utils * @argument {Element} element - Element to apply the attributes to * @argument {Object} styles * Object with a list of properties and values which will be applied to the element */ export default function setAttributes(element, attributes) { Object.keys(attributes).forEach(function(prop) { const value = attributes[prop]; if (value !== false) { element.setAttribute(prop, attributes[prop]); } else { element.removeAttribute(prop); } }); } ",
"import setStyles from '../utils/setStyles'; import setAttributes from '../utils/setAttributes'; import getReferenceOffsets from '../utils/getReferenceOffsets'; import computeAutoPlacement from '../utils/computeAutoPlacement'; /** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by `update` method * @argument {Object} data.styles - List of style properties - values to apply to popper element * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element * @argument {Object} options - Modifiers configuration and options * @returns {Object} The same data object */ export default function applyStyle(data) { // any property present in `data.styles` will be applied to the popper, // in this way we can make the 3rd party modifiers add custom styles to it // Be aware, modifiers could override the properties defined in the previous // lines of this modifier! setStyles(data.instance.popper, data.styles); // any property present in `data.attributes` will be applied to the popper, // they will be set as HTML attributes of the element setAttributes(data.instance.popper, data.attributes); // if arrowElement is defined and arrowStyles has some properties if (data.arrowElement && Object.keys(data.arrowStyles).length) { setStyles(data.arrowElement, data.arrowStyles); } return data; } /** * Set the x-placement attribute before everything else because it could be used * to add margins to the popper margins needs to be calculated to get the * correct popper offsets. * @method * @memberof Popper.modifiers * @param {HTMLElement} reference - The reference element used to position the popper * @param {HTMLElement} popper - The HTML element used as popper. * @param {Object} options - Popper.js options */ export function applyStyleOnLoad( reference, popper, options, modifierOptions, state ) { // compute reference element offsets const referenceOffsets = getReferenceOffsets(state, popper, reference); // compute auto placement, store placement inside the data object, // modifiers will be able to edit `placement` if needed // and refer to originalPlacement to know the original value const placement = computeAutoPlacement( options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding ); popper.setAttribute('x-placement', placement); // Apply `position` to popper before anything else because // without the position applied we can't guarantee correct computations setStyles(popper, { position: 'absolute' }); return options; } ",
"import getSupportedPropertyName from '../utils/getSupportedPropertyName'; import find from '../utils/find'; import getOffsetParent from '../utils/getOffsetParent'; import getBoundingClientRect from '../utils/getBoundingClientRect'; /** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by `update` method * @argument {Object} options - Modifiers configuration and options * @returns {Object} The data object, properly modified */ export default function computeStyle(data, options) { const { x, y } = options; const { popper } = data.offsets; // Remove this legacy support in Popper.js v2 const legacyGpuAccelerationOption = find( data.instance.modifiers, modifier => modifier.name === 'applyStyle' ).gpuAcceleration; if (legacyGpuAccelerationOption !== undefined) { console.warn( 'WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!' ); } const gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration; const offsetParent = getOffsetParent(data.instance.popper); const offsetParentRect = getBoundingClientRect(offsetParent); // Styles const styles = { position: popper.position, }; // floor sides to avoid blurry text const offsets = { left: Math.floor(popper.left), top: Math.floor(popper.top), bottom: Math.floor(popper.bottom), right: Math.floor(popper.right), }; const sideA = x === 'bottom' ? 'top' : 'bottom'; const sideB = y === 'right' ? 'left' : 'right'; // if gpuAcceleration is set to `true` and transform is supported, // we use `translate3d` to apply the position to the popper we // automatically use the supported prefixed version if needed const prefixedProperty = getSupportedPropertyName('transform'); // now, let's make a step back and look at this code closely (wtf?) // If the content of the popper grows once it's been positioned, it // may happen that the popper gets misplaced because of the new content // overflowing its reference element // To avoid this problem, we provide two options (x and y), which allow // the consumer to define the offset origin. // If we position a popper on top of a reference element, we can set // `x` to `top` to make the popper grow towards its top instead of // its bottom. let left, top; if (sideA === 'bottom') { top = -offsetParentRect.height + offsets.bottom; } else { top = offsets.top; } if (sideB === 'right') { left = -offsetParentRect.width + offsets.right; } else { left = offsets.left; } if (gpuAcceleration && prefixedProperty) { styles[prefixedProperty] = `translate3d(${left}px, ${top}px, 0)`; styles[sideA] = 0; styles[sideB] = 0; styles.willChange = 'transform'; } else { // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties const invertTop = sideA === 'bottom' ? -1 : 1; const invertLeft = sideB === 'right' ? -1 : 1; styles[sideA] = top * invertTop; styles[sideB] = left * invertLeft; styles.willChange = `${sideA}, ${sideB}`; } // Attributes const attributes = { 'x-placement': data.placement, }; // Update `data` attributes, styles and arrowStyles data.attributes = { ...attributes, ...data.attributes }; data.styles = { ...styles, ...data.styles }; data.arrowStyles = { ...data.offsets.arrow, ...data.arrowStyles }; return data; } ",
"import find from './find'; /** * Helper used to know if the given modifier depends from another one.<br /> * It checks if the needed modifier is listed and enabled. * @method * @memberof Popper.Utils * @param {Array} modifiers - list of modifiers * @param {String} requestingName - name of requesting modifier * @param {String} requestedName - name of requested modifier * @returns {Boolean} */ export default function isModifierRequired( modifiers, requestingName, requestedName ) { const requesting = find(modifiers, ({ name }) => name === requestingName); const isRequired = !!requesting && modifiers.some(modifier => { return ( modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order ); }); if (!isRequired) { const requesting = `\`${requestingName}\``; const requested = `\`${requestedName}\``; console.warn( `${requested} modifier is required by ${requesting} modifier in order to work, be sure to include it before ${requesting}!` ); } return isRequired; } ",
"import getClientRect from '../utils/getClientRect'; import getOuterSizes from '../utils/getOuterSizes'; import isModifierRequired from '../utils/isModifierRequired'; import getStyleComputedProperty from '../utils/getStyleComputedProperty'; /** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by update method * @argument {Object} options - Modifiers configuration and options * @returns {Object} The data object, properly modified */ export default function arrow(data, options) { // arrow depends on keepTogether in order to work if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) { return data; } let arrowElement = options.element; // if arrowElement is a string, suppose it's a CSS selector if (typeof arrowElement === 'string') { arrowElement = data.instance.popper.querySelector(arrowElement); // if arrowElement is not found, don't run the modifier if (!arrowElement) { return data; } } else { // if the arrowElement isn't a query selector we must check that the // provided DOM node is child of its popper node if (!data.instance.popper.contains(arrowElement)) { console.warn( 'WARNING: `arrow.element` must be child of its popper element!' ); return data; } } const placement = data.placement.split('-')[0]; const { popper, reference } = data.offsets; const isVertical = ['left', 'right'].indexOf(placement) !== -1; const len = isVertical ? 'height' : 'width'; const sideCapitalized = isVertical ? 'Top' : 'Left'; const side = sideCapitalized.toLowerCase(); const altSide = isVertical ? 'left' : 'top'; const opSide = isVertical ? 'bottom' : 'right'; const arrowElementSize = getOuterSizes(arrowElement)[len]; // // extends keepTogether behavior making sure the popper and its // reference have enough pixels in conjuction // // top/left side if (reference[opSide] - arrowElementSize < popper[side]) { data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize); } // bottom/right side if (reference[side] + arrowElementSize > popper[opSide]) { data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide]; } // compute center of the popper const center = reference[side] + reference[len] / 2 - arrowElementSize / 2; // Compute the sideValue using the updated popper offsets // take popper margin in account because we don't have this info available const popperMarginSide = getStyleComputedProperty( data.instance.popper, `margin${sideCapitalized}` ).replace('px', ''); let sideValue = center - getClientRect(data.offsets.popper)[side] - popperMarginSide; // prevent arrowElement from being placed not contiguously to its popper sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0); data.arrowElement = arrowElement; data.offsets.arrow = {}; data.offsets.arrow[side] = Math.round(sideValue); data.offsets.arrow[altSide] = ''; // make sure to unset any eventual altSide value from the DOM node return data; } ",
"/** * Get the opposite placement variation of the given one * @method * @memberof Popper.Utils * @argument {String} placement variation * @returns {String} flipped placement variation */ export default function getOppositeVariation(variation) { if (variation === 'end') { return 'start'; } else if (variation === 'start') { return 'end'; } return variation; } ",
"/** * List of accepted placements to use as values of the `placement` option.<br /> * Valid placements are: * - `auto` * - `top` * - `right` * - `bottom` * - `left` * * Each placement can have a variation from this list: * - `-start` * - `-end` * * Variations are interpreted easily if you think of them as the left to right * written languages. Horizontally (`top` and `bottom`), `start` is left and `end` * is right.<br /> * Vertically (`left` and `right`), `start` is top and `end` is bottom. * * Some valid examples are: * - `top-end` (on top of reference, right aligned) * - `right-start` (on right of reference, top aligned) * - `bottom` (on bottom, centered) * - `auto-right` (on the side with more space available, alignment depends by placement) * * @static * @type {Array} * @enum {String} * @readonly * @method placements * @memberof Popper */ export default [ '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', ]; ",
"import placements from '../methods/placements'; // Get rid of `auto` `auto-start` and `auto-end` const validPlacements = placements.slice(3); /** * Given an initial placement, returns all the subsequent placements * clockwise (or counter-clockwise). * * @method * @memberof Popper.Utils * @argument {String} placement - A valid placement (it accepts variations) * @argument {Boolean} counter - Set to true to walk the placements counterclockwise * @returns {Array} placements including their variations */ export default function clockwise(placement, counter = false) { const index = validPlacements.indexOf(placement); const arr = validPlacements .slice(index + 1) .concat(validPlacements.slice(0, index)); return counter ? arr.reverse() : arr; } ",
"import getOppositePlacement from '../utils/getOppositePlacement'; import getOppositeVariation from '../utils/getOppositeVariation'; import getPopperOffsets from '../utils/getPopperOffsets'; import runModifiers from '../utils/runModifiers'; import getBoundaries from '../utils/getBoundaries'; import isModifierEnabled from '../utils/isModifierEnabled'; import clockwise from '../utils/clockwise'; const BEHAVIORS = { FLIP: 'flip', CLOCKWISE: 'clockwise', COUNTERCLOCKWISE: 'counterclockwise', }; /** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by update method * @argument {Object} options - Modifiers configuration and options * @returns {Object} The data object, properly modified */ export default function flip(data, options) { // if `inner` modifier is enabled, we can't use the `flip` modifier if (isModifierEnabled(data.instance.modifiers, 'inner')) { return data; } if (data.flipped && data.placement === data.originalPlacement) { // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides return data; } const boundaries = getBoundaries( data.instance.popper, data.instance.reference, options.padding, options.boundariesElement ); let placement = data.placement.split('-')[0]; let placementOpposite = getOppositePlacement(placement); let variation = data.placement.split('-')[1] || ''; let flipOrder = []; switch (options.behavior) { case BEHAVIORS.FLIP: flipOrder = [placement, placementOpposite]; break; case BEHAVIORS.CLOCKWISE: flipOrder = clockwise(placement); break; case BEHAVIORS.COUNTERCLOCKWISE: flipOrder = clockwise(placement, true); break; default: flipOrder = options.behavior; } flipOrder.forEach((step, index) => { if (placement !== step || flipOrder.length === index + 1) { return data; } placement = data.placement.split('-')[0]; placementOpposite = getOppositePlacement(placement); const popperOffsets = data.offsets.popper; const refOffsets = data.offsets.reference; // using floor because the reference offsets may contain decimals we are not going to consider here const floor = Math.floor; const overlapsRef = (placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left)) || (placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right)) || (placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top)) || (placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom)); const overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left); const overflowsRight = floor(popperOffsets.right) > floor(boundaries.right); const overflowsTop = floor(popperOffsets.top) < floor(boundaries.top); const overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom); const overflowsBoundaries = (placement === 'left' && overflowsLeft) || (placement === 'right' && overflowsRight) || (placement === 'top' && overflowsTop) || (placement === 'bottom' && overflowsBottom); // flip the variation if required const isVertical = ['top', 'bottom'].indexOf(placement) !== -1; const flippedVariation = !!options.flipVariations && ((isVertical && variation === 'start' && overflowsLeft) || (isVertical && variation === 'end' && overflowsRight) || (!isVertical && variation === 'start' && overflowsTop) || (!isVertical && variation === 'end' && overflowsBottom)); if (overlapsRef || overflowsBoundaries || flippedVariation) { // this boolean to detect any flip loop data.flipped = true; if (overlapsRef || overflowsBoundaries) { placement = flipOrder[index + 1]; } if (flippedVariation) { variation = getOppositeVariation(variation); } data.placement = placement + (variation ? '-' + variation : ''); // this object contains `position`, we want to preserve it along with // any additional property we may add in the future data.offsets.popper = { ...data.offsets.popper, ...getPopperOffsets( data.instance.popper, data.offsets.reference, data.placement ), }; data = runModifiers(data.instance.modifiers, data, 'flip'); } }); return data; } ",
"/** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by update method * @argument {Object} options - Modifiers configuration and options * @returns {Object} The data object, properly modified */ export default function keepTogether(data) { const { popper, reference } = data.offsets; const placement = data.placement.split('-')[0]; const floor = Math.floor; const isVertical = ['top', 'bottom'].indexOf(placement) !== -1; const side = isVertical ? 'right' : 'bottom'; const opSide = isVertical ? 'left' : 'top'; const measurement = isVertical ? 'width' : 'height'; if (popper[side] < floor(reference[opSide])) { data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement]; } if (popper[opSide] > floor(reference[side])) { data.offsets.popper[opSide] = floor(reference[side]); } return data; } ",
"import isNumeric from '../utils/isNumeric'; import getClientRect from '../utils/getClientRect'; import find from '../utils/find'; /** * Converts a string containing value + unit into a px value number * @function * @memberof {modifiers~offset} * @private * @argument {String} str - Value + unit string * @argument {String} measurement - `height` or `width` * @argument {Object} popperOffsets * @argument {Object} referenceOffsets * @returns {Number|String} * Value in pixels, or original string if no values were extracted */ export function toValue(str, measurement, popperOffsets, referenceOffsets) { // separate value from unit const split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/); const value = +split[1]; const unit = split[2]; // If it's not a number it's an operator, I guess if (!value) { return str; } if (unit.indexOf('%') === 0) { let element; switch (unit) { case '%p': element = popperOffsets; break; case '%': case '%r': default: element = referenceOffsets; } const rect = getClientRect(element); return rect[measurement] / 100 * value; } else if (unit === 'vh' || unit === 'vw') { // if is a vh or vw, we calculate the size based on the viewport let size; if (unit === 'vh') { size = Math.max( document.documentElement.clientHeight, window.innerHeight || 0 ); } else { size = Math.max( document.documentElement.clientWidth, window.innerWidth || 0 ); } return size / 100 * value; } else { // if is an explicit pixel unit, we get rid of the unit and keep the value // if is an implicit unit, it's px, and we return just the value return value; } } /** * Parse an `offset` string to extrapolate `x` and `y` numeric offsets. * @function * @memberof {modifiers~offset} * @private * @argument {String} offset * @argument {Object} popperOffsets * @argument {Object} referenceOffsets * @argument {String} basePlacement * @returns {Array} a two cells array with x and y offsets in numbers */ export function parseOffset( offset, popperOffsets, referenceOffsets, basePlacement ) { const offsets = [0, 0]; // Use height if placement is left or right and index is 0 otherwise use width // in this way the first offset will use an axis and the second one // will use the other one const useHeight = ['right', 'left'].indexOf(basePlacement) !== -1; // Split the offset string to obtain a list of values and operands // The regex addresses values with the plus or minus sign in front (+10, -20, etc) const fragments = offset.split(/(\+|\-)/).map(frag => frag.trim()); // Detect if the offset string contains a pair of values or a single one // they could be separated by comma or space const divider = fragments.indexOf( find(fragments, frag => frag.search(/,|\s/) !== -1) ); if (fragments[divider] && fragments[divider].indexOf(',') === -1) { console.warn( 'Offsets separated by white space(s) are deprecated, use a comma (,) instead.' ); } // If divider is found, we divide the list of values and operands to divide // them by ofset X and Y. const splitRegex = /\s*,\s*|\s+/; let ops = divider !== -1 ? [ fragments .slice(0, divider) .concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat( fragments.slice(divider + 1) ), ] : [fragments]; // Convert the values with units to absolute pixels to allow our computations ops = ops.map((op, index) => { // Most of the units rely on the orientation of the popper const measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width'; let mergeWithPrevious = false; return ( op // This aggregates any `+` or `-` sign that aren't considered operators // e.g.: 10 + +5 => [10, +, +5] .reduce((a, b) => { if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) { a[a.length - 1] = b; mergeWithPrevious = true; return a; } else if (mergeWithPrevious) { a[a.length - 1] += b; mergeWithPrevious = false; return a; } else { return a.concat(b); } }, []) // Here we convert the string values into number values (in px) .map(str => toValue(str, measurement, popperOffsets, referenceOffsets)) ); }); // Loop trough the offsets arrays and execute the operations ops.forEach((op, index) => { op.forEach((frag, index2) => { if (isNumeric(frag)) { offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1); } }); }); return offsets; } /** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by update method * @argument {Object} options - Modifiers configuration and options * @argument {Number|String} options.offset=0 * The offset value as described in the modifier description * @returns {Object} The data object, properly modified */ export default function offset(data, { offset }) { const { placement, offsets: { popper, reference } } = data; const basePlacement = placement.split('-')[0]; let offsets; if (isNumeric(+offset)) { offsets = [+offset, 0]; } else { offsets = parseOffset(offset, popper, reference, basePlacement); } if (basePlacement === 'left') { popper.top += offsets[0]; popper.left -= offsets[1]; } else if (basePlacement === 'right') { popper.top += offsets[0]; popper.left += offsets[1]; } else if (basePlacement === 'top') { popper.left += offsets[0]; popper.top -= offsets[1]; } else if (basePlacement === 'bottom') { popper.left += offsets[0]; popper.top += offsets[1]; } data.popper = popper; return data; } ",
"import getOffsetParent from '../utils/getOffsetParent'; import getBoundaries from '../utils/getBoundaries'; /** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by `update` method * @argument {Object} options - Modifiers configuration and options * @returns {Object} The data object, properly modified */ export default function preventOverflow(data, options) { let boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper); // If offsetParent is the reference element, we really want to // go one step up and use the next offsetParent as reference to // avoid to make this modifier completely useless and look like broken if (data.instance.reference === boundariesElement) { boundariesElement = getOffsetParent(boundariesElement); } const boundaries = getBoundaries( data.instance.popper, data.instance.reference, options.padding, boundariesElement ); options.boundaries = boundaries; const order = options.priority; let popper = data.offsets.popper; const check = { primary(placement) { let value = popper[placement]; if ( popper[placement] < boundaries[placement] && !options.escapeWithReference ) { value = Math.max(popper[placement], boundaries[placement]); } return { [placement]: value }; }, secondary(placement) { const mainSide = placement === 'right' ? 'left' : 'top'; let value = popper[mainSide]; if ( popper[placement] > boundaries[placement] && !options.escapeWithReference ) { value = Math.min( popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height) ); } return { [mainSide]: value }; }, }; order.forEach(placement => { const side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary'; popper = { ...popper, ...check[side](placement) }; }); data.offsets.popper = popper; return data; } ",
"/** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by `update` method * @argument {Object} options - Modifiers configuration and options * @returns {Object} The data object, properly modified */ export default function shift(data) { const placement = data.placement; const basePlacement = placement.split('-')[0]; const shiftvariation = placement.split('-')[1]; // if shift shiftvariation is specified, run the modifier if (shiftvariation) { const { reference, popper } = data.offsets; const isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1; const side = isVertical ? 'left' : 'top'; const measurement = isVertical ? 'width' : 'height'; const shiftOffsets = { start: { [side]: reference[side] }, end: { [side]: reference[side] + reference[measurement] - popper[measurement], }, }; data.offsets.popper = { ...popper, ...shiftOffsets[shiftvariation] }; } return data; } ",
"import isModifierRequired from '../utils/isModifierRequired'; import find from '../utils/find'; /** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by update method * @argument {Object} options - Modifiers configuration and options * @returns {Object} The data object, properly modified */ export default function hide(data) { if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) { return data; } const refRect = data.offsets.reference; const bound = find( data.instance.modifiers, modifier => modifier.name === 'preventOverflow' ).boundaries; if ( refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left ) { // Avoid unnecessary DOM access if visibility hasn't changed if (data.hide === true) { return data; } data.hide = true; data.attributes['x-out-of-boundaries'] = ''; } else { // Avoid unnecessary DOM access if visibility hasn't changed if (data.hide === false) { return data; } data.hide = false; data.attributes['x-out-of-boundaries'] = false; } return data; } ",
"import getClientRect from '../utils/getClientRect'; import getOppositePlacement from '../utils/getOppositePlacement'; /** * @function * @memberof Modifiers * @argument {Object} data - The data object generated by `update` method * @argument {Object} options - Modifiers configuration and options * @returns {Object} The data object, properly modified */ export default function inner(data) { const placement = data.placement; const basePlacement = placement.split('-')[0]; const { popper, reference } = data.offsets; const isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1; const subtractLength = ['top', 'left'].indexOf(basePlacement) === -1; popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0); data.placement = getOppositePlacement(placement); data.offsets.popper = getClientRect(popper); return data; } ",
"import applyStyle, { applyStyleOnLoad } from './applyStyle'; import computeStyle from './computeStyle'; import arrow from './arrow'; import flip from './flip'; import keepTogether from './keepTogether'; import offset from './offset'; import preventOverflow from './preventOverflow'; import shift from './shift'; import hide from './hide'; import inner from './inner'; /** * Modifier function, each modifier can have a function of this type assigned * to its `fn` property.<br /> * These functions will be called on each update, this means that you must * make sure they are performant enough to avoid performance bottlenecks. * * @function ModifierFn * @argument {dataObject} data - The data object generated by `update` method * @argument {Object} options - Modifiers configuration and options * @returns {dataObject} The data object, properly modified */ /** * Modifiers are plugins used to alter the behavior of your poppers.<br /> * Popper.js uses a set of 9 modifiers to provide all the basic functionalities * needed by the library. * * Usually you don't want to override the `order`, `fn` and `onLoad` props. * All the other properties are configurations that could be tweaked. * @namespace modifiers */ export default { /** * Modifier used to shift the popper on the start or end of its reference * element.<br /> * It will read the variation of the `placement` property.<br /> * It can be one either `-end` or `-start`. * @memberof modifiers * @inner */ shift: { /** @prop {number} order=100 - Index used to define the order of execution */ order: 100, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: shift, }, /** * The `offset` modifier can shift your popper on both its axis. * * It accepts the following units: * - `px` or unitless, interpreted as pixels * - `%` or `%r`, percentage relative to the length of the reference element * - `%p`, percentage relative to the length of the popper element * - `vw`, CSS viewport width unit * - `vh`, CSS viewport height unit * * For length is intended the main axis relative to the placement of the popper.<br /> * This means that if the placement is `top` or `bottom`, the length will be the * `width`. In case of `left` or `right`, it will be the height. * * You can provide a single value (as `Number` or `String`), or a pair of values * as `String` divided by a comma or one (or more) white spaces.<br /> * The latter is a deprecated method because it leads to confusion and will be * removed in v2.<br /> * Additionally, it accepts additions and subtractions between different units. * Note that multiplications and divisions aren't supported. * * Valid examples are: * ``` * 10 * '10%' * '10, 10' * '10%, 10' * '10 + 10%' * '10 - 5vh + 3%' * '-10px + 5vh, 5px - 6%' * ``` * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap * > with their reference element, unfortunately, you will have to disable the `flip` modifier. * > More on this [reading this issue](https://github.com/FezVrasta/popper.js/issues/373) * * @memberof modifiers * @inner */ offset: { /** @prop {number} order=200 - Index used to define the order of execution */ order: 200, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: offset, /** @prop {Number|String} offset=0 * The offset value as described in the modifier description */ offset: 0, }, /** * Modifier used to prevent the popper from being positioned outside the boundary. * * An scenario exists where the reference itself is not within the boundaries.<br /> * We can say it has "escaped the boundaries" — or just "escaped".<br /> * In this case we need to decide whether the popper should either: * * - detach from the reference and remain "trapped" in the boundaries, or * - if it should ignore the boundary and "escape with its reference" * * When `escapeWithReference` is set to`true` and reference is completely * outside its boundaries, the popper will overflow (or completely leave) * the boundaries in order to remain attached to the edge of the reference. * * @memberof modifiers * @inner */ preventOverflow: { /** @prop {number} order=300 - Index used to define the order of execution */ order: 300, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: preventOverflow, /** * @prop {Array} [priority=['left','right','top','bottom']] * Popper will try to prevent overflow following these priorities by default, * then, it could overflow on the left and on top of the `boundariesElement` */ priority: ['left', 'right', 'top', 'bottom'], /** * @prop {number} padding=5 * Amount of pixel used to define a minimum distance between the boundaries * and the popper this makes sure the popper has always a little padding * between the edges of its container */ padding: 5, /** * @prop {String|HTMLElement} boundariesElement='scrollParent' * Boundaries used by the modifier, can be `scrollParent`, `window`, * `viewport` or any DOM element. */ boundariesElement: 'scrollParent', }, /** * Modifier used to make sure the reference and its popper stay near eachothers * without leaving any gap between the two. Expecially useful when the arrow is * enabled and you want to assure it to point to its reference element. * It cares only about the first axis, you can still have poppers with margin * between the popper and its reference element. * @memberof modifiers * @inner */ keepTogether: { /** @prop {number} order=400 - Index used to define the order of execution */ order: 400, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: keepTogether, }, /** * This modifier is used to move the `arrowElement` of the popper to make * sure it is positioned between the reference element and its popper element. * It will read the outer size of the `arrowElement` node to detect how many * pixels of conjuction are needed. * * It has no effect if no `arrowElement` is provided. * @memberof modifiers * @inner */ arrow: { /** @prop {number} order=500 - Index used to define the order of execution */ order: 500, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: arrow, /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */ element: '[x-arrow]', }, /** * Modifier used to flip the popper's placement when it starts to overlap its * reference element. * * Requires the `preventOverflow` modifier before it in order to work. * * **NOTE:** this modifier will interrupt the current update cycle and will * restart it if it detects the need to flip the placement. * @memberof modifiers * @inner */ flip: { /** @prop {number} order=600 - Index used to define the order of execution */ order: 600, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: flip, /** * @prop {String|Array} behavior='flip' * The behavior used to change the popper's placement. It can be one of * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid * placements (with optional variations). */ behavior: 'flip', /** * @prop {number} padding=5 * The popper will flip if it hits the edges of the `boundariesElement` */ padding: 5, /** * @prop {String|HTMLElement} boundariesElement='viewport' * The element which will define the boundaries of the popper position, * the popper will never be placed outside of the defined boundaries * (except if keepTogether is enabled) */ boundariesElement: 'viewport', }, /** * Modifier used to make the popper flow toward the inner of the reference element. * By default, when this modifier is disabled, the popper will be placed outside * the reference element. * @memberof modifiers * @inner */ inner: { /** @prop {number} order=700 - Index used to define the order of execution */ order: 700, /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */ enabled: false, /** @prop {ModifierFn} */ fn: inner, }, /** * Modifier used to hide the popper when its reference element is outside of the * popper boundaries. It will set a `x-out-of-boundaries` attribute which can * be used to hide with a CSS selector the popper when its reference is * out of boundaries. * * Requires the `preventOverflow` modifier before it in order to work. * @memberof modifiers * @inner */ hide: { /** @prop {number} order=800 - Index used to define the order of execution */ order: 800, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: hide, }, /** * Computes the style that will be applied to the popper element to gets * properly positioned. * * Note that this modifier will not touch the DOM, it just prepares the styles * so that `applyStyle` modifier can apply it. This separation is useful * in case you need to replace `applyStyle` with a custom implementation. * * This modifier has `850` as `order` value to maintain backward compatibility * with previous versions of Popper.js. Expect the modifiers ordering method * to change in future major versions of the library. * * @memberof modifiers * @inner */ computeStyle: { /** @prop {number} order=850 - Index used to define the order of execution */ order: 850, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: computeStyle, /** * @prop {Boolean} gpuAcceleration=true * If true, it uses the CSS 3d transformation to position the popper. * Otherwise, it will use the `top` and `left` properties. */ gpuAcceleration: true, /** * @prop {string} [x='bottom'] * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin. * Change this if your popper should grow in a direction different from `bottom` */ x: 'bottom', /** * @prop {string} [x='left'] * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin. * Change this if your popper should grow in a direction different from `right` */ y: 'right', }, /** * Applies the computed styles to the popper element. * * All the DOM manipulations are limited to this modifier. This is useful in case * you want to integrate Popper.js inside a framework or view library and you * want to delegate all the DOM manipulations to it. * * Note that if you disable this modifier, you must make sure the popper element * has its position set to `absolute` before Popper.js can do its work! * * Just disable this modifier and define you own to achieve the desired effect. * * @memberof modifiers * @inner */ applyStyle: { /** @prop {number} order=900 - Index used to define the order of execution */ order: 900, /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ enabled: true, /** @prop {ModifierFn} */ fn: applyStyle, /** @prop {Function} */ onLoad: applyStyleOnLoad, /** * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier * @prop {Boolean} gpuAcceleration=true * If true, it uses the CSS 3d transformation to position the popper. * Otherwise, it will use the `top` and `left` properties. */ gpuAcceleration: undefined, }, }; /** * The `dataObject` is an object containing all the informations used by Popper.js * this object get passed to modifiers and to the `onCreate` and `onUpdate` callbacks. * @name dataObject * @property {Object} data.instance The Popper.js instance * @property {String} data.placement Placement applied to popper * @property {String} data.originalPlacement Placement originally defined on init * @property {Boolean} data.flipped True if popper has been flipped by flip modifier * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper. * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier * @property {Object} data.styles Any CSS property defined here will be applied to the popper, it expects the JavaScript nomenclature (eg. `marginBottom`) * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow, it expects the JavaScript nomenclature (eg. `marginBottom`) * @property {Object} data.boundaries Offsets of the popper boundaries * @property {Object} data.offsets The measurements of popper, reference and arrow elements. * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0 */ ",
"import modifiers from '../modifiers/index'; /** * Default options provided to Popper.js constructor.<br /> * These can be overriden using the `options` argument of Popper.js.<br /> * To override an option, simply pass as 3rd argument an object with the same * structure of this object, example: * ``` * new Popper(ref, pop, { * modifiers: { * preventOverflow: { enabled: false } * } * }) * ``` * @type {Object} * @static * @memberof Popper */ export default { /** * Popper's placement * @prop {Popper.placements} placement='bottom' */ placement: 'bottom', /** * Whether events (resize, scroll) are initially enabled * @prop {Boolean} eventsEnabled=true */ eventsEnabled: true, /** * Set to true if you want to automatically remove the popper when * you call the `destroy` method. * @prop {Boolean} removeOnDestroy=false */ removeOnDestroy: false, /** * Callback called when the popper is created.<br /> * By default, is set to no-op.<br /> * Access Popper.js instance with `data.instance`. * @prop {onCreate} */ onCreate: () => {}, /** * Callback called when the popper is updated, this callback is not called * on the initialization/creation of the popper, but only on subsequent * updates.<br /> * By default, is set to no-op.<br /> * Access Popper.js instance with `data.instance`. * @prop {onUpdate} */ onUpdate: () => {}, /** * List of modifiers used to modify the offsets before they are applied to the popper. * They provide most of the functionalities of Popper.js * @prop {modifiers} */ modifiers, }; /** * @callback onCreate * @param {dataObject} data */ /** * @callback onUpdate * @param {dataObject} data */ ",
"// Utils import debounce from './utils/debounce'; import isFunction from './utils/isFunction'; // Methods import update from './methods/update'; import destroy from './methods/destroy'; import enableEventListeners from './methods/enableEventListeners'; import disableEventListeners from './methods/disableEventListeners'; import Defaults from './methods/defaults'; import placements from './methods/placements'; export default class Popper { /** * Create a new Popper.js instance * @class Popper * @param {HTMLElement|referenceObject} reference - The reference element used to position the popper * @param {HTMLElement} popper - The HTML element used as popper. * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults) * @return {Object} instance - The generated Popper.js instance */ constructor(reference, popper, options = {}) { // make update() debounced, so that it only runs at most once-per-tick this.update = debounce(this.update.bind(this)); // with {} we create a new object with the options inside it this.options = { ...Popper.Defaults, ...options }; // init state this.state = { isDestroyed: false, isCreated: false, scrollParents: [], }; // get reference and popper elements (allow jQuery wrappers) this.reference = reference.jquery ? reference[0] : reference; this.popper = popper.jquery ? popper[0] : popper; // Deep merge modifiers options this.options.modifiers = {}; Object.keys({ ...Popper.Defaults.modifiers, ...options.modifiers, }).forEach(name => { this.options.modifiers[name] = { // If it's a built-in modifier, use it as base ...(Popper.Defaults.modifiers[name] || {}), // If there are custom options, override and merge with default ones ...(options.modifiers ? options.modifiers[name] : {}), }; }); // Refactoring modifiers' list (Object => Array) this.modifiers = Object.keys(this.options.modifiers) .map(name => ({ name, ...this.options.modifiers[name], })) // sort the modifiers by order .sort((a, b) => a.order - b.order); // modifiers have the ability to execute arbitrary code when Popper.js get inited // such code is executed in the same order of its modifier // they could add new properties to their options configuration // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`! this.modifiers.forEach(modifierOptions => { if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) { modifierOptions.onLoad( this.reference, this.popper, this.options, modifierOptions, this.state ); } }); // fire the first update to position the popper in the right place this.update(); const eventsEnabled = this.options.eventsEnabled; if (eventsEnabled) { // setup event listeners, they will take care of update the position in specific situations this.enableEventListeners(); } this.state.eventsEnabled = eventsEnabled; } // We can't use class properties because they don't get listed in the // class prototype and break stuff like Sinon stubs update() { return update.call(this); } destroy() { return destroy.call(this); } enableEventListeners() { return enableEventListeners.call(this); } disableEventListeners() { return disableEventListeners.call(this); } /** * Schedule an update, it will run on the next UI update available * @method scheduleUpdate * @memberof Popper */ scheduleUpdate = () => requestAnimationFrame(this.update); /** * Collection of utilities useful when writing custom modifiers. * Starting from version 1.7, this method is available only if you * include `popper-utils.js` before `popper.js`. * * **DEPRECATION**: This way to access PopperUtils is deprecated * and will be removed in v2! Use the PopperUtils module directly instead. * Due to the high instability of the methods contained in Utils, we can't * guarantee them to follow semver. Use them at your own risk! * @static * @private * @type {Object} * @deprecated since version 1.8 * @member Utils * @memberof Popper */ static Utils = (typeof window !== 'undefined' ? window : global).PopperUtils; static placements = placements; static Defaults = Defaults; } /** * The `referenceObject` is an object that provides an interface compatible with Popper.js * and lets you use it as replacement of a real DOM node.<br /> * You can use this method to position a popper relatively to a set of coordinates * in case you don't have a DOM node to use as reference. * * ``` * new Popper(referenceObject, popperNode); * ``` * * NB: This feature isn't supported in Internet Explorer 10 * @name referenceObject * @property {Function} data.getBoundingClientRect * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method. * @property {number} data.clientWidth * An ES6 getter that will return the width of the virtual reference element. * @property {number} data.clientHeight * An ES6 getter that will return the height of the virtual reference element. */ ",
],
names: [
"nativeHints",
"some",
"fn",
"toString",
"indexOf",
"isBrowser",
"window",
"longerTimeoutBrowsers",
"timeoutDuration",
"i",
"length",
"navigator",
"userAgent",
"microtaskDebounce",
"scheduled",
"elem",
"document",
"createElement",
"observer",
"MutationObserver",
"observe",
"attributes",
"setAttribute",
"taskDebounce",
"supportsNativeMutationObserver",
"isNative",
"isFunction",
"functionToCheck",
"getType",
"call",
"getStyleComputedProperty",
"element",
"nodeType",
"css",
"getComputedStyle",
"property",
"getParentNode",
"nodeName",
"parentNode",
"host",
"getScrollParent",
"body",
"overflow",
"overflowX",
"overflowY",
"test",
"getOffsetParent",
"offsetParent",
"documentElement",
"isOffsetContainer",
"firstElementChild",
"getRoot",
"node",
"findCommonOffsetParent",
"element1",
"element2",
"order",
"compareDocumentPosition",
"Node",
"DOCUMENT_POSITION_FOLLOWING",
"start",
"end",
"range",
"createRange",
"setStart",
"setEnd",
"commonAncestorContainer",
"contains",
"element1root",
"getScroll",
"side",
"upperSide",
"html",
"scrollingElement",
"includeScroll",
"subtract",
"scrollTop",
"scrollLeft",
"modifier",
"top",
"bottom",
"left",
"right",
"getBordersSize",
"sideA",
"axis",
"sideB",
"styles",
"split",
"isIE10",
"appVersion",
"getSize",
"Math",
"max",
"computedStyle",
"getWindowSizes",
"getClientRect",
"offsets",
"width",
"height",
"getBoundingClientRect",
"rect",
"result",
"sizes",
"clientWidth",
"clientHeight",
"horizScrollbar",
"offsetWidth",
"vertScrollbar",
"offsetHeight",
"getOffsetRectRelativeToArbitraryNode",
"runIsIE10",
"isHTML",
"parent",
"childrenRect",
"parentRect",
"scrollParent",
"borderTopWidth",
"borderLeftWidth",
"marginTop",
"marginLeft",
"getViewportOffsetRectRelativeToArtbitraryNode",
"relativeOffset",
"innerWidth",
"innerHeight",
"offset",
"isFixed",
"getBoundaries",
"boundaries",
"boundariesElement",
"boundariesNode",
"getArea",
"computeAutoPlacement",
"padding",
"placement",
"rects",
"refRect",
"sortedAreas",
"Object",
"keys",
"map",
"sort",
"b",
"area",
"a",
"filteredAreas",
"filter",
"popper",
"computedPlacement",
"key",
"variation",
"getReferenceOffsets",
"commonOffsetParent",
"getOuterSizes",
"x",
"parseFloat",
"marginBottom",
"y",
"marginRight",
"getOppositePlacement",
"hash",
"replace",
"getPopperOffsets",
"popperRect",
"popperOffsets",
"isHoriz",
"mainSide",
"secondarySide",
"measurement",
"secondaryMeasurement",
"referenceOffsets",
"find",
"Array",
"prototype",
"arr",
"findIndex",
"cur",
"match",
"obj",
"runModifiers",
"modifiersToRun",
"ends",
"modifiers",
"slice",
"forEach",
"function",
"warn",
"enabled",
"data",
"reference",
"update",
"state",
"isDestroyed",
"options",
"flip",
"originalPlacement",
"position",
"isCreated",
"onUpdate",
"onCreate",
"isModifierEnabled",
"name",
"getSupportedPropertyName",
"prefixes",
"upperProp",
"charAt",
"toUpperCase",
"prefix",
"toCheck",
"style",
"destroy",
"removeAttribute",
"disableEventListeners",
"removeOnDestroy",
"removeChild",
"attachToScrollParents",
"isBody",
"target",
"addEventListener",
"passive",
"push",
"setupEventListeners",
"updateBound",
"scrollElement",
"scrollParents",
"eventsEnabled",
"enableEventListeners",
"scheduleUpdate",
"removeEventListeners",
"removeEventListener",
"cancelAnimationFrame",
"isNumeric",
"n",
"isNaN",
"isFinite",
"setStyles",
"unit",
"setAttributes",
"value",
"applyStyle",
"instance",
"arrowElement",
"arrowStyles",
"applyStyleOnLoad",
"computeStyle",
"floor",
"legacyGpuAccelerationOption",
"gpuAcceleration",
"offsetParentRect",
"prefixedProperty",
"willChange",
"invertTop",
"invertLeft",
"arrow",
"isModifierRequired",
"requesting",
"isRequired",
"requested",
"querySelector",
"isVertical",
"len",
"sideCapitalized",
"toLowerCase",
"altSide",
"opSide",
"arrowElementSize",
"center",
"popperMarginSide",
"sideValue",
"min",
"round",
"getOppositeVariation",
"validPlacements",
"placements",
"clockwise",
"counter",
"index",
"concat",
"reverse",
"BEHAVIORS",
"flipped",
"placementOpposite",
"flipOrder",
"behavior",
"FLIP",
"CLOCKWISE",
"COUNTERCLOCKWISE",
"refOffsets",
"overlapsRef",
"overflowsLeft",
"overflowsRight",
"overflowsTop",
"overflowsBottom",
"overflowsBoundaries",
"flippedVariation",
"flipVariations",
"keepTogether",
"toValue",
"str",
"size",
"parseOffset",
"useHeight",
"fragments",
"frag",
"trim",
"divider",
"search",
"splitRegex",
"ops",
"mergeWithPrevious",
"op",
"reduce",
"index2",
"basePlacement",
"preventOverflow",
"priority",
"check",
"escapeWithReference",
"shift",
"shiftvariation",
"shiftOffsets",
"hide",
"bound",
"inner",
"subtractLength",
"Popper",
"requestAnimationFrame",
"debounce",
"bind",
"Defaults",
"jquery",
"modifierOptions",
"onLoad",
"Utils",
"global",
"PopperUtils",
],
mappings: "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",
}