vendor: 5,847 bytes, lines 1-170
1/** 2 * @popperjs/core v2.11.8 - MIT License 3 */ 4 5(function (global, factory) { 6 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : 7 typeof define === 'function' && define.amd ? define(['exports'], factory) : 8 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Popper = {})); 9}(this, (function (exports) { 'use strict'; 10 11 function getWindow(node) { 12 if (node == null) { 13 return window; 14 } 15 16 if (node.toString() !== '[object Window]') { 17 var ownerDocument = node.ownerDocument; 18 return ownerDocument ? ownerDocument.defaultView || window : window; 19 } 20 21 return node; 22 } 23 24 function isElement(node) { 25 var OwnElement = getWindow(node).Element; 26 return node instanceof OwnElement || node instanceof Element; 27 } 28 29 function isHTMLElement(node) { 30 var OwnElement = getWindow(node).HTMLElement; 31 return node instanceof OwnElement || node instanceof HTMLElement; 32 } 33 34 function isShadowRoot(node) { 35 // IE 11 has no ShadowRoot 36 if (typeof ShadowRoot === 'undefined') { 37 return false; 38 } 39 40 var OwnElement = getWindow(node).ShadowRoot; 41 return node instanceof OwnElement || node instanceof ShadowRoot; 42 } 43 44 var max = Math.max; 45 var min = Math.min; 46 var round = Math.round; 47 48 function getUAString() { 49 var uaData = navigator.userAgentData; 50 51 if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) { 52 return uaData.brands.map(function (item) { 53 return item.brand + "/" + item.version; 54 }).join(' '); 55 } 56 57 return navigator.userAgent; 58 } 59 60 function isLayoutViewport() { 61 return !/^((?!chrome|android).)*safari/i.test(getUAString()); 62 } 63 64 function getBoundingClientRect(element, includeScale, isFixedStrategy) { 65 if (includeScale === void 0) { 66 includeScale = false; 67 } 68 69 if (isFixedStrategy === void 0) { 70 isFixedStrategy = false; 71 } 72 73 var clientRect = element.getBoundingClientRect(); 74 var scaleX = 1; 75 var scaleY = 1; 76 77 if (includeScale && isHTMLElement(element)) { 78 scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1; 79 scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1; 80 } 81 82 var _ref = isElement(element) ? getWindow(element) : window, 83 visualViewport = _ref.visualViewport; 84 85 var addVisualOffsets = !isLayoutViewport() && isFixedStrategy; 86 var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX; 87 var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY; 88 var width = clientRect.width / scaleX; 89 var height = clientRect.height / scaleY; 90 return { 91 width: width, 92 height: height, 93 top: y, 94 right: x + width, 95 bottom: y + height, 96 left: x, 97 x: x, 98 y: y 99 }; 100 } 101 102 function getWindowScroll(node) { 103 var win = getWindow(node); 104 var scrollLeft = win.pageXOffset; 105 var scrollTop = win.pageYOffset; 106 return { 107 scrollLeft: scrollLeft, 108 scrollTop: scrollTop 109 }; 110 } 111 112 function getHTMLElementScroll(element) { 113 return { 114 scrollLeft: element.scrollLeft, 115 scrollTop: element.scrollTop 116 }; 117 } 118 119 function getNodeScroll(node) { 120 if (node === getWindow(node) || !isHTMLElement(node)) { 121 return getWindowScroll(node); 122 } else { 123 return getHTMLElementScroll(node); 124 } 125 } 126 127 function getNodeName(element) { 128 return element ? (element.nodeName || '').toLowerCase() : null; 129 } 130 131 function getDocumentElement(element) { 132 // $FlowFixMe[incompatible-return]: assume body is always available 133 return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing] 134 element.document) || window.document).documentElement; 135 } 136 137 function getWindowScrollBarX(element) { 138 // If <html> has a CSS width greater than the viewport, then this will be 139 // incorrect for RTL. 140 // Popper 1 is broken in this case and never had a bug report so let's assume 141 // it's not an issue. I don't think anyone ever specifies width on <html> 142 // anyway. 143 // Browsers where the left scrollbar doesn't cause an issue report `0` for 144 // this (e.g. Edge 2019, IE11, Safari) 145 return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; 146 } 147 148 function getComputedStyle(element) { 149 return getWindow(element).getComputedStyle(element); 150 } 151 152 function isScrollParent(element) { 153 // Firefox wants us to check `-x` and `-y` variations as well 154 var _getComputedStyle = getComputedStyle(element), 155 overflow = _getComputedStyle.overflow, 156 overflowX = _getComputedStyle.overflowX, 157 overflowY = _getComputedStyle.overflowY; 158 159 return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); 160 } 161 162 function isElementScaled(element) { 163 var rect = element.getBoundingClientRect(); 164 var scaleX = round(rect.width) / element.offsetWidth || 1; 165 var scaleY = round(rect.height) / element.offsetHeight || 1; 166 return scaleX !== 1 || scaleY !== 1; 167 } // Returns the composite rect of an element relative to its offsetParent. 168 // Composite means it takes into account transforms as well as layout. 169 170
vendor: 8,503 bytes, lines 171-391
171 function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) { 172 if (isFixed === void 0) { 173 isFixed = false; 174 } 175 176 var isOffsetParentAnElement = isHTMLElement(offsetParent); 177 var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent); 178 var documentElement = getDocumentElement(offsetParent); 179 var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed); 180 var scroll = { 181 scrollLeft: 0, 182 scrollTop: 0 183 }; 184 var offsets = { 185 x: 0, 186 y: 0 187 }; 188 189 if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { 190 if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078 191 isScrollParent(documentElement)) { 192 scroll = getNodeScroll(offsetParent); 193 } 194 195 if (isHTMLElement(offsetParent)) { 196 offsets = getBoundingClientRect(offsetParent, true); 197 offsets.x += offsetParent.clientLeft; 198 offsets.y += offsetParent.clientTop; 199 } else if (documentElement) { 200 offsets.x = getWindowScrollBarX(documentElement); 201 } 202 } 203 204 return { 205 x: rect.left + scroll.scrollLeft - offsets.x, 206 y: rect.top + scroll.scrollTop - offsets.y, 207 width: rect.width, 208 height: rect.height 209 }; 210 } 211 212 // means it doesn't take into account transforms. 213 214 function getLayoutRect(element) { 215 var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed. 216 // Fixes https://github.com/popperjs/popper-core/issues/1223 217 218 var width = element.offsetWidth; 219 var height = element.offsetHeight; 220 221 if (Math.abs(clientRect.width - width) <= 1) { 222 width = clientRect.width; 223 } 224 225 if (Math.abs(clientRect.height - height) <= 1) { 226 height = clientRect.height; 227 } 228 229 return { 230 x: element.offsetLeft, 231 y: element.offsetTop, 232 width: width, 233 height: height 234 }; 235 } 236 237 function getParentNode(element) { 238 if (getNodeName(element) === 'html') { 239 return element; 240 } 241 242 return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle 243 // $FlowFixMe[incompatible-return] 244 // $FlowFixMe[prop-missing] 245 element.assignedSlot || // step into the shadow DOM of the parent of a slotted node 246 element.parentNode || ( // DOM Element detected 247 isShadowRoot(element) ? element.host : null) || // ShadowRoot detected 248 // $FlowFixMe[incompatible-call]: HTMLElement is a Node 249 getDocumentElement(element) // fallback 250 251 ); 252 } 253 254 function getScrollParent(node) { 255 if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) { 256 // $FlowFixMe[incompatible-return]: assume body is always available 257 return node.ownerDocument.body; 258 } 259 260 if (isHTMLElement(node) && isScrollParent(node)) { 261 return node; 262 } 263 264 return getScrollParent(getParentNode(node)); 265 } 266 267 /* 268 given a DOM element, return the list of all scroll parents, up the list of ancesors 269 until we get to the top window object. This list is what we attach scroll listeners 270 to, because if any of these parent elements scroll, we'll need to re-calculate the 271 reference element's position. 272 */ 273 274 function listScrollParents(element, list) { 275 var _element$ownerDocumen; 276 277 if (list === void 0) { 278 list = []; 279 } 280 281 var scrollParent = getScrollParent(element); 282 var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body); 283 var win = getWindow(scrollParent); 284 var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent; 285 var updatedList = list.concat(target); 286 return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here 287 updatedList.concat(listScrollParents(getParentNode(target))); 288 } 289 290 function isTableElement(element) { 291 return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0; 292 } 293 294 function getTrueOffsetParent(element) { 295 if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837 296 getComputedStyle(element).position === 'fixed') { 297 return null; 298 } 299 300 return element.offsetParent; 301 } // `.offsetParent` reports `null` for fixed elements, while absolute elements 302 // return the containing block 303 304 305 function getContainingBlock(element) { 306 var isFirefox = /firefox/i.test(getUAString()); 307 var isIE = /Trident/i.test(getUAString()); 308 309 if (isIE && isHTMLElement(element)) { 310 // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport 311 var elementCss = getComputedStyle(element); 312 313 if (elementCss.position === 'fixed') { 314 return null; 315 } 316 } 317 318 var currentNode = getParentNode(element); 319 320 if (isShadowRoot(currentNode)) { 321 currentNode = currentNode.host; 322 } 323 324 while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) { 325 var css = getComputedStyle(currentNode); // This is non-exhaustive but covers the most common CSS properties that 326 // create a containing block. 327 // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block 328 329 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') { 330 return currentNode; 331 } else { 332 currentNode = currentNode.parentNode; 333 } 334 } 335 336 return null; 337 } // Gets the closest ancestor positioned element. Handles some edge cases, 338 // such as table ancestors and cross browser bugs. 339 340 341 function getOffsetParent(element) { 342 var window = getWindow(element); 343 var offsetParent = getTrueOffsetParent(element); 344 345 while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') { 346 offsetParent = getTrueOffsetParent(offsetParent); 347 } 348 349 if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static')) { 350 return window; 351 } 352 353 return offsetParent || getContainingBlock(element) || window; 354 } 355 356 var top = 'top'; 357 var bottom = 'bottom'; 358 var right = 'right'; 359 var left = 'left'; 360 var auto = 'auto'; 361 var basePlacements = [top, bottom, right, left]; 362 var start = 'start'; 363 var end = 'end'; 364 var clippingParents = 'clippingParents'; 365 var viewport = 'viewport'; 366 var popper = 'popper'; 367 var reference = 'reference'; 368 var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) { 369 return acc.concat([placement + "-" + start, placement + "-" + end]); 370 }, []); 371 var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) { 372 return acc.concat([placement, placement + "-" + start, placement + "-" + end]); 373 }, []); // modifiers that need to read the DOM 374 375 var beforeRead = 'beforeRead'; 376 var read = 'read'; 377 var afterRead = 'afterRead'; // pure-logic modifiers 378 379 var beforeMain = 'beforeMain'; 380 var main = 'main'; 381 var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state) 382 383 var beforeWrite = 'beforeWrite'; 384 var write = 'write'; 385 var afterWrite = 'afterWrite'; 386 var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite]; 387 388 function order(modifiers) { 389 var map = new Map(); 390 var visited = new Set(); 391 var result = [];
vendor: 2,673 bytes, lines 392-472
392 modifiers.forEach(function (modifier) { 393 map.set(modifier.name, modifier); 394 }); // On visiting object, check for its dependencies and visit them recursively 395 396 function sort(modifier) { 397 visited.add(modifier.name); 398 var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []); 399 requires.forEach(function (dep) { 400 if (!visited.has(dep)) { 401 var depModifier = map.get(dep); 402 403 if (depModifier) { 404 sort(depModifier); 405 } 406 } 407 }); 408 result.push(modifier); 409 } 410 411 modifiers.forEach(function (modifier) { 412 if (!visited.has(modifier.name)) { 413 // check for visited object 414 sort(modifier); 415 } 416 }); 417 return result; 418 } 419 420 function orderModifiers(modifiers) { 421 // order based on dependencies 422 var orderedModifiers = order(modifiers); // order based on phase 423 424 return modifierPhases.reduce(function (acc, phase) { 425 return acc.concat(orderedModifiers.filter(function (modifier) { 426 return modifier.phase === phase; 427 })); 428 }, []); 429 } 430 431 function debounce(fn) { 432 var pending; 433 return function () { 434 if (!pending) { 435 pending = new Promise(function (resolve) { 436 Promise.resolve().then(function () { 437 pending = undefined; 438 resolve(fn()); 439 }); 440 }); 441 } 442 443 return pending; 444 }; 445 } 446 447 function mergeByName(modifiers) { 448 var merged = modifiers.reduce(function (merged, current) { 449 var existing = merged[current.name]; 450 merged[current.name] = existing ? Object.assign({}, existing, current, { 451 options: Object.assign({}, existing.options, current.options), 452 data: Object.assign({}, existing.data, current.data) 453 }) : current; 454 return merged; 455 }, {}); // IE11 does not support Object.values 456 457 return Object.keys(merged).map(function (key) { 458 return merged[key]; 459 }); 460 } 461 462 function getViewportRect(element, strategy) { 463 var win = getWindow(element); 464 var html = getDocumentElement(element); 465 var visualViewport = win.visualViewport; 466 var width = html.clientWidth; 467 var height = html.clientHeight; 468 var x = 0; 469 var y = 0; 470 471 if (visualViewport) { 472 width = visualViewport.width;
vendor: 4,227 bytes, lines 473-583
473 height = visualViewport.height; 474 var layoutViewport = isLayoutViewport(); 475 476 if (layoutViewport || !layoutViewport && strategy === 'fixed') { 477 x = visualViewport.offsetLeft; 478 y = visualViewport.offsetTop; 479 } 480 } 481 482 return { 483 width: width, 484 height: height, 485 x: x + getWindowScrollBarX(element), 486 y: y 487 }; 488 } 489 490 // of the `<html>` and `<body>` rect bounds if horizontally scrollable 491 492 function getDocumentRect(element) { 493 var _element$ownerDocumen; 494 495 var html = getDocumentElement(element); 496 var winScroll = getWindowScroll(element); 497 var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; 498 var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); 499 var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); 500 var x = -winScroll.scrollLeft + getWindowScrollBarX(element); 501 var y = -winScroll.scrollTop; 502 503 if (getComputedStyle(body || html).direction === 'rtl') { 504 x += max(html.clientWidth, body ? body.clientWidth : 0) - width; 505 } 506 507 return { 508 width: width, 509 height: height, 510 x: x, 511 y: y 512 }; 513 } 514 515 function contains(parent, child) { 516 var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method 517 518 if (parent.contains(child)) { 519 return true; 520 } // then fallback to custom implementation with Shadow DOM support 521 else if (rootNode && isShadowRoot(rootNode)) { 522 var next = child; 523 524 do { 525 if (next && parent.isSameNode(next)) { 526 return true; 527 } // $FlowFixMe[prop-missing]: need a better way to handle this... 528 529 530 next = next.parentNode || next.host; 531 } while (next); 532 } // Give up, the result is false 533 534 535 return false; 536 } 537 538 function rectToClientRect(rect) { 539 return Object.assign({}, rect, { 540 left: rect.x, 541 top: rect.y, 542 right: rect.x + rect.width, 543 bottom: rect.y + rect.height 544 }); 545 } 546 547 function getInnerBoundingClientRect(element, strategy) { 548 var rect = getBoundingClientRect(element, false, strategy === 'fixed'); 549 rect.top = rect.top + element.clientTop; 550 rect.left = rect.left + element.clientLeft; 551 rect.bottom = rect.top + element.clientHeight; 552 rect.right = rect.left + element.clientWidth; 553 rect.width = element.clientWidth; 554 rect.height = element.clientHeight; 555 rect.x = rect.left; 556 rect.y = rect.top; 557 return rect; 558 } 559 560 function getClientRectFromMixedType(element, clippingParent, strategy) { 561 return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element))); 562 } // A "clipping parent" is an overflowable container with the characteristic of 563 // clipping (or hiding) overflowing elements with a position different from 564 // `initial` 565 566 567 function getClippingParents(element) { 568 var clippingParents = listScrollParents(getParentNode(element)); 569 var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle(element).position) >= 0; 570 var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element; 571 572 if (!isElement(clipperElement)) { 573 return []; 574 } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414 575 576 577 return clippingParents.filter(function (clippingParent) { 578 return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body'; 579 }); 580 } // Gets the maximum area that the element is visible in due to any number of 581 // clipping parents 582 583
vendor: 9,807 bytes, lines 584-818
584 function getClippingRect(element, boundary, rootBoundary, strategy) { 585 var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary); 586 var clippingParents = [].concat(mainClippingParents, [rootBoundary]); 587 var firstClippingParent = clippingParents[0]; 588 var clippingRect = clippingParents.reduce(function (accRect, clippingParent) { 589 var rect = getClientRectFromMixedType(element, clippingParent, strategy); 590 accRect.top = max(rect.top, accRect.top); 591 accRect.right = min(rect.right, accRect.right); 592 accRect.bottom = min(rect.bottom, accRect.bottom); 593 accRect.left = max(rect.left, accRect.left); 594 return accRect; 595 }, getClientRectFromMixedType(element, firstClippingParent, strategy)); 596 clippingRect.width = clippingRect.right - clippingRect.left; 597 clippingRect.height = clippingRect.bottom - clippingRect.top; 598 clippingRect.x = clippingRect.left; 599 clippingRect.y = clippingRect.top; 600 return clippingRect; 601 } 602 603 function getBasePlacement(placement) { 604 return placement.split('-')[0]; 605 } 606 607 function getVariation(placement) { 608 return placement.split('-')[1]; 609 } 610 611 function getMainAxisFromPlacement(placement) { 612 return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y'; 613 } 614 615 function computeOffsets(_ref) { 616 var reference = _ref.reference, 617 element = _ref.element, 618 placement = _ref.placement; 619 var basePlacement = placement ? getBasePlacement(placement) : null; 620 var variation = placement ? getVariation(placement) : null; 621 var commonX = reference.x + reference.width / 2 - element.width / 2; 622 var commonY = reference.y + reference.height / 2 - element.height / 2; 623 var offsets; 624 625 switch (basePlacement) { 626 case top: 627 offsets = { 628 x: commonX, 629 y: reference.y - element.height 630 }; 631 break; 632 633 case bottom: 634 offsets = { 635 x: commonX, 636 y: reference.y + reference.height 637 }; 638 break; 639 640 case right: 641 offsets = { 642 x: reference.x + reference.width, 643 y: commonY 644 }; 645 break; 646 647 case left: 648 offsets = { 649 x: reference.x - element.width, 650 y: commonY 651 }; 652 break; 653 654 default: 655 offsets = { 656 x: reference.x, 657 y: reference.y 658 }; 659 } 660 661 var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; 662 663 if (mainAxis != null) { 664 var len = mainAxis === 'y' ? 'height' : 'width'; 665 666 switch (variation) { 667 case start: 668 offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2); 669 break; 670 671 case end: 672 offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2); 673 break; 674 } 675 } 676 677 return offsets; 678 } 679 680 function getFreshSideObject() { 681 return { 682 top: 0, 683 right: 0, 684 bottom: 0, 685 left: 0 686 }; 687 } 688 689 function mergePaddingObject(paddingObject) { 690 return Object.assign({}, getFreshSideObject(), paddingObject); 691 } 692 693 function expandToHashMap(value, keys) { 694 return keys.reduce(function (hashMap, key) { 695 hashMap[key] = value; 696 return hashMap; 697 }, {}); 698 } 699 700 function detectOverflow(state, options) { 701 if (options === void 0) { 702 options = {}; 703 } 704 705 var _options = options, 706 _options$placement = _options.placement, 707 placement = _options$placement === void 0 ? state.placement : _options$placement, 708 _options$strategy = _options.strategy, 709 strategy = _options$strategy === void 0 ? state.strategy : _options$strategy, 710 _options$boundary = _options.boundary, 711 boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, 712 _options$rootBoundary = _options.rootBoundary, 713 rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, 714 _options$elementConte = _options.elementContext, 715 elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, 716 _options$altBoundary = _options.altBoundary, 717 altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, 718 _options$padding = _options.padding, 719 padding = _options$padding === void 0 ? 0 : _options$padding; 720 var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); 721 var altContext = elementContext === popper ? reference : popper; 722 var popperRect = state.rects.popper; 723 var element = state.elements[altBoundary ? altContext : elementContext]; 724 var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy); 725 var referenceClientRect = getBoundingClientRect(state.elements.reference); 726 var popperOffsets = computeOffsets({ 727 reference: referenceClientRect, 728 element: popperRect, 729 strategy: 'absolute', 730 placement: placement 731 }); 732 var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets)); 733 var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect 734 // 0 or negative = within the clipping rect 735 736 var overflowOffsets = { 737 top: clippingClientRect.top - elementClientRect.top + paddingObject.top, 738 bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom, 739 left: clippingClientRect.left - elementClientRect.left + paddingObject.left, 740 right: elementClientRect.right - clippingClientRect.right + paddingObject.right 741 }; 742 var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element 743 744 if (elementContext === popper && offsetData) { 745 var offset = offsetData[placement]; 746 Object.keys(overflowOffsets).forEach(function (key) { 747 var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1; 748 var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x'; 749 overflowOffsets[key] += offset[axis] * multiply; 750 }); 751 } 752 753 return overflowOffsets; 754 } 755 756 var DEFAULT_OPTIONS = { 757 placement: 'bottom', 758 modifiers: [], 759 strategy: 'absolute' 760 }; 761 762 function areValidElements() { 763 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 764 args[_key] = arguments[_key]; 765 } 766 767 return !args.some(function (element) { 768 return !(element && typeof element.getBoundingClientRect === 'function'); 769 }); 770 } 771 772 function popperGenerator(generatorOptions) { 773 if (generatorOptions === void 0) { 774 generatorOptions = {}; 775 } 776 777 var _generatorOptions = generatorOptions, 778 _generatorOptions$def = _generatorOptions.defaultModifiers, 779 defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, 780 _generatorOptions$def2 = _generatorOptions.defaultOptions, 781 defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2; 782 return function createPopper(reference, popper, options) { 783 if (options === void 0) { 784 options = defaultOptions; 785 } 786 787 var state = { 788 placement: 'bottom', 789 orderedModifiers: [], 790 options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions), 791 modifiersData: {}, 792 elements: { 793 reference: reference, 794 popper: popper 795 }, 796 attributes: {}, 797 styles: {} 798 }; 799 var effectCleanupFns = []; 800 var isDestroyed = false; 801 var instance = { 802 state: state, 803 setOptions: function setOptions(setOptionsAction) { 804 var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction; 805 cleanupModifierEffects(); 806 state.options = Object.assign({}, defaultOptions, state.options, options); 807 state.scrollParents = { 808 reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [], 809 popper: listScrollParents(popper) 810 }; // Orders the modifiers based on their dependencies and `phase` 811 // properties 812 813 var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers 814 815 state.orderedModifiers = orderedModifiers.filter(function (m) { 816 return m.enabled; 817 }); 818 runModifierEffects();
vendor: 4,634 bytes, lines 819-911
819 return instance.update(); 820 }, 821 // Sync update â it will always be executed, even if not necessary. This 822 // is useful for low frequency updates where sync behavior simplifies the 823 // logic. 824 // For high frequency updates (e.g. `resize` and `scroll` events), always 825 // prefer the async Popper#update method 826 forceUpdate: function forceUpdate() { 827 if (isDestroyed) { 828 return; 829 } 830 831 var _state$elements = state.elements, 832 reference = _state$elements.reference, 833 popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements 834 // anymore 835 836 if (!areValidElements(reference, popper)) { 837 return; 838 } // Store the reference and popper rects to be read by modifiers 839 840 841 state.rects = { 842 reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'), 843 popper: getLayoutRect(popper) 844 }; // Modifiers have the ability to reset the current update cycle. The 845 // most common use case for this is the `flip` modifier changing the 846 // placement, which then needs to re-run all the modifiers, because the 847 // logic was previously ran for the previous placement and is therefore 848 // stale/incorrect 849 850 state.reset = false; 851 state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier 852 // is filled with the initial data specified by the modifier. This means 853 // it doesn't persist and is fresh on each update. 854 // To ensure persistent data, use `${name}#persistent` 855 856 state.orderedModifiers.forEach(function (modifier) { 857 return state.modifiersData[modifier.name] = Object.assign({}, modifier.data); 858 }); 859 860 for (var index = 0; index < state.orderedModifiers.length; index++) { 861 if (state.reset === true) { 862 state.reset = false; 863 index = -1; 864 continue; 865 } 866 867 var _state$orderedModifie = state.orderedModifiers[index], 868 fn = _state$orderedModifie.fn, 869 _state$orderedModifie2 = _state$orderedModifie.options, 870 _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, 871 name = _state$orderedModifie.name; 872 873 if (typeof fn === 'function') { 874 state = fn({ 875 state: state, 876 options: _options, 877 name: name, 878 instance: instance 879 }) || state; 880 } 881 } 882 }, 883 // Async and optimistically optimized update â it will not be executed if 884 // not necessary (debounced to run at most once-per-tick) 885 update: debounce(function () { 886 return new Promise(function (resolve) { 887 instance.forceUpdate(); 888 resolve(state); 889 }); 890 }), 891 destroy: function destroy() { 892 cleanupModifierEffects(); 893 isDestroyed = true; 894 } 895 }; 896 897 if (!areValidElements(reference, popper)) { 898 return instance; 899 } 900 901 instance.setOptions(options).then(function (state) { 902 if (!isDestroyed && options.onFirstUpdate) { 903 options.onFirstUpdate(state); 904 } 905 }); // Modifiers have the ability to execute arbitrary code before the first 906 // update cycle runs. They will be executed in the same order as the update 907 // cycle. This is useful when a modifier adds some persistent data that 908 // other modifiers need to use, but the modifier is run after the dependent 909 // one. 910 911 function runModifierEffects() {
vendor: 9,616 bytes, lines 912-1180
912 state.orderedModifiers.forEach(function (_ref) { 913 var name = _ref.name, 914 _ref$options = _ref.options, 915 options = _ref$options === void 0 ? {} : _ref$options, 916 effect = _ref.effect; 917 918 if (typeof effect === 'function') { 919 var cleanupFn = effect({ 920 state: state, 921 name: name, 922 instance: instance, 923 options: options 924 }); 925 926 var noopFn = function noopFn() {}; 927 928 effectCleanupFns.push(cleanupFn || noopFn); 929 } 930 }); 931 } 932 933 function cleanupModifierEffects() { 934 effectCleanupFns.forEach(function (fn) { 935 return fn(); 936 }); 937 effectCleanupFns = []; 938 } 939 940 return instance; 941 }; 942 } 943 944 var passive = { 945 passive: true 946 }; 947 948 function effect$2(_ref) { 949 var state = _ref.state, 950 instance = _ref.instance, 951 options = _ref.options; 952 var _options$scroll = options.scroll, 953 scroll = _options$scroll === void 0 ? true : _options$scroll, 954 _options$resize = options.resize, 955 resize = _options$resize === void 0 ? true : _options$resize; 956 var window = getWindow(state.elements.popper); 957 var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); 958 959 if (scroll) { 960 scrollParents.forEach(function (scrollParent) { 961 scrollParent.addEventListener('scroll', instance.update, passive); 962 }); 963 } 964 965 if (resize) { 966 window.addEventListener('resize', instance.update, passive); 967 } 968 969 return function () { 970 if (scroll) { 971 scrollParents.forEach(function (scrollParent) { 972 scrollParent.removeEventListener('scroll', instance.update, passive); 973 }); 974 } 975 976 if (resize) { 977 window.removeEventListener('resize', instance.update, passive); 978 } 979 }; 980 } // eslint-disable-next-line import/no-unused-modules 981 982 983 var eventListeners = { 984 name: 'eventListeners', 985 enabled: true, 986 phase: 'write', 987 fn: function fn() {}, 988 effect: effect$2, 989 data: {} 990 }; 991 992 function popperOffsets(_ref) { 993 var state = _ref.state, 994 name = _ref.name; 995 // Offsets are the actual position the popper needs to have to be 996 // properly positioned near its reference element 997 // This is the most basic placement, and will be adjusted by 998 // the modifiers in the next step 999 state.modifiersData[name] = computeOffsets({ 1000 reference: state.rects.reference, 1001 element: state.rects.popper, 1002 strategy: 'absolute', 1003 placement: state.placement 1004 }); 1005 } // eslint-disable-next-line import/no-unused-modules 1006 1007 1008 var popperOffsets$1 = { 1009 name: 'popperOffsets', 1010 enabled: true, 1011 phase: 'read', 1012 fn: popperOffsets, 1013 data: {} 1014 }; 1015 1016 var unsetSides = { 1017 top: 'auto', 1018 right: 'auto', 1019 bottom: 'auto', 1020 left: 'auto' 1021 }; // Round the offsets to the nearest suitable subpixel based on the DPR. 1022 // Zooming can change the DPR, but it seems to report a value that will 1023 // cleanly divide the values into the appropriate subpixels. 1024 1025 function roundOffsetsByDPR(_ref, win) { 1026 var x = _ref.x, 1027 y = _ref.y; 1028 var dpr = win.devicePixelRatio || 1; 1029 return { 1030 x: round(x * dpr) / dpr || 0, 1031 y: round(y * dpr) / dpr || 0 1032 }; 1033 } 1034 1035 function mapToStyles(_ref2) { 1036 var _Object$assign2; 1037 1038 var popper = _ref2.popper, 1039 popperRect = _ref2.popperRect, 1040 placement = _ref2.placement, 1041 variation = _ref2.variation, 1042 offsets = _ref2.offsets, 1043 position = _ref2.position, 1044 gpuAcceleration = _ref2.gpuAcceleration, 1045 adaptive = _ref2.adaptive, 1046 roundOffsets = _ref2.roundOffsets, 1047 isFixed = _ref2.isFixed; 1048 var _offsets$x = offsets.x, 1049 x = _offsets$x === void 0 ? 0 : _offsets$x, 1050 _offsets$y = offsets.y, 1051 y = _offsets$y === void 0 ? 0 : _offsets$y; 1052 1053 var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({ 1054 x: x, 1055 y: y 1056 }) : { 1057 x: x, 1058 y: y 1059 }; 1060 1061 x = _ref3.x; 1062 y = _ref3.y; 1063 var hasX = offsets.hasOwnProperty('x'); 1064 var hasY = offsets.hasOwnProperty('y'); 1065 var sideX = left; 1066 var sideY = top; 1067 var win = window; 1068 1069 if (adaptive) { 1070 var offsetParent = getOffsetParent(popper); 1071 var heightProp = 'clientHeight'; 1072 var widthProp = 'clientWidth'; 1073 1074 if (offsetParent === getWindow(popper)) { 1075 offsetParent = getDocumentElement(popper); 1076 1077 if (getComputedStyle(offsetParent).position !== 'static' && position === 'absolute') { 1078 heightProp = 'scrollHeight'; 1079 widthProp = 'scrollWidth'; 1080 } 1081 } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it 1082 1083 1084 offsetParent = offsetParent; 1085 1086 if (placement === top || (placement === left || placement === right) && variation === end) { 1087 sideY = bottom; 1088 var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing] 1089 offsetParent[heightProp]; 1090 y -= offsetY - popperRect.height; 1091 y *= gpuAcceleration ? 1 : -1; 1092 } 1093 1094 if (placement === left || (placement === top || placement === bottom) && variation === end) { 1095 sideX = right; 1096 var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing] 1097 offsetParent[widthProp]; 1098 x -= offsetX - popperRect.width; 1099 x *= gpuAcceleration ? 1 : -1; 1100 } 1101 } 1102 1103 var commonStyles = Object.assign({ 1104 position: position 1105 }, adaptive && unsetSides); 1106 1107 var _ref4 = roundOffsets === true ? roundOffsetsByDPR({ 1108 x: x, 1109 y: y 1110 }, getWindow(popper)) : { 1111 x: x, 1112 y: y 1113 }; 1114 1115 x = _ref4.x; 1116 y = _ref4.y; 1117 1118 if (gpuAcceleration) { 1119 var _Object$assign; 1120 1121 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)); 1122 } 1123 1124 return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2)); 1125 } 1126 1127 function computeStyles(_ref5) { 1128 var state = _ref5.state, 1129 options = _ref5.options; 1130 var _options$gpuAccelerat = options.gpuAcceleration, 1131 gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, 1132 _options$adaptive = options.adaptive, 1133 adaptive = _options$adaptive === void 0 ? true : _options$adaptive, 1134 _options$roundOffsets = options.roundOffsets, 1135 roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets; 1136 var commonStyles = { 1137 placement: getBasePlacement(state.placement), 1138 variation: getVariation(state.placement), 1139 popper: state.elements.popper, 1140 popperRect: state.rects.popper, 1141 gpuAcceleration: gpuAcceleration, 1142 isFixed: state.options.strategy === 'fixed' 1143 }; 1144 1145 if (state.modifiersData.popperOffsets != null) { 1146 state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, { 1147 offsets: state.modifiersData.popperOffsets, 1148 position: state.options.strategy, 1149 adaptive: adaptive, 1150 roundOffsets: roundOffsets 1151 }))); 1152 } 1153 1154 if (state.modifiersData.arrow != null) { 1155 state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, { 1156 offsets: state.modifiersData.arrow, 1157 position: 'absolute', 1158 adaptive: false, 1159 roundOffsets: roundOffsets 1160 }))); 1161 } 1162 1163 state.attributes.popper = Object.assign({}, state.attributes.popper, { 1164 'data-popper-placement': state.placement 1165 }); 1166 } // eslint-disable-next-line import/no-unused-modules 1167 1168 1169 var computeStyles$1 = { 1170 name: 'computeStyles', 1171 enabled: true, 1172 phase: 'beforeWrite', 1173 fn: computeStyles, 1174 data: {} 1175 }; 1176 1177 // and applies them to the HTMLElements such as popper and arrow 1178 1179 function applyStyles(_ref) { 1180 var state = _ref.state;
vendor: 25,581 bytes, lines 1181-1824
1181 Object.keys(state.elements).forEach(function (name) { 1182 var style = state.styles[name] || {}; 1183 var attributes = state.attributes[name] || {}; 1184 var element = state.elements[name]; // arrow is optional + virtual elements 1185 1186 if (!isHTMLElement(element) || !getNodeName(element)) { 1187 return; 1188 } // Flow doesn't support to extend this property, but it's the most 1189 // effective way to apply styles to an HTMLElement 1190 // $FlowFixMe[cannot-write] 1191 1192 1193 Object.assign(element.style, style); 1194 Object.keys(attributes).forEach(function (name) { 1195 var value = attributes[name]; 1196 1197 if (value === false) { 1198 element.removeAttribute(name); 1199 } else { 1200 element.setAttribute(name, value === true ? '' : value); 1201 } 1202 }); 1203 }); 1204 } 1205 1206 function effect$1(_ref2) { 1207 var state = _ref2.state; 1208 var initialStyles = { 1209 popper: { 1210 position: state.options.strategy, 1211 left: '0', 1212 top: '0', 1213 margin: '0' 1214 }, 1215 arrow: { 1216 position: 'absolute' 1217 }, 1218 reference: {} 1219 }; 1220 Object.assign(state.elements.popper.style, initialStyles.popper); 1221 state.styles = initialStyles; 1222 1223 if (state.elements.arrow) { 1224 Object.assign(state.elements.arrow.style, initialStyles.arrow); 1225 } 1226 1227 return function () { 1228 Object.keys(state.elements).forEach(function (name) { 1229 var element = state.elements[name]; 1230 var attributes = state.attributes[name] || {}; 1231 var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them 1232 1233 var style = styleProperties.reduce(function (style, property) { 1234 style[property] = ''; 1235 return style; 1236 }, {}); // arrow is optional + virtual elements 1237 1238 if (!isHTMLElement(element) || !getNodeName(element)) { 1239 return; 1240 } 1241 1242 Object.assign(element.style, style); 1243 Object.keys(attributes).forEach(function (attribute) { 1244 element.removeAttribute(attribute); 1245 }); 1246 }); 1247 }; 1248 } // eslint-disable-next-line import/no-unused-modules 1249 1250 1251 var applyStyles$1 = { 1252 name: 'applyStyles', 1253 enabled: true, 1254 phase: 'write', 1255 fn: applyStyles, 1256 effect: effect$1, 1257 requires: ['computeStyles'] 1258 }; 1259 1260 function distanceAndSkiddingToXY(placement, rects, offset) { 1261 var basePlacement = getBasePlacement(placement); 1262 var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1; 1263 1264 var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, { 1265 placement: placement 1266 })) : offset, 1267 skidding = _ref[0], 1268 distance = _ref[1]; 1269 1270 skidding = skidding || 0; 1271 distance = (distance || 0) * invertDistance; 1272 return [left, right].indexOf(basePlacement) >= 0 ? { 1273 x: distance, 1274 y: skidding 1275 } : { 1276 x: skidding, 1277 y: distance 1278 }; 1279 } 1280 1281 function offset(_ref2) { 1282 var state = _ref2.state, 1283 options = _ref2.options, 1284 name = _ref2.name; 1285 var _options$offset = options.offset, 1286 offset = _options$offset === void 0 ? [0, 0] : _options$offset; 1287 var data = placements.reduce(function (acc, placement) { 1288 acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset); 1289 return acc; 1290 }, {}); 1291 var _data$state$placement = data[state.placement], 1292 x = _data$state$placement.x, 1293 y = _data$state$placement.y; 1294 1295 if (state.modifiersData.popperOffsets != null) { 1296 state.modifiersData.popperOffsets.x += x; 1297 state.modifiersData.popperOffsets.y += y; 1298 } 1299 1300 state.modifiersData[name] = data; 1301 } // eslint-disable-next-line import/no-unused-modules 1302 1303 1304 var offset$1 = { 1305 name: 'offset', 1306 enabled: true, 1307 phase: 'main', 1308 requires: ['popperOffsets'], 1309 fn: offset 1310 }; 1311 1312 var hash$1 = { 1313 left: 'right', 1314 right: 'left', 1315 bottom: 'top', 1316 top: 'bottom' 1317 }; 1318 function getOppositePlacement(placement) { 1319 return placement.replace(/left|right|bottom|top/g, function (matched) { 1320 return hash$1[matched]; 1321 }); 1322 } 1323 1324 var hash = { 1325 start: 'end', 1326 end: 'start' 1327 }; 1328 function getOppositeVariationPlacement(placement) { 1329 return placement.replace(/start|end/g, function (matched) { 1330 return hash[matched]; 1331 }); 1332 } 1333 1334 function computeAutoPlacement(state, options) { 1335 if (options === void 0) { 1336 options = {}; 1337 } 1338 1339 var _options = options, 1340 placement = _options.placement, 1341 boundary = _options.boundary, 1342 rootBoundary = _options.rootBoundary, 1343 padding = _options.padding, 1344 flipVariations = _options.flipVariations, 1345 _options$allowedAutoP = _options.allowedAutoPlacements, 1346 allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP; 1347 var variation = getVariation(placement); 1348 var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) { 1349 return getVariation(placement) === variation; 1350 }) : basePlacements; 1351 var allowedPlacements = placements$1.filter(function (placement) { 1352 return allowedAutoPlacements.indexOf(placement) >= 0; 1353 }); 1354 1355 if (allowedPlacements.length === 0) { 1356 allowedPlacements = placements$1; 1357 } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions... 1358 1359 1360 var overflows = allowedPlacements.reduce(function (acc, placement) { 1361 acc[placement] = detectOverflow(state, { 1362 placement: placement, 1363 boundary: boundary, 1364 rootBoundary: rootBoundary, 1365 padding: padding 1366 })[getBasePlacement(placement)]; 1367 return acc; 1368 }, {}); 1369 return Object.keys(overflows).sort(function (a, b) { 1370 return overflows[a] - overflows[b]; 1371 }); 1372 } 1373 1374 function getExpandedFallbackPlacements(placement) { 1375 if (getBasePlacement(placement) === auto) { 1376 return []; 1377 } 1378 1379 var oppositePlacement = getOppositePlacement(placement); 1380 return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)]; 1381 } 1382 1383 function flip(_ref) { 1384 var state = _ref.state, 1385 options = _ref.options, 1386 name = _ref.name; 1387 1388 if (state.modifiersData[name]._skip) { 1389 return; 1390 } 1391 1392 var _options$mainAxis = options.mainAxis, 1393 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, 1394 _options$altAxis = options.altAxis, 1395 checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, 1396 specifiedFallbackPlacements = options.fallbackPlacements, 1397 padding = options.padding, 1398 boundary = options.boundary, 1399 rootBoundary = options.rootBoundary, 1400 altBoundary = options.altBoundary, 1401 _options$flipVariatio = options.flipVariations, 1402 flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, 1403 allowedAutoPlacements = options.allowedAutoPlacements; 1404 var preferredPlacement = state.options.placement; 1405 var basePlacement = getBasePlacement(preferredPlacement); 1406 var isBasePlacement = basePlacement === preferredPlacement; 1407 var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement)); 1408 var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) { 1409 return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, { 1410 placement: placement, 1411 boundary: boundary, 1412 rootBoundary: rootBoundary, 1413 padding: padding, 1414 flipVariations: flipVariations, 1415 allowedAutoPlacements: allowedAutoPlacements 1416 }) : placement); 1417 }, []); 1418 var referenceRect = state.rects.reference; 1419 var popperRect = state.rects.popper; 1420 var checksMap = new Map(); 1421 var makeFallbackChecks = true; 1422 var firstFittingPlacement = placements[0]; 1423 1424 for (var i = 0; i < placements.length; i++) { 1425 var placement = placements[i]; 1426 1427 var _basePlacement = getBasePlacement(placement); 1428 1429 var isStartVariation = getVariation(placement) === start; 1430 var isVertical = [top, bottom].indexOf(_basePlacement) >= 0; 1431 var len = isVertical ? 'width' : 'height'; 1432 var overflow = detectOverflow(state, { 1433 placement: placement, 1434 boundary: boundary, 1435 rootBoundary: rootBoundary, 1436 altBoundary: altBoundary, 1437 padding: padding 1438 }); 1439 var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top; 1440 1441 if (referenceRect[len] > popperRect[len]) { 1442 mainVariationSide = getOppositePlacement(mainVariationSide); 1443 } 1444 1445 var altVariationSide = getOppositePlacement(mainVariationSide); 1446 var checks = []; 1447 1448 if (checkMainAxis) { 1449 checks.push(overflow[_basePlacement] <= 0); 1450 } 1451 1452 if (checkAltAxis) { 1453 checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0); 1454 } 1455 1456 if (checks.every(function (check) { 1457 return check; 1458 })) { 1459 firstFittingPlacement = placement; 1460 makeFallbackChecks = false; 1461 break; 1462 } 1463 1464 checksMap.set(placement, checks); 1465 } 1466 1467 if (makeFallbackChecks) { 1468 // `2` may be desired in some cases â research later 1469 var numberOfChecks = flipVariations ? 3 : 1; 1470 1471 var _loop = function _loop(_i) { 1472 var fittingPlacement = placements.find(function (placement) { 1473 var checks = checksMap.get(placement); 1474 1475 if (checks) { 1476 return checks.slice(0, _i).every(function (check) { 1477 return check; 1478 }); 1479 } 1480 }); 1481 1482 if (fittingPlacement) { 1483 firstFittingPlacement = fittingPlacement; 1484 return "break"; 1485 } 1486 }; 1487 1488 for (var _i = numberOfChecks; _i > 0; _i--) { 1489 var _ret = _loop(_i); 1490 1491 if (_ret === "break") break; 1492 } 1493 } 1494 1495 if (state.placement !== firstFittingPlacement) { 1496 state.modifiersData[name]._skip = true; 1497 state.placement = firstFittingPlacement; 1498 state.reset = true; 1499 } 1500 } // eslint-disable-next-line import/no-unused-modules 1501 1502 1503 var flip$1 = { 1504 name: 'flip', 1505 enabled: true, 1506 phase: 'main', 1507 fn: flip, 1508 requiresIfExists: ['offset'], 1509 data: { 1510 _skip: false 1511 } 1512 }; 1513 1514 function getAltAxis(axis) { 1515 return axis === 'x' ? 'y' : 'x'; 1516 } 1517 1518 function within(min$1, value, max$1) { 1519 return max(min$1, min(value, max$1)); 1520 } 1521 function withinMaxClamp(min, value, max) { 1522 var v = within(min, value, max); 1523 return v > max ? max : v; 1524 } 1525 1526 function preventOverflow(_ref) { 1527 var state = _ref.state, 1528 options = _ref.options, 1529 name = _ref.name; 1530 var _options$mainAxis = options.mainAxis, 1531 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, 1532 _options$altAxis = options.altAxis, 1533 checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, 1534 boundary = options.boundary, 1535 rootBoundary = options.rootBoundary, 1536 altBoundary = options.altBoundary, 1537 padding = options.padding, 1538 _options$tether = options.tether, 1539 tether = _options$tether === void 0 ? true : _options$tether, 1540 _options$tetherOffset = options.tetherOffset, 1541 tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset; 1542 var overflow = detectOverflow(state, { 1543 boundary: boundary, 1544 rootBoundary: rootBoundary, 1545 padding: padding, 1546 altBoundary: altBoundary 1547 }); 1548 var basePlacement = getBasePlacement(state.placement); 1549 var variation = getVariation(state.placement); 1550 var isBasePlacement = !variation; 1551 var mainAxis = getMainAxisFromPlacement(basePlacement); 1552 var altAxis = getAltAxis(mainAxis); 1553 var popperOffsets = state.modifiersData.popperOffsets; 1554 var referenceRect = state.rects.reference; 1555 var popperRect = state.rects.popper; 1556 var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, { 1557 placement: state.placement 1558 })) : tetherOffset; 1559 var normalizedTetherOffsetValue = typeof tetherOffsetValue === 'number' ? { 1560 mainAxis: tetherOffsetValue, 1561 altAxis: tetherOffsetValue 1562 } : Object.assign({ 1563 mainAxis: 0, 1564 altAxis: 0 1565 }, tetherOffsetValue); 1566 var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null; 1567 var data = { 1568 x: 0, 1569 y: 0 1570 }; 1571 1572 if (!popperOffsets) { 1573 return; 1574 } 1575 1576 if (checkMainAxis) { 1577 var _offsetModifierState$; 1578 1579 var mainSide = mainAxis === 'y' ? top : left; 1580 var altSide = mainAxis === 'y' ? bottom : right; 1581 var len = mainAxis === 'y' ? 'height' : 'width'; 1582 var offset = popperOffsets[mainAxis]; 1583 var min$1 = offset + overflow[mainSide]; 1584 var max$1 = offset - overflow[altSide]; 1585 var additive = tether ? -popperRect[len] / 2 : 0; 1586 var minLen = variation === start ? referenceRect[len] : popperRect[len]; 1587 var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go 1588 // outside the reference bounds 1589 1590 var arrowElement = state.elements.arrow; 1591 var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : { 1592 width: 0, 1593 height: 0 1594 }; 1595 var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject(); 1596 var arrowPaddingMin = arrowPaddingObject[mainSide]; 1597 var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want 1598 // to include its full size in the calculation. If the reference is small 1599 // and near the edge of a boundary, the popper can overflow even if the 1600 // reference is not overflowing as well (e.g. virtual elements with no 1601 // width or height) 1602 1603 var arrowLen = within(0, referenceRect[len], arrowRect[len]); 1604 var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis; 1605 var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis; 1606 var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow); 1607 var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0; 1608 var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0; 1609 var tetherMin = offset + minOffset - offsetModifierValue - clientOffset; 1610 var tetherMax = offset + maxOffset - offsetModifierValue; 1611 var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1); 1612 popperOffsets[mainAxis] = preventedOffset; 1613 data[mainAxis] = preventedOffset - offset; 1614 } 1615 1616 if (checkAltAxis) { 1617 var _offsetModifierState$2; 1618 1619 var _mainSide = mainAxis === 'x' ? top : left; 1620 1621 var _altSide = mainAxis === 'x' ? bottom : right; 1622 1623 var _offset = popperOffsets[altAxis]; 1624 1625 var _len = altAxis === 'y' ? 'height' : 'width'; 1626 1627 var _min = _offset + overflow[_mainSide]; 1628 1629 var _max = _offset - overflow[_altSide]; 1630 1631 var isOriginSide = [top, left].indexOf(basePlacement) !== -1; 1632 1633 var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0; 1634 1635 var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis; 1636 1637 var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max; 1638 1639 var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max); 1640 1641 popperOffsets[altAxis] = _preventedOffset; 1642 data[altAxis] = _preventedOffset - _offset; 1643 } 1644 1645 state.modifiersData[name] = data; 1646 } // eslint-disable-next-line import/no-unused-modules 1647 1648 1649 var preventOverflow$1 = { 1650 name: 'preventOverflow', 1651 enabled: true, 1652 phase: 'main', 1653 fn: preventOverflow, 1654 requiresIfExists: ['offset'] 1655 }; 1656 1657 var toPaddingObject = function toPaddingObject(padding, state) { 1658 padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, { 1659 placement: state.placement 1660 })) : padding; 1661 return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); 1662 }; 1663 1664 function arrow(_ref) { 1665 var _state$modifiersData$; 1666 1667 var state = _ref.state, 1668 name = _ref.name, 1669 options = _ref.options; 1670 var arrowElement = state.elements.arrow; 1671 var popperOffsets = state.modifiersData.popperOffsets; 1672 var basePlacement = getBasePlacement(state.placement); 1673 var axis = getMainAxisFromPlacement(basePlacement); 1674 var isVertical = [left, right].indexOf(basePlacement) >= 0; 1675 var len = isVertical ? 'height' : 'width'; 1676 1677 if (!arrowElement || !popperOffsets) { 1678 return; 1679 } 1680 1681 var paddingObject = toPaddingObject(options.padding, state); 1682 var arrowRect = getLayoutRect(arrowElement); 1683 var minProp = axis === 'y' ? top : left; 1684 var maxProp = axis === 'y' ? bottom : right; 1685 var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len]; 1686 var startDiff = popperOffsets[axis] - state.rects.reference[axis]; 1687 var arrowOffsetParent = getOffsetParent(arrowElement); 1688 var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0; 1689 var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is 1690 // outside of the popper bounds 1691 1692 var min = paddingObject[minProp]; 1693 var max = clientSize - arrowRect[len] - paddingObject[maxProp]; 1694 var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference; 1695 var offset = within(min, center, max); // Prevents breaking syntax highlighting... 1696 1697 var axisProp = axis; 1698 state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$); 1699 } 1700 1701 function effect(_ref2) { 1702 var state = _ref2.state, 1703 options = _ref2.options; 1704 var _options$element = options.element, 1705 arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element; 1706 1707 if (arrowElement == null) { 1708 return; 1709 } // CSS selector 1710 1711 1712 if (typeof arrowElement === 'string') { 1713 arrowElement = state.elements.popper.querySelector(arrowElement); 1714 1715 if (!arrowElement) { 1716 return; 1717 } 1718 } 1719 1720 if (!contains(state.elements.popper, arrowElement)) { 1721 return; 1722 } 1723 1724 state.elements.arrow = arrowElement; 1725 } // eslint-disable-next-line import/no-unused-modules 1726 1727 1728 var arrow$1 = { 1729 name: 'arrow', 1730 enabled: true, 1731 phase: 'main', 1732 fn: arrow, 1733 effect: effect, 1734 requires: ['popperOffsets'], 1735 requiresIfExists: ['preventOverflow'] 1736 }; 1737 1738 function getSideOffsets(overflow, rect, preventedOffsets) { 1739 if (preventedOffsets === void 0) { 1740 preventedOffsets = { 1741 x: 0, 1742 y: 0 1743 }; 1744 } 1745 1746 return { 1747 top: overflow.top - rect.height - preventedOffsets.y, 1748 right: overflow.right - rect.width + preventedOffsets.x, 1749 bottom: overflow.bottom - rect.height + preventedOffsets.y, 1750 left: overflow.left - rect.width - preventedOffsets.x 1751 }; 1752 } 1753 1754 function isAnySideFullyClipped(overflow) { 1755 return [top, right, bottom, left].some(function (side) { 1756 return overflow[side] >= 0; 1757 }); 1758 } 1759 1760 function hide(_ref) { 1761 var state = _ref.state, 1762 name = _ref.name; 1763 var referenceRect = state.rects.reference; 1764 var popperRect = state.rects.popper; 1765 var preventedOffsets = state.modifiersData.preventOverflow; 1766 var referenceOverflow = detectOverflow(state, { 1767 elementContext: 'reference' 1768 }); 1769 var popperAltOverflow = detectOverflow(state, { 1770 altBoundary: true 1771 }); 1772 var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect); 1773 var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets); 1774 var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets); 1775 var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); 1776 state.modifiersData[name] = { 1777 referenceClippingOffsets: referenceClippingOffsets, 1778 popperEscapeOffsets: popperEscapeOffsets, 1779 isReferenceHidden: isReferenceHidden, 1780 hasPopperEscaped: hasPopperEscaped 1781 }; 1782 state.attributes.popper = Object.assign({}, state.attributes.popper, { 1783 'data-popper-reference-hidden': isReferenceHidden, 1784 'data-popper-escaped': hasPopperEscaped 1785 }); 1786 } // eslint-disable-next-line import/no-unused-modules 1787 1788 1789 var hide$1 = { 1790 name: 'hide', 1791 enabled: true, 1792 phase: 'main', 1793 requiresIfExists: ['preventOverflow'], 1794 fn: hide 1795 }; 1796 1797 var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1]; 1798 var createPopper$1 = /*#__PURE__*/popperGenerator({ 1799 defaultModifiers: defaultModifiers$1 1800 }); // eslint-disable-next-line import/no-unused-modules 1801 1802 var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1]; 1803 var createPopper = /*#__PURE__*/popperGenerator({ 1804 defaultModifiers: defaultModifiers 1805 }); // eslint-disable-next-line import/no-unused-modules 1806 1807 exports.applyStyles = applyStyles$1; 1808 exports.arrow = arrow$1; 1809 exports.computeStyles = computeStyles$1; 1810 exports.createPopper = createPopper; 1811 exports.createPopperLite = createPopper$1; 1812 exports.defaultModifiers = defaultModifiers; 1813 exports.detectOverflow = detectOverflow; 1814 exports.eventListeners = eventListeners; 1815 exports.flip = flip$1; 1816 exports.hide = hide$1; 1817 exports.offset = offset$1; 1818 exports.popperGenerator = popperGenerator; 1819 exports.popperOffsets = popperOffsets$1; 1820 exports.preventOverflow = preventOverflow$1; 1821 1822 Object.defineProperty(exports, '__esModule', { value: true }); 1823 1824})));
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.