1/******/ (() => { // webpackBootstrap 2/******/ "use strict"; 3/******/ var __webpack_modules__ = ({ 4 5/***/ "lodash": 6/*!*************************!*\ 7 !*** external "lodash" ***! 8 \*************************/ 9/***/ ((module) => { 10 11module.exports = window["lodash"]; 12 13/***/ }), 14
vendor: 1,113 bytes, lines 15-43
15/***/ "./node_modules/@babel/runtime/helpers/esm/defineProperty.js": 16/*!*******************************************************************!*\ 17 !*** ./node_modules/@babel/runtime/helpers/esm/defineProperty.js ***! 18 \*******************************************************************/ 19/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 20 21__webpack_require__.r(__webpack_exports__); 22/* harmony export */ __webpack_require__.d(__webpack_exports__, { 23/* harmony export */ "default": () => (/* binding */ _defineProperty) 24/* harmony export */ }); 25/* harmony import */ var _toPropertyKey_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./toPropertyKey.js */ "./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"); 26 27function _defineProperty(obj, key, value) { 28 key = (0,_toPropertyKey_js__WEBPACK_IMPORTED_MODULE_0__["default"])(key); 29 if (key in obj) { 30 Object.defineProperty(obj, key, { 31 value: value, 32 enumerable: true, 33 configurable: true, 34 writable: true 35 }); 36 } else { 37 obj[key] = value; 38 } 39 return obj; 40} 41 42/***/ }), 43
vendor: 1,245 bytes, lines 44-68
44/***/ "./node_modules/@babel/runtime/helpers/esm/toPrimitive.js": 45/*!****************************************************************!*\ 46 !*** ./node_modules/@babel/runtime/helpers/esm/toPrimitive.js ***! 47 \****************************************************************/ 48/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 49 50__webpack_require__.r(__webpack_exports__); 51/* harmony export */ __webpack_require__.d(__webpack_exports__, { 52/* harmony export */ "default": () => (/* binding */ _toPrimitive) 53/* harmony export */ }); 54/* harmony import */ var _typeof_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./typeof.js */ "./node_modules/@babel/runtime/helpers/esm/typeof.js"); 55 56function _toPrimitive(input, hint) { 57 if ((0,_typeof_js__WEBPACK_IMPORTED_MODULE_0__["default"])(input) !== "object" || input === null) return input; 58 var prim = input[Symbol.toPrimitive]; 59 if (prim !== undefined) { 60 var res = prim.call(input, hint || "default"); 61 if ((0,_typeof_js__WEBPACK_IMPORTED_MODULE_0__["default"])(res) !== "object") return res; 62 throw new TypeError("@@toPrimitive must return a primitive value."); 63 } 64 return (hint === "string" ? String : Number)(input); 65} 66 67/***/ }), 68
vendor: 1,159 bytes, lines 69-89
69/***/ "./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js": 70/*!******************************************************************!*\ 71 !*** ./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js ***! 72 \******************************************************************/ 73/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 74 75__webpack_require__.r(__webpack_exports__); 76/* harmony export */ __webpack_require__.d(__webpack_exports__, { 77/* harmony export */ "default": () => (/* binding */ _toPropertyKey) 78/* harmony export */ }); 79/* harmony import */ var _typeof_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./typeof.js */ "./node_modules/@babel/runtime/helpers/esm/typeof.js"); 80/* harmony import */ var _toPrimitive_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./toPrimitive.js */ "./node_modules/@babel/runtime/helpers/esm/toPrimitive.js"); 81 82 83function _toPropertyKey(arg) { 84 var key = (0,_toPrimitive_js__WEBPACK_IMPORTED_MODULE_1__["default"])(arg, "string"); 85 return (0,_typeof_js__WEBPACK_IMPORTED_MODULE_0__["default"])(key) === "symbol" ? key : String(key); 86} 87 88/***/ }), 89
vendor: 895 bytes, lines 90-111
90/***/ "./node_modules/@babel/runtime/helpers/esm/typeof.js": 91/*!***********************************************************!*\ 92 !*** ./node_modules/@babel/runtime/helpers/esm/typeof.js ***! 93 \***********************************************************/ 94/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 95 96__webpack_require__.r(__webpack_exports__); 97/* harmony export */ __webpack_require__.d(__webpack_exports__, { 98/* harmony export */ "default": () => (/* binding */ _typeof) 99/* harmony export */ }); 100function _typeof(o) { 101 "@babel/helpers - typeof"; 102 103 return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { 104 return typeof o; 105 } : function (o) { 106 return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; 107 }, _typeof(o); 108} 109 110/***/ }), 111
vendor: 39,338 bytes, lines 112-1148
112/***/ "./node_modules/@floating-ui/core/dist/floating-ui.core.mjs": 113/*!******************************************************************!*\ 114 !*** ./node_modules/@floating-ui/core/dist/floating-ui.core.mjs ***! 115 \******************************************************************/ 116/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 117 118__webpack_require__.r(__webpack_exports__); 119/* harmony export */ __webpack_require__.d(__webpack_exports__, { 120/* harmony export */ arrow: () => (/* binding */ arrow), 121/* harmony export */ autoPlacement: () => (/* binding */ autoPlacement), 122/* harmony export */ computePosition: () => (/* binding */ computePosition), 123/* harmony export */ detectOverflow: () => (/* binding */ detectOverflow), 124/* harmony export */ flip: () => (/* binding */ flip), 125/* harmony export */ hide: () => (/* binding */ hide), 126/* harmony export */ inline: () => (/* binding */ inline), 127/* harmony export */ limitShift: () => (/* binding */ limitShift), 128/* harmony export */ offset: () => (/* binding */ offset), 129/* harmony export */ rectToClientRect: () => (/* reexport safe */ _floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.rectToClientRect), 130/* harmony export */ shift: () => (/* binding */ shift), 131/* harmony export */ size: () => (/* binding */ size) 132/* harmony export */ }); 133/* harmony import */ var _floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @floating-ui/utils */ "./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs"); 134 135 136 137function computeCoordsFromPlacement(_ref, placement, rtl) { 138 let { 139 reference, 140 floating 141 } = _ref; 142 const sideAxis = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSideAxis)(placement); 143 const alignmentAxis = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignmentAxis)(placement); 144 const alignLength = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAxisLength)(alignmentAxis); 145 const side = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(placement); 146 const isVertical = sideAxis === 'y'; 147 const commonX = reference.x + reference.width / 2 - floating.width / 2; 148 const commonY = reference.y + reference.height / 2 - floating.height / 2; 149 const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2; 150 let coords; 151 switch (side) { 152 case 'top': 153 coords = { 154 x: commonX, 155 y: reference.y - floating.height 156 }; 157 break; 158 case 'bottom': 159 coords = { 160 x: commonX, 161 y: reference.y + reference.height 162 }; 163 break; 164 case 'right': 165 coords = { 166 x: reference.x + reference.width, 167 y: commonY 168 }; 169 break; 170 case 'left': 171 coords = { 172 x: reference.x - floating.width, 173 y: commonY 174 }; 175 break; 176 default: 177 coords = { 178 x: reference.x, 179 y: reference.y 180 }; 181 } 182 switch ((0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignment)(placement)) { 183 case 'start': 184 coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1); 185 break; 186 case 'end': 187 coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1); 188 break; 189 } 190 return coords; 191} 192 193/** 194 * Computes the `x` and `y` coordinates that will place the floating element 195 * next to a reference element when it is given a certain positioning strategy. 196 * 197 * This export does not have any `platform` interface logic. You will need to 198 * write one for the platform you are using Floating UI with. 199 */ 200const computePosition = async (reference, floating, config) => { 201 const { 202 placement = 'bottom', 203 strategy = 'absolute', 204 middleware = [], 205 platform 206 } = config; 207 const validMiddleware = middleware.filter(Boolean); 208 const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating)); 209 let rects = await platform.getElementRects({ 210 reference, 211 floating, 212 strategy 213 }); 214 let { 215 x, 216 y 217 } = computeCoordsFromPlacement(rects, placement, rtl); 218 let statefulPlacement = placement; 219 let middlewareData = {}; 220 let resetCount = 0; 221 for (let i = 0; i < validMiddleware.length; i++) { 222 const { 223 name, 224 fn 225 } = validMiddleware[i]; 226 const { 227 x: nextX, 228 y: nextY, 229 data, 230 reset 231 } = await fn({ 232 x, 233 y, 234 initialPlacement: placement, 235 placement: statefulPlacement, 236 strategy, 237 middlewareData, 238 rects, 239 platform, 240 elements: { 241 reference, 242 floating 243 } 244 }); 245 x = nextX != null ? nextX : x; 246 y = nextY != null ? nextY : y; 247 middlewareData = { 248 ...middlewareData, 249 [name]: { 250 ...middlewareData[name], 251 ...data 252 } 253 }; 254 if (reset && resetCount <= 50) { 255 resetCount++; 256 if (typeof reset === 'object') { 257 if (reset.placement) { 258 statefulPlacement = reset.placement; 259 } 260 if (reset.rects) { 261 rects = reset.rects === true ? await platform.getElementRects({ 262 reference, 263 floating, 264 strategy 265 }) : reset.rects; 266 } 267 ({ 268 x, 269 y 270 } = computeCoordsFromPlacement(rects, statefulPlacement, rtl)); 271 } 272 i = -1; 273 continue; 274 } 275 } 276 return { 277 x, 278 y, 279 placement: statefulPlacement, 280 strategy, 281 middlewareData 282 }; 283}; 284 285/** 286 * Resolves with an object of overflow side offsets that determine how much the 287 * element is overflowing a given clipping boundary on each side. 288 * - positive = overflowing the boundary by that number of pixels 289 * - negative = how many pixels left before it will overflow 290 * - 0 = lies flush with the boundary 291 * @see https://floating-ui.com/docs/detectOverflow 292 */ 293async function detectOverflow(state, options) { 294 var _await$platform$isEle; 295 if (options === void 0) { 296 options = {}; 297 } 298 const { 299 x, 300 y, 301 platform, 302 rects, 303 elements, 304 strategy 305 } = state; 306 const { 307 boundary = 'clippingAncestors', 308 rootBoundary = 'viewport', 309 elementContext = 'floating', 310 altBoundary = false, 311 padding = 0 312 } = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state); 313 const paddingObject = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getPaddingObject)(padding); 314 const altContext = elementContext === 'floating' ? 'reference' : 'floating'; 315 const element = elements[altBoundary ? altContext : elementContext]; 316 const clippingClientRect = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.rectToClientRect)(await platform.getClippingRect({ 317 element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))), 318 boundary, 319 rootBoundary, 320 strategy 321 })); 322 const rect = elementContext === 'floating' ? { 323 ...rects.floating, 324 x, 325 y 326 } : rects.reference; 327 const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating)); 328 const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || { 329 x: 1, 330 y: 1 331 } : { 332 x: 1, 333 y: 1 334 }; 335 const elementClientRect = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.rectToClientRect)(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({ 336 rect, 337 offsetParent, 338 strategy 339 }) : rect); 340 return { 341 top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y, 342 bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y, 343 left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x, 344 right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x 345 }; 346} 347 348/** 349 * Provides data to position an inner element of the floating element so that it 350 * appears centered to the reference element. 351 * @see https://floating-ui.com/docs/arrow 352 */ 353const arrow = options => ({ 354 name: 'arrow', 355 options, 356 async fn(state) { 357 const { 358 x, 359 y, 360 placement, 361 rects, 362 platform, 363 elements, 364 middlewareData 365 } = state; 366 // Since `element` is required, we don't Partial<> the type. 367 const { 368 element, 369 padding = 0 370 } = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state) || {}; 371 if (element == null) { 372 return {}; 373 } 374 const paddingObject = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getPaddingObject)(padding); 375 const coords = { 376 x, 377 y 378 }; 379 const axis = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignmentAxis)(placement); 380 const length = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAxisLength)(axis); 381 const arrowDimensions = await platform.getDimensions(element); 382 const isYAxis = axis === 'y'; 383 const minProp = isYAxis ? 'top' : 'left'; 384 const maxProp = isYAxis ? 'bottom' : 'right'; 385 const clientProp = isYAxis ? 'clientHeight' : 'clientWidth'; 386 const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length]; 387 const startDiff = coords[axis] - rects.reference[axis]; 388 const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element)); 389 let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0; 390 391 // DOM platform can return `window` as the `offsetParent`. 392 if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) { 393 clientSize = elements.floating[clientProp] || rects.floating[length]; 394 } 395 const centerToReference = endDiff / 2 - startDiff / 2; 396 397 // If the padding is large enough that it causes the arrow to no longer be 398 // centered, modify the padding so that it is centered. 399 const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1; 400 const minPadding = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.min)(paddingObject[minProp], largestPossiblePadding); 401 const maxPadding = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.min)(paddingObject[maxProp], largestPossiblePadding); 402 403 // Make sure the arrow doesn't overflow the floating element if the center 404 // point is outside the floating element's bounds. 405 const min$1 = minPadding; 406 const max = clientSize - arrowDimensions[length] - maxPadding; 407 const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference; 408 const offset = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.clamp)(min$1, center, max); 409 410 // If the reference is small enough that the arrow's padding causes it to 411 // to point to nothing for an aligned placement, adjust the offset of the 412 // floating element itself. To ensure `shift()` continues to take action, 413 // a single reset is performed when this is true. 414 const shouldAddOffset = !middlewareData.arrow && (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignment)(placement) != null && center != offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0; 415 const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0; 416 return { 417 [axis]: coords[axis] + alignmentOffset, 418 data: { 419 [axis]: offset, 420 centerOffset: center - offset - alignmentOffset, 421 ...(shouldAddOffset && { 422 alignmentOffset 423 }) 424 }, 425 reset: shouldAddOffset 426 }; 427 } 428}); 429 430function getPlacementList(alignment, autoAlignment, allowedPlacements) { 431 const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignment)(placement) === alignment), ...allowedPlacements.filter(placement => (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignment)(placement) !== alignment)] : allowedPlacements.filter(placement => (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(placement) === placement); 432 return allowedPlacementsSortedByAlignment.filter(placement => { 433 if (alignment) { 434 return (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignment)(placement) === alignment || (autoAlignment ? (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getOppositeAlignmentPlacement)(placement) !== placement : false); 435 } 436 return true; 437 }); 438} 439/** 440 * Optimizes the visibility of the floating element by choosing the placement 441 * that has the most space available automatically, without needing to specify a 442 * preferred placement. Alternative to `flip`. 443 * @see https://floating-ui.com/docs/autoPlacement 444 */ 445const autoPlacement = function (options) { 446 if (options === void 0) { 447 options = {}; 448 } 449 return { 450 name: 'autoPlacement', 451 options, 452 async fn(state) { 453 var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE; 454 const { 455 rects, 456 middlewareData, 457 placement, 458 platform, 459 elements 460 } = state; 461 const { 462 crossAxis = false, 463 alignment, 464 allowedPlacements = _floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.placements, 465 autoAlignment = true, 466 ...detectOverflowOptions 467 } = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state); 468 const placements$1 = alignment !== undefined || allowedPlacements === _floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements; 469 const overflow = await detectOverflow(state, detectOverflowOptions); 470 const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0; 471 const currentPlacement = placements$1[currentIndex]; 472 if (currentPlacement == null) { 473 return {}; 474 } 475 const alignmentSides = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignmentSides)(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))); 476 477 // Make `computeCoords` start from the right place. 478 if (placement !== currentPlacement) { 479 return { 480 reset: { 481 placement: placements$1[0] 482 } 483 }; 484 } 485 const currentOverflows = [overflow[(0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]]; 486 const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), { 487 placement: currentPlacement, 488 overflows: currentOverflows 489 }]; 490 const nextPlacement = placements$1[currentIndex + 1]; 491 492 // There are more placements to check. 493 if (nextPlacement) { 494 return { 495 data: { 496 index: currentIndex + 1, 497 overflows: allOverflows 498 }, 499 reset: { 500 placement: nextPlacement 501 } 502 }; 503 } 504 const placementsSortedByMostSpace = allOverflows.map(d => { 505 const alignment = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignment)(d.placement); 506 return [d.placement, alignment && crossAxis ? 507 // Check along the mainAxis and main crossAxis side. 508 d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) : 509 // Check only the mainAxis. 510 d.overflows[0], d.overflows]; 511 }).sort((a, b) => a[1] - b[1]); 512 const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0, 513 // Aligned placements should not check their opposite crossAxis 514 // side. 515 (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignment)(d[0]) ? 2 : 3).every(v => v <= 0)); 516 const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0]; 517 if (resetPlacement !== placement) { 518 return { 519 data: { 520 index: currentIndex + 1, 521 overflows: allOverflows 522 }, 523 reset: { 524 placement: resetPlacement 525 } 526 }; 527 } 528 return {}; 529 } 530 }; 531}; 532 533/** 534 * Optimizes the visibility of the floating element by flipping the `placement` 535 * in order to keep it in view when the preferred placement(s) will overflow the 536 * clipping boundary. Alternative to `autoPlacement`. 537 * @see https://floating-ui.com/docs/flip 538 */ 539const flip = function (options) { 540 if (options === void 0) { 541 options = {}; 542 } 543 return { 544 name: 'flip', 545 options, 546 async fn(state) { 547 var _middlewareData$arrow, _middlewareData$flip; 548 const { 549 placement, 550 middlewareData, 551 rects, 552 initialPlacement, 553 platform, 554 elements 555 } = state; 556 const { 557 mainAxis: checkMainAxis = true, 558 crossAxis: checkCrossAxis = true, 559 fallbackPlacements: specifiedFallbackPlacements, 560 fallbackStrategy = 'bestFit', 561 fallbackAxisSideDirection = 'none', 562 flipAlignment = true, 563 ...detectOverflowOptions 564 } = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state); 565 566 // If a reset by the arrow was caused due to an alignment offset being 567 // added, we should skip any logic now since `flip()` has already done its 568 // work. 569 // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643 570 if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) { 571 return {}; 572 } 573 const side = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(placement); 574 const isBasePlacement = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(initialPlacement) === initialPlacement; 575 const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)); 576 const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [(0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getOppositePlacement)(initialPlacement)] : (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getExpandedPlacements)(initialPlacement)); 577 if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') { 578 fallbackPlacements.push(...(0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getOppositeAxisPlacements)(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl)); 579 } 580 const placements = [initialPlacement, ...fallbackPlacements]; 581 const overflow = await detectOverflow(state, detectOverflowOptions); 582 const overflows = []; 583 let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || []; 584 if (checkMainAxis) { 585 overflows.push(overflow[side]); 586 } 587 if (checkCrossAxis) { 588 const sides = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignmentSides)(placement, rects, rtl); 589 overflows.push(overflow[sides[0]], overflow[sides[1]]); 590 } 591 overflowsData = [...overflowsData, { 592 placement, 593 overflows 594 }]; 595 596 // One or more sides is overflowing. 597 if (!overflows.every(side => side <= 0)) { 598 var _middlewareData$flip2, _overflowsData$filter; 599 const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1; 600 const nextPlacement = placements[nextIndex]; 601 if (nextPlacement) { 602 // Try next placement and re-run the lifecycle. 603 return { 604 data: { 605 index: nextIndex, 606 overflows: overflowsData 607 }, 608 reset: { 609 placement: nextPlacement 610 } 611 }; 612 } 613 614 // First, find the candidates that fit on the mainAxis side of overflow, 615 // then find the placement that fits the best on the main crossAxis side. 616 let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement; 617 618 // Otherwise fallback. 619 if (!resetPlacement) { 620 switch (fallbackStrategy) { 621 case 'bestFit': 622 { 623 var _overflowsData$map$so; 624 const placement = (_overflowsData$map$so = overflowsData.map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0]; 625 if (placement) { 626 resetPlacement = placement; 627 } 628 break; 629 } 630 case 'initialPlacement': 631 resetPlacement = initialPlacement; 632 break; 633 } 634 } 635 if (placement !== resetPlacement) { 636 return { 637 reset: { 638 placement: resetPlacement 639 } 640 }; 641 } 642 } 643 return {}; 644 } 645 }; 646}; 647 648function getSideOffsets(overflow, rect) { 649 return { 650 top: overflow.top - rect.height, 651 right: overflow.right - rect.width, 652 bottom: overflow.bottom - rect.height, 653 left: overflow.left - rect.width 654 }; 655} 656function isAnySideFullyClipped(overflow) { 657 return _floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.sides.some(side => overflow[side] >= 0); 658} 659/** 660 * Provides data to hide the floating element in applicable situations, such as 661 * when it is not in the same clipping context as the reference element. 662 * @see https://floating-ui.com/docs/hide 663 */ 664const hide = function (options) { 665 if (options === void 0) { 666 options = {}; 667 } 668 return { 669 name: 'hide', 670 options, 671 async fn(state) { 672 const { 673 rects 674 } = state; 675 const { 676 strategy = 'referenceHidden', 677 ...detectOverflowOptions 678 } = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state); 679 switch (strategy) { 680 case 'referenceHidden': 681 { 682 const overflow = await detectOverflow(state, { 683 ...detectOverflowOptions, 684 elementContext: 'reference' 685 }); 686 const offsets = getSideOffsets(overflow, rects.reference); 687 return { 688 data: { 689 referenceHiddenOffsets: offsets, 690 referenceHidden: isAnySideFullyClipped(offsets) 691 } 692 }; 693 } 694 case 'escaped': 695 { 696 const overflow = await detectOverflow(state, { 697 ...detectOverflowOptions, 698 altBoundary: true 699 }); 700 const offsets = getSideOffsets(overflow, rects.floating); 701 return { 702 data: { 703 escapedOffsets: offsets, 704 escaped: isAnySideFullyClipped(offsets) 705 } 706 }; 707 } 708 default: 709 { 710 return {}; 711 } 712 } 713 } 714 }; 715}; 716 717function getBoundingRect(rects) { 718 const minX = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.min)(...rects.map(rect => rect.left)); 719 const minY = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.min)(...rects.map(rect => rect.top)); 720 const maxX = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.max)(...rects.map(rect => rect.right)); 721 const maxY = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.max)(...rects.map(rect => rect.bottom)); 722 return { 723 x: minX, 724 y: minY, 725 width: maxX - minX, 726 height: maxY - minY 727 }; 728} 729function getRectsByLine(rects) { 730 const sortedRects = rects.slice().sort((a, b) => a.y - b.y); 731 const groups = []; 732 let prevRect = null; 733 for (let i = 0; i < sortedRects.length; i++) { 734 const rect = sortedRects[i]; 735 if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) { 736 groups.push([rect]); 737 } else { 738 groups[groups.length - 1].push(rect); 739 } 740 prevRect = rect; 741 } 742 return groups.map(rect => (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.rectToClientRect)(getBoundingRect(rect))); 743} 744/** 745 * Provides improved positioning for inline reference elements that can span 746 * over multiple lines, such as hyperlinks or range selections. 747 * @see https://floating-ui.com/docs/inline 748 */ 749const inline = function (options) { 750 if (options === void 0) { 751 options = {}; 752 } 753 return { 754 name: 'inline', 755 options, 756 async fn(state) { 757 const { 758 placement, 759 elements, 760 rects, 761 platform, 762 strategy 763 } = state; 764 // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a 765 // ClientRect's bounds, despite the event listener being triggered. A 766 // padding of 2 seems to handle this issue. 767 const { 768 padding = 2, 769 x, 770 y 771 } = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state); 772 const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []); 773 const clientRects = getRectsByLine(nativeClientRects); 774 const fallback = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.rectToClientRect)(getBoundingRect(nativeClientRects)); 775 const paddingObject = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getPaddingObject)(padding); 776 function getBoundingClientRect() { 777 // There are two rects and they are disjoined. 778 if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) { 779 // Find the first rect in which the point is fully inside. 780 return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback; 781 } 782 783 // There are 2 or more connected rects. 784 if (clientRects.length >= 2) { 785 if ((0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSideAxis)(placement) === 'y') { 786 const firstRect = clientRects[0]; 787 const lastRect = clientRects[clientRects.length - 1]; 788 const isTop = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(placement) === 'top'; 789 const top = firstRect.top; 790 const bottom = lastRect.bottom; 791 const left = isTop ? firstRect.left : lastRect.left; 792 const right = isTop ? firstRect.right : lastRect.right; 793 const width = right - left; 794 const height = bottom - top; 795 return { 796 top, 797 bottom, 798 left, 799 right, 800 width, 801 height, 802 x: left, 803 y: top 804 }; 805 } 806 const isLeftSide = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(placement) === 'left'; 807 const maxRight = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.max)(...clientRects.map(rect => rect.right)); 808 const minLeft = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.min)(...clientRects.map(rect => rect.left)); 809 const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight); 810 const top = measureRects[0].top; 811 const bottom = measureRects[measureRects.length - 1].bottom; 812 const left = minLeft; 813 const right = maxRight; 814 const width = right - left; 815 const height = bottom - top; 816 return { 817 top, 818 bottom, 819 left, 820 right, 821 width, 822 height, 823 x: left, 824 y: top 825 }; 826 } 827 return fallback; 828 } 829 const resetRects = await platform.getElementRects({ 830 reference: { 831 getBoundingClientRect 832 }, 833 floating: elements.floating, 834 strategy 835 }); 836 if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) { 837 return { 838 reset: { 839 rects: resetRects 840 } 841 }; 842 } 843 return {}; 844 } 845 }; 846}; 847 848// For type backwards-compatibility, the `OffsetOptions` type was also 849// Derivable. 850async function convertValueToCoords(state, options) { 851 const { 852 placement, 853 platform, 854 elements 855 } = state; 856 const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)); 857 const side = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(placement); 858 const alignment = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignment)(placement); 859 const isVertical = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSideAxis)(placement) === 'y'; 860 const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1; 861 const crossAxisMulti = rtl && isVertical ? -1 : 1; 862 const rawValue = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state); 863 864 // eslint-disable-next-line prefer-const 865 let { 866 mainAxis, 867 crossAxis, 868 alignmentAxis 869 } = typeof rawValue === 'number' ? { 870 mainAxis: rawValue, 871 crossAxis: 0, 872 alignmentAxis: null 873 } : { 874 mainAxis: 0, 875 crossAxis: 0, 876 alignmentAxis: null, 877 ...rawValue 878 }; 879 if (alignment && typeof alignmentAxis === 'number') { 880 crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis; 881 } 882 return isVertical ? { 883 x: crossAxis * crossAxisMulti, 884 y: mainAxis * mainAxisMulti 885 } : { 886 x: mainAxis * mainAxisMulti, 887 y: crossAxis * crossAxisMulti 888 }; 889} 890 891/** 892 * Modifies the placement by translating the floating element along the 893 * specified axes. 894 * A number (shorthand for `mainAxis` or distance), or an axes configuration 895 * object may be passed. 896 * @see https://floating-ui.com/docs/offset 897 */ 898const offset = function (options) { 899 if (options === void 0) { 900 options = 0; 901 } 902 return { 903 name: 'offset', 904 options, 905 async fn(state) { 906 const { 907 x, 908 y 909 } = state; 910 const diffCoords = await convertValueToCoords(state, options); 911 return { 912 x: x + diffCoords.x, 913 y: y + diffCoords.y, 914 data: diffCoords 915 }; 916 } 917 }; 918}; 919 920/** 921 * Optimizes the visibility of the floating element by shifting it in order to 922 * keep it in view when it will overflow the clipping boundary. 923 * @see https://floating-ui.com/docs/shift 924 */ 925const shift = function (options) { 926 if (options === void 0) { 927 options = {}; 928 } 929 return { 930 name: 'shift', 931 options, 932 async fn(state) { 933 const { 934 x, 935 y, 936 placement 937 } = state; 938 const { 939 mainAxis: checkMainAxis = true, 940 crossAxis: checkCrossAxis = false, 941 limiter = { 942 fn: _ref => { 943 let { 944 x, 945 y 946 } = _ref; 947 return { 948 x, 949 y 950 }; 951 } 952 }, 953 ...detectOverflowOptions 954 } = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state); 955 const coords = { 956 x, 957 y 958 }; 959 const overflow = await detectOverflow(state, detectOverflowOptions); 960 const crossAxis = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSideAxis)((0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(placement)); 961 const mainAxis = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getOppositeAxis)(crossAxis); 962 let mainAxisCoord = coords[mainAxis]; 963 let crossAxisCoord = coords[crossAxis]; 964 if (checkMainAxis) { 965 const minSide = mainAxis === 'y' ? 'top' : 'left'; 966 const maxSide = mainAxis === 'y' ? 'bottom' : 'right'; 967 const min = mainAxisCoord + overflow[minSide]; 968 const max = mainAxisCoord - overflow[maxSide]; 969 mainAxisCoord = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.clamp)(min, mainAxisCoord, max); 970 } 971 if (checkCrossAxis) { 972 const minSide = crossAxis === 'y' ? 'top' : 'left'; 973 const maxSide = crossAxis === 'y' ? 'bottom' : 'right'; 974 const min = crossAxisCoord + overflow[minSide]; 975 const max = crossAxisCoord - overflow[maxSide]; 976 crossAxisCoord = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.clamp)(min, crossAxisCoord, max); 977 } 978 const limitedCoords = limiter.fn({ 979 ...state, 980 [mainAxis]: mainAxisCoord, 981 [crossAxis]: crossAxisCoord 982 }); 983 return { 984 ...limitedCoords, 985 data: { 986 x: limitedCoords.x - x, 987 y: limitedCoords.y - y 988 } 989 }; 990 } 991 }; 992}; 993/** 994 * Built-in `limiter` that will stop `shift()` at a certain point. 995 */ 996const limitShift = function (options) { 997 if (options === void 0) { 998 options = {}; 999 } 1000 return { 1001 options, 1002 fn(state) { 1003 const { 1004 x, 1005 y, 1006 placement, 1007 rects, 1008 middlewareData 1009 } = state; 1010 const { 1011 offset = 0, 1012 mainAxis: checkMainAxis = true, 1013 crossAxis: checkCrossAxis = true 1014 } = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state); 1015 const coords = { 1016 x, 1017 y 1018 }; 1019 const crossAxis = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSideAxis)(placement); 1020 const mainAxis = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getOppositeAxis)(crossAxis); 1021 let mainAxisCoord = coords[mainAxis]; 1022 let crossAxisCoord = coords[crossAxis]; 1023 const rawOffset = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(offset, state); 1024 const computedOffset = typeof rawOffset === 'number' ? { 1025 mainAxis: rawOffset, 1026 crossAxis: 0 1027 } : { 1028 mainAxis: 0, 1029 crossAxis: 0, 1030 ...rawOffset 1031 }; 1032 if (checkMainAxis) { 1033 const len = mainAxis === 'y' ? 'height' : 'width'; 1034 const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis; 1035 const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis; 1036 if (mainAxisCoord < limitMin) { 1037 mainAxisCoord = limitMin; 1038 } else if (mainAxisCoord > limitMax) { 1039 mainAxisCoord = limitMax; 1040 } 1041 } 1042 if (checkCrossAxis) { 1043 var _middlewareData$offse, _middlewareData$offse2; 1044 const len = mainAxis === 'y' ? 'width' : 'height'; 1045 const isOriginSide = ['top', 'left'].includes((0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(placement)); 1046 const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis); 1047 const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0); 1048 if (crossAxisCoord < limitMin) { 1049 crossAxisCoord = limitMin; 1050 } else if (crossAxisCoord > limitMax) { 1051 crossAxisCoord = limitMax; 1052 } 1053 } 1054 return { 1055 [mainAxis]: mainAxisCoord, 1056 [crossAxis]: crossAxisCoord 1057 }; 1058 } 1059 }; 1060}; 1061 1062/** 1063 * Provides data that allows you to change the size of the floating element — 1064 * for instance, prevent it from overflowing the clipping boundary or match the 1065 * width of the reference element. 1066 * @see https://floating-ui.com/docs/size 1067 */ 1068const size = function (options) { 1069 if (options === void 0) { 1070 options = {}; 1071 } 1072 return { 1073 name: 'size', 1074 options, 1075 async fn(state) { 1076 const { 1077 placement, 1078 rects, 1079 platform, 1080 elements 1081 } = state; 1082 const { 1083 apply = () => {}, 1084 ...detectOverflowOptions 1085 } = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.evaluate)(options, state); 1086 const overflow = await detectOverflow(state, detectOverflowOptions); 1087 const side = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSide)(placement); 1088 const alignment = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getAlignment)(placement); 1089 const isYAxis = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.getSideAxis)(placement) === 'y'; 1090 const { 1091 width, 1092 height 1093 } = rects.floating; 1094 let heightSide; 1095 let widthSide; 1096 if (side === 'top' || side === 'bottom') { 1097 heightSide = side; 1098 widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right'; 1099 } else { 1100 widthSide = side; 1101 heightSide = alignment === 'end' ? 'top' : 'bottom'; 1102 } 1103 const overflowAvailableHeight = height - overflow[heightSide]; 1104 const overflowAvailableWidth = width - overflow[widthSide]; 1105 const noShift = !state.middlewareData.shift; 1106 let availableHeight = overflowAvailableHeight; 1107 let availableWidth = overflowAvailableWidth; 1108 if (isYAxis) { 1109 const maximumClippingWidth = width - overflow.left - overflow.right; 1110 availableWidth = alignment || noShift ? (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.min)(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth; 1111 } else { 1112 const maximumClippingHeight = height - overflow.top - overflow.bottom; 1113 availableHeight = alignment || noShift ? (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.min)(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight; 1114 } 1115 if (noShift && !alignment) { 1116 const xMin = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.max)(overflow.left, 0); 1117 const xMax = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.max)(overflow.right, 0); 1118 const yMin = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.max)(overflow.top, 0); 1119 const yMax = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.max)(overflow.bottom, 0); 1120 if (isYAxis) { 1121 availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.max)(overflow.left, overflow.right)); 1122 } else { 1123 availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_0__.max)(overflow.top, overflow.bottom)); 1124 } 1125 } 1126 await apply({ 1127 ...state, 1128 availableWidth, 1129 availableHeight 1130 }); 1131 const nextDimensions = await platform.getDimensions(elements.floating); 1132 if (width !== nextDimensions.width || height !== nextDimensions.height) { 1133 return { 1134 reset: { 1135 rects: true 1136 } 1137 }; 1138 } 1139 return {}; 1140 } 1141 }; 1142}; 1143 1144 1145 1146 1147/***/ }), 1148
vendor: 27,456 bytes, lines 1149-1778
1149/***/ "./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs": 1150/*!****************************************************************!*\ 1151 !*** ./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs ***! 1152 \****************************************************************/ 1153/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 1154 1155__webpack_require__.r(__webpack_exports__); 1156/* harmony export */ __webpack_require__.d(__webpack_exports__, { 1157/* harmony export */ arrow: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.arrow), 1158/* harmony export */ autoPlacement: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.autoPlacement), 1159/* harmony export */ autoUpdate: () => (/* binding */ autoUpdate), 1160/* harmony export */ computePosition: () => (/* binding */ computePosition), 1161/* harmony export */ detectOverflow: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.detectOverflow), 1162/* harmony export */ flip: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.flip), 1163/* harmony export */ getOverflowAncestors: () => (/* reexport safe */ _floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getOverflowAncestors), 1164/* harmony export */ hide: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.hide), 1165/* harmony export */ inline: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.inline), 1166/* harmony export */ limitShift: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.limitShift), 1167/* harmony export */ offset: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.offset), 1168/* harmony export */ platform: () => (/* binding */ platform), 1169/* harmony export */ shift: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.shift), 1170/* harmony export */ size: () => (/* reexport safe */ _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.size) 1171/* harmony export */ }); 1172/* harmony import */ var _floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @floating-ui/utils */ "./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs"); 1173/* harmony import */ var _floating_ui_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @floating-ui/core */ "./node_modules/@floating-ui/core/dist/floating-ui.core.mjs"); 1174/* harmony import */ var _floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @floating-ui/utils/dom */ "./node_modules/@floating-ui/utils/dom/dist/floating-ui.utils.dom.mjs"); 1175 1176 1177 1178 1179 1180 1181function getCssDimensions(element) { 1182 const css = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(element); 1183 // In testing environments, the `width` and `height` properties are empty 1184 // strings for SVG elements, returning NaN. Fallback to `0` in this case. 1185 let width = parseFloat(css.width) || 0; 1186 let height = parseFloat(css.height) || 0; 1187 const hasOffset = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(element); 1188 const offsetWidth = hasOffset ? element.offsetWidth : width; 1189 const offsetHeight = hasOffset ? element.offsetHeight : height; 1190 const shouldFallback = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.round)(width) !== offsetWidth || (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.round)(height) !== offsetHeight; 1191 if (shouldFallback) { 1192 width = offsetWidth; 1193 height = offsetHeight; 1194 } 1195 return { 1196 width, 1197 height, 1198 $: shouldFallback 1199 }; 1200} 1201 1202function unwrapElement(element) { 1203 return !(0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isElement)(element) ? element.contextElement : element; 1204} 1205 1206function getScale(element) { 1207 const domElement = unwrapElement(element); 1208 if (!(0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(domElement)) { 1209 return (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.createCoords)(1); 1210 } 1211 const rect = domElement.getBoundingClientRect(); 1212 const { 1213 width, 1214 height, 1215 $ 1216 } = getCssDimensions(domElement); 1217 let x = ($ ? (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.round)(rect.width) : rect.width) / width; 1218 let y = ($ ? (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.round)(rect.height) : rect.height) / height; 1219 1220 // 0, NaN, or Infinity should always fallback to 1. 1221 1222 if (!x || !Number.isFinite(x)) { 1223 x = 1; 1224 } 1225 if (!y || !Number.isFinite(y)) { 1226 y = 1; 1227 } 1228 return { 1229 x, 1230 y 1231 }; 1232} 1233 1234const noOffsets = /*#__PURE__*/(0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.createCoords)(0); 1235function getVisualOffsets(element) { 1236 const win = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getWindow)(element); 1237 if (!(0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isWebKit)() || !win.visualViewport) { 1238 return noOffsets; 1239 } 1240 return { 1241 x: win.visualViewport.offsetLeft, 1242 y: win.visualViewport.offsetTop 1243 }; 1244} 1245function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) { 1246 if (isFixed === void 0) { 1247 isFixed = false; 1248 } 1249 if (!floatingOffsetParent || isFixed && floatingOffsetParent !== (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getWindow)(element)) { 1250 return false; 1251 } 1252 return isFixed; 1253} 1254 1255function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) { 1256 if (includeScale === void 0) { 1257 includeScale = false; 1258 } 1259 if (isFixedStrategy === void 0) { 1260 isFixedStrategy = false; 1261 } 1262 const clientRect = element.getBoundingClientRect(); 1263 const domElement = unwrapElement(element); 1264 let scale = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.createCoords)(1); 1265 if (includeScale) { 1266 if (offsetParent) { 1267 if ((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isElement)(offsetParent)) { 1268 scale = getScale(offsetParent); 1269 } 1270 } else { 1271 scale = getScale(element); 1272 } 1273 } 1274 const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.createCoords)(0); 1275 let x = (clientRect.left + visualOffsets.x) / scale.x; 1276 let y = (clientRect.top + visualOffsets.y) / scale.y; 1277 let width = clientRect.width / scale.x; 1278 let height = clientRect.height / scale.y; 1279 if (domElement) { 1280 const win = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getWindow)(domElement); 1281 const offsetWin = offsetParent && (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isElement)(offsetParent) ? (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getWindow)(offsetParent) : offsetParent; 1282 let currentIFrame = win.frameElement; 1283 while (currentIFrame && offsetParent && offsetWin !== win) { 1284 const iframeScale = getScale(currentIFrame); 1285 const iframeRect = currentIFrame.getBoundingClientRect(); 1286 const css = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(currentIFrame); 1287 const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x; 1288 const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y; 1289 x *= iframeScale.x; 1290 y *= iframeScale.y; 1291 width *= iframeScale.x; 1292 height *= iframeScale.y; 1293 x += left; 1294 y += top; 1295 currentIFrame = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getWindow)(currentIFrame).frameElement; 1296 } 1297 } 1298 return (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.rectToClientRect)({ 1299 width, 1300 height, 1301 x, 1302 y 1303 }); 1304} 1305 1306function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) { 1307 let { 1308 rect, 1309 offsetParent, 1310 strategy 1311 } = _ref; 1312 const isOffsetParentAnElement = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(offsetParent); 1313 const documentElement = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getDocumentElement)(offsetParent); 1314 if (offsetParent === documentElement) { 1315 return rect; 1316 } 1317 let scroll = { 1318 scrollLeft: 0, 1319 scrollTop: 0 1320 }; 1321 let scale = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.createCoords)(1); 1322 const offsets = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.createCoords)(0); 1323 if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') { 1324 if ((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getNodeName)(offsetParent) !== 'body' || (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isOverflowElement)(documentElement)) { 1325 scroll = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getNodeScroll)(offsetParent); 1326 } 1327 if ((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(offsetParent)) { 1328 const offsetRect = getBoundingClientRect(offsetParent); 1329 scale = getScale(offsetParent); 1330 offsets.x = offsetRect.x + offsetParent.clientLeft; 1331 offsets.y = offsetRect.y + offsetParent.clientTop; 1332 } 1333 } 1334 return { 1335 width: rect.width * scale.x, 1336 height: rect.height * scale.y, 1337 x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x, 1338 y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y 1339 }; 1340} 1341 1342function getClientRects(element) { 1343 return Array.from(element.getClientRects()); 1344} 1345 1346function getWindowScrollBarX(element) { 1347 // If <html> has a CSS width greater than the viewport, then this will be 1348 // incorrect for RTL. 1349 return getBoundingClientRect((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getDocumentElement)(element)).left + (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getNodeScroll)(element).scrollLeft; 1350} 1351 1352// Gets the entire size of the scrollable document area, even extending outside 1353// of the `<html>` and `<body>` rect bounds if horizontally scrollable. 1354function getDocumentRect(element) { 1355 const html = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getDocumentElement)(element); 1356 const scroll = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getNodeScroll)(element); 1357 const body = element.ownerDocument.body; 1358 const width = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.max)(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth); 1359 const height = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.max)(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight); 1360 let x = -scroll.scrollLeft + getWindowScrollBarX(element); 1361 const y = -scroll.scrollTop; 1362 if ((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(body).direction === 'rtl') { 1363 x += (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.max)(html.clientWidth, body.clientWidth) - width; 1364 } 1365 return { 1366 width, 1367 height, 1368 x, 1369 y 1370 }; 1371} 1372 1373function getViewportRect(element, strategy) { 1374 const win = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getWindow)(element); 1375 const html = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getDocumentElement)(element); 1376 const visualViewport = win.visualViewport; 1377 let width = html.clientWidth; 1378 let height = html.clientHeight; 1379 let x = 0; 1380 let y = 0; 1381 if (visualViewport) { 1382 width = visualViewport.width; 1383 height = visualViewport.height; 1384 const visualViewportBased = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isWebKit)(); 1385 if (!visualViewportBased || visualViewportBased && strategy === 'fixed') { 1386 x = visualViewport.offsetLeft; 1387 y = visualViewport.offsetTop; 1388 } 1389 } 1390 return { 1391 width, 1392 height, 1393 x, 1394 y 1395 }; 1396} 1397 1398// Returns the inner client rect, subtracting scrollbars if present. 1399function getInnerBoundingClientRect(element, strategy) { 1400 const clientRect = getBoundingClientRect(element, true, strategy === 'fixed'); 1401 const top = clientRect.top + element.clientTop; 1402 const left = clientRect.left + element.clientLeft; 1403 const scale = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(element) ? getScale(element) : (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.createCoords)(1); 1404 const width = element.clientWidth * scale.x; 1405 const height = element.clientHeight * scale.y; 1406 const x = left * scale.x; 1407 const y = top * scale.y; 1408 return { 1409 width, 1410 height, 1411 x, 1412 y 1413 }; 1414} 1415function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) { 1416 let rect; 1417 if (clippingAncestor === 'viewport') { 1418 rect = getViewportRect(element, strategy); 1419 } else if (clippingAncestor === 'document') { 1420 rect = getDocumentRect((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getDocumentElement)(element)); 1421 } else if ((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isElement)(clippingAncestor)) { 1422 rect = getInnerBoundingClientRect(clippingAncestor, strategy); 1423 } else { 1424 const visualOffsets = getVisualOffsets(element); 1425 rect = { 1426 ...clippingAncestor, 1427 x: clippingAncestor.x - visualOffsets.x, 1428 y: clippingAncestor.y - visualOffsets.y 1429 }; 1430 } 1431 return (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.rectToClientRect)(rect); 1432} 1433function hasFixedPositionAncestor(element, stopNode) { 1434 const parentNode = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getParentNode)(element); 1435 if (parentNode === stopNode || !(0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isElement)(parentNode) || (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isLastTraversableNode)(parentNode)) { 1436 return false; 1437 } 1438 return (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode); 1439} 1440 1441// A "clipping ancestor" is an `overflow` element with the characteristic of 1442// clipping (or hiding) child elements. This returns all clipping ancestors 1443// of the given element up the tree. 1444function getClippingElementAncestors(element, cache) { 1445 const cachedResult = cache.get(element); 1446 if (cachedResult) { 1447 return cachedResult; 1448 } 1449 let result = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getOverflowAncestors)(element, [], false).filter(el => (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isElement)(el) && (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getNodeName)(el) !== 'body'); 1450 let currentContainingBlockComputedStyle = null; 1451 const elementIsFixed = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(element).position === 'fixed'; 1452 let currentNode = elementIsFixed ? (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getParentNode)(element) : element; 1453 1454 // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block 1455 while ((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isElement)(currentNode) && !(0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isLastTraversableNode)(currentNode)) { 1456 const computedStyle = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(currentNode); 1457 const currentNodeIsContaining = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isContainingBlock)(currentNode); 1458 if (!currentNodeIsContaining && computedStyle.position === 'fixed') { 1459 currentContainingBlockComputedStyle = null; 1460 } 1461 const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isOverflowElement)(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode); 1462 if (shouldDropCurrentNode) { 1463 // Drop non-containing blocks. 1464 result = result.filter(ancestor => ancestor !== currentNode); 1465 } else { 1466 // Record last containing block for next iteration. 1467 currentContainingBlockComputedStyle = computedStyle; 1468 } 1469 currentNode = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getParentNode)(currentNode); 1470 } 1471 cache.set(element, result); 1472 return result; 1473} 1474 1475// Gets the maximum area that the element is visible in due to any number of 1476// clipping ancestors. 1477function getClippingRect(_ref) { 1478 let { 1479 element, 1480 boundary, 1481 rootBoundary, 1482 strategy 1483 } = _ref; 1484 const elementClippingAncestors = boundary === 'clippingAncestors' ? getClippingElementAncestors(element, this._c) : [].concat(boundary); 1485 const clippingAncestors = [...elementClippingAncestors, rootBoundary]; 1486 const firstClippingAncestor = clippingAncestors[0]; 1487 const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => { 1488 const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy); 1489 accRect.top = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.max)(rect.top, accRect.top); 1490 accRect.right = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.min)(rect.right, accRect.right); 1491 accRect.bottom = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.min)(rect.bottom, accRect.bottom); 1492 accRect.left = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.max)(rect.left, accRect.left); 1493 return accRect; 1494 }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy)); 1495 return { 1496 width: clippingRect.right - clippingRect.left, 1497 height: clippingRect.bottom - clippingRect.top, 1498 x: clippingRect.left, 1499 y: clippingRect.top 1500 }; 1501} 1502 1503function getDimensions(element) { 1504 return getCssDimensions(element); 1505} 1506 1507function getRectRelativeToOffsetParent(element, offsetParent, strategy) { 1508 const isOffsetParentAnElement = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(offsetParent); 1509 const documentElement = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getDocumentElement)(offsetParent); 1510 const isFixed = strategy === 'fixed'; 1511 const rect = getBoundingClientRect(element, true, isFixed, offsetParent); 1512 let scroll = { 1513 scrollLeft: 0, 1514 scrollTop: 0 1515 }; 1516 const offsets = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.createCoords)(0); 1517 if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { 1518 if ((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getNodeName)(offsetParent) !== 'body' || (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isOverflowElement)(documentElement)) { 1519 scroll = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getNodeScroll)(offsetParent); 1520 } 1521 if (isOffsetParentAnElement) { 1522 const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent); 1523 offsets.x = offsetRect.x + offsetParent.clientLeft; 1524 offsets.y = offsetRect.y + offsetParent.clientTop; 1525 } else if (documentElement) { 1526 offsets.x = getWindowScrollBarX(documentElement); 1527 } 1528 } 1529 return { 1530 x: rect.left + scroll.scrollLeft - offsets.x, 1531 y: rect.top + scroll.scrollTop - offsets.y, 1532 width: rect.width, 1533 height: rect.height 1534 }; 1535} 1536 1537function getTrueOffsetParent(element, polyfill) { 1538 if (!(0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(element) || (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(element).position === 'fixed') { 1539 return null; 1540 } 1541 if (polyfill) { 1542 return polyfill(element); 1543 } 1544 return element.offsetParent; 1545} 1546 1547// Gets the closest ancestor positioned element. Handles some edge cases, 1548// such as table ancestors and cross browser bugs. 1549function getOffsetParent(element, polyfill) { 1550 const window = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getWindow)(element); 1551 if (!(0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isHTMLElement)(element)) { 1552 return window; 1553 } 1554 let offsetParent = getTrueOffsetParent(element, polyfill); 1555 while (offsetParent && (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isTableElement)(offsetParent) && (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(offsetParent).position === 'static') { 1556 offsetParent = getTrueOffsetParent(offsetParent, polyfill); 1557 } 1558 if (offsetParent && ((0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getNodeName)(offsetParent) === 'html' || (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getNodeName)(offsetParent) === 'body' && (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(offsetParent).position === 'static' && !(0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isContainingBlock)(offsetParent))) { 1559 return window; 1560 } 1561 return offsetParent || (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getContainingBlock)(element) || window; 1562} 1563 1564const getElementRects = async function (_ref) { 1565 let { 1566 reference, 1567 floating, 1568 strategy 1569 } = _ref; 1570 const getOffsetParentFn = this.getOffsetParent || getOffsetParent; 1571 const getDimensionsFn = this.getDimensions; 1572 return { 1573 reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy), 1574 floating: { 1575 x: 0, 1576 y: 0, 1577 ...(await getDimensionsFn(floating)) 1578 } 1579 }; 1580}; 1581 1582function isRTL(element) { 1583 return (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getComputedStyle)(element).direction === 'rtl'; 1584} 1585 1586const platform = { 1587 convertOffsetParentRelativeRectToViewportRelativeRect, 1588 getDocumentElement: _floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getDocumentElement, 1589 getClippingRect, 1590 getOffsetParent, 1591 getElementRects, 1592 getClientRects, 1593 getDimensions, 1594 getScale, 1595 isElement: _floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.isElement, 1596 isRTL 1597}; 1598 1599// https://samthor.au/2021/observing-dom/ 1600function observeMove(element, onMove) { 1601 let io = null; 1602 let timeoutId; 1603 const root = (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getDocumentElement)(element); 1604 function cleanup() { 1605 clearTimeout(timeoutId); 1606 io && io.disconnect(); 1607 io = null; 1608 } 1609 function refresh(skip, threshold) { 1610 if (skip === void 0) { 1611 skip = false; 1612 } 1613 if (threshold === void 0) { 1614 threshold = 1; 1615 } 1616 cleanup(); 1617 const { 1618 left, 1619 top, 1620 width, 1621 height 1622 } = element.getBoundingClientRect(); 1623 if (!skip) { 1624 onMove(); 1625 } 1626 if (!width || !height) { 1627 return; 1628 } 1629 const insetTop = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.floor)(top); 1630 const insetRight = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.floor)(root.clientWidth - (left + width)); 1631 const insetBottom = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.floor)(root.clientHeight - (top + height)); 1632 const insetLeft = (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.floor)(left); 1633 const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px"; 1634 const options = { 1635 rootMargin, 1636 threshold: (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.max)(0, (0,_floating_ui_utils__WEBPACK_IMPORTED_MODULE_2__.min)(1, threshold)) || 1 1637 }; 1638 let isFirstUpdate = true; 1639 function handleObserve(entries) { 1640 const ratio = entries[0].intersectionRatio; 1641 if (ratio !== threshold) { 1642 if (!isFirstUpdate) { 1643 return refresh(); 1644 } 1645 if (!ratio) { 1646 timeoutId = setTimeout(() => { 1647 refresh(false, 1e-7); 1648 }, 100); 1649 } else { 1650 refresh(false, ratio); 1651 } 1652 } 1653 isFirstUpdate = false; 1654 } 1655 1656 // Older browsers don't support a `document` as the root and will throw an 1657 // error. 1658 try { 1659 io = new IntersectionObserver(handleObserve, { 1660 ...options, 1661 // Handle <iframe>s 1662 root: root.ownerDocument 1663 }); 1664 } catch (e) { 1665 io = new IntersectionObserver(handleObserve, options); 1666 } 1667 io.observe(element); 1668 } 1669 refresh(true); 1670 return cleanup; 1671} 1672 1673/** 1674 * Automatically updates the position of the floating element when necessary. 1675 * Should only be called when the floating element is mounted on the DOM or 1676 * visible on the screen. 1677 * @returns cleanup function that should be invoked when the floating element is 1678 * removed from the DOM or hidden from the screen. 1679 * @see https://floating-ui.com/docs/autoUpdate 1680 */ 1681function autoUpdate(reference, floating, update, options) { 1682 if (options === void 0) { 1683 options = {}; 1684 } 1685 const { 1686 ancestorScroll = true, 1687 ancestorResize = true, 1688 elementResize = typeof ResizeObserver === 'function', 1689 layoutShift = typeof IntersectionObserver === 'function', 1690 animationFrame = false 1691 } = options; 1692 const referenceEl = unwrapElement(reference); 1693 const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? (0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getOverflowAncestors)(referenceEl) : []), ...(0,_floating_ui_utils_dom__WEBPACK_IMPORTED_MODULE_1__.getOverflowAncestors)(floating)] : []; 1694 ancestors.forEach(ancestor => { 1695 ancestorScroll && ancestor.addEventListener('scroll', update, { 1696 passive: true 1697 }); 1698 ancestorResize && ancestor.addEventListener('resize', update); 1699 }); 1700 const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null; 1701 let reobserveFrame = -1; 1702 let resizeObserver = null; 1703 if (elementResize) { 1704 resizeObserver = new ResizeObserver(_ref => { 1705 let [firstEntry] = _ref; 1706 if (firstEntry && firstEntry.target === referenceEl && resizeObserver) { 1707 // Prevent update loops when using the `size` middleware. 1708 // https://github.com/floating-ui/floating-ui/issues/1740 1709 resizeObserver.unobserve(floating); 1710 cancelAnimationFrame(reobserveFrame); 1711 reobserveFrame = requestAnimationFrame(() => { 1712 resizeObserver && resizeObserver.observe(floating); 1713 }); 1714 } 1715 update(); 1716 }); 1717 if (referenceEl && !animationFrame) { 1718 resizeObserver.observe(referenceEl); 1719 } 1720 resizeObserver.observe(floating); 1721 } 1722 let frameId; 1723 let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null; 1724 if (animationFrame) { 1725 frameLoop(); 1726 } 1727 function frameLoop() { 1728 const nextRefRect = getBoundingClientRect(reference); 1729 if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) { 1730 update(); 1731 } 1732 prevRefRect = nextRefRect; 1733 frameId = requestAnimationFrame(frameLoop); 1734 } 1735 update(); 1736 return () => { 1737 ancestors.forEach(ancestor => { 1738 ancestorScroll && ancestor.removeEventListener('scroll', update); 1739 ancestorResize && ancestor.removeEventListener('resize', update); 1740 }); 1741 cleanupIo && cleanupIo(); 1742 resizeObserver && resizeObserver.disconnect(); 1743 resizeObserver = null; 1744 if (animationFrame) { 1745 cancelAnimationFrame(frameId); 1746 } 1747 }; 1748} 1749 1750/** 1751 * Computes the `x` and `y` coordinates that will place the floating element 1752 * next to a reference element when it is given a certain CSS positioning 1753 * strategy. 1754 */ 1755const computePosition = (reference, floating, options) => { 1756 // This caches the expensive `getClippingElementAncestors` function so that 1757 // multiple lifecycle resets re-use the same result. It only lives for a 1758 // single call. If other functions become expensive, we can add them as well. 1759 const cache = new Map(); 1760 const mergedOptions = { 1761 platform, 1762 ...options 1763 }; 1764 const platformWithCache = { 1765 ...mergedOptions.platform, 1766 _c: cache 1767 }; 1768 return (0,_floating_ui_core__WEBPACK_IMPORTED_MODULE_0__.computePosition)(reference, floating, { 1769 ...mergedOptions, 1770 platform: platformWithCache 1771 }); 1772}; 1773 1774 1775 1776 1777/***/ }), 1778
vendor: 5,867 bytes, lines 1779-1939
1779/***/ "./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs": 1780/*!********************************************************************!*\ 1781 !*** ./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs ***! 1782 \********************************************************************/ 1783/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 1784 1785__webpack_require__.r(__webpack_exports__); 1786/* harmony export */ __webpack_require__.d(__webpack_exports__, { 1787/* harmony export */ alignments: () => (/* binding */ alignments), 1788/* harmony export */ clamp: () => (/* binding */ clamp), 1789/* harmony export */ createCoords: () => (/* binding */ createCoords), 1790/* harmony export */ evaluate: () => (/* binding */ evaluate), 1791/* harmony export */ expandPaddingObject: () => (/* binding */ expandPaddingObject), 1792/* harmony export */ floor: () => (/* binding */ floor), 1793/* harmony export */ getAlignment: () => (/* binding */ getAlignment), 1794/* harmony export */ getAlignmentAxis: () => (/* binding */ getAlignmentAxis), 1795/* harmony export */ getAlignmentSides: () => (/* binding */ getAlignmentSides), 1796/* harmony export */ getAxisLength: () => (/* binding */ getAxisLength), 1797/* harmony export */ getExpandedPlacements: () => (/* binding */ getExpandedPlacements), 1798/* harmony export */ getOppositeAlignmentPlacement: () => (/* binding */ getOppositeAlignmentPlacement), 1799/* harmony export */ getOppositeAxis: () => (/* binding */ getOppositeAxis), 1800/* harmony export */ getOppositeAxisPlacements: () => (/* binding */ getOppositeAxisPlacements), 1801/* harmony export */ getOppositePlacement: () => (/* binding */ getOppositePlacement), 1802/* harmony export */ getPaddingObject: () => (/* binding */ getPaddingObject), 1803/* harmony export */ getSide: () => (/* binding */ getSide), 1804/* harmony export */ getSideAxis: () => (/* binding */ getSideAxis), 1805/* harmony export */ max: () => (/* binding */ max), 1806/* harmony export */ min: () => (/* binding */ min), 1807/* harmony export */ placements: () => (/* binding */ placements), 1808/* harmony export */ rectToClientRect: () => (/* binding */ rectToClientRect), 1809/* harmony export */ round: () => (/* binding */ round), 1810/* harmony export */ sides: () => (/* binding */ sides) 1811/* harmony export */ }); 1812const sides = ['top', 'right', 'bottom', 'left']; 1813const alignments = ['start', 'end']; 1814const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []); 1815const min = Math.min; 1816const max = Math.max; 1817const round = Math.round; 1818const floor = Math.floor; 1819const createCoords = v => ({ 1820 x: v, 1821 y: v 1822}); 1823const oppositeSideMap = { 1824 left: 'right', 1825 right: 'left', 1826 bottom: 'top', 1827 top: 'bottom' 1828}; 1829const oppositeAlignmentMap = { 1830 start: 'end', 1831 end: 'start' 1832}; 1833function clamp(start, value, end) { 1834 return max(start, min(value, end)); 1835} 1836function evaluate(value, param) { 1837 return typeof value === 'function' ? value(param) : value; 1838} 1839function getSide(placement) { 1840 return placement.split('-')[0]; 1841} 1842function getAlignment(placement) { 1843 return placement.split('-')[1]; 1844} 1845function getOppositeAxis(axis) { 1846 return axis === 'x' ? 'y' : 'x'; 1847} 1848function getAxisLength(axis) { 1849 return axis === 'y' ? 'height' : 'width'; 1850} 1851function getSideAxis(placement) { 1852 return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x'; 1853} 1854function getAlignmentAxis(placement) { 1855 return getOppositeAxis(getSideAxis(placement)); 1856} 1857function getAlignmentSides(placement, rects, rtl) { 1858 if (rtl === void 0) { 1859 rtl = false; 1860 } 1861 const alignment = getAlignment(placement); 1862 const alignmentAxis = getAlignmentAxis(placement); 1863 const length = getAxisLength(alignmentAxis); 1864 let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top'; 1865 if (rects.reference[length] > rects.floating[length]) { 1866 mainAlignmentSide = getOppositePlacement(mainAlignmentSide); 1867 } 1868 return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)]; 1869} 1870function getExpandedPlacements(placement) { 1871 const oppositePlacement = getOppositePlacement(placement); 1872 return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)]; 1873} 1874function getOppositeAlignmentPlacement(placement) { 1875 return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]); 1876} 1877function getSideList(side, isStart, rtl) { 1878 const lr = ['left', 'right']; 1879 const rl = ['right', 'left']; 1880 const tb = ['top', 'bottom']; 1881 const bt = ['bottom', 'top']; 1882 switch (side) { 1883 case 'top': 1884 case 'bottom': 1885 if (rtl) return isStart ? rl : lr; 1886 return isStart ? lr : rl; 1887 case 'left': 1888 case 'right': 1889 return isStart ? tb : bt; 1890 default: 1891 return []; 1892 } 1893} 1894function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) { 1895 const alignment = getAlignment(placement); 1896 let list = getSideList(getSide(placement), direction === 'start', rtl); 1897 if (alignment) { 1898 list = list.map(side => side + "-" + alignment); 1899 if (flipAlignment) { 1900 list = list.concat(list.map(getOppositeAlignmentPlacement)); 1901 } 1902 } 1903 return list; 1904} 1905function getOppositePlacement(placement) { 1906 return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]); 1907} 1908function expandPaddingObject(padding) { 1909 return { 1910 top: 0, 1911 right: 0, 1912 bottom: 0, 1913 left: 0, 1914 ...padding 1915 }; 1916} 1917function getPaddingObject(padding) { 1918 return typeof padding !== 'number' ? expandPaddingObject(padding) : { 1919 top: padding, 1920 right: padding, 1921 bottom: padding, 1922 left: padding 1923 }; 1924} 1925function rectToClientRect(rect) { 1926 return { 1927 ...rect, 1928 top: rect.y, 1929 left: rect.x, 1930 right: rect.x + rect.width, 1931 bottom: rect.y + rect.height 1932 }; 1933} 1934 1935 1936 1937 1938/***/ }), 1939
vendor: 6,696 bytes, lines 1940-2097
1940/***/ "./node_modules/@floating-ui/utils/dom/dist/floating-ui.utils.dom.mjs": 1941/*!****************************************************************************!*\ 1942 !*** ./node_modules/@floating-ui/utils/dom/dist/floating-ui.utils.dom.mjs ***! 1943 \****************************************************************************/ 1944/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 1945 1946__webpack_require__.r(__webpack_exports__); 1947/* harmony export */ __webpack_require__.d(__webpack_exports__, { 1948/* harmony export */ getComputedStyle: () => (/* binding */ getComputedStyle), 1949/* harmony export */ getContainingBlock: () => (/* binding */ getContainingBlock), 1950/* harmony export */ getDocumentElement: () => (/* binding */ getDocumentElement), 1951/* harmony export */ getNearestOverflowAncestor: () => (/* binding */ getNearestOverflowAncestor), 1952/* harmony export */ getNodeName: () => (/* binding */ getNodeName), 1953/* harmony export */ getNodeScroll: () => (/* binding */ getNodeScroll), 1954/* harmony export */ getOverflowAncestors: () => (/* binding */ getOverflowAncestors), 1955/* harmony export */ getParentNode: () => (/* binding */ getParentNode), 1956/* harmony export */ getWindow: () => (/* binding */ getWindow), 1957/* harmony export */ isContainingBlock: () => (/* binding */ isContainingBlock), 1958/* harmony export */ isElement: () => (/* binding */ isElement), 1959/* harmony export */ isHTMLElement: () => (/* binding */ isHTMLElement), 1960/* harmony export */ isLastTraversableNode: () => (/* binding */ isLastTraversableNode), 1961/* harmony export */ isNode: () => (/* binding */ isNode), 1962/* harmony export */ isOverflowElement: () => (/* binding */ isOverflowElement), 1963/* harmony export */ isShadowRoot: () => (/* binding */ isShadowRoot), 1964/* harmony export */ isTableElement: () => (/* binding */ isTableElement), 1965/* harmony export */ isWebKit: () => (/* binding */ isWebKit) 1966/* harmony export */ }); 1967function getNodeName(node) { 1968 if (isNode(node)) { 1969 return (node.nodeName || '').toLowerCase(); 1970 } 1971 // Mocked nodes in testing environments may not be instances of Node. By 1972 // returning `#document` an infinite loop won't occur. 1973 // https://github.com/floating-ui/floating-ui/issues/2317 1974 return '#document'; 1975} 1976function getWindow(node) { 1977 var _node$ownerDocument; 1978 return (node == null ? void 0 : (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window; 1979} 1980function getDocumentElement(node) { 1981 var _ref; 1982 return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement; 1983} 1984function isNode(value) { 1985 return value instanceof Node || value instanceof getWindow(value).Node; 1986} 1987function isElement(value) { 1988 return value instanceof Element || value instanceof getWindow(value).Element; 1989} 1990function isHTMLElement(value) { 1991 return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement; 1992} 1993function isShadowRoot(value) { 1994 // Browsers without `ShadowRoot` support. 1995 if (typeof ShadowRoot === 'undefined') { 1996 return false; 1997 } 1998 return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot; 1999} 2000function isOverflowElement(element) { 2001 const { 2002 overflow, 2003 overflowX, 2004 overflowY, 2005 display 2006 } = getComputedStyle(element); 2007 return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display); 2008} 2009function isTableElement(element) { 2010 return ['table', 'td', 'th'].includes(getNodeName(element)); 2011} 2012function isContainingBlock(element) { 2013 const webkit = isWebKit(); 2014 const css = getComputedStyle(element); 2015 2016 // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block 2017 return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value)); 2018} 2019function getContainingBlock(element) { 2020 let currentNode = getParentNode(element); 2021 while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) { 2022 if (isContainingBlock(currentNode)) { 2023 return currentNode; 2024 } else { 2025 currentNode = getParentNode(currentNode); 2026 } 2027 } 2028 return null; 2029} 2030function isWebKit() { 2031 if (typeof CSS === 'undefined' || !CSS.supports) return false; 2032 return CSS.supports('-webkit-backdrop-filter', 'none'); 2033} 2034function isLastTraversableNode(node) { 2035 return ['html', 'body', '#document'].includes(getNodeName(node)); 2036} 2037function getComputedStyle(element) { 2038 return getWindow(element).getComputedStyle(element); 2039} 2040function getNodeScroll(element) { 2041 if (isElement(element)) { 2042 return { 2043 scrollLeft: element.scrollLeft, 2044 scrollTop: element.scrollTop 2045 }; 2046 } 2047 return { 2048 scrollLeft: element.pageXOffset, 2049 scrollTop: element.pageYOffset 2050 }; 2051} 2052function getParentNode(node) { 2053 if (getNodeName(node) === 'html') { 2054 return node; 2055 } 2056 const result = 2057 // Step into the shadow DOM of the parent of a slotted node. 2058 node.assignedSlot || 2059 // DOM Element detected. 2060 node.parentNode || 2061 // ShadowRoot detected. 2062 isShadowRoot(node) && node.host || 2063 // Fallback. 2064 getDocumentElement(node); 2065 return isShadowRoot(result) ? result.host : result; 2066} 2067function getNearestOverflowAncestor(node) { 2068 const parentNode = getParentNode(node); 2069 if (isLastTraversableNode(parentNode)) { 2070 return node.ownerDocument ? node.ownerDocument.body : node.body; 2071 } 2072 if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) { 2073 return parentNode; 2074 } 2075 return getNearestOverflowAncestor(parentNode); 2076} 2077function getOverflowAncestors(node, list, traverseIframes) { 2078 var _node$ownerDocument2; 2079 if (list === void 0) { 2080 list = []; 2081 } 2082 if (traverseIframes === void 0) { 2083 traverseIframes = true; 2084 } 2085 const scrollableAncestor = getNearestOverflowAncestor(node); 2086 const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body); 2087 const win = getWindow(scrollableAncestor); 2088 if (isBody) { 2089 return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []); 2090 } 2091 return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes)); 2092} 2093 2094 2095 2096 2097/***/ })
vendor: 4,778 bytes, lines 2097-2202
2097 2098 2099/******/ }); 2100/************************************************************************/ 2101/******/ // The module cache 2102/******/ var __webpack_module_cache__ = {}; 2103/******/ 2104/******/ // The require function 2105/******/ function __webpack_require__(moduleId) { 2106/******/ // Check if module is in cache 2107/******/ var cachedModule = __webpack_module_cache__[moduleId]; 2108/******/ if (cachedModule !== undefined) { 2109/******/ return cachedModule.exports; 2110/******/ } 2111/******/ // Create a new module (and put it into the cache) 2112/******/ var module = __webpack_module_cache__[moduleId] = { 2113/******/ // no module.id needed 2114/******/ // no module.loaded needed 2115/******/ exports: {} 2116/******/ }; 2117/******/ 2118/******/ // Execute the module function 2119/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); 2120/******/ 2121/******/ // Return the exports of the module 2122/******/ return module.exports; 2123/******/ } 2124/******/ 2125/************************************************************************/ 2126/******/ /* webpack/runtime/compat get default export */ 2127/******/ (() => { 2128/******/ // getDefaultExport function for compatibility with non-harmony modules 2129/******/ __webpack_require__.n = (module) => { 2130/******/ var getter = module && module.__esModule ? 2131/******/ () => (module['default']) : 2132/******/ () => (module); 2133/******/ __webpack_require__.d(getter, { a: getter }); 2134/******/ return getter; 2135/******/ }; 2136/******/ })(); 2137/******/ 2138/******/ /* webpack/runtime/define property getters */ 2139/******/ (() => { 2140/******/ // define getter functions for harmony exports 2141/******/ __webpack_require__.d = (exports, definition) => { 2142/******/ for(var key in definition) { 2143/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 2144/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 2145/******/ } 2146/******/ } 2147/******/ }; 2148/******/ })(); 2149/******/ 2150/******/ /* webpack/runtime/hasOwnProperty shorthand */ 2151/******/ (() => { 2152/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 2153/******/ })(); 2154/******/ 2155/******/ /* webpack/runtime/make namespace object */ 2156/******/ (() => { 2157/******/ // define __esModule on exports 2158/******/ __webpack_require__.r = (exports) => { 2159/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 2160/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 2161/******/ } 2162/******/ Object.defineProperty(exports, '__esModule', { value: true }); 2163/******/ }; 2164/******/ })(); 2165/******/ 2166/************************************************************************/ 2167var __webpack_exports__ = {}; 2168// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk. 2169(() => { 2170/*!**********************************!*\ 2171 !*** ./src/dataorg-tool-tips.js ***! 2172 \**********************************/ 2173__webpack_require__.r(__webpack_exports__); 2174/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/esm/defineProperty.js"); 2175/* harmony import */ var _floating_ui_dom__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @floating-ui/dom */ "./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs"); 2176/* harmony import */ var _floating_ui_dom__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @floating-ui/dom */ "./node_modules/@floating-ui/core/dist/floating-ui.core.mjs"); 2177/* harmony import */ var lodash__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lodash */ "lodash"); 2178/* harmony import */ var lodash__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(lodash__WEBPACK_IMPORTED_MODULE_1__); 2179 2180 2181 2182 2183/** 2184 * @function initUpdateToolTips 2185 * @description inits and updates (as needed) the tooltip position on the page based on x,y position of the trigger. 2186 * @param button string 2187 * @param tooltip string 2188 */ 2189var initUpdateToolTips = function initUpdateToolTips(button, tooltip) { 2190 var arrowEl = tooltip.querySelector('[data-popper-arrow]'); 2191 (0,_floating_ui_dom__WEBPACK_IMPORTED_MODULE_2__.computePosition)(button, tooltip, { 2192 placement: 'top', 2193 middleware: [(0,_floating_ui_dom__WEBPACK_IMPORTED_MODULE_3__.flip)(), (0,_floating_ui_dom__WEBPACK_IMPORTED_MODULE_3__.shift)({ 2194 padding: 32 2195 }), (0,_floating_ui_dom__WEBPACK_IMPORTED_MODULE_3__.offset)(20), (0,_floating_ui_dom__WEBPACK_IMPORTED_MODULE_3__.arrow)({ 2196 element: arrowEl 2197 })] 2198 }).then(function (_ref) { 2199 var x = _ref.x, 2200 y = _ref.y, 2201 placement = _ref.placement, 2202 middlewareData = _ref.middlewareData;
2203 Object.assign(tooltip.style, { 2204 left: "".concat(x, "px"), 2205 top: "".concat(y, "px") 2206 }); 2207 var _middlewareData$arrow = middlewareData.arrow, 2208 arrowX = _middlewareData$arrow.x, 2209 arrowY = _middlewareData$arrow.y; 2210 var staticSide = { 2211 top: 'bottom', 2212 right: 'left', 2213 bottom: 'top', 2214 left: 'right' 2215 }[placement.split('-')[0]]; 2216 Object.assign(arrowEl.style, (0,_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__["default"])({ 2217 left: arrowX != null ? "".concat(arrowX, "px") : '', 2218 top: arrowY != null ? "".concat(arrowY, "px") : '', 2219 right: '', 2220 bottom: '' 2221 }, staticSide, '-15px')); 2222 }); 2223}; 2224 2225/** 2226 * @function createToolTip 2227 * @description Create a tooltip from the available text in the data attr. 2228 * @param button string 2229 * @param uid string 2230 */ 2231var createToolTip = function createToolTip(button, uid) { 2232 var content = JSON.parse(button.dataset.tooltip); 2233 var toolTipContent = document.createElement('div'); 2234 var toolTipArrow = document.createElement('div'); 2235 button.setAttribute('aria-describedby', uid); 2236 toolTipArrow.setAttribute('data-popper-arrow', ''); 2237 toolTipContent.classList.add('tribe-tooltip-content'); 2238 toolTipContent.setAttribute('tribe-tooltip-content', ''); 2239 toolTipContent.setAttribute('role', 'tooltip'); 2240 toolTipContent.setAttribute('id', uid); 2241 toolTipContent.innerHTML = "".concat(content.toolTipContent).concat(toolTipArrow.outerHTML); 2242 button.insertAdjacentHTML('afterend', toolTipContent.outerHTML); 2243 initUpdateToolTips(button, button.nextElementSibling); 2244}; 2245 2246/** 2247 * @function toolTipShow 2248 * @description display the tooltip. 2249 * @param e Object 2250 */ 2251var toolTipShow = function toolTipShow(e) { 2252 var el = e.target; 2253 el.nextElementSibling.classList.add('tribe-tooltip-visible'); 2254 initUpdateToolTips(e.target, el.nextElementSibling); 2255}; 2256 2257/** 2258 * @function toolTipHide 2259 * @description hide the tooltip. 2260 * @param e Object 2261 */ 2262var toolTipHide = function toolTipHide(e) { 2263 var el = e.target; 2264 el.nextElementSibling.classList.remove('tribe-tooltip-visible'); 2265}; 2266var bindEvents = function bindEvents() { 2267 document.querySelectorAll('[data-tooltip]').forEach(function (tooltip) { 2268 var uid = lodash__WEBPACK_IMPORTED_MODULE_1___default().uniqueId('tribe-tool-tip--'); 2269 createToolTip(tooltip, uid); 2270 2271 // hover or focus. 2272 tooltip.addEventListener('focus', function (e) { 2273 return toolTipShow(e); 2274 }); 2275 tooltip.addEventListener('mouseenter', function (e) { 2276 return toolTipShow(e); 2277 }); 2278 2279 // leave hover or focus. 2280 tooltip.addEventListener('blur', function (e) { 2281 return toolTipHide(e); 2282 }); 2283 tooltip.addEventListener('mouseout', function (e) { 2284 return toolTipHide(e); 2285 }); 2286 }); 2287}; 2288var dataToolTipsInit = function dataToolTipsInit() { 2289 bindEvents(); 2290}; 2291dataToolTipsInit(); 2292})(); 2293 2294/******/ })() 2295; 2296//# sourceMappingURL=dataorg-tool-tips.js.map
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.