init 3

node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js.flow

@@ -0,0 +1,8 @@
+// @flow
+import getWindow from './getWindow';
+
+export default function getComputedStyle(
+  element: Element
+): CSSStyleDeclaration {
+  return getWindow(element).getComputedStyle(element);
+}

node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.d.ts

@@ -0,0 +1,2 @@
+import type { Rect } from "../types";
+export default function getDocumentRect(element: HTMLElement): Rect;

node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.d.ts

@@ -0,0 +1,4 @@
+export default function getHTMLElementScroll(element: HTMLElement): {
+    scrollLeft: number;
+    scrollTop: number;
+};

node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js.flow

@@ -0,0 +1,18 @@
+// @flow
+import getParentNode from './getParentNode';
+import isScrollParent from './isScrollParent';
+import getNodeName from './getNodeName';
+import { isHTMLElement } from './instanceOf';
+
+export default function getScrollParent(node: Node): HTMLElement {
+  if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
+    // $FlowFixMe[incompatible-return]: assume body is always available
+    return node.ownerDocument.body;
+  }
+
+  if (isHTMLElement(node) && isScrollParent(node)) {
+    return node;
+  }
+
+  return getScrollParent(getParentNode(node));
+}

node_modules/@popperjs/core/lib/dom-utils/getViewportRect.d.ts

@@ -0,0 +1,7 @@
+import type { PositioningStrategy } from "../types";
+export default function getViewportRect(element: Element, strategy: PositioningStrategy): {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+};

node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js

@@ -0,0 +1,31 @@
+import getWindow from "./getWindow.js";
+import getDocumentElement from "./getDocumentElement.js";
+import getWindowScrollBarX from "./getWindowScrollBarX.js";
+import isLayoutViewport from "./isLayoutViewport.js";
+export default function getViewportRect(element, strategy) {
+  var win = getWindow(element);
+  var html = getDocumentElement(element);
+  var visualViewport = win.visualViewport;
+  var width = html.clientWidth;
+  var height = html.clientHeight;
+  var x = 0;
+  var y = 0;
+
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    var layoutViewport = isLayoutViewport();
+
+    if (layoutViewport || !layoutViewport && strategy === 'fixed') {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+
+  return {
+    width: width,
+    height: height,
+    x: x + getWindowScrollBarX(element),
+    y: y
+  };
+}

node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js.flow

@@ -0,0 +1,39 @@
+// @flow
+import getWindow from './getWindow';
+import getDocumentElement from './getDocumentElement';
+import getWindowScrollBarX from './getWindowScrollBarX';
+import isLayoutViewport from './isLayoutViewport';
+import type { PositioningStrategy } from '../types';
+
+export default function getViewportRect(
+  element: Element,
+  strategy: PositioningStrategy
+) {
+  const win = getWindow(element);
+  const html = getDocumentElement(element);
+  const visualViewport = win.visualViewport;
+
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x = 0;
+  let y = 0;
+
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+
+    const layoutViewport = isLayoutViewport();
+
+    if (layoutViewport || (!layoutViewport && strategy === 'fixed')) {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+
+  return {
+    width,
+    height,
+    x: x + getWindowScrollBarX(element),
+    y,
+  };
+}

node_modules/@popperjs/core/lib/dom-utils/listScrollParents.d.ts

@@ -0,0 +1,2 @@
+import type { Window, VisualViewport } from "../types";
+export default function listScrollParents(element: Node, list?: Array<Element | Window>): Array<Element | Window | VisualViewport>;

node_modules/@popperjs/core/lib/enums.js

@@ -0,0 +1,31 @@
+export var top = 'top';
+export var bottom = 'bottom';
+export var right = 'right';
+export var left = 'left';
+export var auto = 'auto';
+export var basePlacements = [top, bottom, right, left];
+export var start = 'start';
+export var end = 'end';
+export var clippingParents = 'clippingParents';
+export var viewport = 'viewport';
+export var popper = 'popper';
+export var reference = 'reference';
+export var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
+  return acc.concat([placement + "-" + start, placement + "-" + end]);
+}, []);
+export var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
+  return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
+}, []); // modifiers that need to read the DOM
+
+export var beforeRead = 'beforeRead';
+export var read = 'read';
+export var afterRead = 'afterRead'; // pure-logic modifiers
+
+export var beforeMain = 'beforeMain';
+export var main = 'main';
+export var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)
+
+export var beforeWrite = 'beforeWrite';
+export var write = 'write';
+export var afterWrite = 'afterWrite';
+export var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];

node_modules/@popperjs/core/lib/modifiers/arrow.js.flow

@@ -0,0 +1,120 @@
+// @flow
+import type { Modifier, ModifierArguments, Padding, Rect } from '../types';
+import type { Placement } from '../enums';
+import getBasePlacement from '../utils/getBasePlacement';
+import getLayoutRect from '../dom-utils/getLayoutRect';
+import contains from '../dom-utils/contains';
+import getOffsetParent from '../dom-utils/getOffsetParent';
+import getMainAxisFromPlacement from '../utils/getMainAxisFromPlacement';
+import { within } from '../utils/within';
+import mergePaddingObject from '../utils/mergePaddingObject';
+import expandToHashMap from '../utils/expandToHashMap';
+import { left, right, basePlacements, top, bottom } from '../enums';
+
+// eslint-disable-next-line import/no-unused-modules
+export type Options = {
+  element: HTMLElement | string | null,
+  padding:
+    | Padding
+    | (({|
+        popper: Rect,
+        reference: Rect,
+        placement: Placement,
+      |}) => Padding),
+};
+
+const toPaddingObject = (padding, state) => {
+  padding =
+    typeof padding === 'function'
+      ? padding({ ...state.rects, placement: state.placement })
+      : padding;
+
+  return mergePaddingObject(
+    typeof padding !== 'number'
+      ? padding
+      : expandToHashMap(padding, basePlacements)
+  );
+};
+
+function arrow({ state, name, options }: ModifierArguments<Options>) {
+  const arrowElement = state.elements.arrow;
+  const popperOffsets = state.modifiersData.popperOffsets;
+  const basePlacement = getBasePlacement(state.placement);
+  const axis = getMainAxisFromPlacement(basePlacement);
+  const isVertical = [left, right].indexOf(basePlacement) >= 0;
+  const len = isVertical ? 'height' : 'width';
+
+  if (!arrowElement || !popperOffsets) {
+    return;
+  }
+
+  const paddingObject = toPaddingObject(options.padding, state);
+  const arrowRect = getLayoutRect(arrowElement);
+  const minProp = axis === 'y' ? top : left;
+  const maxProp = axis === 'y' ? bottom : right;
+
+  const endDiff =
+    state.rects.reference[len] +
+    state.rects.reference[axis] -
+    popperOffsets[axis] -
+    state.rects.popper[len];
+  const startDiff = popperOffsets[axis] - state.rects.reference[axis];
+
+  const arrowOffsetParent = getOffsetParent(arrowElement);
+  const clientSize = arrowOffsetParent
+    ? axis === 'y'
+      ? arrowOffsetParent.clientHeight || 0
+      : arrowOffsetParent.clientWidth || 0
+    : 0;
+
+  const centerToReference = endDiff / 2 - startDiff / 2;
+
+  // Make sure the arrow doesn't overflow the popper if the center point is
+  // outside of the popper bounds
+  const min = paddingObject[minProp];
+  const max = clientSize - arrowRect[len] - paddingObject[maxProp];
+  const center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
+  const offset = within(min, center, max);
+
+  // Prevents breaking syntax highlighting...
+  const axisProp: string = axis;
+  state.modifiersData[name] = {
+    [axisProp]: offset,
+    centerOffset: offset - center,
+  };
+}
+
+function effect({ state, options }: ModifierArguments<Options>) {
+  let { element: arrowElement = '[data-popper-arrow]' } = options;
+
+  if (arrowElement == null) {
+    return;
+  }
+
+  // CSS selector
+  if (typeof arrowElement === 'string') {
+    arrowElement = state.elements.popper.querySelector(arrowElement);
+
+    if (!arrowElement) {
+      return;
+    }
+  }
+
+  if (!contains(state.elements.popper, arrowElement)) {
+    return;
+  }
+
+  state.elements.arrow = arrowElement;
+}
+
+// eslint-disable-next-line import/no-unused-modules
+export type ArrowModifier = Modifier<'arrow', Options>;
+export default ({
+  name: 'arrow',
+  enabled: true,
+  phase: 'main',
+  fn: arrow,
+  effect,
+  requires: ['popperOffsets'],
+  requiresIfExists: ['preventOverflow'],
+}: ArrowModifier);

node_modules/@popperjs/core/lib/popper-base.js.flow

@@ -0,0 +1,7 @@
+// @flow
+import { createPopper, popperGenerator, detectOverflow } from './createPopper';
+
+export type * from './types';
+
+// eslint-disable-next-line import/no-unused-modules
+export { createPopper, popperGenerator, detectOverflow };

node_modules/@popperjs/core/lib/popper-lite.js.flow

@@ -0,0 +1,21 @@
+// @flow
+import { popperGenerator, detectOverflow } from './createPopper';
+
+import eventListeners from './modifiers/eventListeners';
+import popperOffsets from './modifiers/popperOffsets';
+import computeStyles from './modifiers/computeStyles';
+import applyStyles from './modifiers/applyStyles';
+
+export type * from './types';
+
+const defaultModifiers = [
+  eventListeners,
+  popperOffsets,
+  computeStyles,
+  applyStyles,
+];
+
+const createPopper = popperGenerator({ defaultModifiers });
+
+// eslint-disable-next-line import/no-unused-modules
+export { createPopper, popperGenerator, defaultModifiers, detectOverflow };

node_modules/@popperjs/core/lib/utils/computeOffsets.js

@@ -0,0 +1,70 @@
+import getBasePlacement from "./getBasePlacement.js";
+import getVariation from "./getVariation.js";
+import getMainAxisFromPlacement from "./getMainAxisFromPlacement.js";
+import { top, right, bottom, left, start, end } from "../enums.js";
+export default function computeOffsets(_ref) {
+  var reference = _ref.reference,
+      element = _ref.element,
+      placement = _ref.placement;
+  var basePlacement = placement ? getBasePlacement(placement) : null;
+  var variation = placement ? getVariation(placement) : null;
+  var commonX = reference.x + reference.width / 2 - element.width / 2;
+  var commonY = reference.y + reference.height / 2 - element.height / 2;
+  var offsets;
+
+  switch (basePlacement) {
+    case top:
+      offsets = {
+        x: commonX,
+        y: reference.y - element.height
+      };
+      break;
+
+    case bottom:
+      offsets = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+
+    case right:
+      offsets = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+
+    case left:
+      offsets = {
+        x: reference.x - element.width,
+        y: commonY
+      };
+      break;
+
+    default:
+      offsets = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+
+  var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
+
+  if (mainAxis != null) {
+    var len = mainAxis === 'y' ? 'height' : 'width';
+
+    switch (variation) {
+      case start:
+        offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
+        break;
+
+      case end:
+        offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
+        break;
+
+      default:
+    }
+  }
+
+  return offsets;
+}

node_modules/@popperjs/core/lib/utils/getFreshSideObject.d.ts

@@ -0,0 +1,2 @@
+import type { SideObject } from "../types";
+export default function getFreshSideObject(): SideObject;

node_modules/@popperjs/core/lib/utils/getOppositePlacement.js

@@ -0,0 +1,11 @@
+var hash = {
+  left: 'right',
+  right: 'left',
+  bottom: 'top',
+  top: 'bottom'
+};
+export default function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, function (matched) {
+    return hash[matched];
+  });
+}

node_modules/@popperjs/core/lib/utils/getVariation.js.flow

@@ -0,0 +1,6 @@
+// @flow
+import { type Variation, type Placement } from '../enums';
+
+export default function getVariation(placement: Placement): ?Variation {
+  return (placement.split('-')[1]: any);
+}