https://sgb.gov.br/o/cprm-theme/js/gov/core-init.js?v=1

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

2027/***/ "./node_modules/flatpickr/dist/esm/utils/polyfills.js":
2028/***/ (() => {
2029
2030"use strict";
2031
2032if (typeof Object.assign !== "function") {
2033    Object.assign = function (target) {
2034        var args = [];
2035        for (var _i = 1; _i < arguments.length; _i++) {
2036            args[_i - 1] = arguments[_i];
2037        }
2038        if (!target) {
2039            throw TypeError("Cannot convert undefined or null to object");
2040        }
2041        var _loop_1 = function (source) {
2042            if (source) {
2043                Object.keys(source).forEach(function (key) { return (target[key] = source[key]); });
2044            }
2045        };
2046        for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
2047            var source = args_1[_a];
2048            _loop_1(source);
2049        }
2050        return target;
2051    };
2052}
2053
2054
2055/***/ }),
2056

2057/***/ "./node_modules/flatpickr/dist/l10n/pt.js":
2058/***/ (function(__unused_webpack_module, exports) {
2059
2060(function (global, factory) {
2061   true ? factory(exports) :
2062  0;
2063}(this, (function (exports) { 'use strict';
2064
2065  var fp = typeof window !== "undefined" && window.flatpickr !== undefined
2066      ? window.flatpickr
2067      : {
2068          l10ns: {},
2069      };
2070  var Portuguese = {
2071      weekdays: {
2072          shorthand: ["Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sáb"],
2073          longhand: [
2074              "Domingo",
2075              "Segunda-feira",
2076              "Terça-feira",
2077              "Quarta-feira",
2078              "Quinta-feira",
2079              "Sexta-feira",
2080              "Sábado",
2081          ],
2082      },
2083      months: {
2084          shorthand: [
2085              "Jan",
2086              "Fev",
2087              "Mar",
2088              "Abr",
2089              "Mai",
2090              "Jun",
2091              "Jul",
2092              "Ago",
2093              "Set",
2094              "Out",
2095              "Nov",
2096              "Dez",
2097          ],
2098          longhand: [
2099              "Janeiro",
2100              "Fevereiro",
2101              "Março",
2102              "Abril",
2103              "Maio",
2104              "Junho",
2105              "Julho",
2106              "Agosto",
2107              "Setembro",
2108              "Outubro",
2109              "Novembro",
2110              "Dezembro",
2111          ],
2112      },
2113      rangeSeparator: " até ",
2114      time_24hr: true,
2115  };
2116  fp.l10ns.pt = Portuguese;
2117  var pt = fp.l10ns;
2118
2119  exports.Portuguese = Portuguese;
2120  exports.default = pt;
2121
2122  Object.defineProperty(exports, '__esModule', { value: true });
2123
2124})));
2125
2126
2127/***/ }),
2128

2129/***/ "./node_modules/focus-visible/dist/focus-visible.js":
2130/***/ (function() {
2131
2132(function (global, factory) {
2133   true ? factory() :
2134  0;
2135}(this, (function () { 'use strict';
2136
2137  /**
2138   * Applies the :focus-visible polyfill at the given scope.
2139   * A scope in this case is either the top-level Document or a Shadow Root.
2140   *
2141   * @param {(Document|ShadowRoot)} scope
2142   * @see https://github.com/WICG/focus-visible
2143   */
2144  function applyFocusVisiblePolyfill(scope) {
2145    var hadKeyboardEvent = true;
2146    var hadFocusVisibleRecently = false;
2147    var hadFocusVisibleRecentlyTimeout = null;
2148
2149    var inputTypesAllowlist = {
2150      text: true,
2151      search: true,
2152      url: true,
2153      tel: true,
2154      email: true,
2155      password: true,
2156      number: true,
2157      date: true,
2158      month: true,
2159      week: true,
2160      time: true,
2161      datetime: true,
2162      'datetime-local': true
2163    };
2164
2165    /**
2166     * Helper function for legacy browsers and iframes which sometimes focus
2167     * elements like document, body, and non-interactive SVG.
2168     * @param {Element} el
2169     */
2170    function isValidFocusTarget(el) {
2171      if (
2172        el &&
2173        el !== document &&
2174        el.nodeName !== 'HTML' &&
2175        el.nodeName !== 'BODY' &&
2176        'classList' in el &&
2177        'contains' in el.classList
2178      ) {
2179        return true;
2180      }
2181      return false;
2182    }
2183
2184    /**
2185     * Computes whether the given element should automatically trigger the
2186     * `focus-visible` class being added, i.e. whether it should always match
2187     * `:focus-visible` when focused.
2188     * @param {Element} el
2189     * @return {boolean}
2190     */
2191    function focusTriggersKeyboardModality(el) {
2192      var type = el.type;
2193      var tagName = el.tagName;
2194
2195      if (tagName === 'INPUT' && inputTypesAllowlist[type] && !el.readOnly) {
2196        return true;
2197      }
2198
2199      if (tagName === 'TEXTAREA' && !el.readOnly) {
2200        return true;
2201      }
2202
2203      if (el.isContentEditable) {
2204        return true;
2205      }
2206
2207      return false;
2208    }
2209
2210    /**
2211     * Add the `focus-visible` class to the given element if it was not added by
2212     * the author.
2213     * @param {Element} el
2214     */
2215    function addFocusVisibleClass(el) {
2216      if (el.classList.contains('focus-visible')) {
2217        return;
2218      }
2219      el.classList.add('focus-visible');
2220      el.setAttribute('data-focus-visible-added', '');
2221    }
2222
2223    /**
2224     * Remove the `focus-visible` class from the given element if it was not
2225     * originally added by the author.
2226     * @param {Element} el
2227     */
2228    function removeFocusVisibleClass(el) {
2229      if (!el.hasAttribute('data-focus-visible-added')) {
2230        return;
2231      }
2232      el.classList.remove('focus-visible');
2233      el.removeAttribute('data-focus-visible-added');
2234    }
2235
2236    /**
2237     * If the most recent user interaction was via the keyboard;
2238     * and the key press did not include a meta, alt/option, or control key;
2239     * then the modality is keyboard. Otherwise, the modality is not keyboard.
2240     * Apply `focus-visible` to any current active element and keep track
2241     * of our keyboard modality state with `hadKeyboardEvent`.
2242     * @param {KeyboardEvent} e
2243     */
2244    function onKeyDown(e) {
2245      if (e.metaKey || e.altKey || e.ctrlKey) {
2246        return;
2247      }
2248
2249      if (isValidFocusTarget(scope.activeElement)) {
2250        addFocusVisibleClass(scope.activeElement);
2251      }
2252
2253      hadKeyboardEvent = true;
2254    }
2255
2256    /**
2257     * If at any point a user clicks with a pointing device, ensure that we change
2258     * the modality away from keyboard.
2259     * This avoids the situation where a user presses a key on an already focused
2260     * element, and then clicks on a different element, focusing it with a
2261     * pointing device, while we still think we're in keyboard modality.
2262     * @param {Event} e
2263     */
2264    function onPointerDown(e) {
2265      hadKeyboardEvent = false;
2266    }
2267
2268    /**
2269     * On `focus`, add the `focus-visible` class to the target if:
2270     * - the target received focus as a result of keyboard navigation, or
2271     * - the event target is an element that will likely require interaction
2272     *   via the keyboard (e.g. a text box)
2273     * @param {Event} e
2274     */
2275    function onFocus(e) {
2276      // Prevent IE from focusing the document or HTML element.
2277      if (!isValidFocusTarget(e.target)) {
2278        return;
2279      }
2280
2281      if (hadKeyboardEvent || focusTriggersKeyboardModality(e.target)) {
2282        addFocusVisibleClass(e.target);
2283      }
2284    }
2285
2286    /**
2287     * On `blur`, remove the `focus-visible` class from the target.
2288     * @param {Event} e
2289     */
2290    function onBlur(e) {
2291      if (!isValidFocusTarget(e.target)) {
2292        return;
2293      }
2294
2295      if (
2296        e.target.classList.contains('focus-visible') ||
2297        e.target.hasAttribute('data-focus-visible-added')
2298      ) {
2299        // To detect a tab/window switch, we look for a blur event followed
2300        // rapidly by a visibility change.
2301        // If we don't see a visibility change within 100ms, it's probably a
2302        // regular focus change.
2303        hadFocusVisibleRecently = true;
2304        window.clearTimeout(hadFocusVisibleRecentlyTimeout);
2305        hadFocusVisibleRecentlyTimeout = window.setTimeout(function() {
2306          hadFocusVisibleRecently = false;
2307        }, 100);
2308        removeFocusVisibleClass(e.target);
2309      }
2310    }
2311
2312    /**
2313     * If the user changes tabs, keep track of whether or not the previously
2314     * focused element had .focus-visible.
2315     * @param {Event} e
2316     */
2317    function onVisibilityChange(e) {
2318      if (document.visibilityState === 'hidden') {
2319        // If the tab becomes active again, the browser will handle calling focus
2320        // on the element (Safari actually calls it twice).
2321        // If this tab change caused a blur on an element with focus-visible,
2322        // re-apply the class when the user switches back to the tab.
2323        if (hadFocusVisibleRecently) {
2324          hadKeyboardEvent = true;
2325        }
2326        addInitialPointerMoveListeners();
2327      }
2328    }
2329
2330    /**
2331     * Add a group of listeners to detect usage of any pointing devices.
2332     * These listeners will be added when the polyfill first loads, and anytime
2333     * the window is blurred, so that they are active when the window regains
2334     * focus.
2335     */
2336    function addInitialPointerMoveListeners() {
2337      document.addEventListener('mousemove', onInitialPointerMove);
2338      document.addEventListener('mousedown', onInitialPointerMove);
2339      document.addEventListener('mouseup', onInitialPointerMove);
2340      document.addEventListener('pointermove', onInitialPointerMove);
2341      document.addEventListener('pointerdown', onInitialPointerMove);
2342      document.addEventListener('pointerup', onInitialPointerMove);
2343      document.addEventListener('touchmove', onInitialPointerMove);
2344      document.addEventListener('touchstart', onInitialPointerMove);
2345      document.addEventListener('touchend', onInitialPointerMove);
2346    }
2347
2348    function removeInitialPointerMoveListeners() {
2349      document.removeEventListener('mousemove', onInitialPointerMove);
2350      document.removeEventListener('mousedown', onInitialPointerMove);
2351      document.removeEventListener('mouseup', onInitialPointerMove);
2352      document.removeEventListener('pointermove', onInitialPointerMove);
2353      document.removeEventListener('pointerdown', onInitialPointerMove);
2354      document.removeEventListener('pointerup', onInitialPointerMove);
2355      document.removeEventListener('touchmove', onInitialPointerMove);
2356      document.removeEventListener('touchstart', onInitialPointerMove);
2357      document.removeEventListener('touchend', onInitialPointerMove);
2358    }
2359
2360    /**
2361     * When the polfyill first loads, assume the user is in keyboard modality.
2362     * If any event is received from a pointing device (e.g. mouse, pointer,
2363     * touch), turn off keyboard modality.
2364     * This accounts for situations where focus enters the page from the URL bar.
2365     * @param {Event} e
2366     */
2367    function onInitialPointerMove(e) {
2368      // Work around a Safari quirk that fires a mousemove on <html> whenever the
2369      // window blurs, even if you're tabbing out of the page. ¯\_(ツ)_/¯
2370      if (e.target.nodeName && e.target.nodeName.toLowerCase() === 'html') {
2371        return;
2372      }
2373
2374      hadKeyboardEvent = false;
2375      removeInitialPointerMoveListeners();
2376    }
2377
2378    // For some kinds of state, we are interested in changes at the global scope
2379    // only. For example, global pointer input, global key presses and global
2380    // visibility change should affect the state at every scope:
2381    document.addEventListener('keydown', onKeyDown, true);
2382    document.addEventListener('mousedown', onPointerDown, true);
2383    document.addEventListener('pointerdown', onPointerDown, true);
2384    document.addEventListener('touchstart', onPointerDown, true);
2385    document.addEventListener('visibilitychange', onVisibilityChange, true);
2386
2387    addInitialPointerMoveListeners();
2388
2389    // For focus and blur, we specifically care about state changes in the local
2390    // scope. This is because focus / blur events that originate from within a
2391    // shadow root are not re-dispatched from the host element if it was already
2392    // the active element in its own scope:
2393    scope.addEventListener('focus', onFocus, true);
2394    scope.addEventListener('blur', onBlur, true);
2395
2396    // We detect that a node is a ShadowRoot by ensuring that it is a
2397    // DocumentFragment and also has a host property. This check covers native
2398    // implementation and polyfill implementation transparently. If we only cared
2399    // about the native implementation, we could just check if the scope was
2400    // an instance of a ShadowRoot.
2401    if (scope.nodeType === Node.DOCUMENT_FRAGMENT_NODE && scope.host) {
2402      // Since a ShadowRoot is a special kind of DocumentFragment, it does not
2403      // have a root element to add a class to. So, we add this attribute to the
2404      // host element instead:
2405      scope.host.setAttribute('data-js-focus-visible', '');
2406    } else if (scope.nodeType === Node.DOCUMENT_NODE) {
2407      document.documentElement.classList.add('js-focus-visible');
2408      document.documentElement.setAttribute('data-js-focus-visible', '');
2409    }
2410  }
2411
2412  // It is important to wrap all references to global window and document in
2413  // these checks to support server-side rendering use cases
2414  // @see https://github.com/WICG/focus-visible/issues/199
2415  if (typeof window !== 'undefined' && typeof document !== 'undefined') {
2416    // Make the polyfill helper globally available. This can be used as a signal
2417    // to interested libraries that wish to coordinate with the polyfill for e.g.,
2418    // applying the polyfill to a shadow root:
2419    window.applyFocusVisiblePolyfill = applyFocusVisiblePolyfill;
2420
2421    // Notify interested libraries of the polyfill's presence, in case the
2422    // polyfill was loaded lazily:
2423    var event;
2424
2425    try {
2426      event = new CustomEvent('focus-visible-polyfill-ready');
2427    } catch (error) {
2428      // IE11 does not support using CustomEvent as a constructor directly:
2429      event = document.createEvent('CustomEvent');
2430      event.initCustomEvent('focus-visible-polyfill-ready', false, false, {});
2431    }
2432
2433    window.dispatchEvent(event);
2434  }
2435
2436  if (typeof document !== 'undefined') {
2437    // Apply the polyfill to the global document, so that no JavaScript
2438    // coordination is required to use the polyfill in the top-level document:
2439    applyFocusVisiblePolyfill(document);
2440  }
2441
2442})));
2443
2444
2445/***/ }),
2446

2447/***/ "./src/components/accordion/accordion.js":
2448/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
2449
2450"use strict";
2451/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2452/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
2453/* harmony export */ });
2454class BRAccordion {
2455  constructor(name, component) {
2456    this.name = name
2457    this.component = component
2458    this._setBehavior()
2459  }
2460
2461  _setBehavior() {
2462    for (const button of this.component.querySelectorAll('button.header')) {
2463      button.addEventListener('click', (event) => {
2464        this._collapse(event)
2465        this._changeIcon(event)
2466      })
2467    }
2468  }
2469
2470  // eslint-disable-next-line complexity
2471  _collapse(event) {
2472    if (this.component.hasAttribute('single')) {
2473      for (const field of this.component.querySelectorAll('.item')) {
2474        if (field === event.currentTarget.parentNode) {
2475          if (field.hasAttribute('active')) {
2476            field.removeAttribute('active')
2477          } else {
2478            field.setAttribute('active', '')
2479          }
2480        } else {
2481          if (field.hasAttribute('active')) {
2482            field.removeAttribute('active')
2483          }
2484        }
2485      }
2486    } else {
2487      for (const field of this.component.querySelectorAll('.item')) {
2488        if (field === event.currentTarget.parentNode) {
2489          if (field.hasAttribute('active')) {
2490            field.removeAttribute('active')
2491          } else {
2492            field.setAttribute('active', '')
2493          }
2494        }
2495      }
2496    }
2497  }
2498
2499  _changeIcon() {
2500    for (const field of this.component.querySelectorAll('.item')) {
2501      if (field.hasAttribute('active')) {
2502        for (const icon of field.querySelectorAll('.icon')) {
2503          icon.children[0].classList.remove('fa-angle-down')
2504          icon.children[0].classList.add('fa-angle-up')
2505        }
2506      } else {
2507        for (const icon of field.querySelectorAll('.icon')) {
2508          icon.children[0].classList.remove('fa-angle-up')
2509          icon.children[0].classList.add('fa-angle-down')
2510        }
2511      }
2512    }
2513  }
2514}
2515
2516/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (BRAccordion);
2517
2518
2519/***/ }),
2520

2577/***/ "./src/components/breadcrumb/breadcrumb.js":
2578/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
2579
2580"use strict";
2581/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2582/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
2583/* harmony export */ });
2584class BRBreadcrumb {
2585  /**
2586   * Instancia um componente breadcrumb
2587   * @param {string} name - nome do componente
2588   * @param {object} component - referencia ao objeto do DOM
2589   **/
2590  constructor(name, component) {
2591    this.name = name
2592    this.component = component
2593    this._setBehavior()
2594  }
2595
2596  /**
2597   * Define os comportamentos do componente
2598   * @private
2599   */
2600  _setBehavior() {
2601    this._setView()
2602    window.addEventListener('resize', () => {
2603      this._setView()
2604    })
2605    window.document.addEventListener('click', (event) => {
2606      if (
2607        !this.component.contains(event.target) &&
2608        this.component.querySelector('.br-card')
2609      ) {
2610        this.component.querySelector('.br-card').remove()
2611      }
2612    })
2613
2614    // window.addEventListener('resize', (event) => {})
2615  }
2616  /**
2617   * Reseta a view do breadcrumb
2618   */
2619  resetBreadcrumbs() {
2620    this._reset()
2621
2622    const brcardBreadcrumb = this.component.querySelector('.br-card')
2623    if (brcardBreadcrumb !== null) {
2624      brcardBreadcrumb.remove()
2625    }
2626    this._setView()
2627  }
2628
2629  /**
2630   * Atualiza a visualização do componente
2631   * @private
2632   */
2633  _setView() {
2634    this._reset()
2635    for (const crumbList of this.component.querySelectorAll('.crumb-list')) {
2636      const crumbs = crumbList.querySelectorAll('.crumb:not([data-active])')
2637      if (window.innerWidth < 575) {
2638        if (crumbs.length !== 1) {
2639          crumbs.forEach((crumb) => {
2640            crumb.classList.add('d-none')
2641          })
2642          this._insertExpandButton()
2643        }
2644      } else {
2645        if (
2646          crumbList.scrollWidth > crumbList.offsetWidth ||
2647          crumbs.length > 5
2648        ) {
2649          crumbs.forEach((crumb, index) => {
2650            if (index > 0 && index < crumbs.length - 1) {
2651              crumb.classList.add('d-none')
2652            }
2653          })
2654          this._insertExpandButton()
2655        }
2656      }
2657    }
2658  }
2659
2660  /**
2661   * Insere botao de expandir
2662   * @private
2663   */
2664  _insertExpandButton() {
2665    const crumb = this._createCrumb()
2666    const crumbList = this.component.querySelector('.crumb-list')
2667    const crumbs = crumbList.querySelectorAll('.crumb')
2668    crumbList.insertBefore(crumb, crumbs[1])
2669  }
2670
2671  /**
2672   * Reinicia componente
2673   * @private
2674   */
2675  _reset() {
2676    this.component.querySelectorAll('.crumb-list .crumb').forEach((crumb) => {
2677      if (crumb.classList.contains('menu-mobil')) {
2678        crumb.remove()
2679      } else {
2680        crumb.classList.remove('d-none')
2681      }
2682    })
2683  }
2684
2685  /**
2686   * Insere elementos
2687   * @private
2688   */
2689  _createCrumb() {
2690    const crumb = document.createElement('li')
2691    crumb.classList.add('crumb', 'menu-mobil')
2692    crumb.setAttribute('data-toggle', 'dropdown')
2693
2694    const button = document.createElement('button')
2695    button.classList.add('br-button', 'circle')
2696
2697    const span = document.createElement('span')
2698    span.classList.add('sr-only')
2699    span.innerHTML = 'Botão Menu'
2700
2701    const folderIcon = document.createElement('i')
2702    folderIcon.classList.add('fas', 'fa-folder-plus')
2703
2704    const chevronIcon = document.createElement('i')
2705    chevronIcon.classList.add('icon', 'fas', 'fa-chevron-right')
2706
2707    crumb.appendChild(chevronIcon)
2708    crumb.appendChild(button)
2709    button.appendChild(span)
2710    button.appendChild(folderIcon)
2711
2712    crumb.addEventListener('click', () => {
2713      let card = this.component.querySelector('.br-card')
2714      if (card) {
2715        folderIcon.classList.remove('fas', 'fa-folder-minus')
2716        folderIcon.classList.add('fas', 'fa-folder-plus')
2717        this.component.querySelector('.br-card').remove()
2718      } else {
2719        folderIcon.classList.remove('fas', 'fa-folder-plus')
2720        folderIcon.classList.add('fas', 'fa-folder-minus')