Proyectos de Subversion Moodle

Rev

| Ultima modificación | Ver Log |

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