1

admin/node_modules/@popperjs/core/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Federico Zivolo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

admin/node_modules/@popperjs/core/README.md

@@ -0,0 +1,376 @@
+<!-- <HEADER> // IGNORE IT -->
+<p align="center">
+  <img src="https://rawcdn.githack.com/popperjs/popper-core/8805a5d7599e14619c9e7ac19a3713285d8e5d7f/docs/src/images/popper-logo-outlined.svg" alt="Popper" height="300px"/>
+</p>
+
+<div align="center">
+  <h1>Tooltip & Popover Positioning Engine</h1>
+</div>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@popperjs/core">
+    <img src="https://img.shields.io/npm/v/@popperjs/core?style=for-the-badge" alt="npm version" />
+  </a>
+  <a href="https://www.npmjs.com/package/@popperjs/core">
+    <img src="https://img.shields.io/endpoint?style=for-the-badge&url=https://runkit.io/fezvrasta/combined-npm-downloads/1.0.0?packages=popper.js,@popperjs/core" alt="npm downloads per month (popper.js + @popperjs/core)" />
+  </a>
+  <a href="https://rollingversions.com/popperjs/popper-core">
+    <img src="https://img.shields.io/badge/Rolling%20Versions-Enabled-brightgreen?style=for-the-badge" alt="Rolling Versions" />
+  </a>
+</p>
+
+<br />
+<!-- </HEADER> // NOW BEGINS THE README -->
+
+**Positioning tooltips and popovers is difficult. Popper is here to help!**
+
+Given an element, such as a button, and a tooltip element describing it, Popper
+will automatically put the tooltip in the right place near the button.
+
+It will position _any_ UI element that "pops out" from the flow of your document
+and floats near a target element. The most common example is a tooltip, but it
+also includes popovers, drop-downs, and more. All of these can be generically
+described as a "popper" element.
+
+## Demo
+
+[![Popper visualized](https://i.imgur.com/F7qWsmV.jpg)](https://popper.js.org)
+
+## Docs
+
+- [v2.x (latest)](https://popper.js.org/docs/v2/)
+- [v1.x](https://popper.js.org/docs/v1/)
+
+We've created a
+[Migration Guide](https://popper.js.org/docs/v2/migration-guide/) to help you
+migrate from Popper 1 to Popper 2.
+
+To contribute to the Popper website and documentation, please visit the
+[dedicated repository](https://github.com/popperjs/website).
+
+## Why not use pure CSS?
+
+- **Clipping and overflow issues**: Pure CSS poppers will not be prevented from
+  overflowing clipping boundaries, such as the viewport. It will get partially
+  cut off or overflows if it's near the edge since there is no dynamic
+  positioning logic. When using Popper, your popper will always be positioned in
+  the right place without needing manual adjustments.
+- **No flipping**: CSS poppers will not flip to a different placement to fit
+  better in view if necessary. While you can manually adjust for the main axis
+  overflow, this feature cannot be achieved via CSS alone. Popper automatically
+  flips the tooltip to make it fit in view as best as possible for the user.
+- **No virtual positioning**: CSS poppers cannot follow the mouse cursor or be
+  used as a context menu. Popper allows you to position your tooltip relative to
+  any coordinates you desire.
+- **Slower development cycle**: When pure CSS is used to position popper
+  elements, the lack of dynamic positioning means they must be carefully placed
+  to consider overflow on all screen sizes. In reusable component libraries,
+  this means a developer can't just add the component anywhere on the page,
+  because these issues need to be considered and adjusted for every time. With
+  Popper, you can place your elements anywhere and they will be positioned
+  correctly, without needing to consider different screen sizes, layouts, etc.
+  This massively speeds up development time because this work is automatically
+  offloaded to Popper.
+- **Lack of extensibility**: CSS poppers cannot be easily extended to fit any
+  arbitrary use case you may need to adjust for. Popper is built with
+  extensibility in mind.
+
+## Why Popper?
+
+With the CSS drawbacks out of the way, we now move on to Popper in the
+JavaScript space itself.
+
+Naive JavaScript tooltip implementations usually have the following problems:
+
+- **Scrolling containers**: They don't ensure the tooltip stays with the
+  reference element while scrolling when inside any number of scrolling
+  containers.
+- **DOM context**: They often require the tooltip move outside of its original
+  DOM context because they don't handle `offsetParent` contexts.
+- **Compatibility**: Popper handles an incredible number of edge cases regarding
+  different browsers and environments (mobile viewports, RTL, scrollbars enabled
+  or disabled, etc.). Popper is a popular and well-maintained library, so you
+  can be confident positioning will work for your users on any device.
+- **Configurability**: They often lack advanced configurability to suit any
+  possible use case.
+- **Size**: They are usually relatively large in size, or require an ancient
+  jQuery dependency.
+- **Performance**: They often have runtime performance issues and update the
+  tooltip position too slowly.
+
+**Popper solves all of these key problems in an elegant, performant manner.** It
+is a lightweight ~3 kB library that aims to provide a reliable and extensible
+positioning engine you can use to ensure all your popper elements are positioned
+in the right place.
+
+When you start writing your own popper implementation, you'll quickly run into
+all of the problems mentioned above. These widgets are incredibly common in our
+UIs; we've done the hard work figuring this out so you don't need to spend hours
+fixing and handling numerous edge cases that we already ran into while building
+the library!
+
+Popper is used in popular libraries like Bootstrap, Foundation, Material UI, and
+more. It's likely you've already used popper elements on the web positioned by
+Popper at some point in the past few years.
+
+Since we write UIs using powerful abstraction libraries such as React or Angular
+nowadays, you'll also be glad to know Popper can fully integrate with them and
+be a good citizen together with your other components. Check out `react-popper`
+for the official Popper wrapper for React.
+
+## Installation
+
+### 1. Package Manager
+
+```bash
+# With npm
+npm i @popperjs/core
+
+# With Yarn
+yarn add @popperjs/core
+```
+
+### 2. CDN
+
+```html
+<!-- Development version -->
+<script src="https://unpkg.com/@popperjs/core@2/dist/umd/popper.js"></script>
+
+<!-- Production version -->
+<script src="https://unpkg.com/@popperjs/core@2"></script>
+```
+
+### 3. Direct Download?
+
+Managing dependencies by "directly downloading" them and placing them into your
+source code is not recommended for a variety of reasons, including missing out
+on feat/fix updates easily. Please use a versioning management system like a CDN
+or npm/Yarn.
+
+## Usage
+
+The most straightforward way to get started is to import Popper from the `unpkg`
+CDN, which includes all of its features. You can call the `Popper.createPopper`
+constructor to create new popper instances.
+
+Here is a complete example:
+
+```html
+<!DOCTYPE html>
+<title>Popper example</title>
+
+<style>
+  #tooltip {
+    background-color: #333;
+    color: white;
+    padding: 5px 10px;
+    border-radius: 4px;
+    font-size: 13px;
+  }
+</style>
+
+<button id="button" aria-describedby="tooltip">I'm a button</button>
+<div id="tooltip" role="tooltip">I'm a tooltip</div>
+
+<script src="https://unpkg.com/@popperjs/core@^2.0.0"></script>
+<script>
+  const button = document.querySelector('#button');
+  const tooltip = document.querySelector('#tooltip');
+
+  // Pass the button, the tooltip, and some options, and Popper will do the
+  // magic positioning for you:
+  Popper.createPopper(button, tooltip, {
+    placement: 'right',
+  });
+</script>
+```
+
+Visit the [tutorial](https://popper.js.org/docs/v2/tutorial/) for an example of
+how to build your own tooltip from scratch using Popper.
+
+### Module bundlers
+
+You can import the `createPopper` constructor from the fully-featured file:
+
+```js
+import { createPopper } from '@popperjs/core';
+
+const button = document.querySelector('#button');
+const tooltip = document.querySelector('#tooltip');
+
+// Pass the button, the tooltip, and some options, and Popper will do the
+// magic positioning for you:
+createPopper(button, tooltip, {
+  placement: 'right',
+});
+```
+
+All the modifiers listed in the docs menu will be enabled and "just work", so
+you don't need to think about setting Popper up. The size of Popper including
+all of its features is about 5 kB minzipped, but it may grow a bit in the
+future.
+
+#### Popper Lite (tree-shaking)
+
+If bundle size is important, you'll want to take advantage of tree-shaking. The
+library is built in a modular way to allow to import only the parts you really
+need.
+
+```js
+import { createPopperLite as createPopper } from '@popperjs/core';
+```
+
+The Lite version includes the most necessary modifiers that will compute the
+offsets of the popper, compute and add the positioning styles, and add event
+listeners. This is close in bundle size to pure CSS tooltip libraries, and
+behaves somewhat similarly.
+
+However, this does not include the features that makes Popper truly useful.
+
+The two most useful modifiers not included in Lite are `preventOverflow` and
+`flip`:
+
+```js
+import {
+  createPopperLite as createPopper,
+  preventOverflow,
+  flip,
+} from '@popperjs/core';
+
+const button = document.querySelector('#button');
+const tooltip = document.querySelector('#tooltip');
+
+createPopper(button, tooltip, {
+  modifiers: [preventOverflow, flip],
+});
+```
+
+As you make more poppers, you may be finding yourself needing other modifiers
+provided by the library.
+
+See [tree-shaking](https://popper.js.org/docs/v2/performance/#tree-shaking) for more
+information.
+
+## Distribution targets
+
+Popper is distributed in 3 different versions, in 3 different file formats.
+
+The 3 file formats are:
+
+- `esm` (works with `import` syntax — **recommended**)
+- `umd` (works with `<script>` tags or RequireJS)
+- `cjs` (works with `require()` syntax)
+
+There are two different `esm` builds, one for bundler consumers (e.g. webpack,
+Rollup, etc..), which is located under `/lib`, and one for browsers with native
+support for ES Modules, under `/dist/esm`. The only difference within the two,
+is that the browser-compatible version doesn't make use of
+`process.env.NODE_ENV` to run development checks.
+
+The 3 versions are:
+
+- `popper`: includes all the modifiers (features) in one file (**default**);
+- `popper-lite`: includes only the minimum amount of modifiers to provide the
+  basic functionality;
+- `popper-base`: doesn't include any modifier, you must import them separately;
+
+Below you can find the size of each version, minified and compressed with the
+[Brotli compression algorithm](https://medium.com/groww-engineering/enable-brotli-compression-in-webpack-with-fallback-to-gzip-397a57cf9fc6):
+
+<!-- Don't change the labels to use hyphens, it breaks, even when encoded -->
+
+![](https://badge-size.now.sh/https://unpkg.com/@popperjs/core/dist/umd/popper.min.js?compression=brotli&label=popper)
+![](https://badge-size.now.sh/https://unpkg.com/@popperjs/core/dist/umd/popper-lite.min.js?compression=brotli&label=popper%20lite)
+![](https://badge-size.now.sh/https://unpkg.com/@popperjs/core/dist/umd/popper-base.min.js?compression=brotli&label=popper%20base)
+
+## Hacking the library
+
+If you want to play with the library, implement new features, fix a bug you
+found, or simply experiment with it, this section is for you!
+
+First of all, make sure to have
+[Yarn installed](https://yarnpkg.com/lang/en/docs/install).
+
+Install the development dependencies:
+
+```bash
+yarn install
+```
+
+And run the development environment:
+
+```bash
+yarn dev
+```
+
+Then, simply open one the development server web page:
+
+```bash
+# macOS and Linux
+open localhost:5000
+
+# Windows
+start localhost:5000
+```
+
+From there, you can open any of the examples (`.html` files) to fiddle with
+them.
+
+Now any change you will made to the source code, will be automatically compiled,
+you just need to refresh the page.
+
+If the page is not working properly, try to go in _"Developer Tools >
+Application > Clear storage"_ and click on "_Clear site data_".  
+To run the examples you need a browser with
+[JavaScript modules via script tag support](https://caniuse.com/#feat=es6-module).
+
+## Test Suite
+
+Popper is currently tested with unit tests, and functional tests. Both of them
+are run by Jest.
+
+### Unit Tests
+
+The unit tests use JSDOM to provide a primitive document object API, they are
+used to ensure the utility functions behave as expected in isolation.
+
+### Functional Tests
+
+The functional tests run with Puppeteer, to take advantage of a complete browser
+environment. They are currently running on Chromium, and Firefox.
+
+You can run them with `yarn test:functional`. Set the `PUPPETEER_BROWSER`
+environment variable to `firefox` to run them on the Mozilla browser.
+
+The assertions are written in form of image snapshots, so that it's easy to
+assert for the correct Popper behavior without having to write a lot of offsets
+comparisons manually.
+
+You can mark a `*.test.js` file to run in the Puppeteer environment by
+prepending a `@jest-environment puppeteer` JSDoc comment to the interested file.
+
+Here's an example of a basic functional test:
+
+```js
+/**
+ * @jest-environment puppeteer
+ * @flow
+ */
+import { screenshot } from '../utils/puppeteer.js';
+
+it('should position the popper on the right', async () => {
+  const page = await browser.newPage();
+  await page.goto(`${TEST_URL}/basic.html`);
+
+  expect(await screenshot(page)).toMatchImageSnapshot();
+});
+```
+
+You can find the complete
+[`jest-puppeteer` documentation here](https://github.com/smooth-code/jest-puppeteer#api),
+and the
+[`jest-image-snapshot` documentation here](https://github.com/americanexpress/jest-image-snapshot#%EF%B8%8F-api).
+
+## License
+
+MIT

admin/node_modules/@popperjs/core/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

admin/node_modules/@popperjs/core/lib/createPopper.d.ts

@@ -0,0 +1,9 @@
+import type { OptionsGeneric, Modifier, Instance, VirtualElement } from "./types";
+import detectOverflow from "./utils/detectOverflow";
+declare type PopperGeneratorArgs = {
+    defaultModifiers?: Array<Modifier<any, any>>;
+    defaultOptions?: Partial<OptionsGeneric<any>>;
+};
+export declare function popperGenerator(generatorOptions?: PopperGeneratorArgs): <TModifier extends Partial<Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<OptionsGeneric<TModifier>>) => Instance;
+export declare const createPopper: <TModifier extends Partial<Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<OptionsGeneric<TModifier>>) => Instance;
+export { detectOverflow };

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

@@ -0,0 +1 @@
+export default function contains(parent: Element, child: Element): boolean;

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

@@ -0,0 +1,2 @@
+import type { ClientRectObject, VirtualElement } from "../types";
+export default function getBoundingClientRect(element: Element | VirtualElement, includeScale?: boolean): ClientRectObject;

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

@@ -0,0 +1,3 @@
+import type { ClientRectObject } from "../types";
+import type { Boundary, RootBoundary } from "../enums";
+export default function getClippingRect(element: Element, boundary: Boundary, rootBoundary: RootBoundary): ClientRectObject;

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

@@ -0,0 +1,2 @@
+import type { Rect, VirtualElement, Window } from "../types";
+export default function getCompositeRect(elementOrVirtualElement: Element | VirtualElement, offsetParent: Element | Window, isFixed?: boolean): Rect;

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

@@ -0,0 +1 @@
+export default function getComputedStyle(element: Element): CSSStyleDeclaration;

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

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

admin/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;

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

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

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

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

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

@@ -0,0 +1,2 @@
+import type { Window } from "../types";
+export default function getNodeName(element: (Node | null | undefined) | Window): string | null | undefined;

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

@@ -0,0 +1,5 @@
+import type { Window } from "../types";
+export default function getNodeScroll(node: Node | Window): {
+    scrollLeft: any;
+    scrollTop: any;
+};

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

@@ -0,0 +1 @@
+export default function getOffsetParent(element: Element): any;

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

@@ -0,0 +1 @@
+export default function getParentNode(element: Node | ShadowRoot): Node;

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

@@ -0,0 +1 @@
+export default function getScrollParent(node: Node): HTMLElement;

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

@@ -0,0 +1,6 @@
+export default function getViewportRect(element: Element): {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+};

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

@@ -0,0 +1 @@
+export default function getWindow(node: any): any;

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

@@ -0,0 +1,5 @@
+import type { Window } from "../types";
+export default function getWindowScroll(node: Node | Window): {
+    scrollLeft: any;
+    scrollTop: any;
+};

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

@@ -0,0 +1 @@
+export default function getWindowScrollBarX(element: Element): number;

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

@@ -0,0 +1,4 @@
+declare function isElement(node: unknown): boolean;
+declare function isHTMLElement(node: unknown): boolean;
+declare function isShadowRoot(node: unknown): boolean;
+export { isElement, isHTMLElement, isShadowRoot };

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

@@ -0,0 +1 @@
+export default function isScrollParent(element: HTMLElement): boolean;

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

@@ -0,0 +1 @@
+export default function isTableElement(element: Element): boolean;

admin/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>;

admin/node_modules/@popperjs/core/lib/enums.d.ts

@@ -0,0 +1,34 @@
+export declare const top: "top";
+export declare const bottom: "bottom";
+export declare const right: "right";
+export declare const left: "left";
+export declare const auto: "auto";
+export declare type BasePlacement = typeof top | typeof bottom | typeof right | typeof left;
+export declare const basePlacements: Array<BasePlacement>;
+export declare const start: "start";
+export declare const end: "end";
+export declare type Variation = typeof start | typeof end;
+export declare const clippingParents: "clippingParents";
+export declare const viewport: "viewport";
+export declare type Boundary = Element | Array<Element> | typeof clippingParents;
+export declare type RootBoundary = typeof viewport | "document";
+export declare const popper: "popper";
+export declare const reference: "reference";
+export declare type Context = typeof popper | typeof reference;
+export declare type VariationPlacement = "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
+export declare type AutoPlacement = "auto" | "auto-start" | "auto-end";
+export declare type ComputedPlacement = VariationPlacement | BasePlacement;
+export declare type Placement = AutoPlacement | BasePlacement | VariationPlacement;
+export declare const variationPlacements: Array<VariationPlacement>;
+export declare const placements: Array<Placement>;
+export declare const beforeRead: "beforeRead";
+export declare const read: "read";
+export declare const afterRead: "afterRead";
+export declare const beforeMain: "beforeMain";
+export declare const main: "main";
+export declare const afterMain: "afterMain";
+export declare const beforeWrite: "beforeWrite";
+export declare const write: "write";
+export declare const afterWrite: "afterWrite";
+export declare const modifierPhases: Array<ModifierPhases>;
+export declare type ModifierPhases = typeof beforeRead | typeof read | typeof afterRead | typeof beforeMain | typeof main | typeof afterMain | typeof beforeWrite | typeof write | typeof afterWrite;

admin/node_modules/@popperjs/core/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./enums";
+export * from "./modifiers";
+export { popperGenerator, detectOverflow, createPopper as createPopperBase } from "./createPopper";
+export { createPopper } from "./popper";
+export { createPopper as createPopperLite } from "./popper-lite";

admin/node_modules/@popperjs/core/lib/modifiers/applyStyles.d.ts

@@ -0,0 +1,4 @@
+import type { Modifier } from "../types";
+export declare type ApplyStylesModifier = Modifier<"applyStyles", {}>;
+declare const _default: ApplyStylesModifier;
+export default _default;

admin/node_modules/@popperjs/core/lib/modifiers/arrow.d.ts

@@ -0,0 +1,13 @@
+import type { Modifier, Padding, Rect } from "../types";
+import type { Placement } from "../enums";
+export declare type Options = {
+    element: HTMLElement | string | null;
+    padding: Padding | ((arg0: {
+        popper: Rect;
+        reference: Rect;
+        placement: Placement;
+    }) => Padding);
+};
+export declare type ArrowModifier = Modifier<"arrow", Options>;
+declare const _default: ArrowModifier;
+export default _default;

admin/node_modules/@popperjs/core/lib/modifiers/computeStyles.d.ts

@@ -0,0 +1,38 @@
+import type { PositioningStrategy, Offsets, Modifier, Rect } from "../types";
+import { BasePlacement, Variation } from "../enums";
+export declare type RoundOffsets = (offsets: Partial<{
+    x: number;
+    y: number;
+    centerOffset: number;
+}>) => Offsets;
+export declare type Options = {
+    gpuAcceleration: boolean;
+    adaptive: boolean;
+    roundOffsets?: boolean | RoundOffsets;
+};
+export declare function mapToStyles({ popper, popperRect, placement, variation, offsets, position, gpuAcceleration, adaptive, roundOffsets, isFixed }: {
+    popper: HTMLElement;
+    popperRect: Rect;
+    placement: BasePlacement;
+    variation: Variation | null | undefined;
+    offsets: Partial<{
+        x: number;
+        y: number;
+        centerOffset: number;
+    }>;
+    position: PositioningStrategy;
+    gpuAcceleration: boolean;
+    adaptive: boolean;
+    roundOffsets: boolean | RoundOffsets;
+    isFixed: boolean;
+}): {
+    transform: string;
+    top: string;
+    right: string;
+    bottom: string;
+    left: string;
+    position: PositioningStrategy;
+};
+export declare type ComputeStylesModifier = Modifier<"computeStyles", Options>;
+declare const _default: ComputeStylesModifier;
+export default _default;

admin/node_modules/@popperjs/core/lib/modifiers/eventListeners.d.ts

@@ -0,0 +1,8 @@
+import type { Modifier } from "../types";
+export declare type Options = {
+    scroll: boolean;
+    resize: boolean;
+};
+export declare type EventListenersModifier = Modifier<"eventListeners", Options>;
+declare const _default: EventListenersModifier;
+export default _default;

admin/node_modules/@popperjs/core/lib/modifiers/flip.d.ts

@@ -0,0 +1,16 @@
+import type { Placement, Boundary, RootBoundary } from "../enums";
+import type { Modifier, Padding } from "../types";
+export declare type Options = {
+    mainAxis: boolean;
+    altAxis: boolean;
+    fallbackPlacements: Array<Placement>;
+    padding: Padding;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    altBoundary: boolean;
+    flipVariations: boolean;
+    allowedAutoPlacements: Array<Placement>;
+};
+export declare type FlipModifier = Modifier<"flip", Options>;
+declare const _default: FlipModifier;
+export default _default;

admin/node_modules/@popperjs/core/lib/modifiers/hide.d.ts

@@ -0,0 +1,4 @@
+import type { Modifier } from "../types";
+export declare type HideModifier = Modifier<"hide", {}>;
+declare const _default: HideModifier;
+export default _default;

admin/node_modules/@popperjs/core/lib/modifiers/index.d.ts

@@ -0,0 +1,9 @@
+export { default as applyStyles } from "./applyStyles";
+export { default as arrow } from "./arrow";
+export { default as computeStyles } from "./computeStyles";
+export { default as eventListeners } from "./eventListeners";
+export { default as flip } from "./flip";
+export { default as hide } from "./hide";
+export { default as offset } from "./offset";
+export { default as popperOffsets } from "./popperOffsets";
+export { default as preventOverflow } from "./preventOverflow";

admin/node_modules/@popperjs/core/lib/modifiers/offset.d.ts

@@ -0,0 +1,18 @@
+import type { Placement } from "../enums";
+import type { Modifier, Rect, Offsets } from "../types";
+export declare type OffsetsFunction = (arg0: {
+    popper: Rect;
+    reference: Rect;
+    placement: Placement;
+}) => [number | null | undefined, number | null | undefined];
+declare type Offset = OffsetsFunction | [number | null | undefined, number | null | undefined];
+export declare type Options = {
+    offset: Offset;
+};
+export declare function distanceAndSkiddingToXY(placement: Placement, rects: {
+    popper: Rect;
+    reference: Rect;
+}, offset: Offset): Offsets;
+export declare type OffsetModifier = Modifier<"offset", Options>;
+declare const _default: OffsetModifier;
+export default _default;

admin/node_modules/@popperjs/core/lib/modifiers/popperOffsets.d.ts

@@ -0,0 +1,4 @@
+import type { Modifier } from "../types";
+export declare type PopperOffsetsModifier = Modifier<"popperOffsets", {}>;
+declare const _default: PopperOffsetsModifier;
+export default _default;

admin/node_modules/@popperjs/core/lib/modifiers/preventOverflow.d.ts

@@ -0,0 +1,30 @@
+import type { Placement, Boundary, RootBoundary } from "../enums";
+import type { Rect, Modifier, Padding } from "../types";
+declare type TetherOffset = ((arg0: {
+    popper: Rect;
+    reference: Rect;
+    placement: Placement;
+}) => number | {
+    mainAxis: number;
+    altAxis: number;
+}) | number | {
+    mainAxis: number;
+    altAxis: number;
+};
+export declare type Options = {
+    mainAxis: boolean;
+    altAxis: boolean;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    altBoundary: boolean;
+    /**
+     * Allows the popper to overflow from its boundaries to keep it near its
+     * reference element
+     */
+    tether: boolean;
+    tetherOffset: TetherOffset;
+    padding: Padding;
+};
+export declare type PreventOverflowModifier = Modifier<"preventOverflow", Options>;
+declare const _default: PreventOverflowModifier;
+export default _default;

admin/node_modules/@popperjs/core/lib/popper-base.d.ts

@@ -0,0 +1,3 @@
+import { createPopper, popperGenerator, detectOverflow } from "./createPopper";
+export * from "./types";
+export { createPopper, popperGenerator, detectOverflow };

admin/node_modules/@popperjs/core/lib/popper-lite.d.ts

@@ -0,0 +1,5 @@
+import { popperGenerator, detectOverflow } from "./createPopper";
+export * from "./types";
+declare const defaultModifiers: (import("./modifiers/popperOffsets").PopperOffsetsModifier | import("./modifiers/eventListeners").EventListenersModifier | import("./modifiers/computeStyles").ComputeStylesModifier | import("./modifiers/applyStyles").ApplyStylesModifier)[];
+declare const createPopper: <TModifier extends Partial<import("./types").Modifier<any, any>>>(reference: Element | import("./types").VirtualElement, popper: HTMLElement, options?: Partial<import("./types").OptionsGeneric<TModifier>>) => import("./types").Instance;
+export { createPopper, popperGenerator, defaultModifiers, detectOverflow };

admin/node_modules/@popperjs/core/lib/popper.d.ts

@@ -0,0 +1,7 @@
+import { popperGenerator, detectOverflow } from "./createPopper";
+export * from "./types";
+declare const defaultModifiers: (import("./modifiers/popperOffsets").PopperOffsetsModifier | import("./modifiers/flip").FlipModifier | import("./modifiers/hide").HideModifier | import("./modifiers/offset").OffsetModifier | import("./modifiers/eventListeners").EventListenersModifier | import("./modifiers/computeStyles").ComputeStylesModifier | import("./modifiers/arrow").ArrowModifier | import("./modifiers/preventOverflow").PreventOverflowModifier | import("./modifiers/applyStyles").ApplyStylesModifier)[];
+declare const createPopper: <TModifier extends Partial<import("./types").Modifier<any, any>>>(reference: Element | import("./types").VirtualElement, popper: HTMLElement, options?: Partial<import("./types").OptionsGeneric<TModifier>>) => import("./types").Instance;
+export { createPopper, popperGenerator, defaultModifiers, detectOverflow };
+export { createPopper as createPopperLite } from "./popper-lite";
+export * from "./modifiers";

admin/node_modules/@popperjs/core/lib/types.d.ts

@@ -0,0 +1,167 @@
+import type { Placement, ModifierPhases } from "./enums";
+import type { PopperOffsetsModifier } from "./modifiers/popperOffsets";
+import type { FlipModifier } from "./modifiers/flip";
+import type { HideModifier } from "./modifiers/hide";
+import type { OffsetModifier } from "./modifiers/offset";
+import type { EventListenersModifier } from "./modifiers/eventListeners";
+import type { ComputeStylesModifier } from "./modifiers/computeStyles";
+import type { ArrowModifier } from "./modifiers/arrow";
+import type { PreventOverflowModifier } from "./modifiers/preventOverflow";
+import type { ApplyStylesModifier } from "./modifiers/applyStyles";
+export declare type Obj = {
+    [key: string]: any;
+};
+export declare type VisualViewport = EventTarget & {
+    width: number;
+    height: number;
+    offsetLeft: number;
+    offsetTop: number;
+    scale: number;
+};
+export declare type Window = {
+    innerHeight: number;
+    offsetHeight: number;
+    innerWidth: number;
+    offsetWidth: number;
+    pageXOffset: number;
+    pageYOffset: number;
+    getComputedStyle: typeof getComputedStyle;
+    addEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
+    removeEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
+    Element: Element;
+    HTMLElement: HTMLElement;
+    Node: Node;
+    toString(): "[object Window]";
+    devicePixelRatio: number;
+    visualViewport?: VisualViewport;
+    ShadowRoot: ShadowRoot;
+};
+export declare type Rect = {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+};
+export declare type Offsets = {
+    y: number;
+    x: number;
+};
+export declare type PositioningStrategy = "absolute" | "fixed";
+export declare type StateRects = {
+    reference: Rect;
+    popper: Rect;
+};
+export declare type StateOffsets = {
+    popper: Offsets;
+    arrow?: Offsets;
+};
+declare type OffsetData = {
+    [key in Placement]?: Offsets;
+};
+export declare type State = {
+    elements: {
+        reference: Element | VirtualElement;
+        popper: HTMLElement;
+        arrow?: HTMLElement;
+    };
+    options: OptionsGeneric<any>;
+    placement: Placement;
+    strategy: PositioningStrategy;
+    orderedModifiers: Array<Modifier<any, any>>;
+    rects: StateRects;
+    scrollParents: {
+        reference: Array<Element | Window | VisualViewport>;
+        popper: Array<Element | Window | VisualViewport>;
+    };
+    styles: {
+        [key: string]: Partial<CSSStyleDeclaration>;
+    };
+    attributes: {
+        [key: string]: {
+            [key: string]: string | boolean;
+        };
+    };
+    modifiersData: {
+        arrow?: {
+            x?: number;
+            y?: number;
+            centerOffset: number;
+        };
+        hide?: {
+            isReferenceHidden: boolean;
+            hasPopperEscaped: boolean;
+            referenceClippingOffsets: SideObject;
+            popperEscapeOffsets: SideObject;
+        };
+        offset?: OffsetData;
+        preventOverflow?: Offsets;
+        popperOffsets?: Offsets;
+        [key: string]: any;
+    };
+    reset: boolean;
+};
+declare type SetAction<S> = S | ((prev: S) => S);
+export declare type Instance = {
+    state: State;
+    destroy: () => void;
+    forceUpdate: () => void;
+    update: () => Promise<Partial<State>>;
+    setOptions: (setOptionsAction: SetAction<Partial<OptionsGeneric<any>>>) => Promise<Partial<State>>;
+};
+export declare type ModifierArguments<Options extends Obj> = {
+    state: State;
+    instance: Instance;
+    options: Partial<Options>;
+    name: string;
+};
+export declare type Modifier<Name, Options extends Obj> = {
+    name: Name;
+    enabled: boolean;
+    phase: ModifierPhases;
+    requires?: Array<string>;
+    requiresIfExists?: Array<string>;
+    fn: (arg0: ModifierArguments<Options>) => State | void;
+    effect?: (arg0: ModifierArguments<Options>) => (() => void) | void;
+    options?: Partial<Options>;
+    data?: Obj;
+};
+export declare type StrictModifiers = Partial<OffsetModifier> | Partial<ApplyStylesModifier> | Partial<ArrowModifier> | Partial<HideModifier> | Partial<ComputeStylesModifier> | Partial<EventListenersModifier> | Partial<FlipModifier> | Partial<PreventOverflowModifier> | Partial<PopperOffsetsModifier>;
+export declare type EventListeners = {
+    scroll: boolean;
+    resize: boolean;
+};
+export declare type Options = {
+    placement: Placement;
+    modifiers: Array<Partial<Modifier<any, any>>>;
+    strategy: PositioningStrategy;
+    onFirstUpdate?: (arg0: Partial<State>) => void;
+};
+export declare type OptionsGeneric<TModifier> = {
+    placement: Placement;
+    modifiers: Array<TModifier>;
+    strategy: PositioningStrategy;
+    onFirstUpdate?: (arg0: Partial<State>) => void;
+};
+export declare type UpdateCallback = (arg0: State) => void;
+export declare type ClientRectObject = {
+    x: number;
+    y: number;
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+};
+export declare type SideObject = {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+};
+export declare type Padding = number | Partial<SideObject>;
+export declare type VirtualElement = {
+    getBoundingClientRect: () => ClientRect | DOMRect;
+    contextElement?: Element;
+};
+export {};

admin/node_modules/@popperjs/core/lib/utils/computeAutoPlacement.d.ts

@@ -0,0 +1,12 @@
+import type { State, Padding } from "../types";
+import type { Placement, ComputedPlacement, Boundary, RootBoundary } from "../enums";
+declare type Options = {
+    placement: Placement;
+    padding: Padding;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    flipVariations: boolean;
+    allowedAutoPlacements?: Array<Placement>;
+};
+export default function computeAutoPlacement(state: Partial<State>, options?: Options): Array<ComputedPlacement>;
+export {};

admin/node_modules/@popperjs/core/lib/utils/computeOffsets.d.ts

@@ -0,0 +1,8 @@
+import type { Rect, PositioningStrategy, Offsets, ClientRectObject } from "../types";
+import { Placement } from "../enums";
+export default function computeOffsets({ reference, element, placement }: {
+    reference: Rect | ClientRectObject;
+    element: Rect | ClientRectObject;
+    strategy: PositioningStrategy;
+    placement?: Placement;
+}): Offsets;

admin/node_modules/@popperjs/core/lib/utils/debounce.d.ts

@@ -0,0 +1 @@
+export default function debounce<T>(fn: (...args: Array<any>) => any): () => Promise<T>;

admin/node_modules/@popperjs/core/lib/utils/detectOverflow.d.ts

@@ -0,0 +1,11 @@
+import type { State, SideObject, Padding } from "../types";
+import type { Placement, Boundary, RootBoundary, Context } from "../enums";
+export declare type Options = {
+    placement: Placement;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    elementContext: Context;
+    altBoundary: boolean;
+    padding: Padding;
+};
+export default function detectOverflow(state: State, options?: Partial<Options>): SideObject;

admin/node_modules/@popperjs/core/lib/utils/expandToHashMap.d.ts

@@ -0,0 +1,3 @@
+export default function expandToHashMap<T extends number | string | boolean, K extends string>(value: T, keys: Array<K>): {
+    [key: string]: T;
+};

admin/node_modules/@popperjs/core/lib/utils/format.d.ts

@@ -0,0 +1 @@
+export default function format(str: string, ...args: Array<string>): string;

admin/node_modules/@popperjs/core/lib/utils/getAltAxis.d.ts

@@ -0,0 +1 @@
+export default function getAltAxis(axis: "x" | "y"): "x" | "y";

admin/node_modules/@popperjs/core/lib/utils/getAltLen.d.ts

@@ -0,0 +1 @@
+export default function getAltLen(len: "width" | "height"): "width" | "height";

admin/node_modules/@popperjs/core/lib/utils/getBasePlacement.d.ts

@@ -0,0 +1,2 @@
+import { BasePlacement, Placement, auto } from "../enums";
+export default function getBasePlacement(placement: Placement | typeof auto): BasePlacement;

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

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

admin/node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.d.ts

@@ -0,0 +1,2 @@
+import type { Placement } from "../enums";
+export default function getMainAxisFromPlacement(placement: Placement): "x" | "y";

admin/node_modules/@popperjs/core/lib/utils/getOppositePlacement.d.ts

@@ -0,0 +1,2 @@
+import type { Placement } from "../enums";
+export default function getOppositePlacement(placement: Placement): Placement;

admin/node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.d.ts

@@ -0,0 +1,2 @@
+import type { Placement } from "../enums";
+export default function getOppositeVariationPlacement(placement: Placement): Placement;

admin/node_modules/@popperjs/core/lib/utils/getVariation.d.ts

@@ -0,0 +1,2 @@
+import { Variation, Placement } from "../enums";
+export default function getVariation(placement: Placement): Variation | null | undefined;

admin/node_modules/@popperjs/core/lib/utils/math.d.ts

@@ -0,0 +1,3 @@
+export declare const max: (...values: number[]) => number;
+export declare const min: (...values: number[]) => number;
+export declare const round: (x: number) => number;

admin/node_modules/@popperjs/core/lib/utils/mergeByName.d.ts

@@ -0,0 +1,2 @@
+import type { Modifier } from "../types";
+export default function mergeByName(modifiers: Array<Partial<Modifier<any, any>>>): Array<Partial<Modifier<any, any>>>;

admin/node_modules/@popperjs/core/lib/utils/mergePaddingObject.d.ts

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

admin/node_modules/@popperjs/core/lib/utils/orderModifiers.d.ts

@@ -0,0 +1,2 @@
+import type { Modifier } from "../types";
+export default function orderModifiers(modifiers: Array<Modifier<any, any>>): Array<Modifier<any, any>>;

admin/node_modules/@popperjs/core/lib/utils/rectToClientRect.d.ts

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

admin/node_modules/@popperjs/core/lib/utils/uniqueBy.d.ts

@@ -0,0 +1 @@
+export default function uniqueBy<T>(arr: Array<T>, fn: (arg0: T) => any): Array<T>;

admin/node_modules/@popperjs/core/lib/utils/validateModifiers.d.ts

@@ -0,0 +1 @@
+export default function validateModifiers(modifiers: Array<any>): void;

admin/node_modules/@popperjs/core/lib/utils/within.d.ts

@@ -0,0 +1,2 @@
+export declare function within(min: number, value: number, max: number): number;
+export declare function withinMaxClamp(min: number, value: number, max: number): number;