2020-02-03 08:22:14 -05:00
/ * *
2021-11-17 07:47:55 -05:00
* @ popperjs / core v2 . 10.2 - MIT License
2020-02-03 08:22:14 -05:00
* /
( function ( global , factory ) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory ( exports ) :
typeof define === 'function' && define . amd ? define ( [ 'exports' ] , factory ) :
2021-08-26 10:37:04 -04:00
( global = typeof globalThis !== 'undefined' ? globalThis : global || self , factory ( global . Popper = { } ) ) ;
2020-02-03 08:22:14 -05:00
} ( this , ( function ( exports ) { 'use strict' ;
2021-11-17 07:47:55 -05:00
// import { isHTMLElement } from './instanceOf';
function getBoundingClientRect ( element , // eslint-disable-next-line unused-imports/no-unused-vars
includeScale ) {
var rect = element . getBoundingClientRect ( ) ;
var scaleX = 1 ;
var scaleY = 1 ; // FIXME:
// `offsetWidth` returns an integer while `getBoundingClientRect`
// returns a float. This results in `scaleX` or `scaleY` being
// non-1 when it should be for elements that aren't a full pixel in
// width or height.
// if (isHTMLElement(element) && includeScale) {
// const offsetHeight = element.offsetHeight;
// const offsetWidth = element.offsetWidth;
// // Do not attempt to divide by 0, otherwise we get `Infinity` as scale
// // Fallback to 1 in case both values are `0`
// if (offsetWidth > 0) {
// scaleX = rect.width / offsetWidth || 1;
// }
// if (offsetHeight > 0) {
// scaleY = rect.height / offsetHeight || 1;
// }
// }
return {
width : rect . width / scaleX ,
height : rect . height / scaleY ,
top : rect . top / scaleY ,
right : rect . right / scaleX ,
bottom : rect . bottom / scaleY ,
left : rect . left / scaleX ,
x : rect . left / scaleX ,
y : rect . top / scaleY
} ;
}
2020-02-03 08:22:14 -05:00
function getWindow ( node ) {
2021-08-26 10:37:04 -04:00
if ( node == null ) {
return window ;
}
2020-02-04 09:34:46 -05:00
if ( node . toString ( ) !== '[object Window]' ) {
2020-02-03 08:22:14 -05:00
var ownerDocument = node . ownerDocument ;
2021-08-26 10:37:04 -04:00
return ownerDocument ? ownerDocument . defaultView || window : window ;
2020-02-03 08:22:14 -05:00
}
return node ;
}
2021-11-17 07:47:55 -05:00
function getWindowScroll ( node ) {
var win = getWindow ( node ) ;
var scrollLeft = win . pageXOffset ;
var scrollTop = win . pageYOffset ;
return {
scrollLeft : scrollLeft ,
scrollTop : scrollTop
} ;
}
2021-08-26 10:37:04 -04:00
function isElement ( node ) {
var OwnElement = getWindow ( node ) . Element ;
return node instanceof OwnElement || node instanceof Element ;
}
function isHTMLElement ( node ) {
var OwnElement = getWindow ( node ) . HTMLElement ;
return node instanceof OwnElement || node instanceof HTMLElement ;
}
function isShadowRoot ( node ) {
// IE 11 has no ShadowRoot
if ( typeof ShadowRoot === 'undefined' ) {
return false ;
}
var OwnElement = getWindow ( node ) . ShadowRoot ;
return node instanceof OwnElement || node instanceof ShadowRoot ;
}
2020-02-03 08:22:14 -05:00
function getHTMLElementScroll ( element ) {
return {
scrollLeft : element . scrollLeft ,
scrollTop : element . scrollTop
} ;
}
function getNodeScroll ( node ) {
if ( node === getWindow ( node ) || ! isHTMLElement ( node ) ) {
return getWindowScroll ( node ) ;
} else {
return getHTMLElementScroll ( node ) ;
}
}
function getNodeName ( element ) {
return element ? ( element . nodeName || '' ) . toLowerCase ( ) : null ;
}
2020-02-04 09:34:46 -05:00
function getDocumentElement ( element ) {
2021-08-26 10:37:04 -04:00
// $FlowFixMe[incompatible-return]: assume body is always available
return ( ( isElement ( element ) ? element . ownerDocument : // $FlowFixMe[prop-missing]
element . document ) || window . document ) . documentElement ;
2020-02-03 08:22:14 -05:00
}
2020-02-04 09:34:46 -05:00
function getWindowScrollBarX ( element ) {
// If <html> has a CSS width greater than the viewport, then this will be
// incorrect for RTL.
// Popper 1 is broken in this case and never had a bug report so let's assume
// it's not an issue. I don't think anyone ever specifies width on <html>
// anyway.
// Browsers where the left scrollbar doesn't cause an issue report `0` for
// this (e.g. Edge 2019, IE11, Safari)
return getBoundingClientRect ( getDocumentElement ( element ) ) . left + getWindowScroll ( element ) . scrollLeft ;
2020-02-03 08:22:14 -05:00
}
2021-08-26 10:37:04 -04:00
function getComputedStyle ( element ) {
return getWindow ( element ) . getComputedStyle ( element ) ;
}
function isScrollParent ( element ) {
// Firefox wants us to check `-x` and `-y` variations as well
var _getComputedStyle = getComputedStyle ( element ) ,
overflow = _getComputedStyle . overflow ,
overflowX = _getComputedStyle . overflowX ,
overflowY = _getComputedStyle . overflowY ;
return /auto|scroll|overlay|hidden/ . test ( overflow + overflowY + overflowX ) ;
}
function isElementScaled ( element ) {
var rect = element . getBoundingClientRect ( ) ;
var scaleX = rect . width / element . offsetWidth || 1 ;
var scaleY = rect . height / element . offsetHeight || 1 ;
return scaleX !== 1 || scaleY !== 1 ;
} // Returns the composite rect of an element relative to its offsetParent.
2020-02-03 08:22:14 -05:00
// Composite means it takes into account transforms as well as layout.
2021-08-26 10:37:04 -04:00
2020-02-03 08:22:14 -05:00
function getCompositeRect ( elementOrVirtualElement , offsetParent , isFixed ) {
if ( isFixed === void 0 ) {
isFixed = false ;
}
2021-08-26 10:37:04 -04:00
var isOffsetParentAnElement = isHTMLElement ( offsetParent ) ;
2021-11-17 07:47:55 -05:00
isHTMLElement ( offsetParent ) && isElementScaled ( offsetParent ) ;
2021-08-26 10:37:04 -04:00
var documentElement = getDocumentElement ( offsetParent ) ;
2021-11-17 07:47:55 -05:00
var rect = getBoundingClientRect ( elementOrVirtualElement ) ;
2020-02-03 08:22:14 -05:00
var scroll = {
scrollLeft : 0 ,
scrollTop : 0
} ;
var offsets = {
x : 0 ,
y : 0
} ;
2021-08-26 10:37:04 -04:00
if ( isOffsetParentAnElement || ! isOffsetParentAnElement && ! isFixed ) {
if ( getNodeName ( offsetParent ) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
isScrollParent ( documentElement ) ) {
2020-02-03 08:22:14 -05:00
scroll = getNodeScroll ( offsetParent ) ;
}
if ( isHTMLElement ( offsetParent ) ) {
2021-11-17 07:47:55 -05:00
offsets = getBoundingClientRect ( offsetParent ) ;
2020-02-04 09:34:46 -05:00
offsets . x += offsetParent . clientLeft ;
offsets . y += offsetParent . clientTop ;
2021-08-26 10:37:04 -04:00
} else if ( documentElement ) {
2020-02-04 09:34:46 -05:00
offsets . x = getWindowScrollBarX ( documentElement ) ;
2020-02-03 08:22:14 -05:00
}
}
return {
x : rect . left + scroll . scrollLeft - offsets . x ,
y : rect . top + scroll . scrollTop - offsets . y ,
width : rect . width ,
height : rect . height
} ;
}
// means it doesn't take into account transforms.
2021-08-26 10:37:04 -04:00
2020-02-03 08:22:14 -05:00
function getLayoutRect ( element ) {
2021-08-26 10:37:04 -04:00
var clientRect = getBoundingClientRect ( element ) ; // Use the clientRect sizes if it's not been transformed.
// Fixes https://github.com/popperjs/popper-core/issues/1223
var width = element . offsetWidth ;
var height = element . offsetHeight ;
if ( Math . abs ( clientRect . width - width ) <= 1 ) {
width = clientRect . width ;
}
if ( Math . abs ( clientRect . height - height ) <= 1 ) {
height = clientRect . height ;
}
2020-02-03 08:22:14 -05:00
return {
x : element . offsetLeft ,
y : element . offsetTop ,
2021-08-26 10:37:04 -04:00
width : width ,
height : height
2020-02-03 08:22:14 -05:00
} ;
}
function getParentNode ( element ) {
if ( getNodeName ( element ) === 'html' ) {
return element ;
}
2021-08-26 10:37:04 -04:00
return ( // this is a quicker (but less type safe) way to save quite some bytes from the bundle
// $FlowFixMe[incompatible-return]
// $FlowFixMe[prop-missing]
element . assignedSlot || // step into the shadow DOM of the parent of a slotted node
element . parentNode || ( // DOM Element detected
isShadowRoot ( element ) ? element . host : null ) || // ShadowRoot detected
// $FlowFixMe[incompatible-call]: HTMLElement is a Node
getDocumentElement ( element ) // fallback
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
) ;
2020-02-04 09:34:46 -05:00
}
2020-02-03 08:22:14 -05:00
function getScrollParent ( node ) {
2020-02-04 09:34:46 -05:00
if ( [ 'html' , 'body' , '#document' ] . indexOf ( getNodeName ( node ) ) >= 0 ) {
2021-08-26 10:37:04 -04:00
// $FlowFixMe[incompatible-return]: assume body is always available
2020-02-03 08:22:14 -05:00
return node . ownerDocument . body ;
}
2021-08-26 10:37:04 -04:00
if ( isHTMLElement ( node ) && isScrollParent ( node ) ) {
return node ;
2020-02-03 08:22:14 -05:00
}
return getScrollParent ( getParentNode ( node ) ) ;
}
2021-08-26 10:37:04 -04:00
/ *
given a DOM element , return the list of all scroll parents , up the list of ancesors
until we get to the top window object . This list is what we attach scroll listeners
to , because if any of these parent elements scroll , we ' ll need to re - calculate the
reference element ' s position .
* /
2020-02-03 08:22:14 -05:00
function listScrollParents ( element , list ) {
2021-08-26 10:37:04 -04:00
var _element$ownerDocumen ;
2020-02-03 08:22:14 -05:00
if ( list === void 0 ) {
list = [ ] ;
}
var scrollParent = getScrollParent ( element ) ;
2021-08-26 10:37:04 -04:00
var isBody = scrollParent === ( ( _element$ownerDocumen = element . ownerDocument ) == null ? void 0 : _element$ownerDocumen . body ) ;
var win = getWindow ( scrollParent ) ;
var target = isBody ? [ win ] . concat ( win . visualViewport || [ ] , isScrollParent ( scrollParent ) ? scrollParent : [ ] ) : scrollParent ;
2020-02-03 08:22:14 -05:00
var updatedList = list . concat ( target ) ;
2021-08-26 10:37:04 -04:00
return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
2020-02-04 09:34:46 -05:00
updatedList . concat ( listScrollParents ( getParentNode ( target ) ) ) ;
2020-02-03 08:22:14 -05:00
}
function isTableElement ( element ) {
2020-02-04 09:34:46 -05:00
return [ 'table' , 'td' , 'th' ] . indexOf ( getNodeName ( element ) ) >= 0 ;
2020-02-03 08:22:14 -05:00
}
function getTrueOffsetParent ( element ) {
2021-08-26 10:37:04 -04:00
if ( ! isHTMLElement ( element ) || // https://github.com/popperjs/popper-core/issues/837
getComputedStyle ( element ) . position === 'fixed' ) {
2020-02-03 08:22:14 -05:00
return null ;
}
2021-08-26 10:37:04 -04:00
return element . offsetParent ;
} // `.offsetParent` reports `null` for fixed elements, while absolute elements
// return the containing block
function getContainingBlock ( element ) {
var isFirefox = navigator . userAgent . toLowerCase ( ) . indexOf ( 'firefox' ) !== - 1 ;
var isIE = navigator . userAgent . indexOf ( 'Trident' ) !== - 1 ;
if ( isIE && isHTMLElement ( element ) ) {
// In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
var elementCss = getComputedStyle ( element ) ;
if ( elementCss . position === 'fixed' ) {
return null ;
}
}
var currentNode = getParentNode ( element ) ;
while ( isHTMLElement ( currentNode ) && [ 'html' , 'body' ] . indexOf ( getNodeName ( currentNode ) ) < 0 ) {
var css = getComputedStyle ( currentNode ) ; // This is non-exhaustive but covers the most common CSS properties that
// create a containing block.
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
if ( css . transform !== 'none' || css . perspective !== 'none' || css . contain === 'paint' || [ 'transform' , 'perspective' ] . indexOf ( css . willChange ) !== - 1 || isFirefox && css . willChange === 'filter' || isFirefox && css . filter && css . filter !== 'none' ) {
return currentNode ;
} else {
currentNode = currentNode . parentNode ;
}
}
return null ;
} // Gets the closest ancestor positioned element. Handles some edge cases,
// such as table ancestors and cross browser bugs.
2020-02-03 08:22:14 -05:00
function getOffsetParent ( element ) {
var window = getWindow ( element ) ;
2021-08-26 10:37:04 -04:00
var offsetParent = getTrueOffsetParent ( element ) ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
while ( offsetParent && isTableElement ( offsetParent ) && getComputedStyle ( offsetParent ) . position === 'static' ) {
2020-02-03 08:22:14 -05:00
offsetParent = getTrueOffsetParent ( offsetParent ) ;
}
2021-08-26 10:37:04 -04:00
if ( offsetParent && ( getNodeName ( offsetParent ) === 'html' || getNodeName ( offsetParent ) === 'body' && getComputedStyle ( offsetParent ) . position === 'static' ) ) {
2020-02-03 08:22:14 -05:00
return window ;
}
2021-08-26 10:37:04 -04:00
return offsetParent || getContainingBlock ( element ) || window ;
2020-02-03 08:22:14 -05:00
}
var top = 'top' ;
var bottom = 'bottom' ;
var right = 'right' ;
var left = 'left' ;
var auto = 'auto' ;
var basePlacements = [ top , bottom , right , left ] ;
var start = 'start' ;
var end = 'end' ;
var clippingParents = 'clippingParents' ;
var viewport = 'viewport' ;
var popper = 'popper' ;
var reference = 'reference' ;
2021-08-26 10:37:04 -04:00
var variationPlacements = /*#__PURE__*/ basePlacements . reduce ( function ( acc , placement ) {
2020-02-03 08:22:14 -05:00
return acc . concat ( [ placement + "-" + start , placement + "-" + end ] ) ;
} , [ ] ) ;
2021-08-26 10:37:04 -04:00
var placements = /*#__PURE__*/ [ ] . concat ( basePlacements , [ auto ] ) . reduce ( function ( acc , placement ) {
2020-02-03 08:22:14 -05:00
return acc . concat ( [ placement , placement + "-" + start , placement + "-" + end ] ) ;
} , [ ] ) ; // modifiers that need to read the DOM
var beforeRead = 'beforeRead' ;
var read = 'read' ;
var afterRead = 'afterRead' ; // pure-logic modifiers
var beforeMain = 'beforeMain' ;
var main = 'main' ;
var afterMain = 'afterMain' ; // modifier with the purpose to write to the DOM (or write into a framework state)
var beforeWrite = 'beforeWrite' ;
var write = 'write' ;
var afterWrite = 'afterWrite' ;
var modifierPhases = [ beforeRead , read , afterRead , beforeMain , main , afterMain , beforeWrite , write , afterWrite ] ;
function order ( modifiers ) {
var map = new Map ( ) ;
var visited = new Set ( ) ;
var result = [ ] ;
modifiers . forEach ( function ( modifier ) {
map . set ( modifier . name , modifier ) ;
} ) ; // On visiting object, check for its dependencies and visit them recursively
function sort ( modifier ) {
visited . add ( modifier . name ) ;
var requires = [ ] . concat ( modifier . requires || [ ] , modifier . requiresIfExists || [ ] ) ;
requires . forEach ( function ( dep ) {
if ( ! visited . has ( dep ) ) {
var depModifier = map . get ( dep ) ;
if ( depModifier ) {
sort ( depModifier ) ;
}
}
} ) ;
result . push ( modifier ) ;
}
modifiers . forEach ( function ( modifier ) {
if ( ! visited . has ( modifier . name ) ) {
// check for visited object
sort ( modifier ) ;
}
} ) ;
return result ;
}
function orderModifiers ( modifiers ) {
// order based on dependencies
var orderedModifiers = order ( modifiers ) ; // order based on phase
return modifierPhases . reduce ( function ( acc , phase ) {
return acc . concat ( orderedModifiers . filter ( function ( modifier ) {
return modifier . phase === phase ;
} ) ) ;
} , [ ] ) ;
}
function debounce ( fn ) {
var pending ;
return function ( ) {
if ( ! pending ) {
pending = new Promise ( function ( resolve ) {
Promise . resolve ( ) . then ( function ( ) {
pending = undefined ;
resolve ( fn ( ) ) ;
} ) ;
} ) ;
}
return pending ;
} ;
}
function format ( str ) {
for ( var _len = arguments . length , args = new Array ( _len > 1 ? _len - 1 : 0 ) , _key = 1 ; _key < _len ; _key ++ ) {
args [ _key - 1 ] = arguments [ _key ] ;
}
return [ ] . concat ( args ) . reduce ( function ( p , c ) {
return p . replace ( /%s/ , c ) ;
} , str ) ;
}
var INVALID _MODIFIER _ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s' ;
var MISSING _DEPENDENCY _ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available' ;
var VALID _PROPERTIES = [ 'name' , 'enabled' , 'phase' , 'fn' , 'effect' , 'requires' , 'options' ] ;
function validateModifiers ( modifiers ) {
modifiers . forEach ( function ( modifier ) {
2021-11-17 07:47:55 -05:00
[ ] . concat ( Object . keys ( modifier ) , VALID _PROPERTIES ) // IE11-compatible replacement for `new Set(iterable)`
. filter ( function ( value , index , self ) {
return self . indexOf ( value ) === index ;
} ) . forEach ( function ( key ) {
2020-02-03 08:22:14 -05:00
switch ( key ) {
case 'name' :
if ( typeof modifier . name !== 'string' ) {
console . error ( format ( INVALID _MODIFIER _ERROR , String ( modifier . name ) , '"name"' , '"string"' , "\"" + String ( modifier . name ) + "\"" ) ) ;
}
break ;
case 'enabled' :
if ( typeof modifier . enabled !== 'boolean' ) {
console . error ( format ( INVALID _MODIFIER _ERROR , modifier . name , '"enabled"' , '"boolean"' , "\"" + String ( modifier . enabled ) + "\"" ) ) ;
}
2021-11-17 07:47:55 -05:00
break ;
2020-02-03 08:22:14 -05:00
case 'phase' :
2020-02-04 09:34:46 -05:00
if ( modifierPhases . indexOf ( modifier . phase ) < 0 ) {
2020-02-03 08:22:14 -05:00
console . error ( format ( INVALID _MODIFIER _ERROR , modifier . name , '"phase"' , "either " + modifierPhases . join ( ', ' ) , "\"" + String ( modifier . phase ) + "\"" ) ) ;
}
break ;
case 'fn' :
if ( typeof modifier . fn !== 'function' ) {
console . error ( format ( INVALID _MODIFIER _ERROR , modifier . name , '"fn"' , '"function"' , "\"" + String ( modifier . fn ) + "\"" ) ) ;
}
break ;
case 'effect' :
2021-11-17 07:47:55 -05:00
if ( modifier . effect != null && typeof modifier . effect !== 'function' ) {
2020-02-03 08:22:14 -05:00
console . error ( format ( INVALID _MODIFIER _ERROR , modifier . name , '"effect"' , '"function"' , "\"" + String ( modifier . fn ) + "\"" ) ) ;
}
break ;
case 'requires' :
2021-11-17 07:47:55 -05:00
if ( modifier . requires != null && ! Array . isArray ( modifier . requires ) ) {
2020-02-03 08:22:14 -05:00
console . error ( format ( INVALID _MODIFIER _ERROR , modifier . name , '"requires"' , '"array"' , "\"" + String ( modifier . requires ) + "\"" ) ) ;
}
break ;
case 'requiresIfExists' :
if ( ! Array . isArray ( modifier . requiresIfExists ) ) {
console . error ( format ( INVALID _MODIFIER _ERROR , modifier . name , '"requiresIfExists"' , '"array"' , "\"" + String ( modifier . requiresIfExists ) + "\"" ) ) ;
}
break ;
case 'options' :
case 'data' :
break ;
default :
console . error ( "PopperJS: an invalid property has been provided to the \"" + modifier . name + "\" modifier, valid properties are " + VALID _PROPERTIES . map ( function ( s ) {
return "\"" + s + "\"" ;
} ) . join ( ', ' ) + "; but \"" + key + "\" was provided." ) ;
}
modifier . requires && modifier . requires . forEach ( function ( requirement ) {
if ( modifiers . find ( function ( mod ) {
return mod . name === requirement ;
} ) == null ) {
console . error ( format ( MISSING _DEPENDENCY _ERROR , String ( modifier . name ) , requirement , requirement ) ) ;
}
} ) ;
} ) ;
} ) ;
}
function uniqueBy ( arr , fn ) {
var identifiers = new Set ( ) ;
return arr . filter ( function ( item ) {
var identifier = fn ( item ) ;
if ( ! identifiers . has ( identifier ) ) {
identifiers . add ( identifier ) ;
return true ;
}
} ) ;
}
function getBasePlacement ( placement ) {
return placement . split ( '-' ) [ 0 ] ;
}
2020-03-11 05:34:58 -04:00
function mergeByName ( modifiers ) {
var merged = modifiers . reduce ( function ( merged , current ) {
var existing = merged [ current . name ] ;
2021-08-26 10:37:04 -04:00
merged [ current . name ] = existing ? Object . assign ( { } , existing , current , {
options : Object . assign ( { } , existing . options , current . options ) ,
data : Object . assign ( { } , existing . data , current . data )
2020-03-11 05:34:58 -04:00
} ) : current ;
return merged ;
} , { } ) ; // IE11 does not support Object.values
return Object . keys ( merged ) . map ( function ( key ) {
return merged [ key ] ;
} ) ;
}
2021-08-26 10:37:04 -04:00
function getViewportRect ( element ) {
var win = getWindow ( element ) ;
var html = getDocumentElement ( element ) ;
var visualViewport = win . visualViewport ;
var width = html . clientWidth ;
var height = html . clientHeight ;
var x = 0 ;
var y = 0 ; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper
// can be obscured underneath it.
// Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even
// if it isn't open, so if this isn't available, the popper will be detected
// to overflow the bottom of the screen too early.
if ( visualViewport ) {
width = visualViewport . width ;
height = visualViewport . height ; // Uses Layout Viewport (like Chrome; Safari does not currently)
// In Chrome, it returns a value very close to 0 (+/-) but contains rounding
// errors due to floating point numbers, so we need to check precision.
// Safari returns a number <= 0, usually < -1 when pinch-zoomed
// Feature detection fails in mobile emulation mode in Chrome.
// Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
// 0.001
// Fallback here: "Not Safari" userAgent
if ( ! /^((?!chrome|android).)*safari/i . test ( navigator . userAgent ) ) {
x = visualViewport . offsetLeft ;
y = visualViewport . offsetTop ;
}
}
return {
width : width ,
height : height ,
x : x + getWindowScrollBarX ( element ) ,
y : y
} ;
}
var max = Math . max ;
var min = Math . min ;
var round = Math . round ;
// of the `<html>` and `<body>` rect bounds if horizontally scrollable
function getDocumentRect ( element ) {
var _element$ownerDocumen ;
var html = getDocumentElement ( element ) ;
var winScroll = getWindowScroll ( element ) ;
var body = ( _element$ownerDocumen = element . ownerDocument ) == null ? void 0 : _element$ownerDocumen . body ;
var width = max ( html . scrollWidth , html . clientWidth , body ? body . scrollWidth : 0 , body ? body . clientWidth : 0 ) ;
var height = max ( html . scrollHeight , html . clientHeight , body ? body . scrollHeight : 0 , body ? body . clientHeight : 0 ) ;
var x = - winScroll . scrollLeft + getWindowScrollBarX ( element ) ;
var y = - winScroll . scrollTop ;
if ( getComputedStyle ( body || html ) . direction === 'rtl' ) {
x += max ( html . clientWidth , body ? body . clientWidth : 0 ) - width ;
}
return {
width : width ,
height : height ,
x : x ,
y : y
} ;
}
function contains ( parent , child ) {
var rootNode = child . getRootNode && child . getRootNode ( ) ; // First, attempt with faster native method
if ( parent . contains ( child ) ) {
return true ;
} // then fallback to custom implementation with Shadow DOM support
else if ( rootNode && isShadowRoot ( rootNode ) ) {
var next = child ;
do {
if ( next && parent . isSameNode ( next ) ) {
return true ;
} // $FlowFixMe[prop-missing]: need a better way to handle this...
next = next . parentNode || next . host ;
} while ( next ) ;
} // Give up, the result is false
return false ;
}
function rectToClientRect ( rect ) {
return Object . assign ( { } , rect , {
left : rect . x ,
top : rect . y ,
right : rect . x + rect . width ,
bottom : rect . y + rect . height
} ) ;
}
function getInnerBoundingClientRect ( element ) {
var rect = getBoundingClientRect ( element ) ;
rect . top = rect . top + element . clientTop ;
rect . left = rect . left + element . clientLeft ;
rect . bottom = rect . top + element . clientHeight ;
rect . right = rect . left + element . clientWidth ;
rect . width = element . clientWidth ;
rect . height = element . clientHeight ;
rect . x = rect . left ;
rect . y = rect . top ;
return rect ;
}
function getClientRectFromMixedType ( element , clippingParent ) {
return clippingParent === viewport ? rectToClientRect ( getViewportRect ( element ) ) : isHTMLElement ( clippingParent ) ? getInnerBoundingClientRect ( clippingParent ) : rectToClientRect ( getDocumentRect ( getDocumentElement ( element ) ) ) ;
} // A "clipping parent" is an overflowable container with the characteristic of
// clipping (or hiding) overflowing elements with a position different from
// `initial`
function getClippingParents ( element ) {
var clippingParents = listScrollParents ( getParentNode ( element ) ) ;
var canEscapeClipping = [ 'absolute' , 'fixed' ] . indexOf ( getComputedStyle ( element ) . position ) >= 0 ;
var clipperElement = canEscapeClipping && isHTMLElement ( element ) ? getOffsetParent ( element ) : element ;
if ( ! isElement ( clipperElement ) ) {
return [ ] ;
} // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
return clippingParents . filter ( function ( clippingParent ) {
return isElement ( clippingParent ) && contains ( clippingParent , clipperElement ) && getNodeName ( clippingParent ) !== 'body' ;
} ) ;
} // Gets the maximum area that the element is visible in due to any number of
// clipping parents
function getClippingRect ( element , boundary , rootBoundary ) {
var mainClippingParents = boundary === 'clippingParents' ? getClippingParents ( element ) : [ ] . concat ( boundary ) ;
var clippingParents = [ ] . concat ( mainClippingParents , [ rootBoundary ] ) ;
var firstClippingParent = clippingParents [ 0 ] ;
var clippingRect = clippingParents . reduce ( function ( accRect , clippingParent ) {
var rect = getClientRectFromMixedType ( element , clippingParent ) ;
accRect . top = max ( rect . top , accRect . top ) ;
accRect . right = min ( rect . right , accRect . right ) ;
accRect . bottom = min ( rect . bottom , accRect . bottom ) ;
accRect . left = max ( rect . left , accRect . left ) ;
return accRect ;
} , getClientRectFromMixedType ( element , firstClippingParent ) ) ;
clippingRect . width = clippingRect . right - clippingRect . left ;
clippingRect . height = clippingRect . bottom - clippingRect . top ;
clippingRect . x = clippingRect . left ;
clippingRect . y = clippingRect . top ;
return clippingRect ;
}
function getVariation ( placement ) {
return placement . split ( '-' ) [ 1 ] ;
}
function getMainAxisFromPlacement ( placement ) {
return [ 'top' , 'bottom' ] . indexOf ( placement ) >= 0 ? 'x' : 'y' ;
}
function computeOffsets ( _ref ) {
var reference = _ref . reference ,
element = _ref . element ,
placement = _ref . placement ;
var basePlacement = placement ? getBasePlacement ( placement ) : null ;
var variation = placement ? getVariation ( placement ) : null ;
var commonX = reference . x + reference . width / 2 - element . width / 2 ;
var commonY = reference . y + reference . height / 2 - element . height / 2 ;
var offsets ;
switch ( basePlacement ) {
case top :
offsets = {
x : commonX ,
y : reference . y - element . height
} ;
break ;
case bottom :
offsets = {
x : commonX ,
y : reference . y + reference . height
} ;
break ;
case right :
offsets = {
x : reference . x + reference . width ,
y : commonY
} ;
break ;
case left :
offsets = {
x : reference . x - element . width ,
y : commonY
} ;
break ;
default :
offsets = {
x : reference . x ,
y : reference . y
} ;
}
var mainAxis = basePlacement ? getMainAxisFromPlacement ( basePlacement ) : null ;
if ( mainAxis != null ) {
var len = mainAxis === 'y' ? 'height' : 'width' ;
switch ( variation ) {
case start :
offsets [ mainAxis ] = offsets [ mainAxis ] - ( reference [ len ] / 2 - element [ len ] / 2 ) ;
break ;
case end :
offsets [ mainAxis ] = offsets [ mainAxis ] + ( reference [ len ] / 2 - element [ len ] / 2 ) ;
break ;
}
}
return offsets ;
}
function getFreshSideObject ( ) {
return {
top : 0 ,
right : 0 ,
bottom : 0 ,
left : 0
} ;
}
function mergePaddingObject ( paddingObject ) {
return Object . assign ( { } , getFreshSideObject ( ) , paddingObject ) ;
}
function expandToHashMap ( value , keys ) {
return keys . reduce ( function ( hashMap , key ) {
hashMap [ key ] = value ;
return hashMap ;
} , { } ) ;
}
function detectOverflow ( state , options ) {
if ( options === void 0 ) {
options = { } ;
}
var _options = options ,
_options$placement = _options . placement ,
placement = _options$placement === void 0 ? state . placement : _options$placement ,
_options$boundary = _options . boundary ,
boundary = _options$boundary === void 0 ? clippingParents : _options$boundary ,
_options$rootBoundary = _options . rootBoundary ,
rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary ,
_options$elementConte = _options . elementContext ,
elementContext = _options$elementConte === void 0 ? popper : _options$elementConte ,
_options$altBoundary = _options . altBoundary ,
altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary ,
_options$padding = _options . padding ,
padding = _options$padding === void 0 ? 0 : _options$padding ;
var paddingObject = mergePaddingObject ( typeof padding !== 'number' ? padding : expandToHashMap ( padding , basePlacements ) ) ;
var altContext = elementContext === popper ? reference : popper ;
var popperRect = state . rects . popper ;
var element = state . elements [ altBoundary ? altContext : elementContext ] ;
var clippingClientRect = getClippingRect ( isElement ( element ) ? element : element . contextElement || getDocumentElement ( state . elements . popper ) , boundary , rootBoundary ) ;
2021-11-17 07:47:55 -05:00
var referenceClientRect = getBoundingClientRect ( state . elements . reference ) ;
2021-08-26 10:37:04 -04:00
var popperOffsets = computeOffsets ( {
reference : referenceClientRect ,
element : popperRect ,
strategy : 'absolute' ,
placement : placement
} ) ;
var popperClientRect = rectToClientRect ( Object . assign ( { } , popperRect , popperOffsets ) ) ;
var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect ; // positive = overflowing the clipping rect
// 0 or negative = within the clipping rect
var overflowOffsets = {
top : clippingClientRect . top - elementClientRect . top + paddingObject . top ,
bottom : elementClientRect . bottom - clippingClientRect . bottom + paddingObject . bottom ,
left : clippingClientRect . left - elementClientRect . left + paddingObject . left ,
right : elementClientRect . right - clippingClientRect . right + paddingObject . right
} ;
var offsetData = state . modifiersData . offset ; // Offsets can be applied only to the popper element
if ( elementContext === popper && offsetData ) {
var offset = offsetData [ placement ] ;
Object . keys ( overflowOffsets ) . forEach ( function ( key ) {
var multiply = [ right , bottom ] . indexOf ( key ) >= 0 ? 1 : - 1 ;
var axis = [ top , bottom ] . indexOf ( key ) >= 0 ? 'y' : 'x' ;
overflowOffsets [ key ] += offset [ axis ] * multiply ;
} ) ;
}
return overflowOffsets ;
}
2020-03-11 05:34:58 -04:00
var INVALID _ELEMENT _ERROR = 'Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.' ;
2020-02-03 08:22:14 -05:00
var INFINITE _LOOP _ERROR = 'Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.' ;
var DEFAULT _OPTIONS = {
placement : 'bottom' ,
modifiers : [ ] ,
strategy : 'absolute'
} ;
function areValidElements ( ) {
for ( var _len = arguments . length , args = new Array ( _len ) , _key = 0 ; _key < _len ; _key ++ ) {
args [ _key ] = arguments [ _key ] ;
}
return ! args . some ( function ( element ) {
return ! ( element && typeof element . getBoundingClientRect === 'function' ) ;
} ) ;
}
function popperGenerator ( generatorOptions ) {
if ( generatorOptions === void 0 ) {
generatorOptions = { } ;
}
var _generatorOptions = generatorOptions ,
_generatorOptions$def = _generatorOptions . defaultModifiers ,
defaultModifiers = _generatorOptions$def === void 0 ? [ ] : _generatorOptions$def ,
_generatorOptions$def2 = _generatorOptions . defaultOptions ,
defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT _OPTIONS : _generatorOptions$def2 ;
return function createPopper ( reference , popper , options ) {
if ( options === void 0 ) {
options = defaultOptions ;
}
var state = {
placement : 'bottom' ,
orderedModifiers : [ ] ,
2021-08-26 10:37:04 -04:00
options : Object . assign ( { } , DEFAULT _OPTIONS , defaultOptions ) ,
2020-02-03 08:22:14 -05:00
modifiersData : { } ,
elements : {
reference : reference ,
popper : popper
} ,
attributes : { } ,
styles : { }
} ;
var effectCleanupFns = [ ] ;
var isDestroyed = false ;
var instance = {
state : state ,
2021-11-17 07:47:55 -05:00
setOptions : function setOptions ( setOptionsAction ) {
var options = typeof setOptionsAction === 'function' ? setOptionsAction ( state . options ) : setOptionsAction ;
2020-02-03 08:22:14 -05:00
cleanupModifierEffects ( ) ;
2021-08-26 10:37:04 -04:00
state . options = Object . assign ( { } , defaultOptions , state . options , options ) ;
2020-02-03 08:22:14 -05:00
state . scrollParents = {
2021-08-26 10:37:04 -04:00
reference : isElement ( reference ) ? listScrollParents ( reference ) : reference . contextElement ? listScrollParents ( reference . contextElement ) : [ ] ,
2020-02-03 08:22:14 -05:00
popper : listScrollParents ( popper )
} ; // Orders the modifiers based on their dependencies and `phase`
// properties
2020-03-11 05:34:58 -04:00
var orderedModifiers = orderModifiers ( mergeByName ( [ ] . concat ( defaultModifiers , state . options . modifiers ) ) ) ; // Strip out disabled modifiers
state . orderedModifiers = orderedModifiers . filter ( function ( m ) {
return m . enabled ;
} ) ; // Validate the provided modifiers so that the consumer will get warned
2020-02-03 08:22:14 -05:00
// if one of the modifiers is invalid for any reason
{
2020-03-11 05:34:58 -04:00
var modifiers = uniqueBy ( [ ] . concat ( orderedModifiers , state . options . modifiers ) , function ( _ref ) {
var name = _ref . name ;
2020-02-03 08:22:14 -05:00
return name ;
} ) ;
validateModifiers ( modifiers ) ;
if ( getBasePlacement ( state . options . placement ) === auto ) {
2020-03-11 05:34:58 -04:00
var flipModifier = state . orderedModifiers . find ( function ( _ref2 ) {
var name = _ref2 . name ;
2020-02-03 08:22:14 -05:00
return name === 'flip' ;
} ) ;
if ( ! flipModifier ) {
console . error ( [ 'Popper: "auto" placements require the "flip" modifier be' , 'present and enabled to work.' ] . join ( ' ' ) ) ;
}
}
2020-02-04 09:34:46 -05:00
var _getComputedStyle = getComputedStyle ( popper ) ,
marginTop = _getComputedStyle . marginTop ,
marginRight = _getComputedStyle . marginRight ,
marginBottom = _getComputedStyle . marginBottom ,
marginLeft = _getComputedStyle . marginLeft ; // We no longer take into account `margins` on the popper, and it can
// cause bugs with positioning, so we'll warn the consumer
if ( [ marginTop , marginRight , marginBottom , marginLeft ] . some ( function ( margin ) {
return parseFloat ( margin ) ;
} ) ) {
console . warn ( [ 'Popper: CSS "margin" styles cannot be used to apply padding' , 'between the popper and its reference element or boundary.' , 'To replicate margin, use the `offset` modifier, as well as' , 'the `padding` option in the `preventOverflow` and `flip`' , 'modifiers.' ] . join ( ' ' ) ) ;
}
2020-03-11 05:34:58 -04:00
}
2020-02-03 08:22:14 -05:00
runModifierEffects ( ) ;
return instance . update ( ) ;
} ,
// Sync update –
// is useful for low frequency updates where sync behavior simplifies the
// logic.
// For high frequency updates (e.g. `resize` and `scroll` events), always
// prefer the async Popper#update method
forceUpdate : function forceUpdate ( ) {
if ( isDestroyed ) {
return ;
}
var _state$elements = state . elements ,
reference = _state$elements . reference ,
popper = _state$elements . popper ; // Don't proceed if `reference` or `popper` are not valid elements
// anymore
if ( ! areValidElements ( reference , popper ) ) {
{
console . error ( INVALID _ELEMENT _ERROR ) ;
}
return ;
} // Store the reference and popper rects to be read by modifiers
state . rects = {
reference : getCompositeRect ( reference , getOffsetParent ( popper ) , state . options . strategy === 'fixed' ) ,
popper : getLayoutRect ( popper )
} ; // Modifiers have the ability to reset the current update cycle. The
// most common use case for this is the `flip` modifier changing the
// placement, which then needs to re-run all the modifiers, because the
// logic was previously ran for the previous placement and is therefore
// stale/incorrect
state . reset = false ;
state . placement = state . options . placement ; // On each update cycle, the `modifiersData` property for each modifier
// is filled with the initial data specified by the modifier. This means
// it doesn't persist and is fresh on each update.
// To ensure persistent data, use `${name}#persistent`
state . orderedModifiers . forEach ( function ( modifier ) {
return state . modifiersData [ modifier . name ] = Object . assign ( { } , modifier . data ) ;
} ) ;
var _ _debug _loops _ _ = 0 ;
for ( var index = 0 ; index < state . orderedModifiers . length ; index ++ ) {
{
_ _debug _loops _ _ += 1 ;
if ( _ _debug _loops _ _ > 100 ) {
console . error ( INFINITE _LOOP _ERROR ) ;
break ;
}
}
if ( state . reset === true ) {
state . reset = false ;
index = - 1 ;
continue ;
}
var _state$orderedModifie = state . orderedModifiers [ index ] ,
fn = _state$orderedModifie . fn ,
_state$orderedModifie2 = _state$orderedModifie . options ,
_options = _state$orderedModifie2 === void 0 ? { } : _state$orderedModifie2 ,
name = _state$orderedModifie . name ;
if ( typeof fn === 'function' ) {
state = fn ( {
state : state ,
options : _options ,
name : name ,
instance : instance
} ) || state ;
}
}
} ,
// Async and optimistically optimized update –
// not necessary (debounced to run at most once-per-tick)
update : debounce ( function ( ) {
return new Promise ( function ( resolve ) {
instance . forceUpdate ( ) ;
resolve ( state ) ;
} ) ;
} ) ,
destroy : function destroy ( ) {
cleanupModifierEffects ( ) ;
isDestroyed = true ;
}
} ;
if ( ! areValidElements ( reference , popper ) ) {
{
console . error ( INVALID _ELEMENT _ERROR ) ;
}
return instance ;
}
instance . setOptions ( options ) . then ( function ( state ) {
if ( ! isDestroyed && options . onFirstUpdate ) {
options . onFirstUpdate ( state ) ;
}
} ) ; // Modifiers have the ability to execute arbitrary code before the first
// update cycle runs. They will be executed in the same order as the update
// cycle. This is useful when a modifier adds some persistent data that
// other modifiers need to use, but the modifier is run after the dependent
// one.
function runModifierEffects ( ) {
2020-03-11 05:34:58 -04:00
state . orderedModifiers . forEach ( function ( _ref3 ) {
var name = _ref3 . name ,
_ref3$options = _ref3 . options ,
options = _ref3$options === void 0 ? { } : _ref3$options ,
effect = _ref3 . effect ;
2020-02-03 08:22:14 -05:00
if ( typeof effect === 'function' ) {
var cleanupFn = effect ( {
state : state ,
name : name ,
instance : instance ,
options : options
} ) ;
var noopFn = function noopFn ( ) { } ;
effectCleanupFns . push ( cleanupFn || noopFn ) ;
}
} ) ;
}
function cleanupModifierEffects ( ) {
effectCleanupFns . forEach ( function ( fn ) {
return fn ( ) ;
} ) ;
effectCleanupFns = [ ] ;
}
return instance ;
} ;
}
var passive = {
passive : true
} ;
2021-08-26 10:37:04 -04:00
function effect$2 ( _ref ) {
2020-02-03 08:22:14 -05:00
var state = _ref . state ,
instance = _ref . instance ,
options = _ref . options ;
var _options$scroll = options . scroll ,
scroll = _options$scroll === void 0 ? true : _options$scroll ,
_options$resize = options . resize ,
resize = _options$resize === void 0 ? true : _options$resize ;
var window = getWindow ( state . elements . popper ) ;
var scrollParents = [ ] . concat ( state . scrollParents . reference , state . scrollParents . popper ) ;
if ( scroll ) {
scrollParents . forEach ( function ( scrollParent ) {
scrollParent . addEventListener ( 'scroll' , instance . update , passive ) ;
} ) ;
}
if ( resize ) {
window . addEventListener ( 'resize' , instance . update , passive ) ;
}
return function ( ) {
if ( scroll ) {
scrollParents . forEach ( function ( scrollParent ) {
scrollParent . removeEventListener ( 'scroll' , instance . update , passive ) ;
} ) ;
2021-08-26 10:37:04 -04:00
}
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
if ( resize ) {
window . removeEventListener ( 'resize' , instance . update , passive ) ;
2020-02-03 08:22:14 -05:00
}
2021-08-26 10:37:04 -04:00
} ;
} // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
var eventListeners = {
name : 'eventListeners' ,
enabled : true ,
phase : 'write' ,
fn : function fn ( ) { } ,
effect : effect$2 ,
data : { }
} ;
2020-02-03 08:22:14 -05:00
function popperOffsets ( _ref ) {
var state = _ref . state ,
name = _ref . name ;
// Offsets are the actual position the popper needs to have to be
// properly positioned near its reference element
// This is the most basic placement, and will be adjusted by
// the modifiers in the next step
state . modifiersData [ name ] = computeOffsets ( {
reference : state . rects . reference ,
element : state . rects . popper ,
strategy : 'absolute' ,
placement : state . placement
} ) ;
2021-08-26 10:37:04 -04:00
} // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
var popperOffsets$1 = {
name : 'popperOffsets' ,
enabled : true ,
phase : 'read' ,
fn : popperOffsets ,
data : { }
} ;
var unsetSides = {
top : 'auto' ,
right : 'auto' ,
bottom : 'auto' ,
left : 'auto'
} ; // Round the offsets to the nearest suitable subpixel based on the DPR.
// Zooming can change the DPR, but it seems to report a value that will
// cleanly divide the values into the appropriate subpixels.
2021-08-26 10:37:04 -04:00
function roundOffsetsByDPR ( _ref ) {
2020-02-03 08:22:14 -05:00
var x = _ref . x ,
y = _ref . y ;
2020-03-11 05:34:58 -04:00
var win = window ;
var dpr = win . devicePixelRatio || 1 ;
2020-02-03 08:22:14 -05:00
return {
2021-08-26 10:37:04 -04:00
x : round ( round ( x * dpr ) / dpr ) || 0 ,
y : round ( round ( y * dpr ) / dpr ) || 0
2020-02-03 08:22:14 -05:00
} ;
}
function mapToStyles ( _ref2 ) {
var _Object$assign2 ;
var popper = _ref2 . popper ,
popperRect = _ref2 . popperRect ,
placement = _ref2 . placement ,
2021-11-17 07:47:55 -05:00
variation = _ref2 . variation ,
2020-02-03 08:22:14 -05:00
offsets = _ref2 . offsets ,
position = _ref2 . position ,
gpuAcceleration = _ref2 . gpuAcceleration ,
2021-08-26 10:37:04 -04:00
adaptive = _ref2 . adaptive ,
roundOffsets = _ref2 . roundOffsets ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
var _ref3 = roundOffsets === true ? roundOffsetsByDPR ( offsets ) : typeof roundOffsets === 'function' ? roundOffsets ( offsets ) : offsets ,
_ref3$x = _ref3 . x ,
x = _ref3$x === void 0 ? 0 : _ref3$x ,
_ref3$y = _ref3 . y ,
y = _ref3$y === void 0 ? 0 : _ref3$y ;
2020-02-03 08:22:14 -05:00
var hasX = offsets . hasOwnProperty ( 'x' ) ;
var hasY = offsets . hasOwnProperty ( 'y' ) ;
var sideX = left ;
var sideY = top ;
2020-03-11 05:34:58 -04:00
var win = window ;
2020-02-03 08:22:14 -05:00
if ( adaptive ) {
var offsetParent = getOffsetParent ( popper ) ;
2021-08-26 10:37:04 -04:00
var heightProp = 'clientHeight' ;
var widthProp = 'clientWidth' ;
2020-02-03 08:22:14 -05:00
if ( offsetParent === getWindow ( popper ) ) {
offsetParent = getDocumentElement ( popper ) ;
2020-02-04 09:34:46 -05:00
2021-11-17 07:47:55 -05:00
if ( getComputedStyle ( offsetParent ) . position !== 'static' && position === 'absolute' ) {
2021-08-26 10:37:04 -04:00
heightProp = 'scrollHeight' ;
widthProp = 'scrollWidth' ;
}
} // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
2020-02-04 09:34:46 -05:00
2021-08-26 10:37:04 -04:00
offsetParent = offsetParent ;
2020-02-03 08:22:14 -05:00
2021-11-17 07:47:55 -05:00
if ( placement === top || ( placement === left || placement === right ) && variation === end ) {
2021-08-26 10:37:04 -04:00
sideY = bottom ; // $FlowFixMe[prop-missing]
y -= offsetParent [ heightProp ] - popperRect . height ;
2020-02-04 09:34:46 -05:00
y *= gpuAcceleration ? 1 : - 1 ;
2020-02-03 08:22:14 -05:00
}
2021-11-17 07:47:55 -05:00
if ( placement === left || ( placement === top || placement === bottom ) && variation === end ) {
2021-08-26 10:37:04 -04:00
sideX = right ; // $FlowFixMe[prop-missing]
x -= offsetParent [ widthProp ] - popperRect . width ;
2020-02-04 09:34:46 -05:00
x *= gpuAcceleration ? 1 : - 1 ;
2020-02-03 08:22:14 -05:00
}
}
var commonStyles = Object . assign ( {
position : position
} , adaptive && unsetSides ) ;
if ( gpuAcceleration ) {
var _Object$assign ;
2021-11-17 07:47:55 -05:00
return Object . assign ( { } , commonStyles , ( _Object$assign = { } , _Object$assign [ sideY ] = hasY ? '0' : '' , _Object$assign [ sideX ] = hasX ? '0' : '' , _Object$assign . transform = ( win . devicePixelRatio || 1 ) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)" , _Object$assign ) ) ;
2020-02-03 08:22:14 -05:00
}
return Object . assign ( { } , commonStyles , ( _Object$assign2 = { } , _Object$assign2 [ sideY ] = hasY ? y + "px" : '' , _Object$assign2 [ sideX ] = hasX ? x + "px" : '' , _Object$assign2 . transform = '' , _Object$assign2 ) ) ;
}
2021-08-26 10:37:04 -04:00
function computeStyles ( _ref4 ) {
var state = _ref4 . state ,
options = _ref4 . options ;
2020-02-03 08:22:14 -05:00
var _options$gpuAccelerat = options . gpuAcceleration ,
gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat ,
_options$adaptive = options . adaptive ,
2021-08-26 10:37:04 -04:00
adaptive = _options$adaptive === void 0 ? true : _options$adaptive ,
_options$roundOffsets = options . roundOffsets ,
roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets ;
2020-02-04 09:34:46 -05:00
{
2021-08-26 10:37:04 -04:00
var transitionProperty = getComputedStyle ( state . elements . popper ) . transitionProperty || '' ;
2020-03-11 05:34:58 -04:00
if ( adaptive && [ 'transform' , 'top' , 'right' , 'bottom' , 'left' ] . some ( function ( property ) {
return transitionProperty . indexOf ( property ) >= 0 ;
} ) ) {
console . warn ( [ 'Popper: Detected CSS transitions on at least one of the following' , 'CSS properties: "transform", "top", "right", "bottom", "left".' , '\n\n' , 'Disable the "computeStyles" modifier\'s `adaptive` option to allow' , 'for smooth transitions, or remove these properties from the CSS' , 'transition declaration on the popper element if only transitioning' , 'opacity or background-color for example.' , '\n\n' , 'We recommend using the popper element as a wrapper around an inner' , 'element that can have any CSS property transitioned for animations.' ] . join ( ' ' ) ) ;
2020-02-04 09:34:46 -05:00
}
}
2020-02-03 08:22:14 -05:00
var commonStyles = {
placement : getBasePlacement ( state . placement ) ,
2021-11-17 07:47:55 -05:00
variation : getVariation ( state . placement ) ,
2020-02-03 08:22:14 -05:00
popper : state . elements . popper ,
popperRect : state . rects . popper ,
gpuAcceleration : gpuAcceleration
2021-08-26 10:37:04 -04:00
} ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
if ( state . modifiersData . popperOffsets != null ) {
state . styles . popper = Object . assign ( { } , state . styles . popper , mapToStyles ( Object . assign ( { } , commonStyles , {
offsets : state . modifiersData . popperOffsets ,
position : state . options . strategy ,
adaptive : adaptive ,
roundOffsets : roundOffsets
} ) ) ) ;
}
2020-02-03 08:22:14 -05:00
if ( state . modifiersData . arrow != null ) {
2021-08-26 10:37:04 -04:00
state . styles . arrow = Object . assign ( { } , state . styles . arrow , mapToStyles ( Object . assign ( { } , commonStyles , {
2020-02-03 08:22:14 -05:00
offsets : state . modifiersData . arrow ,
position : 'absolute' ,
2021-08-26 10:37:04 -04:00
adaptive : false ,
roundOffsets : roundOffsets
2020-02-03 08:22:14 -05:00
} ) ) ) ;
}
state . attributes . popper = Object . assign ( { } , state . attributes . popper , {
'data-popper-placement' : state . placement
} ) ;
2021-08-26 10:37:04 -04:00
} // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
var computeStyles$1 = {
name : 'computeStyles' ,
enabled : true ,
phase : 'beforeWrite' ,
fn : computeStyles ,
data : { }
} ;
// and applies them to the HTMLElements such as popper and arrow
function applyStyles ( _ref ) {
var state = _ref . state ;
Object . keys ( state . elements ) . forEach ( function ( name ) {
var style = state . styles [ name ] || { } ;
var attributes = state . attributes [ name ] || { } ;
var element = state . elements [ name ] ; // arrow is optional + virtual elements
if ( ! isHTMLElement ( element ) || ! getNodeName ( element ) ) {
return ;
} // Flow doesn't support to extend this property, but it's the most
// effective way to apply styles to an HTMLElement
2021-08-26 10:37:04 -04:00
// $FlowFixMe[cannot-write]
2020-02-03 08:22:14 -05:00
Object . assign ( element . style , style ) ;
2020-02-04 09:34:46 -05:00
Object . keys ( attributes ) . forEach ( function ( name ) {
var value = attributes [ name ] ;
2020-02-03 08:22:14 -05:00
if ( value === false ) {
element . removeAttribute ( name ) ;
} else {
element . setAttribute ( name , value === true ? '' : value ) ;
}
} ) ;
} ) ;
}
2020-02-04 09:34:46 -05:00
function effect$1 ( _ref2 ) {
var state = _ref2 . state ;
2020-02-03 08:22:14 -05:00
var initialStyles = {
2020-03-11 05:34:58 -04:00
popper : {
2021-08-26 10:37:04 -04:00
position : state . options . strategy ,
2020-03-11 05:34:58 -04:00
left : '0' ,
top : '0' ,
margin : '0'
} ,
arrow : {
position : 'absolute'
} ,
reference : { }
2020-02-03 08:22:14 -05:00
} ;
2020-03-11 05:34:58 -04:00
Object . assign ( state . elements . popper . style , initialStyles . popper ) ;
2021-08-26 10:37:04 -04:00
state . styles = initialStyles ;
2020-03-11 05:34:58 -04:00
if ( state . elements . arrow ) {
Object . assign ( state . elements . arrow . style , initialStyles . arrow ) ;
}
2020-02-03 08:22:14 -05:00
return function ( ) {
Object . keys ( state . elements ) . forEach ( function ( name ) {
var element = state . elements [ name ] ;
2020-03-11 05:34:58 -04:00
var attributes = state . attributes [ name ] || { } ;
var styleProperties = Object . keys ( state . styles . hasOwnProperty ( name ) ? state . styles [ name ] : initialStyles [ name ] ) ; // Set all values to an empty string to unset them
2020-02-03 08:22:14 -05:00
var style = styleProperties . reduce ( function ( style , property ) {
2020-03-11 05:34:58 -04:00
style [ property ] = '' ;
return style ;
2020-02-03 08:22:14 -05:00
} , { } ) ; // arrow is optional + virtual elements
if ( ! isHTMLElement ( element ) || ! getNodeName ( element ) ) {
return ;
2021-08-26 10:37:04 -04:00
}
2020-02-03 08:22:14 -05:00
Object . assign ( element . style , style ) ;
Object . keys ( attributes ) . forEach ( function ( attribute ) {
2020-03-11 05:34:58 -04:00
element . removeAttribute ( attribute ) ;
2020-02-03 08:22:14 -05:00
} ) ;
} ) ;
} ;
2021-08-26 10:37:04 -04:00
} // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
var applyStyles$1 = {
name : 'applyStyles' ,
enabled : true ,
phase : 'write' ,
fn : applyStyles ,
effect : effect$1 ,
requires : [ 'computeStyles' ]
} ;
function distanceAndSkiddingToXY ( placement , rects , offset ) {
var basePlacement = getBasePlacement ( placement ) ;
2020-02-04 09:34:46 -05:00
var invertDistance = [ left , top ] . indexOf ( basePlacement ) >= 0 ? - 1 : 1 ;
2020-02-03 08:22:14 -05:00
var _ref = typeof offset === 'function' ? offset ( Object . assign ( { } , rects , {
placement : placement
} ) ) : offset ,
skidding = _ref [ 0 ] ,
distance = _ref [ 1 ] ;
skidding = skidding || 0 ;
distance = ( distance || 0 ) * invertDistance ;
2020-02-04 09:34:46 -05:00
return [ left , right ] . indexOf ( basePlacement ) >= 0 ? {
2020-02-03 08:22:14 -05:00
x : distance ,
y : skidding
} : {
x : skidding ,
y : distance
} ;
}
function offset ( _ref2 ) {
var state = _ref2 . state ,
options = _ref2 . options ,
name = _ref2 . name ;
var _options$offset = options . offset ,
offset = _options$offset === void 0 ? [ 0 , 0 ] : _options$offset ;
var data = placements . reduce ( function ( acc , placement ) {
acc [ placement ] = distanceAndSkiddingToXY ( placement , state . rects , offset ) ;
return acc ;
} , { } ) ;
var _data$state$placement = data [ state . placement ] ,
x = _data$state$placement . x ,
y = _data$state$placement . y ;
2021-08-26 10:37:04 -04:00
if ( state . modifiersData . popperOffsets != null ) {
state . modifiersData . popperOffsets . x += x ;
state . modifiersData . popperOffsets . y += y ;
}
2020-02-03 08:22:14 -05:00
state . modifiersData [ name ] = data ;
2021-08-26 10:37:04 -04:00
} // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
var offset$1 = {
name : 'offset' ,
enabled : true ,
phase : 'main' ,
requires : [ 'popperOffsets' ] ,
fn : offset
} ;
2021-08-26 10:37:04 -04:00
var hash$1 = {
2020-02-03 08:22:14 -05:00
left : 'right' ,
right : 'left' ,
bottom : 'top' ,
top : 'bottom'
} ;
function getOppositePlacement ( placement ) {
return placement . replace ( /left|right|bottom|top/g , function ( matched ) {
2021-08-26 10:37:04 -04:00
return hash$1 [ matched ] ;
2020-02-03 08:22:14 -05:00
} ) ;
}
2021-08-26 10:37:04 -04:00
var hash = {
2020-02-03 08:22:14 -05:00
start : 'end' ,
end : 'start'
} ;
function getOppositeVariationPlacement ( placement ) {
return placement . replace ( /start|end/g , function ( matched ) {
2021-08-26 10:37:04 -04:00
return hash [ matched ] ;
2020-02-03 08:22:14 -05:00
} ) ;
}
function computeAutoPlacement ( state , options ) {
if ( options === void 0 ) {
options = { } ;
}
var _options = options ,
placement = _options . placement ,
boundary = _options . boundary ,
rootBoundary = _options . rootBoundary ,
padding = _options . padding ,
2021-08-26 10:37:04 -04:00
flipVariations = _options . flipVariations ,
_options$allowedAutoP = _options . allowedAutoPlacements ,
allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP ;
2020-02-03 08:22:14 -05:00
var variation = getVariation ( placement ) ;
2021-08-26 10:37:04 -04:00
var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements . filter ( function ( placement ) {
2020-02-04 09:34:46 -05:00
return getVariation ( placement ) === variation ;
2021-08-26 10:37:04 -04:00
} ) : basePlacements ;
var allowedPlacements = placements$1 . filter ( function ( placement ) {
return allowedAutoPlacements . indexOf ( placement ) >= 0 ;
} ) ;
if ( allowedPlacements . length === 0 ) {
allowedPlacements = placements$1 ;
{
console . error ( [ 'Popper: The `allowedAutoPlacements` option did not allow any' , 'placements. Ensure the `placement` option matches the variation' , 'of the allowed placements.' , 'For example, "auto" cannot be used to allow "bottom-start".' , 'Use "auto-start" instead.' ] . join ( ' ' ) ) ;
}
} // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
var overflows = allowedPlacements . reduce ( function ( acc , placement ) {
2020-02-03 08:22:14 -05:00
acc [ placement ] = detectOverflow ( state , {
placement : placement ,
boundary : boundary ,
rootBoundary : rootBoundary ,
padding : padding
} ) [ getBasePlacement ( placement ) ] ;
return acc ;
} , { } ) ;
return Object . keys ( overflows ) . sort ( function ( a , b ) {
return overflows [ a ] - overflows [ b ] ;
} ) ;
}
function getExpandedFallbackPlacements ( placement ) {
if ( getBasePlacement ( placement ) === auto ) {
return [ ] ;
}
var oppositePlacement = getOppositePlacement ( placement ) ;
return [ getOppositeVariationPlacement ( placement ) , oppositePlacement , getOppositeVariationPlacement ( oppositePlacement ) ] ;
}
function flip ( _ref ) {
var state = _ref . state ,
options = _ref . options ,
name = _ref . name ;
if ( state . modifiersData [ name ] . _skip ) {
return ;
}
2021-08-26 10:37:04 -04:00
var _options$mainAxis = options . mainAxis ,
checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis ,
_options$altAxis = options . altAxis ,
checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis ,
specifiedFallbackPlacements = options . fallbackPlacements ,
2020-02-03 08:22:14 -05:00
padding = options . padding ,
boundary = options . boundary ,
rootBoundary = options . rootBoundary ,
2021-08-26 10:37:04 -04:00
altBoundary = options . altBoundary ,
2020-02-03 08:22:14 -05:00
_options$flipVariatio = options . flipVariations ,
2021-08-26 10:37:04 -04:00
flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio ,
allowedAutoPlacements = options . allowedAutoPlacements ;
2020-02-03 08:22:14 -05:00
var preferredPlacement = state . options . placement ;
var basePlacement = getBasePlacement ( preferredPlacement ) ;
var isBasePlacement = basePlacement === preferredPlacement ;
2020-02-04 09:34:46 -05:00
var fallbackPlacements = specifiedFallbackPlacements || ( isBasePlacement || ! flipVariations ? [ getOppositePlacement ( preferredPlacement ) ] : getExpandedFallbackPlacements ( preferredPlacement ) ) ;
2020-03-11 05:34:58 -04:00
var placements = [ preferredPlacement ] . concat ( fallbackPlacements ) . reduce ( function ( acc , placement ) {
return acc . concat ( getBasePlacement ( placement ) === auto ? computeAutoPlacement ( state , {
2020-02-03 08:22:14 -05:00
placement : placement ,
boundary : boundary ,
rootBoundary : rootBoundary ,
padding : padding ,
2021-08-26 10:37:04 -04:00
flipVariations : flipVariations ,
allowedAutoPlacements : allowedAutoPlacements
2020-03-11 05:34:58 -04:00
} ) : placement ) ;
} , [ ] ) ;
2020-02-03 08:22:14 -05:00
var referenceRect = state . rects . reference ;
var popperRect = state . rects . popper ;
var checksMap = new Map ( ) ;
var makeFallbackChecks = true ;
var firstFittingPlacement = placements [ 0 ] ;
for ( var i = 0 ; i < placements . length ; i ++ ) {
var placement = placements [ i ] ;
var _basePlacement = getBasePlacement ( placement ) ;
var isStartVariation = getVariation ( placement ) === start ;
2020-02-04 09:34:46 -05:00
var isVertical = [ top , bottom ] . indexOf ( _basePlacement ) >= 0 ;
2020-02-03 08:22:14 -05:00
var len = isVertical ? 'width' : 'height' ;
var overflow = detectOverflow ( state , {
placement : placement ,
boundary : boundary ,
rootBoundary : rootBoundary ,
2021-08-26 10:37:04 -04:00
altBoundary : altBoundary ,
2020-02-03 08:22:14 -05:00
padding : padding
} ) ;
var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top ;
if ( referenceRect [ len ] > popperRect [ len ] ) {
mainVariationSide = getOppositePlacement ( mainVariationSide ) ;
}
var altVariationSide = getOppositePlacement ( mainVariationSide ) ;
2021-08-26 10:37:04 -04:00
var checks = [ ] ;
if ( checkMainAxis ) {
checks . push ( overflow [ _basePlacement ] <= 0 ) ;
}
if ( checkAltAxis ) {
checks . push ( overflow [ mainVariationSide ] <= 0 , overflow [ altVariationSide ] <= 0 ) ;
}
2020-02-03 08:22:14 -05:00
if ( checks . every ( function ( check ) {
return check ;
} ) ) {
firstFittingPlacement = placement ;
makeFallbackChecks = false ;
break ;
}
checksMap . set ( placement , checks ) ;
}
if ( makeFallbackChecks ) {
// `2` may be desired in some cases –
var numberOfChecks = flipVariations ? 3 : 1 ;
var _loop = function _loop ( _i ) {
var fittingPlacement = placements . find ( function ( placement ) {
var checks = checksMap . get ( placement ) ;
if ( checks ) {
return checks . slice ( 0 , _i ) . every ( function ( check ) {
return check ;
} ) ;
}
} ) ;
if ( fittingPlacement ) {
firstFittingPlacement = fittingPlacement ;
return "break" ;
}
} ;
for ( var _i = numberOfChecks ; _i > 0 ; _i -- ) {
var _ret = _loop ( _i ) ;
if ( _ret === "break" ) break ;
}
}
if ( state . placement !== firstFittingPlacement ) {
state . modifiersData [ name ] . _skip = true ;
state . placement = firstFittingPlacement ;
state . reset = true ;
}
2021-08-26 10:37:04 -04:00
} // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
var flip$1 = {
name : 'flip' ,
enabled : true ,
phase : 'main' ,
fn : flip ,
requiresIfExists : [ 'offset' ] ,
data : {
_skip : false
}
} ;
function getAltAxis ( axis ) {
return axis === 'x' ? 'y' : 'x' ;
}
2021-08-26 10:37:04 -04:00
function within ( min$1 , value , max$1 ) {
return max ( min$1 , min ( value , max$1 ) ) ;
2020-02-03 08:22:14 -05:00
}
function preventOverflow ( _ref ) {
var state = _ref . state ,
options = _ref . options ,
name = _ref . name ;
var _options$mainAxis = options . mainAxis ,
checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis ,
_options$altAxis = options . altAxis ,
checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis ,
boundary = options . boundary ,
rootBoundary = options . rootBoundary ,
2021-08-26 10:37:04 -04:00
altBoundary = options . altBoundary ,
2020-02-03 08:22:14 -05:00
padding = options . padding ,
_options$tether = options . tether ,
tether = _options$tether === void 0 ? true : _options$tether ,
_options$tetherOffset = options . tetherOffset ,
tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset ;
var overflow = detectOverflow ( state , {
boundary : boundary ,
rootBoundary : rootBoundary ,
2021-08-26 10:37:04 -04:00
padding : padding ,
altBoundary : altBoundary
2020-02-03 08:22:14 -05:00
} ) ;
var basePlacement = getBasePlacement ( state . placement ) ;
var variation = getVariation ( state . placement ) ;
var isBasePlacement = ! variation ;
var mainAxis = getMainAxisFromPlacement ( basePlacement ) ;
var altAxis = getAltAxis ( mainAxis ) ;
var popperOffsets = state . modifiersData . popperOffsets ;
var referenceRect = state . rects . reference ;
var popperRect = state . rects . popper ;
var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset ( Object . assign ( { } , state . rects , {
placement : state . placement
} ) ) : tetherOffset ;
var data = {
x : 0 ,
y : 0
} ;
2021-08-26 10:37:04 -04:00
if ( ! popperOffsets ) {
return ;
}
if ( checkMainAxis || checkAltAxis ) {
2020-02-03 08:22:14 -05:00
var mainSide = mainAxis === 'y' ? top : left ;
var altSide = mainAxis === 'y' ? bottom : right ;
var len = mainAxis === 'y' ? 'height' : 'width' ;
var offset = popperOffsets [ mainAxis ] ;
2021-08-26 10:37:04 -04:00
var min$1 = popperOffsets [ mainAxis ] + overflow [ mainSide ] ;
var max$1 = popperOffsets [ mainAxis ] - overflow [ altSide ] ;
2020-02-03 08:22:14 -05:00
var additive = tether ? - popperRect [ len ] / 2 : 0 ;
var minLen = variation === start ? referenceRect [ len ] : popperRect [ len ] ;
var maxLen = variation === start ? - popperRect [ len ] : - referenceRect [ len ] ; // We need to include the arrow in the calculation so the arrow doesn't go
// outside the reference bounds
var arrowElement = state . elements . arrow ;
var arrowRect = tether && arrowElement ? getLayoutRect ( arrowElement ) : {
width : 0 ,
height : 0
} ;
var arrowPaddingObject = state . modifiersData [ 'arrow#persistent' ] ? state . modifiersData [ 'arrow#persistent' ] . padding : getFreshSideObject ( ) ;
var arrowPaddingMin = arrowPaddingObject [ mainSide ] ;
var arrowPaddingMax = arrowPaddingObject [ altSide ] ; // If the reference length is smaller than the arrow length, we don't want
// to include its full size in the calculation. If the reference is small
// and near the edge of a boundary, the popper can overflow even if the
// reference is not overflowing as well (e.g. virtual elements with no
// width or height)
2020-03-11 05:34:58 -04:00
var arrowLen = within ( 0 , referenceRect [ len ] , arrowRect [ len ] ) ;
2020-02-03 08:22:14 -05:00
var minOffset = isBasePlacement ? referenceRect [ len ] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue ;
var maxOffset = isBasePlacement ? - referenceRect [ len ] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue ;
2021-08-26 10:37:04 -04:00
var arrowOffsetParent = state . elements . arrow && getOffsetParent ( state . elements . arrow ) ;
var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent . clientTop || 0 : arrowOffsetParent . clientLeft || 0 : 0 ;
2020-02-03 08:22:14 -05:00
var offsetModifierValue = state . modifiersData . offset ? state . modifiersData . offset [ state . placement ] [ mainAxis ] : 0 ;
2021-08-26 10:37:04 -04:00
var tetherMin = popperOffsets [ mainAxis ] + minOffset - offsetModifierValue - clientOffset ;
2020-03-11 05:34:58 -04:00
var tetherMax = popperOffsets [ mainAxis ] + maxOffset - offsetModifierValue ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
if ( checkMainAxis ) {
var preventedOffset = within ( tether ? min ( min$1 , tetherMin ) : min$1 , offset , tether ? max ( max$1 , tetherMax ) : max$1 ) ;
popperOffsets [ mainAxis ] = preventedOffset ;
data [ mainAxis ] = preventedOffset - offset ;
}
if ( checkAltAxis ) {
var _mainSide = mainAxis === 'x' ? top : left ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
var _altSide = mainAxis === 'x' ? bottom : right ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
var _offset = popperOffsets [ altAxis ] ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
var _min = _offset + overflow [ _mainSide ] ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
var _max = _offset - overflow [ _altSide ] ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
var _preventedOffset = within ( tether ? min ( _min , tetherMin ) : _min , _offset , tether ? max ( _max , tetherMax ) : _max ) ;
2020-02-03 08:22:14 -05:00
2021-08-26 10:37:04 -04:00
popperOffsets [ altAxis ] = _preventedOffset ;
data [ altAxis ] = _preventedOffset - _offset ;
}
2020-02-03 08:22:14 -05:00
}
state . modifiersData [ name ] = data ;
2021-08-26 10:37:04 -04:00
} // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
var preventOverflow$1 = {
name : 'preventOverflow' ,
enabled : true ,
phase : 'main' ,
fn : preventOverflow ,
requiresIfExists : [ 'offset' ]
} ;
2021-08-26 10:37:04 -04:00
var toPaddingObject = function toPaddingObject ( padding , state ) {
padding = typeof padding === 'function' ? padding ( Object . assign ( { } , state . rects , {
placement : state . placement
} ) ) : padding ;
return mergePaddingObject ( typeof padding !== 'number' ? padding : expandToHashMap ( padding , basePlacements ) ) ;
} ;
2020-02-03 08:22:14 -05:00
function arrow ( _ref ) {
var _state$modifiersData$ ;
var state = _ref . state ,
2021-08-26 10:37:04 -04:00
name = _ref . name ,
options = _ref . options ;
2020-02-03 08:22:14 -05:00
var arrowElement = state . elements . arrow ;
var popperOffsets = state . modifiersData . popperOffsets ;
var basePlacement = getBasePlacement ( state . placement ) ;
var axis = getMainAxisFromPlacement ( basePlacement ) ;
2020-02-04 09:34:46 -05:00
var isVertical = [ left , right ] . indexOf ( basePlacement ) >= 0 ;
2020-02-03 08:22:14 -05:00
var len = isVertical ? 'height' : 'width' ;
2021-08-26 10:37:04 -04:00
if ( ! arrowElement || ! popperOffsets ) {
2020-02-03 08:22:14 -05:00
return ;
}
2021-08-26 10:37:04 -04:00
var paddingObject = toPaddingObject ( options . padding , state ) ;
2020-02-03 08:22:14 -05:00
var arrowRect = getLayoutRect ( arrowElement ) ;
var minProp = axis === 'y' ? top : left ;
var maxProp = axis === 'y' ? bottom : right ;
var endDiff = state . rects . reference [ len ] + state . rects . reference [ axis ] - popperOffsets [ axis ] - state . rects . popper [ len ] ;
var startDiff = popperOffsets [ axis ] - state . rects . reference [ axis ] ;
2021-08-26 10:37:04 -04:00
var arrowOffsetParent = getOffsetParent ( arrowElement ) ;
var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent . clientHeight || 0 : arrowOffsetParent . clientWidth || 0 : 0 ;
2020-02-03 08:22:14 -05:00
var centerToReference = endDiff / 2 - startDiff / 2 ; // Make sure the arrow doesn't overflow the popper if the center point is
// outside of the popper bounds
2021-08-26 10:37:04 -04:00
var min = paddingObject [ minProp ] ;
var max = clientSize - arrowRect [ len ] - paddingObject [ maxProp ] ;
var center = clientSize / 2 - arrowRect [ len ] / 2 + centerToReference ;
var offset = within ( min , center , max ) ; // Prevents breaking syntax highlighting...
2020-02-03 08:22:14 -05:00
var axisProp = axis ;
2021-08-26 10:37:04 -04:00
state . modifiersData [ name ] = ( _state$modifiersData$ = { } , _state$modifiersData$ [ axisProp ] = offset , _state$modifiersData$ . centerOffset = offset - center , _state$modifiersData$ ) ;
2020-02-03 08:22:14 -05:00
}
2021-08-26 10:37:04 -04:00
function effect ( _ref2 ) {
2020-02-03 08:22:14 -05:00
var state = _ref2 . state ,
2021-08-26 10:37:04 -04:00
options = _ref2 . options ;
2020-02-03 08:22:14 -05:00
var _options$element = options . element ,
2021-08-26 10:37:04 -04:00
arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element ;
if ( arrowElement == null ) {
return ;
} // CSS selector
2020-02-03 08:22:14 -05:00
if ( typeof arrowElement === 'string' ) {
arrowElement = state . elements . popper . querySelector ( arrowElement ) ;
if ( ! arrowElement ) {
return ;
}
}
2021-08-26 10:37:04 -04:00
{
if ( ! isHTMLElement ( arrowElement ) ) {
console . error ( [ 'Popper: "arrow" element must be an HTMLElement (not an SVGElement).' , 'To use an SVG arrow, wrap it in an HTMLElement that will be used as' , 'the arrow.' ] . join ( ' ' ) ) ;
}
}
2020-02-03 08:22:14 -05:00
if ( ! contains ( state . elements . popper , arrowElement ) ) {
{
console . error ( [ 'Popper: "arrow" modifier\'s `element` must be a child of the popper' , 'element.' ] . join ( ' ' ) ) ;
}
return ;
}
state . elements . arrow = arrowElement ;
2021-08-26 10:37:04 -04:00
} // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
var arrow$1 = {
name : 'arrow' ,
enabled : true ,
phase : 'main' ,
fn : arrow ,
2021-08-26 10:37:04 -04:00
effect : effect ,
2020-02-03 08:22:14 -05:00
requires : [ 'popperOffsets' ] ,
requiresIfExists : [ 'preventOverflow' ]
} ;
function getSideOffsets ( overflow , rect , preventedOffsets ) {
if ( preventedOffsets === void 0 ) {
preventedOffsets = {
x : 0 ,
y : 0
} ;
}
return {
top : overflow . top - rect . height - preventedOffsets . y ,
right : overflow . right - rect . width + preventedOffsets . x ,
bottom : overflow . bottom - rect . height + preventedOffsets . y ,
left : overflow . left - rect . width - preventedOffsets . x
} ;
}
function isAnySideFullyClipped ( overflow ) {
return [ top , right , bottom , left ] . some ( function ( side ) {
return overflow [ side ] >= 0 ;
} ) ;
}
function hide ( _ref ) {
var state = _ref . state ,
name = _ref . name ;
var referenceRect = state . rects . reference ;
var popperRect = state . rects . popper ;
var preventedOffsets = state . modifiersData . preventOverflow ;
var referenceOverflow = detectOverflow ( state , {
elementContext : 'reference'
} ) ;
var popperAltOverflow = detectOverflow ( state , {
altBoundary : true
} ) ;
var referenceClippingOffsets = getSideOffsets ( referenceOverflow , referenceRect ) ;
var popperEscapeOffsets = getSideOffsets ( popperAltOverflow , popperRect , preventedOffsets ) ;
var isReferenceHidden = isAnySideFullyClipped ( referenceClippingOffsets ) ;
var hasPopperEscaped = isAnySideFullyClipped ( popperEscapeOffsets ) ;
state . modifiersData [ name ] = {
referenceClippingOffsets : referenceClippingOffsets ,
popperEscapeOffsets : popperEscapeOffsets ,
isReferenceHidden : isReferenceHidden ,
hasPopperEscaped : hasPopperEscaped
} ;
state . attributes . popper = Object . assign ( { } , state . attributes . popper , {
'data-popper-reference-hidden' : isReferenceHidden ,
'data-popper-escaped' : hasPopperEscaped
} ) ;
2021-08-26 10:37:04 -04:00
} // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
var hide$1 = {
name : 'hide' ,
enabled : true ,
phase : 'main' ,
requiresIfExists : [ 'preventOverflow' ] ,
fn : hide
} ;
2021-08-26 10:37:04 -04:00
var defaultModifiers$1 = [ eventListeners , popperOffsets$1 , computeStyles$1 , applyStyles$1 ] ;
var createPopper$1 = /*#__PURE__*/ popperGenerator ( {
defaultModifiers : defaultModifiers$1
} ) ; // eslint-disable-next-line import/no-unused-modules
2020-02-03 08:22:14 -05:00
var defaultModifiers = [ eventListeners , popperOffsets$1 , computeStyles$1 , applyStyles$1 , offset$1 , flip$1 , preventOverflow$1 , arrow$1 , hide$1 ] ;
2021-08-26 10:37:04 -04:00
var createPopper = /*#__PURE__*/ popperGenerator ( {
2020-02-03 08:22:14 -05:00
defaultModifiers : defaultModifiers
} ) ; // eslint-disable-next-line import/no-unused-modules
2021-08-26 10:37:04 -04:00
exports . applyStyles = applyStyles$1 ;
exports . arrow = arrow$1 ;
exports . computeStyles = computeStyles$1 ;
2020-02-03 08:22:14 -05:00
exports . createPopper = createPopper ;
2021-08-26 10:37:04 -04:00
exports . createPopperLite = createPopper$1 ;
2020-02-03 08:22:14 -05:00
exports . defaultModifiers = defaultModifiers ;
2021-08-26 10:37:04 -04:00
exports . detectOverflow = detectOverflow ;
exports . eventListeners = eventListeners ;
exports . flip = flip$1 ;
exports . hide = hide$1 ;
exports . offset = offset$1 ;
2020-02-03 08:22:14 -05:00
exports . popperGenerator = popperGenerator ;
2021-08-26 10:37:04 -04:00
exports . popperOffsets = popperOffsets$1 ;
exports . preventOverflow = preventOverflow$1 ;
2020-02-03 08:22:14 -05:00
Object . defineProperty ( exports , '__esModule' , { value : true } ) ;
} ) ) ) ;
2021-01-20 08:59:34 -05:00
//# sourceMappingURL=/popper.js.map
