{“version”:3,“file”:“popper.min.js”,“sources”:,“sourcesContent”:[“/**n * Check if the given variable is a functionn * @methodn * @memberof Popper.Utilsn * @argument {Any} functionToCheck - variable to checkn * @returns {Boolean} answer to: is a function?n */nexport default function isFunction(functionToCheck) {n const getType = {};n return (n functionToCheck &&n getType.toString.call(functionToCheck) === '[object Function]'n );n}n”,“/**n * Get CSS computed property of the given elementn * @methodn * @memberof Popper.Utilsn * @argument {Eement} elementn * @argument {String} propertyn */nexport default function getStyleComputedProperty(element, property) {n if (element.nodeType !== 1) {n return [];n }n // NOTE: 1 DOM access heren const css = getComputedStyle(element, null);n return property ? css : css;n}n”,“/**n * Returns the parentNode or the host of the elementn * @methodn * @memberof Popper.Utilsn * @argument {Element} elementn * @returns {Element} parentn */nexport default function getParentNode(element) {n if (element.nodeName === 'HTML') {n return element;n }n return element.parentNode || element.host;n}n”,“import getStyleComputedProperty from './getStyleComputedProperty';nimport getParentNode from './getParentNode';nn/**n * Returns the scrolling parent of the given elementn * @methodn * @memberof Popper.Utilsn * @argument {Element} elementn * @returns {Element} scroll parentn */nexport default function getScrollParent(element) {n // Return body, `getScroll` will take care to get the correct `scrollTop` from itn if (!element) {n return document.bodyn }nn switch (element.nodeName) {n case 'HTML':n case 'BODY':n return element.ownerDocument.bodyn case '#document':n return element.bodyn }nn // Firefox want us to check `-x` and `-y` variations as welln const { overflow, overflowX, overflowY } = getStyleComputedProperty(element);n if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {n return element;n }nn return getScrollParent(getParentNode(element));n}n”,“import isBrowser from './isBrowser';nnconst isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);nconst isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);nn/**n * Determines if the browser is Internet Explorern * @methodn * @memberof Popper.Utilsn * @param {Number} version to checkn * @returns {Boolean} isIEn */nexport default function isIE(version) {n if (version === 11) {n return isIE11;n }n if (version === 10) {n return isIE10;n }n return isIE11 || isIE10;n}n”,“import getStyleComputedProperty from './getStyleComputedProperty';nimport isIE from './isIE';n/**n * Returns the offset parent of the given elementn * @methodn * @memberof Popper.Utilsn * @argument {Element} elementn * @returns {Element} offset parentn */nexport default function getOffsetParent(element) {n if (!element) {n return document.documentElement;n }nn const noOffsetParent = isIE(10) ? document.body : null;nn // NOTE: 1 DOM access heren let offsetParent = element.offsetParent;n // Skip hidden elements which don't have an offsetParentn while (offsetParent === noOffsetParent && element.nextElementSibling) {n offsetParent = (element = element.nextElementSibling).offsetParent;n }nn const nodeName = offsetParent && offsetParent.nodeName;nn if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {n return element ? element.ownerDocument.documentElement : document.documentElement;n }nn // .offsetParent will return the closest TD or TABLE in casen // no offsetParent is present, I hate this job…n if (n ['TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 &&n getStyleComputedProperty(offsetParent, 'position') === 'static'n ) {n return getOffsetParent(offsetParent);n }nn return offsetParent;n}n”,“import getOffsetParent from './getOffsetParent';nnexport default function isOffsetContainer(element) {n const { nodeName } = element;n if (nodeName === 'BODY') {n return false;n }n return (n nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === elementn );n}n”,“/**n * Finds the root node (document, shadowDOM root) of the given elementn * @methodn * @memberof Popper.Utilsn * @argument {Element} noden * @returns {Element} root noden */nexport default function getRoot(node) {n if (node.parentNode !== null) {n return getRoot(node.parentNode);n }nn return node;n}n”,“import isOffsetContainer from './isOffsetContainer';nimport getRoot from './getRoot';nimport getOffsetParent from './getOffsetParent';nn/**n * Finds the offset parent common to the two provided nodesn * @methodn * @memberof Popper.Utilsn * @argument {Element} element1n * @argument {Element} element2n * @returns {Element} common offset parentn */nexport default function findCommonOffsetParent(element1, element2) {n // This check is needed to avoid errors in case one of the elements isn't defined for any reasonn if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {n return document.documentElement;n }nn // Here we make sure to give as "start" the element that comes first in the DOMn const order =n element1.compareDocumentPosition(element2) &n Node.DOCUMENT_POSITION_FOLLOWING;n const start = order ? element1 : element2;n const end = order ? element2 : element1;nn // Get common ancestor containern const range = document.createRange();n range.setStart(start, 0);n range.setEnd(end, 0);n const { commonAncestorContainer } = range;nn // Both nodes are inside documentn if (n (element1 !== commonAncestorContainer &&n element2 !== commonAncestorContainer) ||n start.contains(end)n ) {n if (isOffsetContainer(commonAncestorContainer)) {n return commonAncestorContainer;n }nn return getOffsetParent(commonAncestorContainer);n }nn // one of the nodes is inside shadowDOM, find which onen const element1root = getRoot(element1);n if (element1root.host) {n return findCommonOffsetParent(element1root.host, element2);n } else {n return findCommonOffsetParent(element1, getRoot(element2).host);n }n}n”,“/**n * Gets the scroll value of the given element in the given side (top and left)n * @methodn * @memberof Popper.Utilsn * @argument {Element} elementn * @argument {String} side `top` or `left`n * @returns {number} amount of scrolled pixelsn */nexport default function getScroll(element, side = 'top') {n const upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';n const nodeName = element.nodeName;nn if (nodeName === 'BODY' || nodeName === 'HTML') {n const html = element.ownerDocument.documentElement;n const scrollingElement = element.ownerDocument.scrollingElement || html;n return scrollingElement;n }nn return element;n}n”,“import getScroll from './getScroll';nn/*n * Sum or subtract the element scroll values (left and top) from a given rect objectn * @methodn * @memberof Popper.Utilsn * @param {Object} rect - Rect object you want to changen * @param {HTMLElement} element - The element from the function reads the scroll valuesn * @param {Boolean} subtract - set to true if you want to subtract the scroll valuesn * @return {Object} rect - The modifier rect objectn */nexport default function includeScroll(rect, element, subtract = false) {n const scrollTop = getScroll(element, 'top');n const scrollLeft = getScroll(element, 'left');n const modifier = subtract ? -1 : 1;n rect.top += scrollTop * modifier;n rect.bottom += scrollTop * modifier;n rect.left += scrollLeft * modifier;n rect.right += scrollLeft * modifier;n return rect;n}n”,“/*n * Helper to detect borders of a given elementn * @methodn * @memberof Popper.Utilsn * @param {CSSStyleDeclaration} stylesn * Result of `getStyleComputedProperty` on the given elementn * @param {String} axis - `x` or `y`n * @return {number} borders - The borders size of the given axisn */nnexport default function getBordersSize(styles, axis) {n const sideA = axis === 'x' ? 'Left' : 'Top';n const sideB = sideA === 'Left' ? 'Right' : 'Bottom';nn return (n parseFloat(styles, 10) +n parseFloat(styles, 10)n );n}n”,“import isIE from './isIE';nnfunction getSize(axis, body, html, computedStyle) {n return Math.max(n body,n body,n html,n html,n html,n isIE(10)n ? html +n computedStyle[`margin${axis === 'Height' ? 'Top' : 'Left'}`] +n computedStyle[`margin${axis === 'Height' ? 'Bottom' : 'Right'}`]n : 0n );n}nnexport default function getWindowSizes() {n const body = document.body;n const html = document.documentElement;n const computedStyle = isIE(10) && getComputedStyle(html);nn return {n height: getSize('Height', body, html, computedStyle),n width: getSize('Width', body, html, computedStyle),n };n}n”,“/**n * Given element offsets, generate an output similar to getBoundingClientRectn * @methodn * @memberof Popper.Utilsn * @argument {Object} offsetsn * @returns {Object} ClientRect like outputn */nexport default function getClientRect(offsets) {n return {n …offsets,n right: offsets.left + offsets.width,n bottom: offsets.top + offsets.height,n };n}n”,“import getStyleComputedProperty from './getStyleComputedProperty';nimport getBordersSize from './getBordersSize';nimport getWindowSizes from './getWindowSizes';nimport getScroll from './getScroll';nimport getClientRect from './getClientRect';nimport isIE from './isIE';nn/**n * Get bounding client rect of given elementn * @methodn * @memberof Popper.Utilsn * @param {HTMLElement} elementn * @return {Object} client rectn */nexport default function getBoundingClientRect(element) {n let rect = {};nn // IE10 10 FIX: Please, don't ask, the element isn'tn // considered in DOM in some circumstances…n // This isn't reproducible in IE10 compatibility mode of IE11n try {n if (isIE(10)) {n rect = element.getBoundingClientRect();n const scrollTop = getScroll(element, 'top');n const scrollLeft = getScroll(element, 'left');n rect.top += scrollTop;n rect.left += scrollLeft;n rect.bottom += scrollTop;n rect.right += scrollLeft;n }n else {n rect = element.getBoundingClientRect();n }n }n catch(e){}nn const result = {n left: rect.left,n top: rect.top,n width: rect.right - rect.left,n height: rect.bottom - rect.top,n };nn // subtract scrollbar size from sizesn const sizes = element.nodeName === 'HTML' ? getWindowSizes() : {};n const width =n sizes.width || element.clientWidth || result.right - result.left;n const height =n sizes.height || element.clientHeight || result.bottom - result.top;nn let horizScrollbar = element.offsetWidth - width;n let vertScrollbar = element.offsetHeight - height;nn // if an hypothetical scrollbar is detected, we must be sure it's not a `border`n // we make this check conditional for performance reasonsn if (horizScrollbar || vertScrollbar) {n const styles = getStyleComputedProperty(element);n horizScrollbar -= getBordersSize(styles, 'x');n vertScrollbar -= getBordersSize(styles, 'y');nn result.width -= horizScrollbar;n result.height -= vertScrollbar;n }nn return getClientRect(result);n}n”,“import getStyleComputedProperty from './getStyleComputedProperty';nimport includeScroll from './includeScroll';nimport getScrollParent from './getScrollParent';nimport getBoundingClientRect from './getBoundingClientRect';nimport runIsIE from './isIE';nimport getClientRect from './getClientRect';nnexport default function getOffsetRectRelativeToArbitraryNode(children, parent, fixedPosition = false) {n const isIE10 = runIsIE(10);n const isHTML = parent.nodeName === 'HTML';n const childrenRect = getBoundingClientRect(children);n const parentRect = getBoundingClientRect(parent);n const scrollParent = getScrollParent(children);nn const styles = getStyleComputedProperty(parent);n const borderTopWidth = parseFloat(styles.borderTopWidth, 10);n const borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);nn // In cases where the parent is fixed, we must ignore negative scroll in offset calcn if(fixedPosition && parent.nodeName === 'HTML') {n parentRect.top = Math.max(parentRect.top, 0);n parentRect.left = Math.max(parentRect.left, 0);n }n let offsets = getClientRect({n top: childrenRect.top - parentRect.top - borderTopWidth,n left: childrenRect.left - parentRect.left - borderLeftWidth,n width: childrenRect.width,n height: childrenRect.height,n });n offsets.marginTop = 0;n offsets.marginLeft = 0;nn // Subtract margins of documentElement in case it's being used as parentn // we do this only on HTML because it's the only element that behavesn // differently when margins are applied to it. The margins are included inn // the box of the documentElement, in the other cases not.n if (!isIE10 && isHTML) {n const marginTop = parseFloat(styles.marginTop, 10);n const marginLeft = parseFloat(styles.marginLeft, 10);nn offsets.top -= borderTopWidth - marginTop;n offsets.bottom -= borderTopWidth - marginTop;n offsets.left -= borderLeftWidth - marginLeft;n offsets.right -= borderLeftWidth - marginLeft;nn // Attach marginTop and marginLeft because in some circumstances we may need themn offsets.marginTop = marginTop;n offsets.marginLeft = marginLeft;n }nn if (n isIE10 && !fixedPositionn ? parent.contains(scrollParent)n : parent === scrollParent && scrollParent.nodeName !== 'BODY'n ) {n offsets = includeScroll(offsets, parent);n }nn return offsets;n}n”,“import getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode';nimport getScroll from './getScroll';nimport getClientRect from './getClientRect';nnexport default function getViewportOffsetRectRelativeToArtbitraryNode(element, excludeScroll = false) {n const html = element.ownerDocument.documentElement;n const relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);n const width = Math.max(html.clientWidth, window.innerWidth || 0);n const height = Math.max(html.clientHeight, window.innerHeight || 0);nn const scrollTop = !excludeScroll ? getScroll(html) : 0;n const scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;nn const offset = {n top: scrollTop - relativeOffset.top + relativeOffset.marginTop,n left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,n width,n height,n };nn return getClientRect(offset);n}n”,“import getStyleComputedProperty from './getStyleComputedProperty';nimport getParentNode from './getParentNode';nn/**n * Check if the given element is fixed or is inside a fixed parentn * @methodn * @memberof Popper.Utilsn * @argument {Element} elementn * @argument {Element} customContainern * @returns {Boolean} answer to "isFixed?"n */nexport default function isFixed(element) {n const nodeName = element.nodeName;n if (nodeName === 'BODY' || nodeName === 'HTML') {n return false;n }n if (getStyleComputedProperty(element, 'position') === 'fixed') {n return true;n }n return isFixed(getParentNode(element));n}n”,“import getStyleComputedProperty from './getStyleComputedProperty';nimport isIE from './isIE';n/**n * Finds the first parent of an element that has a transformed property definedn * @methodn * @memberof Popper.Utilsn * @argument {Element} elementn * @returns {Element} first transformed parent or documentElementn */nnexport default function getFixedPositionOffsetParent(element) {n // This check is needed to avoid errors in case one of the elements isn't defined for any reasonn if (!element || !element.parentElement || isIE()) {n return document.documentElement;n }n let el = element.parentElement;n while (el && getStyleComputedProperty(el, 'transform') === 'none') {n el = el.parentElement;n }n return el || document.documentElement;nn}n”,“import getScrollParent from './getScrollParent';nimport getParentNode from './getParentNode';nimport findCommonOffsetParent from './findCommonOffsetParent';nimport getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode';nimport getViewportOffsetRectRelativeToArtbitraryNode from './getViewportOffsetRectRelativeToArtbitraryNode';nimport getWindowSizes from './getWindowSizes';nimport isFixed from './isFixed';nimport getFixedPositionOffsetParent from './getFixedPositionOffsetParent';nn/**n * Computed the boundaries limits and return themn * @methodn * @memberof Popper.Utilsn * @param {HTMLElement} poppern * @param {HTMLElement} referencen * @param {number} paddingn * @param {HTMLElement} boundariesElement - Element used to define the boundariesn * @param {Boolean} fixedPosition - Is in fixed position moden * @returns {Object} Coordinates of the boundariesn */nexport default function getBoundaries(n popper,n reference,n padding,n boundariesElement,n fixedPosition = falsen) {n // NOTE: 1 DOM access herenn let boundaries = { top: 0, left: 0 };n const offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);nn // Handle viewport casen if (boundariesElement === 'viewport' ) {n boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);n }nn else {n // Handle other cases based on DOM element used as boundariesn let boundariesNode;n if (boundariesElement === 'scrollParent') {n boundariesNode = getScrollParent(getParentNode(reference));n if (boundariesNode.nodeName === 'BODY') {n boundariesNode = popper.ownerDocument.documentElement;n }n } else if (boundariesElement === 'window') {n boundariesNode = popper.ownerDocument.documentElement;n } else {n boundariesNode = boundariesElement;n }nn const offsets = getOffsetRectRelativeToArbitraryNode(n boundariesNode,n offsetParent,n fixedPositionn );nn // In case of HTML, we need a different computationn if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {n const { height, width } = getWindowSizes();n boundaries.top += offsets.top - offsets.marginTop;n boundaries.bottom = height + offsets.top;n boundaries.left += offsets.left - offsets.marginLeft;n boundaries.right = width + offsets.left;n } else {n // for all the other DOM elements, this one is goodn boundaries = offsets;n }n }nn // Add paddingsn boundaries.left += padding;n boundaries.top += padding;n boundaries.right -= padding;n boundaries.bottom -= padding;nn return boundaries;n}n”,“import getBoundaries from '../utils/getBoundaries';nnfunction getArea({ width, height }) {n return width * height;n}nn/**n * Utility used to transform the `auto` placement to the placement with moren * available space.n * @methodn * @memberof Popper.Utilsn * @argument {Object} data - The data object generated by update methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The data object, properly modifiedn */nexport default function computeAutoPlacement(n placement,n refRect,n popper,n reference,n boundariesElement,n padding = 0n) {n if (placement.indexOf('auto') === -1) {n return placement;n }nn const boundaries = getBoundaries(n popper,n reference,n padding,n boundariesElementn );nn const rects = {n top: {n width: boundaries.width,n height: refRect.top - boundaries.top,n },n right: {n width: boundaries.right - refRect.right,n height: boundaries.height,n },n bottom: {n width: boundaries.width,n height: boundaries.bottom - refRect.bottom,n },n left: {n width: refRect.left - boundaries.left,n height: boundaries.height,n },n };nn const sortedAreas = Object.keys(rects)n .map(key => ({n key,n …rects,n area: getArea(rects),n }))n .sort((a, b) => b.area - a.area);nn const filteredAreas = sortedAreas.filter(n ({ width, height }) =>n width >= popper.clientWidth && height >= popper.clientHeightn );nn const computedPlacement = filteredAreas.length > 0n ? filteredAreas.keyn : sortedAreas.key;nn const variation = placement.split(‘-’);nn return computedPlacement + (variation ? `-${variation}` : '');n}n”,“import findCommonOffsetParent from './findCommonOffsetParent';nimport getOffsetRectRelativeToArbitraryNode from './getOffsetRectRelativeToArbitraryNode';nimport getFixedPositionOffsetParent from './getFixedPositionOffsetParent';nn/**n * Get offsets to the reference elementn * @methodn * @memberof Popper.Utilsn * @param {Object} staten * @param {Element} popper - the popper elementn * @param {Element} reference - the reference element (the popper will be relative to this)n * @param {Element} fixedPosition - is in fixed position moden * @returns {Object} An object containing the offsets which will be applied to the poppern */nexport default function getReferenceOffsets(state, popper, reference, fixedPosition = null) {n const commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);n return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);n}n”,“/**n * Get the outer sizes of the given element (offset size + margins)n * @methodn * @memberof Popper.Utilsn * @argument {Element} elementn * @returns {Object} object containing width and height propertiesn */nexport default function getOuterSizes(element) {n const styles = getComputedStyle(element);n const x = parseFloat(styles.marginTop) + parseFloat(styles.marginBottom);n const y = parseFloat(styles.marginLeft) + parseFloat(styles.marginRight);n const result = {n width: element.offsetWidth + y,n height: element.offsetHeight + x,n };n return result;n}n”,“/**n * Get the opposite placement of the given onen * @methodn * @memberof Popper.Utilsn * @argument {String} placementn * @returns {String} flipped placementn */nexport default function getOppositePlacement(placement) {n const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };n return placement.replace(/left|right|bottom|top/g, matched => hash);n}n”,“import getOuterSizes from './getOuterSizes';nimport getOppositePlacement from './getOppositePlacement';nn/**n * Get offsets to the poppern * @methodn * @memberof Popper.Utilsn * @param {Object} position - CSS position the Popper will get appliedn * @param {HTMLElement} popper - the popper elementn * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)n * @param {String} placement - one of the valid placement optionsn * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the poppern */nexport default function getPopperOffsets(popper, referenceOffsets, placement) {n placement = placement.split(‘-’);nn // Get popper node sizesn const popperRect = getOuterSizes(popper);nn // Add position, width and height to our offsets objectn const popperOffsets = {n width: popperRect.width,n height: popperRect.height,n };nn // depending by the popper placement we have to compute its offsets slightly differentlyn const isHoriz = ['right', 'left'].indexOf(placement) !== -1;n const mainSide = isHoriz ? 'top' : 'left';n const secondarySide = isHoriz ? 'left' : 'top';n const measurement = isHoriz ? 'height' : 'width';n const secondaryMeasurement = !isHoriz ? 'height' : 'width';nn popperOffsets =n referenceOffsets +n referenceOffsets / 2 -n popperRect / 2;n if (placement === secondarySide) {n popperOffsets =n referenceOffsets - popperRect;n } else {n popperOffsets =n referenceOffsets;n }nn return popperOffsets;n}n”,“/**n * Mimics the `find` method of Arrayn * @methodn * @memberof Popper.Utilsn * @argument {Array} arrn * @argument propn * @argument valuen * @returns index or -1n */nexport default function find(arr, check) {n // use native find if supportedn if (Array.prototype.find) {n return arr.find(check);n }nn // use `filter` to obtain the same behavior of `find`n return arr.filter(check);n}n”,“import find from './find';nn/**n * Return the index of the matching objectn * @methodn * @memberof Popper.Utilsn * @argument {Array} arrn * @argument propn * @argument valuen * @returns index or -1n */nexport default function findIndex(arr, prop, value) {n // use native findIndex if supportedn if (Array.prototype.findIndex) {n return arr.findIndex(cur => cur === value);n }nn // use `find` + `indexOf` if `findIndex` isn't supportedn const match = find(arr, obj => obj === value);n return arr.indexOf(match);n}n”,“import isFunction from './isFunction';nimport findIndex from './findIndex';nimport getClientRect from '../utils/getClientRect';nn/**n * Loop trough the list of modifiers and run them in order,n * each of them will then edit the data object.n * @methodn * @memberof Popper.Utilsn * @param {dataObject} datan * @param {Array} modifiersn * @param {String} ends - Optional modifier name used as stoppern * @returns {dataObject}n */nexport default function runModifiers(modifiers, data, ends) {n const modifiersToRun = ends === undefinedn ? modifiersn : modifiers.slice(0, findIndex(modifiers, 'name', ends));nn modifiersToRun.forEach(modifier => {n if (modifier) { // eslint-disable-line dot-notationn console.warn('`modifier.function` is deprecated, use `modifier.fn`!');n }n const fn = modifier || modifier.fn; // eslint-disable-line dot-notationn if (modifier.enabled && isFunction(fn)) {n // Add properties to offsets to make them a complete clientRect objectn // we do this before each modifier to make sure the previous one doesn'tn // mess with these valuesn data.offsets.popper = getClientRect(data.offsets.popper);n data.offsets.reference = getClientRect(data.offsets.reference);nn data = fn(data, modifier);n }n });nn return data;n}n”,“import computeAutoPlacement from '../utils/computeAutoPlacement';nimport getReferenceOffsets from '../utils/getReferenceOffsets';nimport getPopperOffsets from '../utils/getPopperOffsets';nimport runModifiers from '../utils/runModifiers';nn/**n * Updates the position of the popper, computing the new offsets and applyingn * the new style.<br />n * Prefer `scheduleUpdate` over `update` because of performance reasons.n * @methodn * @memberof Poppern */nexport default function update() {n // if popper is destroyed, don't perform any further updaten if (this.state.isDestroyed) {n return;n }nn let data = {n instance: this,n styles: {},n arrowStyles: {},n attributes: {},n flipped: false,n offsets: {},n };nn // compute reference element offsetsn data.offsets.reference = getReferenceOffsets(n this.state,n this.popper,n this.reference,n this.options.positionFixedn );nn // compute auto placement, store placement inside the data object,n // modifiers will be able to edit `placement` if neededn // and refer to originalPlacement to know the original valuen data.placement = computeAutoPlacement(n this.options.placement,n data.offsets.reference,n this.popper,n this.reference,n this.options.modifiers.flip.boundariesElement,n this.options.modifiers.flip.paddingn );nn // store the computed placement inside `originalPlacement`n data.originalPlacement = data.placement;nn data.positionFixed = this.options.positionFixed;nn // compute the popper offsetsn data.offsets.popper = getPopperOffsets(n this.popper,n data.offsets.reference,n data.placementn );nn data.offsets.popper.position = this.options.positionFixedn ? 'fixed'n : 'absolute';nn // run the modifiersn data = runModifiers(this.modifiers, data);nn // the first `update` will call `onCreate` callbackn // the other ones will call `onUpdate` callbackn if (!this.state.isCreated) {n this.state.isCreated = true;n this.options.onCreate(data);n } else {n this.options.onUpdate(data);n }n}n”,“/**n * Helper used to know if the given modifier is enabled.n * @methodn * @memberof Popper.Utilsn * @returns {Boolean}n */nexport default function isModifierEnabled(modifiers, modifierName) {n return modifiers.some(n ({ name, enabled }) => enabled && name === modifierNamen );n}n”,“/**n * Get the prefixed supported property namen * @methodn * @memberof Popper.Utilsn * @argument {String} property (camelCase)n * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)n */nexport default function getSupportedPropertyName(property) {n const prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];n const upperProp = property.charAt(0).toUpperCase() + property.slice(1);nn for (let i = 0; i < prefixes.length; i++) {n const prefix = prefixes;n const toCheck = prefix ? `${prefix}${upperProp}` : property;n if (typeof document.body.style !== 'undefined') {n return toCheck;n }n }n return null;n}n”,“import isModifierEnabled from '../utils/isModifierEnabled';nimport getSupportedPropertyName from '../utils/getSupportedPropertyName';nn/**n * Destroy the poppern * @methodn * @memberof Poppern */nexport default function destroy() {n this.state.isDestroyed = true;nn // touch DOM only if `applyStyle` modifier is enabledn if (isModifierEnabled(this.modifiers, 'applyStyle')) {n this.popper.removeAttribute('x-placement');n this.popper.style.position = '';n this.popper.style.top = '';n this.popper.style.left = '';n this.popper.style.right = '';n this.popper.style.bottom = '';n this.popper.style.willChange = '';n this.popper.style = '';n }nn this.disableEventListeners();nn // remove the popper if user explicity asked for the deletion on destroyn // do not use `remove` because IE11 doesn't support itn if (this.options.removeOnDestroy) {n this.popper.parentNode.removeChild(this.popper);n }n return this;n}n”,“/**n * Get the window associated with the elementn * @argument {Element} elementn * @returns {Window}n */nexport default function getWindow(element) {n const ownerDocument = element.ownerDocument;n return ownerDocument ? ownerDocument.defaultView : window;n}n”,“import getScrollParent from './getScrollParent';nimport getWindow from './getWindow';nnfunction attachToScrollParents(scrollParent, event, callback, scrollParents) {n const isBody = scrollParent.nodeName === 'BODY';n const target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;n target.addEventListener(event, callback, { passive: true });nn if (!isBody) {n attachToScrollParents(n getScrollParent(target.parentNode),n event,n callback,n scrollParentsn );n }n scrollParents.push(target);n}nn/**n * Setup needed event listeners used to update the popper positionn * @methodn * @memberof Popper.Utilsn * @privaten */nexport default function setupEventListeners(n reference,n options,n state,n updateBoundn) {n // Resize event listener on windown state.updateBound = updateBound;n getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });nn // Scroll event listener on scroll parentsn const scrollElement = getScrollParent(reference);n attachToScrollParents(n scrollElement,n 'scroll',n state.updateBound,n state.scrollParentsn );n state.scrollElement = scrollElement;n state.eventsEnabled = true;nn return state;n}n”,“import setupEventListeners from '../utils/setupEventListeners';nn/**n * It will add resize/scroll events and start recalculatingn * position of the popper element when they are triggered.n * @methodn * @memberof Poppern */nexport default function enableEventListeners() {n if (!this.state.eventsEnabled) {n this.state = setupEventListeners(n this.reference,n this.options,n this.state,n this.scheduleUpdaten );n }n}n”,“import getWindow from './getWindow';nn/**n * Remove event listeners used to update the popper positionn * @methodn * @memberof Popper.Utilsn * @privaten */nexport default function removeEventListeners(reference, state) {n // Remove resize event listener on windown getWindow(reference).removeEventListener('resize', state.updateBound);nn // Remove scroll event listener on scroll parentsn state.scrollParents.forEach(target => {n target.removeEventListener('scroll', state.updateBound);n });nn // Reset staten state.updateBound = null;n state.scrollParents = [];n state.scrollElement = null;n state.eventsEnabled = false;n return state;n}n”,“import removeEventListeners from '../utils/removeEventListeners';nn/**n * It will remove resize/scroll events and won't recalculate popper positionn * when they are triggered. It also won't trigger onUpdate callback anymore,n * unless you call `update` method manually.n * @methodn * @memberof Poppern */nexport default function disableEventListeners() {n if (this.state.eventsEnabled) {n cancelAnimationFrame(this.scheduleUpdate);n this.state = removeEventListeners(this.reference, this.state);n }n}n”,“/**n * Tells if a given input is a numbern * @methodn * @memberof Popper.Utilsn * @param {*} input to checkn * @return {Boolean}n */nexport default function isNumeric(n) {n return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);n}n”,“import isNumeric from './isNumeric';nn/**n * Set the style to the given poppern * @methodn * @memberof Popper.Utilsn * @argument {Element} element - Element to apply the style ton * @argument {Object} stylesn * Object with a list of properties and values which will be applied to the elementn */nexport default function setStyles(element, styles) {n Object.keys(styles).forEach(prop => {n let unit = '';n // add unit if the value is numeric and is one of the followingn if (n ['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !==n -1 &&n isNumeric(styles)n ) {n unit = 'px';n }n element.style = styles + unit;n });n}n”,“/**n * Set the attributes to the given poppern * @methodn * @memberof Popper.Utilsn * @argument {Element} element - Element to apply the attributes ton * @argument {Object} stylesn * Object with a list of properties and values which will be applied to the elementn */nexport default function setAttributes(element, attributes) {n Object.keys(attributes).forEach(function(prop) {n const value = attributes;n if (value !== false) {n element.setAttribute(prop, attributes);n } else {n element.removeAttribute(prop);n }n });n}n”,“import find from './find';nn/**n * Helper used to know if the given modifier depends from another one.<br />n * It checks if the needed modifier is listed and enabled.n * @methodn * @memberof Popper.Utilsn * @param {Array} modifiers - list of modifiersn * @param {String} requestingName - name of requesting modifiern * @param {String} requestedName - name of requested modifiern * @returns {Boolean}n */nexport default function isModifierRequired(n modifiers,n requestingName,n requestedNamen) {n const requesting = find(modifiers, ({ name }) => name === requestingName);nn const isRequired =n !!requesting &&n modifiers.some(modifier => {n return (n modifier.name === requestedName &&n modifier.enabled &&n modifier.order < requesting.ordern );n });nn if (!isRequired) {n const requesting = `\`${requestingName}\“;n const requested = `\`${requestedName}\“;n console.warn(n `${requested} modifier is required by ${requesting} modifier in order to work, be sure to include it before ${requesting}!`n );n }n return isRequired;n}n”,“/**n * Get the opposite placement variation of the given onen * @methodn * @memberof Popper.Utilsn * @argument {String} placement variationn * @returns {String} flipped placement variationn */nexport default function getOppositeVariation(variation) {n if (variation === 'end') {n return 'start';n } else if (variation === 'start') {n return 'end';n }n return variation;n}n”,“import placements from '../methods/placements';nn// Get rid of `auto` `auto-start` and `auto-end`nconst validPlacements = placements.slice(3);nn/**n * Given an initial placement, returns all the subsequent placementsn * clockwise (or counter-clockwise).n *n * @methodn * @memberof Popper.Utilsn * @argument {String} placement - A valid placement (it accepts variations)n * @argument {Boolean} counter - Set to true to walk the placements counterclockwisen * @returns {Array} placements including their variationsn */nexport default function clockwise(placement, counter = false) {n const index = validPlacements.indexOf(placement);n const arr = validPlacementsn .slice(index + 1)n .concat(validPlacements.slice(0, index));n return counter ? arr.reverse() : arr;n}n”,“import isNumeric from '../utils/isNumeric';nimport getClientRect from '../utils/getClientRect';nimport find from '../utils/find';nn/**n * Converts a string containing value + unit into a px value numbern * @functionn * @memberof {modifiers~offset}n * @privaten * @argument {String} str - Value + unit stringn * @argument {String} measurement - `height` or `width`n * @argument {Object} popperOffsetsn * @argument {Object} referenceOffsetsn * @returns {Number|String}n * Value in pixels, or original string if no values were extractedn */nexport function toValue(str, measurement, popperOffsets, referenceOffsets) {n // separate value from unitn const split = str.match(/((?:\-|+)?\d*\.?\d*)(.*)/);n const value = +split;n const unit = split;nn // If it's not a number it's an operator, I guessn if (!value) {n return str;n }nn if (unit.indexOf('%') === 0) {n let element;n switch (unit) {n case '%p':n element = popperOffsets;n break;n case '%':n case '%r':n default:n element = referenceOffsets;n }nn const rect = getClientRect(element);n return rect / 100 * value;n } else if (unit === 'vh' || unit === 'vw') {n // if is a vh or vw, we calculate the size based on the viewportn let size;n if (unit === 'vh') {n size = Math.max(n document.documentElement.clientHeight,n window.innerHeight || 0n );n } else {n size = Math.max(n document.documentElement.clientWidth,n window.innerWidth || 0n );n }n return size / 100 * value;n } else {n // if is an explicit pixel unit, we get rid of the unit and keep the valuen // if is an implicit unit, it's px, and we return just the valuen return value;n }n}nn/**n * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.n * @functionn * @memberof {modifiers~offset}n * @privaten * @argument {String} offsetn * @argument {Object} popperOffsetsn * @argument {Object} referenceOffsetsn * @argument {String} basePlacementn * @returns {Array} a two cells array with x and y offsets in numbersn */nexport function parseOffset(n offset,n popperOffsets,n referenceOffsets,n basePlacementn) {n const offsets = [0, 0];nn // Use height if placement is left or right and index is 0 otherwise use widthn // in this way the first offset will use an axis and the second onen // will use the other onen const useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;nn // Split the offset string to obtain a list of values and operandsn // The regex addresses values with the plus or minus sign in front (+10, -20, etc)n const fragments = offset.split(/(+|\-)/).map(frag => frag.trim());nn // Detect if the offset string contains a pair of values or a single onen // they could be separated by comma or spacen const divider = fragments.indexOf(n find(fragments, frag => frag.search(/,|\s/) !== -1)n );nn if (fragments && fragments.indexOf(',') === -1) {n console.warn(n 'Offsets separated by white space(s) are deprecated, use a comma (,) instead.'n );n }nn // If divider is found, we divide the list of values and operands to dividen // them by ofset X and Y.n const splitRegex = /\s*,\s*|\s+/;n let ops = divider !== -1n ? [n fragmentsn .slice(0, divider)n .concat([fragments.split(splitRegex)]),n [fragments.split(splitRegex)].concat(n fragments.slice(divider + 1)n ),n ]n : [fragments];nn // Convert the values with units to absolute pixels to allow our computationsn ops = ops.map((op, index) => {n // Most of the units rely on the orientation of the poppern const measurement = (index === 1 ? !useHeight : useHeight)n ? 'height'n : 'width';n let mergeWithPrevious = false;n return (n opn // This aggregates any `+` or `-` sign that aren't considered operatorsn // e.g.: 10 + +5 => [10, +, +5]n .reduce((a, b) => {n if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {n a[a.length - 1] = b;n mergeWithPrevious = true;n return a;n } else if (mergeWithPrevious) {n a[a.length - 1] += b;n mergeWithPrevious = false;n return a;n } else {n return a.concat(b);n }n }, [])n // Here we convert the string values into number values (in px)n .map(str => toValue(str, measurement, popperOffsets, referenceOffsets))n );n });nn // Loop trough the offsets arrays and execute the operationsn ops.forEach((op, index) => {n op.forEach((frag, index2) => {n if (isNumeric(frag)) {n offsets += frag * (op[index2 - 1] === '-' ? -1 : 1);n }n });n });n return offsets;n}nn/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by update methodn * @argument {Object} options - Modifiers configuration and optionsn * @argument {Number|String} options.offset=0n * The offset value as described in the modifier descriptionn * @returns {Object} The data object, properly modifiedn */nexport default function offset(data, { offset }) {n const { placement, offsets: { popper, reference } } = data;n const basePlacement = placement.split(‘-’);nn let offsets;n if (isNumeric(+offset)) {n offsets = [+offset, 0];n } else {n offsets = parseOffset(offset, popper, reference, basePlacement);n }nn if (basePlacement === 'left') {n popper.top += offsets;n popper.left -= offsets;n } else if (basePlacement === 'right') {n popper.top += offsets;n popper.left += offsets;n } else if (basePlacement === 'top') {n popper.left += offsets;n popper.top -= offsets;n } else if (basePlacement === 'bottom') {n popper.left += offsets;n popper.top += offsets;n }nn data.popper = popper;n return data;n}n”,“import isBrowser from './isBrowser';nnconst longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];nlet timeoutDuration = 0;nfor (let i = 0; i < longerTimeoutBrowsers.length; i += 1) {n if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers) >= 0) {n timeoutDuration = 1;n break;n }n}nnexport function microtaskDebounce(fn) {n let called = falsen return () => {n if (called) {n returnn }n called = truen window.Promise.resolve().then(() => {n called = falsen fn()n })n }n}nnexport function taskDebounce(fn) {n let scheduled = false;n return () => {n if (!scheduled) {n scheduled = true;n setTimeout(() => {n scheduled = false;n fn();n }, timeoutDuration);n }n };n}nnconst supportsMicroTasks = isBrowser && window.Promisennn/*n Create a debounced version of a method, that's asynchronously deferredn* but called in the minimum time possible.n*n* @methodn* @memberof Popper.Utilsn* @argument {Function} fnn* @returns {Function}n*/nexport default (supportsMicroTasksn ? microtaskDebouncen : taskDebounce);n”,“import getClientRect from '../utils/getClientRect';nimport getOuterSizes from '../utils/getOuterSizes';nimport isModifierRequired from '../utils/isModifierRequired';nimport getStyleComputedProperty from '../utils/getStyleComputedProperty';nn/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by update methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The data object, properly modifiedn */nexport default function arrow(data, options) {n // arrow depends on keepTogether in order to workn if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {n return data;n }nn let arrowElement = options.element;nn // if arrowElement is a string, suppose it's a CSS selectorn if (typeof arrowElement === 'string') {n arrowElement = data.instance.popper.querySelector(arrowElement);nn // if arrowElement is not found, don't run the modifiern if (!arrowElement) {n return data;n }n } else {n // if the arrowElement isn't a query selector we must check that then // provided DOM node is child of its popper noden if (!data.instance.popper.contains(arrowElement)) {n console.warn(n 'WARNING: `arrow.element` must be child of its popper element!'n );n return data;n }n }nn const placement = data.placement.split(‘-’);n const { popper, reference } = data.offsets;n const isVertical = ['left', 'right'].indexOf(placement) !== -1;nn const len = isVertical ? 'height' : 'width';n const sideCapitalized = isVertical ? 'Top' : 'Left';n const side = sideCapitalized.toLowerCase();n const altSide = isVertical ? 'left' : 'top';n const opSide = isVertical ? 'bottom' : 'right';n const arrowElementSize = getOuterSizes(arrowElement);nn //n // extends keepTogether behavior making sure the popper and itsn // reference have enough pixels in conjuctionn //nn // top/left siden if (reference - arrowElementSize < popper) {n data.offsets.popper -=n popper - (reference - arrowElementSize);n }n // bottom/right siden if (reference + arrowElementSize > popper) {n data.offsets.popper +=n reference + arrowElementSize - popper;n }n data.offsets.popper = getClientRect(data.offsets.popper);nn // compute center of the poppern const center = reference + reference / 2 - arrowElementSize / 2;nn // Compute the sideValue using the updated popper offsetsn // take popper margin in account because we don't have this info availablen const css = getStyleComputedProperty(data.instance.popper);n const popperMarginSide = parseFloat(css, 10);n const popperBorderSide = parseFloat(css, 10);n let sideValue =n center - data.offsets.popper - popperMarginSide - popperBorderSide;nn // prevent arrowElement from being placed not contiguously to its poppern sideValue = Math.max(Math.min(popper - arrowElementSize, sideValue), 0);nn data.arrowElement = arrowElement;n data.offsets.arrow = {n [side]: Math.round(sideValue),n [altSide]: '', // make sure to unset any eventual altSide value from the DOM noden };nn return data;n}n”,“import getSupportedPropertyName from '../utils/getSupportedPropertyName';nimport find from '../utils/find';nimport getOffsetParent from '../utils/getOffsetParent';nimport getBoundingClientRect from '../utils/getBoundingClientRect';nn/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by `update` methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The data object, properly modifiedn */nexport default function computeStyle(data, options) {n const { x, y } = options;n const { popper } = data.offsets;nn // Remove this legacy support in Popper.js v2n const legacyGpuAccelerationOption = find(n data.instance.modifiers,n modifier => modifier.name === 'applyStyle'n ).gpuAcceleration;n if (legacyGpuAccelerationOption !== undefined) {n console.warn(n 'WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!'n );n }n const gpuAcceleration =n legacyGpuAccelerationOption !== undefinedn ? legacyGpuAccelerationOptionn : options.gpuAcceleration;nn const offsetParent = getOffsetParent(data.instance.popper);n const offsetParentRect = getBoundingClientRect(offsetParent);nn // Stylesn const styles = {n position: popper.position,n };nn // Avoid blurry text by using full pixel integers.n // For pixel-perfect positioning, top/bottom prefers roundedn // values, while left/right prefers floored values.n const offsets = {n left: Math.floor(popper.left),n top: Math.round(popper.top),n bottom: Math.round(popper.bottom),n right: Math.floor(popper.right),n };nn const sideA = x === 'bottom' ? 'top' : 'bottom';n const sideB = y === 'right' ? 'left' : 'right';nn // if gpuAcceleration is set to `true` and transform is supported,n // we use `translate3d` to apply the position to the popper wen // automatically use the supported prefixed version if neededn const prefixedProperty = getSupportedPropertyName('transform');nn // now, let's make a step back and look at this code closely (wtf?)n // If the content of the popper grows once it's been positioned, itn // may happen that the popper gets misplaced because of the new contentn // overflowing its reference elementn // To avoid this problem, we provide two options (x and y), which allown // the consumer to define the offset origin.n // If we position a popper on top of a reference element, we can setn // `x` to `top` to make the popper grow towards its top instead ofn // its bottom.n let left, top;n if (sideA === 'bottom') {n top = -offsetParentRect.height + offsets.bottom;n } else {n top = offsets.top;n }n if (sideB === 'right') {n left = -offsetParentRect.width + offsets.right;n } else {n left = offsets.left;n }n if (gpuAcceleration && prefixedProperty) {n styles = `translate3d(${left}px, ${top}px, 0)`;n styles = 0;n styles = 0;n styles.willChange = 'transform';n } else {n // othwerise, we use the standard `top`, `left`, `bottom` and `right` propertiesn const invertTop = sideA === 'bottom' ? -1 : 1;n const invertLeft = sideB === 'right' ? -1 : 1;n styles = top * invertTop;n styles = left * invertLeft;n styles.willChange = `${sideA}, ${sideB}`;n }nn // Attributesn const attributes = {n 'x-placement': data.placement,n };nn // Update `data` attributes, styles and arrowStylesn data.attributes = { …attributes, …data.attributes };n data.styles = { …styles, …data.styles };n data.arrowStyles = { …data.offsets.arrow, …data.arrowStyles };nn return data;n}n”,“export default typeof window !== 'undefined' && typeof document !== 'undefined';n”,“import getOppositePlacement from '../utils/getOppositePlacement';nimport getOppositeVariation from '../utils/getOppositeVariation';nimport getPopperOffsets from '../utils/getPopperOffsets';nimport runModifiers from '../utils/runModifiers';nimport getBoundaries from '../utils/getBoundaries';nimport isModifierEnabled from '../utils/isModifierEnabled';nimport clockwise from '../utils/clockwise';nnconst BEHAVIORS = {n FLIP: 'flip',n CLOCKWISE: 'clockwise',n COUNTERCLOCKWISE: 'counterclockwise',n};nn/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by update methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The data object, properly modifiedn */nexport default function flip(data, options) {n // if `inner` modifier is enabled, we can't use the `flip` modifiern if (isModifierEnabled(data.instance.modifiers, 'inner')) {n return data;n }nn if (data.flipped && data.placement === data.originalPlacement) {n // seems like flip is trying to loop, probably there's not enough space on any of the flippable sidesn return data;n }nn const boundaries = getBoundaries(n data.instance.popper,n data.instance.reference,n options.padding,n options.boundariesElement,n data.positionFixedn );nn let placement = data.placement.split(‘-’);n let placementOpposite = getOppositePlacement(placement);n let variation = data.placement.split(‘-’) || '';nn let flipOrder = [];nn switch (options.behavior) {n case BEHAVIORS.FLIP:n flipOrder = [placement, placementOpposite];n break;n case BEHAVIORS.CLOCKWISE:n flipOrder = clockwise(placement);n break;n case BEHAVIORS.COUNTERCLOCKWISE:n flipOrder = clockwise(placement, true);n break;n default:n flipOrder = options.behavior;n }nn flipOrder.forEach((step, index) => {n if (placement !== step || flipOrder.length === index + 1) {n return data;n }nn placement = data.placement.split(‘-’);n placementOpposite = getOppositePlacement(placement);nn const popperOffsets = data.offsets.popper;n const refOffsets = data.offsets.reference;nn // using floor because the reference offsets may contain decimals we are not going to consider heren const floor = Math.floor;n const overlapsRef =n (placement === 'left' &&n floor(popperOffsets.right) > floor(refOffsets.left)) ||n (placement === 'right' &&n floor(popperOffsets.left) < floor(refOffsets.right)) ||n (placement === 'top' &&n floor(popperOffsets.bottom) > floor(refOffsets.top)) ||n (placement === 'bottom' &&n floor(popperOffsets.top) < floor(refOffsets.bottom));nn const overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);n const overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);n const overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);n const overflowsBottom =n floor(popperOffsets.bottom) > floor(boundaries.bottom);nn const overflowsBoundaries =n (placement === 'left' && overflowsLeft) ||n (placement === 'right' && overflowsRight) ||n (placement === 'top' && overflowsTop) ||n (placement === 'bottom' && overflowsBottom);nn // flip the variation if requiredn const isVertical = ['top', 'bottom'].indexOf(placement) !== -1;n const flippedVariation =n !!options.flipVariations &&n ((isVertical && variation === 'start' && overflowsLeft) ||n (isVertical && variation === 'end' && overflowsRight) ||n (!isVertical && variation === 'start' && overflowsTop) ||n (!isVertical && variation === 'end' && overflowsBottom));nn if (overlapsRef || overflowsBoundaries || flippedVariation) {n // this boolean to detect any flip loopn data.flipped = true;nn if (overlapsRef || overflowsBoundaries) {n placement = flipOrder[index + 1];n }nn if (flippedVariation) {n variation = getOppositeVariation(variation);n }nn data.placement = placement + (variation ? '-' + variation : '');nn // this object contains `position`, we want to preserve it along withn // any additional property we may add in the futuren data.offsets.popper = {n …data.offsets.popper,n …getPopperOffsets(n data.instance.popper,n data.offsets.reference,n data.placementn ),n };nn data = runModifiers(data.instance.modifiers, data, 'flip');n }n });n return data;n}n”,“// Utilsnimport debounce from './utils/debounce';nimport isFunction from './utils/isFunction';nn// Methodsnimport update from './methods/update';nimport destroy from './methods/destroy';nimport enableEventListeners from './methods/enableEventListeners';nimport disableEventListeners from './methods/disableEventListeners';nimport Defaults from './methods/defaults';nimport placements from './methods/placements';nnexport default class Popper {n /**n * Create a new Popper.js instancen * @class Poppern * @param {HTMLElement|referenceObject} reference - The reference element used to position the poppern * @param {HTMLElement} popper - The HTML element used as popper.n * @param {Object} options - Your custom options to override the ones defined in [Defaults](defaults)n * @return {Object} instance - The generated Popper.js instancen */n constructor(reference, popper, options = {}) {n // make update() debounced, so that it only runs at most once-per-tickn this.update = debounce(this.update.bind(this));nn // with {} we create a new object with the options inside itn this.options = { …Popper.Defaults, …options };nn // init staten this.state = {n isDestroyed: false,n isCreated: false,n scrollParents: [],n };nn // get reference and popper elements (allow jQuery wrappers)n this.reference = reference && reference.jquery ? reference : reference;n this.popper = popper && popper.jquery ? popper : popper;nn // Deep merge modifiers optionsn this.options.modifiers = {};n Object.keys({n …Popper.Defaults.modifiers,n …options.modifiers,n }).forEach(name => {n this.options.modifiers = {n // If it's a built-in modifier, use it as basen …(Popper.Defaults.modifiers || {}),n // If there are custom options, override and merge with default onesn …(options.modifiers ? options.modifiers : {}),n };n });nn // Refactoring modifiers' list (Object => Array)n this.modifiers = Object.keys(this.options.modifiers)n .map(name => ({n name,n …this.options.modifiers,n }))n // sort the modifiers by ordern .sort((a, b) => a.order - b.order);nn // modifiers have the ability to execute arbitrary code when Popper.js get initedn // such code is executed in the same order of its modifiern // they could add new properties to their options configurationn // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!n this.modifiers.forEach(modifierOptions => {n if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {n modifierOptions.onLoad(n this.reference,n this.popper,n this.options,n modifierOptions,n this.staten );n }n });nn // fire the first update to position the popper in the right placen this.update();nn const eventsEnabled = this.options.eventsEnabled;n if (eventsEnabled) {n // setup event listeners, they will take care of update the position in specific situationsn this.enableEventListeners();n }nn this.state.eventsEnabled = eventsEnabled;n }nn // We can't use class properties because they don't get listed in then // class prototype and break stuff like Sinon stubsn update() {n return update.call(this);n }n destroy() {n return destroy.call(this);n }n enableEventListeners() {n return enableEventListeners.call(this);n }n disableEventListeners() {n return disableEventListeners.call(this);n }nn /**n * Schedule an update, it will run on the next UI update availablen * @method scheduleUpdaten * @memberof Poppern */n scheduleUpdate = () => requestAnimationFrame(this.update);nn /**n * Collection of utilities useful when writing custom modifiers.n * Starting from version 1.7, this method is available only if youn * include `popper-utils.js` before `popper.js`.n *n * DEPRECATION: This way to access PopperUtils is deprecatedn * and will be removed in v2! Use the PopperUtils module directly instead.n * Due to the high instability of the methods contained in Utils, we can'tn * guarantee them to follow semver. Use them at your own risk!n * @staticn * @privaten * @type {Object}n * @deprecated since version 1.8n * @member Utilsn * @memberof Poppern */n static Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;nn static placements = placements;nn static Defaults = Defaults;n}nn/**n * The `referenceObject` is an object that provides an interface compatible with Popper.jsn * and lets you use it as replacement of a real DOM node.<br />n * You can use this method to position a popper relatively to a set of coordinatesn * in case you don't have a DOM node to use as reference.n *n * “`n * new Popper(referenceObject, popperNode);n * “`n *n * NB: This feature isn't supported in Internet Explorer 10n * @name referenceObjectn * @property {Function} data.getBoundingClientRectn * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.n * @property {number} data.clientWidthn * An ES6 getter that will return the width of the virtual reference element.n * @property {number} data.clientHeightn * An ES6 getter that will return the height of the virtual reference element.n */n”,“import modifiers from '../modifiers/index';nn/**n * Default options provided to Popper.js constructor.<br />n * These can be overriden using the `options` argument of Popper.js.<br />n * To override an option, simply pass as 3rd argument an object with the samen * structure of this object, example:n * “`n * new Popper(ref, pop, {n * modifiers: {n * preventOverflow: { enabled: false }n * }n * })n * “`n * @type {Object}n * @staticn * @memberof Poppern */nexport default {n /**n * Popper's placementn * @prop {Popper.placements} placement='bottom'n */n placement: 'bottom',nn /**n * Set this to true if you want popper to position it self in 'fixed' moden * @prop {Boolean} positionFixed=falsen */n positionFixed: false,nn /**n * Whether events (resize, scroll) are initially enabledn * @prop {Boolean} eventsEnabled=truen */n eventsEnabled: true,nn /**n * Set to true if you want to automatically remove the popper whenn * you call the `destroy` method.n * @prop {Boolean} removeOnDestroy=falsen */n removeOnDestroy: false,nn /**n * Callback called when the popper is created.<br />n * By default, is set to no-op.<br />n * Access Popper.js instance with `data.instance`.n * @prop {onCreate}n */n onCreate: () => {},nn /**n * Callback called when the popper is updated, this callback is not calledn * on the initialization/creation of the popper, but only on subsequentn * updates.<br />n * By default, is set to no-op.<br />n * Access Popper.js instance with `data.instance`.n * @prop {onUpdate}n */n onUpdate: () => {},nn /**n * List of modifiers used to modify the offsets before they are applied to the popper.n * They provide most of the functionalities of Popper.jsn * @prop {modifiers}n */n modifiers,n};nn/**n * @callback onCreaten * @param {dataObject} datan */nn/**n * @callback onUpdaten * @param {dataObject} datan */n”,“import applyStyle, { applyStyleOnLoad } from './applyStyle';nimport computeStyle from './computeStyle';nimport arrow from './arrow';nimport flip from './flip';nimport keepTogether from './keepTogether';nimport offset from './offset';nimport preventOverflow from './preventOverflow';nimport shift from './shift';nimport hide from './hide';nimport inner from './inner';nn/**n * Modifier function, each modifier can have a function of this type assignedn * to its `fn` property.<br />n * These functions will be called on each update, this means that you mustn * make sure they are performant enough to avoid performance bottlenecks.n *n * @function ModifierFnn * @argument {dataObject} data - The data object generated by `update` methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {dataObject} The data object, properly modifiedn */nn/**n * Modifiers are plugins used to alter the behavior of your poppers.<br />n * Popper.js uses a set of 9 modifiers to provide all the basic functionalitiesn * needed by the library.n *n * Usually you don't want to override the `order`, `fn` and `onLoad` props.n * All the other properties are configurations that could be tweaked.n * @namespace modifiersn */nexport default {n /**n * Modifier used to shift the popper on the start or end of its referencen * element.<br />n * It will read the variation of the `placement` property.<br />n * It can be one either `-end` or `-start`.n * @memberof modifiersn * @innern */n shift: {n /** @prop {number} order=100 - Index used to define the order of execution */n order: 100,n /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */n enabled: true,n /** @prop {ModifierFn} */n fn: shift,n },nn /**n * The `offset` modifier can shift your popper on both its axis.n *n * It accepts the following units:n * - `px` or unitless, interpreted as pixelsn * - `%` or `%r`, percentage relative to the length of the reference elementn * - `%p`, percentage relative to the length of the popper elementn * - `vw`, CSS viewport width unitn * - `vh`, CSS viewport height unitn *n * For length is intended the main axis relative to the placement of the popper.<br />n * This means that if the placement is `top` or `bottom`, the length will be then * `width`. In case of `left` or `right`, it will be the height.n *n * You can provide a single value (as `Number` or `String`), or a pair of valuesn * as `String` divided by a comma or one (or more) white spaces.<br />n * The latter is a deprecated method because it leads to confusion and will ben * removed in v2.<br />n * Additionally, it accepts additions and subtractions between different units.n * Note that multiplications and divisions aren't supported.n *n * Valid examples are:n * “`n * 10n * '10%'n * '10, 10'n * '10%, 10'n * '10 + 10%'n * '10 - 5vh + 3%'n * '-10px + 5vh, 5px - 6%'n * “`n * > NB: If you desire to apply offsets to your poppers in a way that may make them overlapn * > with their reference element, unfortunately, you will have to disable the `flip` modifier.n * > More on this [reading this issue](github.com/FezVrasta/popper.js/issues/373)n *n * @memberof modifiersn * @innern */n offset: {n /** @prop {number} order=200 - Index used to define the order of execution */n order: 200,n /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */n enabled: true,n /** @prop {ModifierFn} */n fn: offset,n /** @prop {Number|String} offset=0n * The offset value as described in the modifier descriptionn */n offset: 0,n },nn /**n * Modifier used to prevent the popper from being positioned outside the boundary.n *n * An scenario exists where the reference itself is not within the boundaries.<br />n * We can say it has "escaped the boundaries" — or just "escaped".<br />n * In this case we need to decide whether the popper should either:n *n * - detach from the reference and remain "trapped" in the boundaries, orn * - if it should ignore the boundary and "escape with its reference"n *n * When `escapeWithReference` is set to`true` and reference is completelyn * outside its boundaries, the popper will overflow (or completely leave)n * the boundaries in order to remain attached to the edge of the reference.n *n * @memberof modifiersn * @innern */n preventOverflow: {n /** @prop {number} order=300 - Index used to define the order of execution */n order: 300,n /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */n enabled: true,n /** @prop {ModifierFn} */n fn: preventOverflow,n /**n * @prop {Array} [priority=]n * Popper will try to prevent overflow following these priorities by default,n * then, it could overflow on the left and on top of the `boundariesElement`n */n priority: ['left', 'right', 'top', 'bottom'],n /**n * @prop {number} padding=5n * Amount of pixel used to define a minimum distance between the boundariesn * and the popper this makes sure the popper has always a little paddingn * between the edges of its containern */n padding: 5,n /**n * @prop {String|HTMLElement} boundariesElement='scrollParent'n * Boundaries used by the modifier, can be `scrollParent`, `window`,n * `viewport` or any DOM element.n */n boundariesElement: 'scrollParent',n },nn /**n * Modifier used to make sure the reference and its popper stay near eachothersn * without leaving any gap between the two. Expecially useful when the arrow isn * enabled and you want to assure it to point to its reference element.n * It cares only about the first axis, you can still have poppers with marginn * between the popper and its reference element.n * @memberof modifiersn * @innern */n keepTogether: {n /** @prop {number} order=400 - Index used to define the order of execution */n order: 400,n /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */n enabled: true,n /** @prop {ModifierFn} */n fn: keepTogether,n },nn /**n * This modifier is used to move the `arrowElement` of the popper to maken * sure it is positioned between the reference element and its popper element.n * It will read the outer size of the `arrowElement` node to detect how manyn * pixels of conjuction are needed.n *n * It has no effect if no `arrowElement` is provided.n * @memberof modifiersn * @innern */n arrow: {n /** @prop {number} order=500 - Index used to define the order of execution */n order: 500,n /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */n enabled: true,n /** @prop {ModifierFn} */n fn: arrow,n /** @prop {String|HTMLElement} element=‘' - Selector or node used as arrow */n element: '[x-arrow]',n },nn /**n * Modifier used to flip the popper's placement when it starts to overlap itsn * reference element.n *n * Requires the `preventOverflow` modifier before it in order to work.n *n * NOTE: this modifier will interrupt the current update cycle and willn * restart it if it detects the need to flip the placement.n * @memberof modifiersn * @innern */n flip: {n /** @prop {number} order=600 - Index used to define the order of execution */n order: 600,n /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */n enabled: true,n /** @prop {ModifierFn} */n fn: flip,n /**n * @prop {String|Array} behavior='flip'n * The behavior used to change the popper's placement. It can be one ofn * `flip`, `clockwise`, `counterclockwise` or an array with a list of validn * placements (with optional variations).n */n behavior: 'flip',n /**n * @prop {number} padding=5n * The popper will flip if it hits the edges of the `boundariesElement`n */n padding: 5,n /**n * @prop {String|HTMLElement} boundariesElement='viewport'n * The element which will define the boundaries of the popper position,n * the popper will never be placed outside of the defined boundariesn * (except if keepTogether is enabled)n */n boundariesElement: 'viewport',n },nn /**n * Modifier used to make the popper flow toward the inner of the reference element.n * By default, when this modifier is disabled, the popper will be placed outsiden * the reference element.n * @memberof modifiersn * @innern */n inner: {n /** @prop {number} order=700 - Index used to define the order of execution */n order: 700,n /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */n enabled: false,n /** @prop {ModifierFn} */n fn: inner,n },nn /**n * Modifier used to hide the popper when its reference element is outside of then * popper boundaries. It will set a `x-out-of-boundaries` attribute which cann * be used to hide with a CSS selector the popper when its reference isn * out of boundaries.n *n * Requires the `preventOverflow` modifier before it in order to work.n * @memberof modifiersn * @innern */n hide: {n /** @prop {number} order=800 - Index used to define the order of execution */n order: 800,n /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */n enabled: true,n /** @prop {ModifierFn} */n fn: hide,n },nn /**n * Computes the style that will be applied to the popper element to getsn * properly positioned.n *n * Note that this modifier will not touch the DOM, it just prepares the stylesn * so that `applyStyle` modifier can apply it. This separation is usefuln * in case you need to replace `applyStyle` with a custom implementation.n *n * This modifier has `850` as `order` value to maintain backward compatibilityn * with previous versions of Popper.js. Expect the modifiers ordering methodn * to change in future major versions of the library.n *n * @memberof modifiersn * @innern */n computeStyle: {n /** @prop {number} order=850 - Index used to define the order of execution */n order: 850,n /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */n enabled: true,n /** @prop {ModifierFn} */n fn: computeStyle,n /**n * @prop {Boolean} gpuAcceleration=truen * If true, it uses the CSS 3d transformation to position the popper.n * Otherwise, it will use the `top` and `left` properties.n */n gpuAcceleration: true,n /**n * @prop {string} [x='bottom']n * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.n * Change this if your popper should grow in a direction different from `bottom`n */n x: 'bottom',n /**n * @prop {string} [x='left']n * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.n * Change this if your popper should grow in a direction different from `right`n */n y: 'right',n },nn /**n * Applies the computed styles to the popper element.n *n * All the DOM manipulations are limited to this modifier. This is useful in casen * you want to integrate Popper.js inside a framework or view library and youn * want to delegate all the DOM manipulations to it.n *n * Note that if you disable this modifier, you must make sure the popper elementn * has its position set to `absolute` before Popper.js can do its work!n *n * Just disable this modifier and define you own to achieve the desired effect.n *n * @memberof modifiersn * @innern */n applyStyle: {n /** @prop {number} order=900 - Index used to define the order of execution */n order: 900,n /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */n enabled: true,n /** @prop {ModifierFn} */n fn: applyStyle,n /** @prop {Function} */n onLoad: applyStyleOnLoad,n /**n * @deprecated since version 1.10.0, the property moved to `computeStyle` modifiern * @prop {Boolean} gpuAcceleration=truen * If true, it uses the CSS 3d transformation to position the popper.n * Otherwise, it will use the `top` and `left` properties.n */n gpuAcceleration: undefined,n },n};nn/**n * The `dataObject` is an object containing all the informations used by Popper.jsn * this object get passed to modifiers and to the `onCreate` and `onUpdate` callbacks.n * @name dataObjectn * @property {Object} data.instance The Popper.js instancen * @property {String} data.placement Placement applied to poppern * @property {String} data.originalPlacement Placement originally defined on initn * @property {Boolean} data.flipped True if popper has been flipped by flip modifiern * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper.n * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifiern * @property {Object} data.styles Any CSS property defined here will be applied to the popper, it expects the JavaScript nomenclature (eg. `marginBottom`)n * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow, it expects the JavaScript nomenclature (eg. `marginBottom`)n * @property {Object} data.boundaries Offsets of the popper boundariesn * @property {Object} data.offsets The measurements of popper, reference and arrow elements.n * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` valuesn * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` valuesn * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0n */n”,“/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by `update` methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The data object, properly modifiedn */nexport default function shift(data) {n const placement = data.placement;n const basePlacement = placement.split(’-‘);n const shiftvariation = placement.split(’-‘);nn // if shift shiftvariation is specified, run the modifiern if (shiftvariation) {n const { reference, popper } = data.offsets;n const isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;n const side = isVertical ? 'left' : 'top';n const measurement = isVertical ? 'width' : 'height';nn const shiftOffsets = {n start: { [side]: reference },n end: {n [side]: reference + reference - popper,n },n };nn data.offsets.popper = { …popper, …shiftOffsets };n }nn return data;n}n”,“import getOffsetParent from '../utils/getOffsetParent';nimport getBoundaries from '../utils/getBoundaries';nimport getSupportedPropertyName from '../utils/getSupportedPropertyName';nn/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by `update` methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The data object, properly modifiedn */nexport default function preventOverflow(data, options) {n let boundariesElement =n options.boundariesElement || getOffsetParent(data.instance.popper);nn // If offsetParent is the reference element, we really want ton // go one step up and use the next offsetParent as reference ton // avoid to make this modifier completely useless and look like brokenn if (data.instance.reference === boundariesElement) {n boundariesElement = getOffsetParent(boundariesElement);n }nn // NOTE: DOM access heren // resets the popper's position so that the document size can be calculated excludingn // the size of the popper element itselfn const transformProp = getSupportedPropertyName('transform');n const popperStyles = data.instance.popper.style; // assignment to help minificationn const { top, left, [transformProp]: transform } = popperStyles;n popperStyles.top = '';n popperStyles.left = '';n popperStyles = '';nn const boundaries = getBoundaries(n data.instance.popper,n data.instance.reference,n options.padding,n boundariesElement,n data.positionFixedn );nn // NOTE: DOM access heren // restores the original style properties after the offsets have been computedn popperStyles.top = top;n popperStyles.left = left;n popperStyles = transform;nn options.boundaries = boundaries;nn const order = options.priority;n let popper = data.offsets.popper;nn const check = {n primary(placement) {n let value = popper;n if (n popper < boundaries &&n !options.escapeWithReferencen ) {n value = Math.max(popper, boundaries);n }n return { [placement]: value };n },n secondary(placement) {n const mainSide = placement === 'right' ? 'left' : 'top';n let value = popper;n if (n popper > boundaries &&n !options.escapeWithReferencen ) {n value = Math.min(n popper,n boundaries -n (placement === 'right' ? popper.width : popper.height)n );n }n return { [mainSide]: value };n },n };nn order.forEach(placement => {n const side =n ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';n popper = { …popper, …check(placement) };n });nn data.offsets.popper = popper;nn return data;n}n”,“/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by update methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The data object, properly modifiedn */nexport default function keepTogether(data) {n const { popper, reference } = data.offsets;n const placement = data.placement.split(’-‘);n const floor = Math.floor;n const isVertical = ['top', 'bottom'].indexOf(placement) !== -1;n const side = isVertical ? 'right' : 'bottom';n const opSide = isVertical ? 'left' : 'top';n const measurement = isVertical ? 'width' : 'height';nn if (popper < floor(reference)) {n data.offsets.popper =n floor(reference) - popper;n }n if (popper > floor(reference)) {n data.offsets.popper = floor(reference);n }nn return data;n}n”,“import getClientRect from '../utils/getClientRect';nimport getOppositePlacement from '../utils/getOppositePlacement';nn/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by `update` methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The data object, properly modifiedn */nexport default function inner(data) {n const placement = data.placement;n const basePlacement = placement.split(’-‘);n const { popper, reference } = data.offsets;n const isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;nn const subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;nn popper[isHoriz ? 'left' : 'top'] =n reference -n (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);nn data.placement = getOppositePlacement(placement);n data.offsets.popper = getClientRect(popper);nn return data;n}n”,“import isModifierRequired from '../utils/isModifierRequired';nimport find from '../utils/find';nn/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by update methodn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The data object, properly modifiedn */nexport default function hide(data) {n if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {n return data;n }nn const refRect = data.offsets.reference;n const bound = find(n data.instance.modifiers,n modifier => modifier.name === 'preventOverflow'n ).boundaries;nn if (n refRect.bottom < bound.top ||n refRect.left > bound.right ||n refRect.top > bound.bottom ||n refRect.right < bound.leftn ) {n // Avoid unnecessary DOM access if visibility hasn't changedn if (data.hide === true) {n return data;n }nn data.hide = true;n data.attributes = '';n } else {n // Avoid unnecessary DOM access if visibility hasn't changedn if (data.hide === false) {n return data;n }nn data.hide = false;n data.attributes = false;n }nn return data;n}n”,“import setStyles from '../utils/setStyles';nimport setAttributes from '../utils/setAttributes';nimport getReferenceOffsets from '../utils/getReferenceOffsets';nimport computeAutoPlacement from '../utils/computeAutoPlacement';nn/**n * @functionn * @memberof Modifiersn * @argument {Object} data - The data object generated by `update` methodn * @argument {Object} data.styles - List of style properties - values to apply to popper elementn * @argument {Object} data.attributes - List of attribute properties - values to apply to popper elementn * @argument {Object} options - Modifiers configuration and optionsn * @returns {Object} The same data objectn */nexport default function applyStyle(data) {n // any property present in `data.styles` will be applied to the popper,n // in this way we can make the 3rd party modifiers add custom styles to itn // Be aware, modifiers could override the properties defined in the previousn // lines of this modifier!n setStyles(data.instance.popper, data.styles);nn // any property present in `data.attributes` will be applied to the popper,n // they will be set as HTML attributes of the elementn setAttributes(data.instance.popper, data.attributes);nn // if arrowElement is defined and arrowStyles has some propertiesn if (data.arrowElement && Object.keys(data.arrowStyles).length) {n setStyles(data.arrowElement, data.arrowStyles);n }nn return data;n}nn/**n * Set the x-placement attribute before everything else because it could be usedn * to add margins to the popper margins needs to be calculated to get then * correct popper offsets.n * @methodn * @memberof Popper.modifiersn * @param {HTMLElement} reference - The reference element used to position the poppern * @param {HTMLElement} popper - The HTML element used as poppern * @param {Object} options - Popper.js optionsn */nexport function applyStyleOnLoad(n reference,n popper,n options,n modifierOptions,n staten) {n // compute reference element offsetsn const referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);nn // compute auto placement, store placement inside the data object,n // modifiers will be able to edit `placement` if neededn // and refer to originalPlacement to know the original valuen const placement = computeAutoPlacement(n options.placement,n referenceOffsets,n popper,n reference,n options.modifiers.flip.boundariesElement,n options.modifiers.flip.paddingn );nn popper.setAttribute('x-placement', placement);nn // Apply `position` to popper before anything else becausen // without the position applied we can't guarantee correct computationsn setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });nn return options;n}n”],“names”:,“mappings”:“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”}