Saving all progress

node_modules/@floating-ui/core/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2021-present Floating UI contributors
+
+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.

node_modules/@floating-ui/core/README.md

@@ -0,0 +1,4 @@
+# @floating-ui/core
+
+This is the platform-agnostic core of Floating UI, exposing the main
+`computePosition` function but no platform interface logic.

node_modules/@floating-ui/core/dist/floating-ui.core.d.mts

@@ -0,0 +1,525 @@
+import { AlignedPlacement } from '@floating-ui/utils';
+import { Alignment } from '@floating-ui/utils';
+import { Axis } from '@floating-ui/utils';
+import { ClientRectObject } from '@floating-ui/utils';
+import { Coords } from '@floating-ui/utils';
+import { Dimensions } from '@floating-ui/utils';
+import { ElementRects } from '@floating-ui/utils';
+import { Length } from '@floating-ui/utils';
+import { Padding } from '@floating-ui/utils';
+import { Placement } from '@floating-ui/utils';
+import { Rect } from '@floating-ui/utils';
+import { rectToClientRect } from '@floating-ui/utils';
+import { Side } from '@floating-ui/utils';
+import { SideObject } from '@floating-ui/utils';
+import { Strategy } from '@floating-ui/utils';
+import { VirtualElement } from '@floating-ui/utils';
+
+export { AlignedPlacement }
+
+export { Alignment }
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
+
+export declare interface ArrowOptions {
+    /**
+     * The arrow element to be positioned.
+     * @default undefined
+     */
+    element: any;
+    /**
+     * The padding between the arrow element and the floating element edges.
+     * Useful when the floating element has rounded corners.
+     * @default 0
+     */
+    padding?: Padding;
+}
+
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+export declare const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
+
+export declare interface AutoPlacementOptions extends DetectOverflowOptions {
+    /**
+     * The axis that runs along the alignment of the floating element. Determines
+     * whether to check for most space along this axis.
+     * @default false
+     */
+    crossAxis?: boolean;
+    /**
+     * Choose placements with a particular alignment.
+     * @default undefined
+     */
+    alignment?: Alignment | null;
+    /**
+     * Whether to choose placements with the opposite alignment if the preferred
+     * alignment does not fit.
+     * @default true
+     */
+    autoAlignment?: boolean;
+    /**
+     * Which placements are allowed to be chosen. Placements must be within the
+     * `alignment` option if explicitly set.
+     * @default allPlacements (variable)
+     */
+    allowedPlacements?: Array<Placement>;
+}
+
+export { Axis }
+
+export declare type Boundary = any;
+
+export { ClientRectObject }
+
+export declare type ComputePosition = (reference: unknown, floating: unknown, config: ComputePositionConfig) => Promise<ComputePositionReturn>;
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ *
+ * This export does not have any `platform` interface logic. You will need to
+ * write one for the platform you are using Floating UI with.
+ */
+export declare const computePosition: ComputePosition;
+
+export declare interface ComputePositionConfig {
+    /**
+     * Object to interface with the current platform.
+     */
+    platform: Platform;
+    /**
+     * Where to place the floating element relative to the reference element.
+     */
+    placement?: Placement;
+    /**
+     * The strategy to use when positioning the floating element.
+     */
+    strategy?: Strategy;
+    /**
+     * Array of middleware objects to modify the positioning or provide data for
+     * rendering.
+     */
+    middleware?: Array<Middleware | null | undefined | false>;
+}
+
+export declare interface ComputePositionReturn extends Coords {
+    /**
+     * The final chosen placement of the floating element.
+     */
+    placement: Placement;
+    /**
+     * The strategy used to position the floating element.
+     */
+    strategy: Strategy;
+    /**
+     * Object containing data returned from all middleware, keyed by their name.
+     */
+    middlewareData: MiddlewareData;
+}
+
+export { Coords }
+
+/**
+ * Function option to derive middleware options from state.
+ */
+export declare type Derivable<T> = (state: MiddlewareState) => T;
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+export declare function detectOverflow(state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>): Promise<SideObject>;
+
+export declare interface DetectOverflowOptions {
+    /**
+     * The clipping element(s) or area in which overflow will be checked.
+     * @default 'clippingAncestors'
+     */
+    boundary?: Boundary;
+    /**
+     * The root clipping area in which overflow will be checked.
+     * @default 'viewport'
+     */
+    rootBoundary?: RootBoundary;
+    /**
+     * The element in which overflow is being checked relative to a boundary.
+     * @default 'floating'
+     */
+    elementContext?: ElementContext;
+    /**
+     * Whether to check for overflow using the alternate element's boundary
+     * (`clippingAncestors` boundary only).
+     * @default false
+     */
+    altBoundary?: boolean;
+    /**
+     * Virtual padding for the resolved overflow detection offsets.
+     * @default 0
+     */
+    padding?: Padding;
+}
+
+export { Dimensions }
+
+export declare type ElementContext = 'reference' | 'floating';
+
+export { ElementRects }
+
+export declare interface Elements {
+    reference: ReferenceElement;
+    floating: FloatingElement;
+}
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+export declare const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
+
+export declare interface FlipOptions extends DetectOverflowOptions {
+    /**
+     * The axis that runs along the side of the floating element. Determines
+     * whether overflow along this axis is checked to perform a flip.
+     * @default true
+     */
+    mainAxis?: boolean;
+    /**
+     * The axis that runs along the alignment of the floating element. Determines
+     * whether overflow along this axis is checked to perform a flip.
+     * @default true
+     */
+    crossAxis?: boolean;
+    /**
+     * Placements to try sequentially if the preferred `placement` does not fit.
+     * @default [oppositePlacement] (computed)
+     */
+    fallbackPlacements?: Array<Placement>;
+    /**
+     * What strategy to use when no placements fit.
+     * @default 'bestFit'
+     */
+    fallbackStrategy?: 'bestFit' | 'initialPlacement';
+    /**
+     * Whether to allow fallback to the perpendicular axis of the preferred
+     * placement, and if so, which side direction along the axis to prefer.
+     * @default 'none' (disallow fallback)
+     */
+    fallbackAxisSideDirection?: 'none' | 'start' | 'end';
+    /**
+     * Whether to flip to placements with the opposite alignment if they fit
+     * better.
+     * @default true
+     */
+    flipAlignment?: boolean;
+}
+
+export declare type FloatingElement = any;
+
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+export declare const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
+
+export declare interface HideOptions extends DetectOverflowOptions {
+    /**
+     * The strategy used to determine when to hide the floating element.
+     */
+    strategy?: 'referenceHidden' | 'escaped';
+}
+
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+export declare const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
+
+export declare interface InlineOptions {
+    /**
+     * Viewport-relative `x` coordinate to choose a `ClientRect`.
+     * @default undefined
+     */
+    x?: number;
+    /**
+     * Viewport-relative `y` coordinate to choose a `ClientRect`.
+     * @default undefined
+     */
+    y?: number;
+    /**
+     * Represents the padding around a disjoined rect when choosing it.
+     * @default 2
+     */
+    padding?: Padding;
+}
+
+export { Length }
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+export declare const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
+    options: any;
+    fn: (state: MiddlewareState) => Coords;
+};
+
+declare type LimitShiftOffset = number | {
+    /**
+     * Offset the limiting of the axis that runs along the alignment of the
+     * floating element.
+     */
+    mainAxis?: number;
+    /**
+     * Offset the limiting of the axis that runs along the side of the
+     * floating element.
+     */
+    crossAxis?: number;
+};
+
+export declare interface LimitShiftOptions {
+    /**
+     * Offset when limiting starts. `0` will limit when the opposite edges of the
+     * reference and floating elements are aligned.
+     * - positive = start limiting earlier
+     * - negative = start limiting later
+     */
+    offset?: LimitShiftOffset | Derivable<LimitShiftOffset>;
+    /**
+     * Whether to limit the axis that runs along the alignment of the floating
+     * element.
+     */
+    mainAxis?: boolean;
+    /**
+     * Whether to limit the axis that runs along the side of the floating element.
+     */
+    crossAxis?: boolean;
+}
+
+export declare type Middleware = {
+    name: string;
+    options?: any;
+    fn: (state: MiddlewareState) => Promisable<MiddlewareReturn>;
+};
+
+/**
+ * @deprecated use `MiddlewareState` instead.
+ */
+export declare type MiddlewareArguments = MiddlewareState;
+
+export declare interface MiddlewareData {
+    [key: string]: any;
+    arrow?: Partial<Coords> & {
+        centerOffset: number;
+        alignmentOffset?: number;
+    };
+    autoPlacement?: {
+        index?: number;
+        overflows: Array<{
+            placement: Placement;
+            overflows: Array<number>;
+        }>;
+    };
+    flip?: {
+        index?: number;
+        overflows: Array<{
+            placement: Placement;
+            overflows: Array<number>;
+        }>;
+    };
+    hide?: {
+        referenceHidden?: boolean;
+        escaped?: boolean;
+        referenceHiddenOffsets?: SideObject;
+        escapedOffsets?: SideObject;
+    };
+    offset?: Coords & {
+        placement: Placement;
+    };
+    shift?: Coords & {
+        enabled: {
+            [key in Axis]: boolean;
+        };
+    };
+}
+
+export declare interface MiddlewareReturn extends Partial<Coords> {
+    data?: {
+        [key: string]: any;
+    };
+    reset?: boolean | {
+        placement?: Placement;
+        rects?: boolean | ElementRects;
+    };
+}
+
+export declare interface MiddlewareState extends Coords {
+    initialPlacement: Placement;
+    placement: Placement;
+    strategy: Strategy;
+    middlewareData: MiddlewareData;
+    elements: Elements;
+    rects: ElementRects;
+    platform: Platform;
+}
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+export declare const offset: (options?: OffsetOptions) => Middleware;
+
+export declare type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
+
+declare type OffsetValue = number | {
+    /**
+     * The axis that runs along the side of the floating element. Represents
+     * the distance (gutter or margin) between the reference and floating
+     * element.
+     * @default 0
+     */
+    mainAxis?: number;
+    /**
+     * The axis that runs along the alignment of the floating element.
+     * Represents the skidding between the reference and floating element.
+     * @default 0
+     */
+    crossAxis?: number;
+    /**
+     * The same axis as `crossAxis` but applies only to aligned placements
+     * and inverts the `end` alignment. When set to a number, it overrides the
+     * `crossAxis` value.
+     *
+     * A positive number will move the floating element in the direction of
+     * the opposite edge to the one that is aligned, while a negative number
+     * the reverse.
+     * @default null
+     */
+    alignmentAxis?: number | null;
+};
+
+export { Padding }
+
+export { Placement }
+
+/**
+ * Platform interface methods to work with the current platform.
+ * @see https://floating-ui.com/docs/platform
+ */
+export declare interface Platform {
+    getElementRects: (args: {
+        reference: ReferenceElement;
+        floating: FloatingElement;
+        strategy: Strategy;
+    }) => Promisable<ElementRects>;
+    getClippingRect: (args: {
+        element: any;
+        boundary: Boundary;
+        rootBoundary: RootBoundary;
+        strategy: Strategy;
+    }) => Promisable<Rect>;
+    getDimensions: (element: any) => Promisable<Dimensions>;
+    convertOffsetParentRelativeRectToViewportRelativeRect?: (args: {
+        elements?: Elements;
+        rect: Rect;
+        offsetParent: any;
+        strategy: Strategy;
+    }) => Promisable<Rect>;
+    getOffsetParent?: (element: any) => Promisable<any>;
+    isElement?: (value: any) => Promisable<boolean>;
+    getDocumentElement?: (element: any) => Promisable<any>;
+    getClientRects?: (element: any) => Promisable<Array<ClientRectObject>>;
+    isRTL?: (element: any) => Promisable<boolean>;
+    getScale?: (element: any) => Promisable<{
+        x: number;
+        y: number;
+    }>;
+}
+
+declare type Promisable<T> = T | Promise<T>;
+
+export { Rect }
+
+export { rectToClientRect }
+
+export declare type ReferenceElement = any;
+
+export declare type RootBoundary = 'viewport' | 'document' | Rect;
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+export declare const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
+
+export declare interface ShiftOptions extends DetectOverflowOptions {
+    /**
+     * The axis that runs along the alignment of the floating element. Determines
+     * whether overflow along this axis is checked to perform shifting.
+     * @default true
+     */
+    mainAxis?: boolean;
+    /**
+     * The axis that runs along the side of the floating element. Determines
+     * whether overflow along this axis is checked to perform shifting.
+     * @default false
+     */
+    crossAxis?: boolean;
+    /**
+     * Accepts a function that limits the shifting done in order to prevent
+     * detachment.
+     */
+    limiter?: {
+        fn: (state: MiddlewareState) => Coords;
+        options?: any;
+    };
+}
+
+export { Side }
+
+export { SideObject }
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+export declare const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
+
+export declare interface SizeOptions extends DetectOverflowOptions {
+    /**
+     * Function that is called to perform style mutations to the floating element
+     * to change its size.
+     * @default undefined
+     */
+    apply?(args: MiddlewareState & {
+        availableWidth: number;
+        availableHeight: number;
+    }): void | Promise<void>;
+}
+
+export { Strategy }
+
+export { VirtualElement }
+
+export { }

node_modules/@floating-ui/core/dist/floating-ui.core.d.ts

@@ -0,0 +1,525 @@
+import { AlignedPlacement } from '@floating-ui/utils';
+import { Alignment } from '@floating-ui/utils';
+import { Axis } from '@floating-ui/utils';
+import { ClientRectObject } from '@floating-ui/utils';
+import { Coords } from '@floating-ui/utils';
+import { Dimensions } from '@floating-ui/utils';
+import { ElementRects } from '@floating-ui/utils';
+import { Length } from '@floating-ui/utils';
+import { Padding } from '@floating-ui/utils';
+import { Placement } from '@floating-ui/utils';
+import { Rect } from '@floating-ui/utils';
+import { rectToClientRect } from '@floating-ui/utils';
+import { Side } from '@floating-ui/utils';
+import { SideObject } from '@floating-ui/utils';
+import { Strategy } from '@floating-ui/utils';
+import { VirtualElement } from '@floating-ui/utils';
+
+export { AlignedPlacement }
+
+export { Alignment }
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
+
+export declare interface ArrowOptions {
+    /**
+     * The arrow element to be positioned.
+     * @default undefined
+     */
+    element: any;
+    /**
+     * The padding between the arrow element and the floating element edges.
+     * Useful when the floating element has rounded corners.
+     * @default 0
+     */
+    padding?: Padding;
+}
+
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+export declare const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
+
+export declare interface AutoPlacementOptions extends DetectOverflowOptions {
+    /**
+     * The axis that runs along the alignment of the floating element. Determines
+     * whether to check for most space along this axis.
+     * @default false
+     */
+    crossAxis?: boolean;
+    /**
+     * Choose placements with a particular alignment.
+     * @default undefined
+     */
+    alignment?: Alignment | null;
+    /**
+     * Whether to choose placements with the opposite alignment if the preferred
+     * alignment does not fit.
+     * @default true
+     */
+    autoAlignment?: boolean;
+    /**
+     * Which placements are allowed to be chosen. Placements must be within the
+     * `alignment` option if explicitly set.
+     * @default allPlacements (variable)
+     */
+    allowedPlacements?: Array<Placement>;
+}
+
+export { Axis }
+
+export declare type Boundary = any;
+
+export { ClientRectObject }
+
+export declare type ComputePosition = (reference: unknown, floating: unknown, config: ComputePositionConfig) => Promise<ComputePositionReturn>;
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ *
+ * This export does not have any `platform` interface logic. You will need to
+ * write one for the platform you are using Floating UI with.
+ */
+export declare const computePosition: ComputePosition;
+
+export declare interface ComputePositionConfig {
+    /**
+     * Object to interface with the current platform.
+     */
+    platform: Platform;
+    /**
+     * Where to place the floating element relative to the reference element.
+     */
+    placement?: Placement;
+    /**
+     * The strategy to use when positioning the floating element.
+     */
+    strategy?: Strategy;
+    /**
+     * Array of middleware objects to modify the positioning or provide data for
+     * rendering.
+     */
+    middleware?: Array<Middleware | null | undefined | false>;
+}
+
+export declare interface ComputePositionReturn extends Coords {
+    /**
+     * The final chosen placement of the floating element.
+     */
+    placement: Placement;
+    /**
+     * The strategy used to position the floating element.
+     */
+    strategy: Strategy;
+    /**
+     * Object containing data returned from all middleware, keyed by their name.
+     */
+    middlewareData: MiddlewareData;
+}
+
+export { Coords }
+
+/**
+ * Function option to derive middleware options from state.
+ */
+export declare type Derivable<T> = (state: MiddlewareState) => T;
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+export declare function detectOverflow(state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>): Promise<SideObject>;
+
+export declare interface DetectOverflowOptions {
+    /**
+     * The clipping element(s) or area in which overflow will be checked.
+     * @default 'clippingAncestors'
+     */
+    boundary?: Boundary;
+    /**
+     * The root clipping area in which overflow will be checked.
+     * @default 'viewport'
+     */
+    rootBoundary?: RootBoundary;
+    /**
+     * The element in which overflow is being checked relative to a boundary.
+     * @default 'floating'
+     */
+    elementContext?: ElementContext;
+    /**
+     * Whether to check for overflow using the alternate element's boundary
+     * (`clippingAncestors` boundary only).
+     * @default false
+     */
+    altBoundary?: boolean;
+    /**
+     * Virtual padding for the resolved overflow detection offsets.
+     * @default 0
+     */
+    padding?: Padding;
+}
+
+export { Dimensions }
+
+export declare type ElementContext = 'reference' | 'floating';
+
+export { ElementRects }
+
+export declare interface Elements {
+    reference: ReferenceElement;
+    floating: FloatingElement;
+}
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+export declare const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
+
+export declare interface FlipOptions extends DetectOverflowOptions {
+    /**
+     * The axis that runs along the side of the floating element. Determines
+     * whether overflow along this axis is checked to perform a flip.
+     * @default true
+     */
+    mainAxis?: boolean;
+    /**
+     * The axis that runs along the alignment of the floating element. Determines
+     * whether overflow along this axis is checked to perform a flip.
+     * @default true
+     */
+    crossAxis?: boolean;
+    /**
+     * Placements to try sequentially if the preferred `placement` does not fit.
+     * @default [oppositePlacement] (computed)
+     */
+    fallbackPlacements?: Array<Placement>;
+    /**
+     * What strategy to use when no placements fit.
+     * @default 'bestFit'
+     */
+    fallbackStrategy?: 'bestFit' | 'initialPlacement';
+    /**
+     * Whether to allow fallback to the perpendicular axis of the preferred
+     * placement, and if so, which side direction along the axis to prefer.
+     * @default 'none' (disallow fallback)
+     */
+    fallbackAxisSideDirection?: 'none' | 'start' | 'end';
+    /**
+     * Whether to flip to placements with the opposite alignment if they fit
+     * better.
+     * @default true
+     */
+    flipAlignment?: boolean;
+}
+
+export declare type FloatingElement = any;
+
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+export declare const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
+
+export declare interface HideOptions extends DetectOverflowOptions {
+    /**
+     * The strategy used to determine when to hide the floating element.
+     */
+    strategy?: 'referenceHidden' | 'escaped';
+}
+
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+export declare const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
+
+export declare interface InlineOptions {
+    /**
+     * Viewport-relative `x` coordinate to choose a `ClientRect`.
+     * @default undefined
+     */
+    x?: number;
+    /**
+     * Viewport-relative `y` coordinate to choose a `ClientRect`.
+     * @default undefined
+     */
+    y?: number;
+    /**
+     * Represents the padding around a disjoined rect when choosing it.
+     * @default 2
+     */
+    padding?: Padding;
+}
+
+export { Length }
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+export declare const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
+    options: any;
+    fn: (state: MiddlewareState) => Coords;
+};
+
+declare type LimitShiftOffset = number | {
+    /**
+     * Offset the limiting of the axis that runs along the alignment of the
+     * floating element.
+     */
+    mainAxis?: number;
+    /**
+     * Offset the limiting of the axis that runs along the side of the
+     * floating element.
+     */
+    crossAxis?: number;
+};
+
+export declare interface LimitShiftOptions {
+    /**
+     * Offset when limiting starts. `0` will limit when the opposite edges of the
+     * reference and floating elements are aligned.
+     * - positive = start limiting earlier
+     * - negative = start limiting later
+     */
+    offset?: LimitShiftOffset | Derivable<LimitShiftOffset>;
+    /**
+     * Whether to limit the axis that runs along the alignment of the floating
+     * element.
+     */
+    mainAxis?: boolean;
+    /**
+     * Whether to limit the axis that runs along the side of the floating element.
+     */
+    crossAxis?: boolean;
+}
+
+export declare type Middleware = {
+    name: string;
+    options?: any;
+    fn: (state: MiddlewareState) => Promisable<MiddlewareReturn>;
+};
+
+/**
+ * @deprecated use `MiddlewareState` instead.
+ */
+export declare type MiddlewareArguments = MiddlewareState;
+
+export declare interface MiddlewareData {
+    [key: string]: any;
+    arrow?: Partial<Coords> & {
+        centerOffset: number;
+        alignmentOffset?: number;
+    };
+    autoPlacement?: {
+        index?: number;
+        overflows: Array<{
+            placement: Placement;
+            overflows: Array<number>;
+        }>;
+    };
+    flip?: {
+        index?: number;
+        overflows: Array<{
+            placement: Placement;
+            overflows: Array<number>;
+        }>;
+    };
+    hide?: {
+        referenceHidden?: boolean;
+        escaped?: boolean;
+        referenceHiddenOffsets?: SideObject;
+        escapedOffsets?: SideObject;
+    };
+    offset?: Coords & {
+        placement: Placement;
+    };
+    shift?: Coords & {
+        enabled: {
+            [key in Axis]: boolean;
+        };
+    };
+}
+
+export declare interface MiddlewareReturn extends Partial<Coords> {
+    data?: {
+        [key: string]: any;
+    };
+    reset?: boolean | {
+        placement?: Placement;
+        rects?: boolean | ElementRects;
+    };
+}
+
+export declare interface MiddlewareState extends Coords {
+    initialPlacement: Placement;
+    placement: Placement;
+    strategy: Strategy;
+    middlewareData: MiddlewareData;
+    elements: Elements;
+    rects: ElementRects;
+    platform: Platform;
+}
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+export declare const offset: (options?: OffsetOptions) => Middleware;
+
+export declare type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
+
+declare type OffsetValue = number | {
+    /**
+     * The axis that runs along the side of the floating element. Represents
+     * the distance (gutter or margin) between the reference and floating
+     * element.
+     * @default 0
+     */
+    mainAxis?: number;
+    /**
+     * The axis that runs along the alignment of the floating element.
+     * Represents the skidding between the reference and floating element.
+     * @default 0
+     */
+    crossAxis?: number;
+    /**
+     * The same axis as `crossAxis` but applies only to aligned placements
+     * and inverts the `end` alignment. When set to a number, it overrides the
+     * `crossAxis` value.
+     *
+     * A positive number will move the floating element in the direction of
+     * the opposite edge to the one that is aligned, while a negative number
+     * the reverse.
+     * @default null
+     */
+    alignmentAxis?: number | null;
+};
+
+export { Padding }
+
+export { Placement }
+
+/**
+ * Platform interface methods to work with the current platform.
+ * @see https://floating-ui.com/docs/platform
+ */
+export declare interface Platform {
+    getElementRects: (args: {
+        reference: ReferenceElement;
+        floating: FloatingElement;
+        strategy: Strategy;
+    }) => Promisable<ElementRects>;
+    getClippingRect: (args: {
+        element: any;
+        boundary: Boundary;
+        rootBoundary: RootBoundary;
+        strategy: Strategy;
+    }) => Promisable<Rect>;
+    getDimensions: (element: any) => Promisable<Dimensions>;
+    convertOffsetParentRelativeRectToViewportRelativeRect?: (args: {
+        elements?: Elements;
+        rect: Rect;
+        offsetParent: any;
+        strategy: Strategy;
+    }) => Promisable<Rect>;
+    getOffsetParent?: (element: any) => Promisable<any>;
+    isElement?: (value: any) => Promisable<boolean>;
+    getDocumentElement?: (element: any) => Promisable<any>;
+    getClientRects?: (element: any) => Promisable<Array<ClientRectObject>>;
+    isRTL?: (element: any) => Promisable<boolean>;
+    getScale?: (element: any) => Promisable<{
+        x: number;
+        y: number;
+    }>;
+}
+
+declare type Promisable<T> = T | Promise<T>;
+
+export { Rect }
+
+export { rectToClientRect }
+
+export declare type ReferenceElement = any;
+
+export declare type RootBoundary = 'viewport' | 'document' | Rect;
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+export declare const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
+
+export declare interface ShiftOptions extends DetectOverflowOptions {
+    /**
+     * The axis that runs along the alignment of the floating element. Determines
+     * whether overflow along this axis is checked to perform shifting.
+     * @default true
+     */
+    mainAxis?: boolean;
+    /**
+     * The axis that runs along the side of the floating element. Determines
+     * whether overflow along this axis is checked to perform shifting.
+     * @default false
+     */
+    crossAxis?: boolean;
+    /**
+     * Accepts a function that limits the shifting done in order to prevent
+     * detachment.
+     */
+    limiter?: {
+        fn: (state: MiddlewareState) => Coords;
+        options?: any;
+    };
+}
+
+export { Side }
+
+export { SideObject }
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+export declare const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
+
+export declare interface SizeOptions extends DetectOverflowOptions {
+    /**
+     * Function that is called to perform style mutations to the floating element
+     * to change its size.
+     * @default undefined
+     */
+    apply?(args: MiddlewareState & {
+        availableWidth: number;
+        availableHeight: number;
+    }): void | Promise<void>;
+}
+
+export { Strategy }
+
+export { VirtualElement }
+
+export { }

node_modules/@floating-ui/core/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@floating-ui/core",
+  "version": "1.6.9",
+  "description": "Positioning library for floating elements: tooltips, popovers, dropdowns, and more",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/floating-ui.core.umd.js",
+  "module": "./dist/floating-ui.core.esm.js",
+  "unpkg": "./dist/floating-ui.core.umd.min.js",
+  "types": "./dist/floating-ui.core.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/floating-ui.core.d.mts",
+        "default": "./dist/floating-ui.core.mjs"
+      },
+      "types": "./dist/floating-ui.core.d.ts",
+      "module": "./dist/floating-ui.core.esm.js",
+      "default": "./dist/floating-ui.core.umd.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "author": "atomiks",
+  "license": "MIT",
+  "bugs": "https://github.com/floating-ui/floating-ui",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/floating-ui/floating-ui.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://floating-ui.com",
+  "keywords": [
+    "tooltip",
+    "popover",
+    "dropdown",
+    "menu",
+    "popup",
+    "positioning"
+  ],
+  "dependencies": {
+    "@floating-ui/utils": "^0.2.9"
+  },
+  "devDependencies": {
+    "config": "0.0.0"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "clean": "rimraf dist out-tsc",
+    "dev": "rollup -c -w",
+    "build": "rollup -c",
+    "build:api": "build-api --tsc tsconfig.lib.json",
+    "publint": "publint",
+    "typecheck": "tsc -b"
+  }
+}

node_modules/@floating-ui/dom/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2021-present Floating UI contributors
+
+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.

node_modules/@floating-ui/dom/README.md

@@ -0,0 +1,4 @@
+# @floating-ui/dom
+
+This is the library to use Floating UI on the web, wrapping `@floating-ui/core`
+with DOM interface logic.

node_modules/@floating-ui/dom/dist/floating-ui.dom.browser.mjs

@@ -0,0 +1,916 @@
+import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';
+
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = v => ({
+  x: v,
+  y: v
+});
+
+function hasWindow() {
+  return typeof window !== 'undefined';
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || '').toLowerCase();
+  }
+  // Mocked nodes in testing environments may not be instances of Node. By
+  // returning `#document` an infinite loop won't occur.
+  // https://github.com/floating-ui/floating-ui/issues/2317
+  return '#document';
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+}
+function isTableElement(element) {
+  return ['table', 'td', 'th'].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [':popover-open', ':modal'].some(selector => {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
+  return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === 'undefined' || !CSS.supports) return false;
+  return CSS.supports('-webkit-backdrop-filter', 'none');
+}
+function isLastTraversableNode(node) {
+  return ['html', 'body', '#document'].includes(getNodeName(node));
+}
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === 'html') {
+    return node;
+  }
+  const result =
+  // Step into the shadow DOM of the parent of a slotted node.
+  node.assignedSlot ||
+  // DOM Element detected.
+  node.parentNode ||
+  // ShadowRoot detected.
+  isShadowRoot(node) && node.host ||
+  // Fallback.
+  getDocumentElement(node);
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+
+function getCssDimensions(element) {
+  const css = getComputedStyle(element);
+  // In testing environments, the `width` and `height` properties are empty
+  // strings for SVG elements, returning NaN. Fallback to `0` in this case.
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
+  };
+}
+
+function unwrapElement(element) {
+  return !isElement(element) ? element.contextElement : element;
+}
+
+function getScale(element) {
+  const domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
+  }
+  const rect = domElement.getBoundingClientRect();
+  const {
+    width,
+    height,
+    $
+  } = getCssDimensions(domElement);
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
+
+  // 0, NaN, or Infinity should always fallback to 1.
+
+  if (!x || !Number.isFinite(x)) {
+    x = 1;
+  }
+  if (!y || !Number.isFinite(y)) {
+    y = 1;
+  }
+  return {
+    x,
+    y
+  };
+}
+
+const noOffsets = /*#__PURE__*/createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+    return false;
+  }
+  return isFixed;
+}
+
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement(element);
+  let scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement(offsetParent)) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
+    }
+  }
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement) {
+    const win = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentWin = win;
+    let currentIFrame = getFrameElement(currentWin);
+    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x *= iframeScale.x;
+      y *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x += left;
+      y += top;
+      currentWin = getWindow(currentIFrame);
+      currentIFrame = getFrameElement(currentWin);
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x,
+    y
+  });
+}
+
+// If <html> has a CSS width greater than the viewport, then this will be
+// incorrect for RTL.
+function getWindowScrollBarX(element, rect) {
+  const leftScroll = getNodeScroll(element).scrollLeft;
+  if (!rect) {
+    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+  }
+  return rect.left + leftScroll;
+}
+
+function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
+  if (ignoreScrollbarX === void 0) {
+    ignoreScrollbarX = false;
+  }
+  const htmlRect = documentElement.getBoundingClientRect();
+  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :
+  // RTL <body> scrollbar.
+  getWindowScrollBarX(documentElement, htmlRect));
+  const y = htmlRect.top + scroll.scrollTop;
+  return {
+    x,
+    y
+  };
+}
+
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isFixed = strategy === 'fixed';
+  const documentElement = getDocumentElement(offsetParent);
+  const topLayer = elements ? isTopLayer(elements.floating) : false;
+  if (offsetParent === documentElement || topLayer && isFixed) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
+  return {
+    width: rect.width * scale.x,
+    height: rect.height * scale.y,
+    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+  };
+}
+
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+
+// Gets the entire size of the scrollable document area, even extending outside
+// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
+function getDocumentRect(element) {
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = element.ownerDocument.body;
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle(body).direction === 'rtl') {
+    x += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+
+function getViewportRect(element, strategy) {
+  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 visualViewportBased = isWebKit();
+    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+
+// Returns the inner client rect, subtracting scrollbars if present.
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const width = element.clientWidth * scale.x;
+  const height = element.clientHeight * scale.y;
+  const x = left * scale.x;
+  const y = top * scale.y;
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  let rect;
+  if (clippingAncestor === 'viewport') {
+    rect = getViewportRect(element, strategy);
+  } else if (clippingAncestor === 'document') {
+    rect = getDocumentRect(getDocumentElement(element));
+  } else if (isElement(clippingAncestor)) {
+    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+  } else {
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y,
+      width: clippingAncestor.width,
+      height: clippingAncestor.height
+    };
+  }
+  return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+  const parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
+}
+
+// A "clipping ancestor" is an `overflow` element with the characteristic of
+// clipping (or hiding) child elements. This returns all clipping ancestors
+// of the given element up the tree.
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
+  let currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle(element).position === 'fixed';
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    const computedStyle = getComputedStyle(currentNode);
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
+      currentContainingBlockComputedStyle = null;
+    }
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    if (shouldDropCurrentNode) {
+      // Drop non-containing blocks.
+      result = result.filter(ancestor => ancestor !== currentNode);
+    } else {
+      // Record last containing block for next iteration.
+      currentContainingBlockComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
+}
+
+// Gets the maximum area that the element is visible in due to any number of
+// clipping ancestors.
+function getClippingRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+  const firstClippingAncestor = clippingAncestors[0];
+  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  return {
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
+  };
+}
+
+function getDimensions(element) {
+  const {
+    width,
+    height
+  } = getCssDimensions(element);
+  return {
+    width,
+    height
+  };
+}
+
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === 'fixed';
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      // If the <body> scrollbar appears on the left (e.g. RTL systems). Use
+      // Firefox with layout.scrollbar.side = 3 in about:config to test this.
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
+  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+  return {
+    x,
+    y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+
+function isStaticPositioned(element) {
+  return getComputedStyle(element).position === 'static';
+}
+
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  let rawOffsetParent = element.offsetParent;
+
+  // Firefox returns the <html> element as the offsetParent if it's non-static,
+  // while Chrome and Safari return the <body> element. The <body> element must
+  // be used to perform the correct calculations even if the <html> element is
+  // non-static.
+  if (getDocumentElement(element) === rawOffsetParent) {
+    rawOffsetParent = rawOffsetParent.ownerDocument.body;
+  }
+  return rawOffsetParent;
+}
+
+// Gets the closest ancestor positioned element. Handles some edge cases,
+// such as table ancestors and cross browser bugs.
+function getOffsetParent(element, polyfill) {
+  const win = getWindow(element);
+  if (isTopLayer(element)) {
+    return win;
+  }
+  if (!isHTMLElement(element)) {
+    let svgOffsetParent = getParentNode(element);
+    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+        return svgOffsetParent;
+      }
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+    return win;
+  }
+  return offsetParent || getContainingBlock(element) || win;
+}
+
+const getElementRects = async function (data) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
+  const floatingDimensions = await getDimensionsFn(data.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: floatingDimensions.width,
+      height: floatingDimensions.height
+    }
+  };
+};
+
+function isRTL(element) {
+  return getComputedStyle(element).direction === 'rtl';
+}
+
+const platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+
+function rectsAreEqual(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+
+// https://samthor.au/2021/observing-dom/
+function observeMove(element, onMove) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId);
+    (_io = io) == null || _io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    const elementRectForRootMargin = element.getBoundingClientRect();
+    const {
+      left,
+      top,
+      width,
+      height
+    } = elementRectForRootMargin;
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          // If the reference is clipped, the ratio is 0. Throttle the refresh
+          // to prevent an infinite loop of updates.
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 1000);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
+        // It's possible that even though the ratio is reported as 1, the
+        // element is not actually fully within the IntersectionObserver's root
+        // area anymore. This can happen under performance constraints. This may
+        // be a bug in the browser's IntersectionObserver implementation. To
+        // work around this, we compare the element's bounding rect now with
+        // what it was at the time we created the IntersectionObserver. If they
+        // are not equal then the element moved, so we refresh.
+        refresh();
+      }
+      isFirstUpdate = false;
+    }
+
+    // Older browsers don't support a `document` as the root and will throw an
+    // error.
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root.ownerDocument
+      });
+    } catch (e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  refresh(true);
+  return cleanup;
+}
+
+/**
+ * Automatically updates the position of the floating element when necessary.
+ * Should only be called when the floating element is mounted on the DOM or
+ * visible on the screen.
+ * @returns cleanup function that should be invoked when the floating element is
+ * removed from the DOM or hidden from the screen.
+ * @see https://floating-ui.com/docs/autoUpdate
+ */
+function autoUpdate(reference, floating, update, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    ancestorScroll = true,
+    ancestorResize = true,
+    elementResize = typeof ResizeObserver === 'function',
+    layoutShift = typeof IntersectionObserver === 'function',
+    animationFrame = false
+  } = options;
+  const referenceEl = unwrapElement(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
+  ancestors.forEach(ancestor => {
+    ancestorScroll && ancestor.addEventListener('scroll', update, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener('resize', update);
+  });
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver(_ref => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        // Prevent update loops when using the `size` middleware.
+        // https://github.com/floating-ui/floating-ui/issues/1740
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          var _resizeObserver;
+          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+        });
+      }
+      update();
+    });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
+    }
+    resizeObserver.observe(floating);
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference);
+    if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
+      update();
+    }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  update();
+  return () => {
+    var _resizeObserver2;
+    ancestors.forEach(ancestor => {
+      ancestorScroll && ancestor.removeEventListener('scroll', update);
+      ancestorResize && ancestor.removeEventListener('resize', update);
+    });
+    cleanupIo == null || cleanupIo();
+    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
+  };
+}
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+const detectOverflow = detectOverflow$1;
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+const offset = offset$1;
+
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+const autoPlacement = autoPlacement$1;
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+const shift = shift$1;
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip = flip$1;
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+const size = size$1;
+
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+const hide = hide$1;
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow = arrow$1;
+
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+const inline = inline$1;
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+const limitShift = limitShift$1;
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ */
+const computePosition = (reference, floating, options) => {
+  // This caches the expensive `getClippingElementAncestors` function so that
+  // multiple lifecycle resets re-use the same result. It only lives for a
+  // single call. If other functions become expensive, we can add them as well.
+  const cache = new Map();
+  const mergedOptions = {
+    platform,
+    ...options
+  };
+  const platformWithCache = {
+    ...mergedOptions.platform,
+    _c: cache
+  };
+  return computePosition$1(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
+  });
+};
+
+export { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size };

node_modules/@floating-ui/dom/dist/floating-ui.dom.d.mts

@@ -0,0 +1,356 @@
+import { AlignedPlacement } from '@floating-ui/core';
+import { Alignment } from '@floating-ui/core';
+import type { ArrowOptions as ArrowOptions_2 } from '@floating-ui/core';
+import type { AutoPlacementOptions as AutoPlacementOptions_2 } from '@floating-ui/core';
+import { Axis } from '@floating-ui/core';
+import { ClientRectObject } from '@floating-ui/core';
+import type { ComputePositionConfig as ComputePositionConfig_2 } from '@floating-ui/core';
+import { ComputePositionReturn } from '@floating-ui/core';
+import { Coords } from '@floating-ui/core';
+import type { DetectOverflowOptions as DetectOverflowOptions_2 } from '@floating-ui/core';
+import { Dimensions } from '@floating-ui/core';
+import { ElementContext } from '@floating-ui/core';
+import { ElementRects } from '@floating-ui/core';
+import type { FlipOptions as FlipOptions_2 } from '@floating-ui/core';
+import { getOverflowAncestors } from '@floating-ui/utils/dom';
+import type { HideOptions as HideOptions_2 } from '@floating-ui/core';
+import { InlineOptions } from '@floating-ui/core';
+import { Length } from '@floating-ui/core';
+import { LimitShiftOptions } from '@floating-ui/core';
+import type { Middleware as Middleware_2 } from '@floating-ui/core';
+import { MiddlewareData } from '@floating-ui/core';
+import { MiddlewareReturn } from '@floating-ui/core';
+import type { MiddlewareState as MiddlewareState_2 } from '@floating-ui/core';
+import { Padding } from '@floating-ui/core';
+import { Placement } from '@floating-ui/core';
+import { Rect } from '@floating-ui/core';
+import { RootBoundary } from '@floating-ui/core';
+import type { ShiftOptions as ShiftOptions_2 } from '@floating-ui/core';
+import { Side } from '@floating-ui/core';
+import { SideObject } from '@floating-ui/core';
+import type { SizeOptions as SizeOptions_2 } from '@floating-ui/core';
+import { Strategy } from '@floating-ui/core';
+
+export { AlignedPlacement }
+
+export { Alignment }
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
+
+export declare type ArrowOptions = Prettify<Omit<ArrowOptions_2, 'element'> & {
+    element: Element;
+}>;
+
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+export declare const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
+
+export declare type AutoPlacementOptions = Prettify<Omit<AutoPlacementOptions_2, 'boundary'> & DetectOverflowOptions>;
+
+/**
+ * Automatically updates the position of the floating element when necessary.
+ * Should only be called when the floating element is mounted on the DOM or
+ * visible on the screen.
+ * @returns cleanup function that should be invoked when the floating element is
+ * removed from the DOM or hidden from the screen.
+ * @see https://floating-ui.com/docs/autoUpdate
+ */
+export declare function autoUpdate(reference: ReferenceElement, floating: FloatingElement, update: () => void, options?: AutoUpdateOptions): () => void;
+
+export declare interface AutoUpdateOptions {
+    /**
+     * Whether to update the position when an overflow ancestor is scrolled.
+     * @default true
+     */
+    ancestorScroll?: boolean;
+    /**
+     * Whether to update the position when an overflow ancestor is resized. This
+     * uses the native `resize` event.
+     * @default true
+     */
+    ancestorResize?: boolean;
+    /**
+     * Whether to update the position when either the reference or floating
+     * elements resized. This uses a `ResizeObserver`.
+     * @default true
+     */
+    elementResize?: boolean;
+    /**
+     * Whether to update the position when the reference relocated on the screen
+     * due to layout shift.
+     * @default true
+     */
+    layoutShift?: boolean;
+    /**
+     * Whether to update on every animation frame if necessary. Only use if you
+     * need to update the position in response to an animation using transforms.
+     * @default false
+     */
+    animationFrame?: boolean;
+}
+
+export { Axis }
+
+/**
+ * The clipping boundary area of the floating element.
+ */
+export declare type Boundary = 'clippingAncestors' | Element | Array<Element> | Rect;
+
+export { ClientRectObject }
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ */
+export declare const computePosition: (reference: ReferenceElement, floating: FloatingElement, options?: Partial<ComputePositionConfig>) => Promise<ComputePositionReturn>;
+
+export declare type ComputePositionConfig = Prettify<Omit<ComputePositionConfig_2, 'middleware' | 'platform'> & {
+    /**
+     * Array of middleware objects to modify the positioning or provide data for
+     * rendering.
+     */
+    middleware?: Array<Middleware | null | undefined | false>;
+    /**
+     * Custom or extended platform object.
+     */
+    platform?: Platform;
+}>;
+
+export { ComputePositionReturn }
+
+export { Coords }
+
+export declare type Derivable<T> = (state: MiddlewareState) => T;
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+export declare const detectOverflow: (state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>) => Promise<SideObject>;
+
+export declare type DetectOverflowOptions = Prettify<Omit<DetectOverflowOptions_2, 'boundary'> & {
+    boundary?: Boundary;
+}>;
+
+export { Dimensions }
+
+export { ElementContext }
+
+export { ElementRects }
+
+export declare interface Elements {
+    reference: ReferenceElement;
+    floating: FloatingElement;
+}
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+export declare const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
+
+export declare type FlipOptions = Prettify<Omit<FlipOptions_2, 'boundary'> & DetectOverflowOptions>;
+
+export declare type FloatingElement = HTMLElement;
+
+export { getOverflowAncestors }
+
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+export declare const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
+
+export declare type HideOptions = Prettify<Omit<HideOptions_2, 'boundary'> & DetectOverflowOptions>;
+
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+export declare const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
+
+export { InlineOptions }
+
+export { Length }
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+export declare const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
+    options: any;
+    fn: (state: MiddlewareState) => Coords;
+};
+
+export { LimitShiftOptions }
+
+export declare type Middleware = Prettify<Omit<Middleware_2, 'fn'> & {
+    fn(state: MiddlewareState): Promisable<MiddlewareReturn>;
+}>;
+
+/**
+ * @deprecated use `MiddlewareState` instead.
+ */
+export declare type MiddlewareArguments = MiddlewareState;
+
+export { MiddlewareData }
+
+export { MiddlewareReturn }
+
+export declare type MiddlewareState = Prettify<Omit<MiddlewareState_2, 'elements'> & {
+    elements: Elements;
+}>;
+
+export declare interface NodeScroll {
+    scrollLeft: number;
+    scrollTop: number;
+}
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+export declare const offset: (options?: OffsetOptions) => Middleware;
+
+export declare type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
+
+declare type OffsetValue = number | {
+    /**
+     * The axis that runs along the side of the floating element. Represents
+     * the distance (gutter or margin) between the reference and floating
+     * element.
+     * @default 0
+     */
+    mainAxis?: number;
+    /**
+     * The axis that runs along the alignment of the floating element.
+     * Represents the skidding between the reference and floating element.
+     * @default 0
+     */
+    crossAxis?: number;
+    /**
+     * The same axis as `crossAxis` but applies only to aligned placements
+     * and inverts the `end` alignment. When set to a number, it overrides the
+     * `crossAxis` value.
+     *
+     * A positive number will move the floating element in the direction of
+     * the opposite edge to the one that is aligned, while a negative number
+     * the reverse.
+     * @default null
+     */
+    alignmentAxis?: number | null;
+};
+
+export { Padding }
+
+export { Placement }
+
+export declare interface Platform {
+    getElementRects: (args: {
+        reference: ReferenceElement;
+        floating: FloatingElement;
+        strategy: Strategy;
+    }) => Promisable<ElementRects>;
+    getClippingRect: (args: {
+        element: Element;
+        boundary: Boundary;
+        rootBoundary: RootBoundary;
+        strategy: Strategy;
+    }) => Promisable<Rect>;
+    getDimensions: (element: Element) => Promisable<Dimensions>;
+    convertOffsetParentRelativeRectToViewportRelativeRect: (args: {
+        elements?: Elements;
+        rect: Rect;
+        offsetParent: Element;
+        strategy: Strategy;
+    }) => Promisable<Rect>;
+    getOffsetParent: (element: Element, polyfill?: (element: HTMLElement) => Element | null) => Promisable<Element | Window>;
+    isElement: (value: unknown) => Promisable<boolean>;
+    getDocumentElement: (element: Element) => Promisable<HTMLElement>;
+    getClientRects: (element: Element) => Promisable<Array<ClientRectObject>>;
+    isRTL: (element: Element) => Promisable<boolean>;
+    getScale: (element: HTMLElement) => Promisable<{
+        x: number;
+        y: number;
+    }>;
+}
+
+export declare const platform: Platform;
+
+declare type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+declare type Promisable<T> = T | Promise<T>;
+
+export { Rect }
+
+export declare type ReferenceElement = Element | VirtualElement;
+
+export { RootBoundary }
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+export declare const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
+
+export declare type ShiftOptions = Prettify<Omit<ShiftOptions_2, 'boundary'> & DetectOverflowOptions>;
+
+export { Side }
+
+export { SideObject }
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+export declare const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
+
+export declare type SizeOptions = Prettify<Omit<SizeOptions_2, 'apply' | 'boundary'> & DetectOverflowOptions & {
+    /**
+     * Function that is called to perform style mutations to the floating element
+     * to change its size.
+     * @default undefined
+     */
+    apply?(args: MiddlewareState & {
+        availableWidth: number;
+        availableHeight: number;
+    }): Promisable<void>;
+}>;
+
+export { Strategy }
+
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+export declare interface VirtualElement {
+    getBoundingClientRect(): ClientRectObject;
+    getClientRects?(): Array<ClientRectObject> | DOMRectList;
+    contextElement?: Element;
+}
+
+export { }

node_modules/@floating-ui/dom/dist/floating-ui.dom.d.ts

@@ -0,0 +1,356 @@
+import { AlignedPlacement } from '@floating-ui/core';
+import { Alignment } from '@floating-ui/core';
+import type { ArrowOptions as ArrowOptions_2 } from '@floating-ui/core';
+import type { AutoPlacementOptions as AutoPlacementOptions_2 } from '@floating-ui/core';
+import { Axis } from '@floating-ui/core';
+import { ClientRectObject } from '@floating-ui/core';
+import type { ComputePositionConfig as ComputePositionConfig_2 } from '@floating-ui/core';
+import { ComputePositionReturn } from '@floating-ui/core';
+import { Coords } from '@floating-ui/core';
+import type { DetectOverflowOptions as DetectOverflowOptions_2 } from '@floating-ui/core';
+import { Dimensions } from '@floating-ui/core';
+import { ElementContext } from '@floating-ui/core';
+import { ElementRects } from '@floating-ui/core';
+import type { FlipOptions as FlipOptions_2 } from '@floating-ui/core';
+import { getOverflowAncestors } from '@floating-ui/utils/dom';
+import type { HideOptions as HideOptions_2 } from '@floating-ui/core';
+import { InlineOptions } from '@floating-ui/core';
+import { Length } from '@floating-ui/core';
+import { LimitShiftOptions } from '@floating-ui/core';
+import type { Middleware as Middleware_2 } from '@floating-ui/core';
+import { MiddlewareData } from '@floating-ui/core';
+import { MiddlewareReturn } from '@floating-ui/core';
+import type { MiddlewareState as MiddlewareState_2 } from '@floating-ui/core';
+import { Padding } from '@floating-ui/core';
+import { Placement } from '@floating-ui/core';
+import { Rect } from '@floating-ui/core';
+import { RootBoundary } from '@floating-ui/core';
+import type { ShiftOptions as ShiftOptions_2 } from '@floating-ui/core';
+import { Side } from '@floating-ui/core';
+import { SideObject } from '@floating-ui/core';
+import type { SizeOptions as SizeOptions_2 } from '@floating-ui/core';
+import { Strategy } from '@floating-ui/core';
+
+export { AlignedPlacement }
+
+export { Alignment }
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
+
+export declare type ArrowOptions = Prettify<Omit<ArrowOptions_2, 'element'> & {
+    element: Element;
+}>;
+
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+export declare const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
+
+export declare type AutoPlacementOptions = Prettify<Omit<AutoPlacementOptions_2, 'boundary'> & DetectOverflowOptions>;
+
+/**
+ * Automatically updates the position of the floating element when necessary.
+ * Should only be called when the floating element is mounted on the DOM or
+ * visible on the screen.
+ * @returns cleanup function that should be invoked when the floating element is
+ * removed from the DOM or hidden from the screen.
+ * @see https://floating-ui.com/docs/autoUpdate
+ */
+export declare function autoUpdate(reference: ReferenceElement, floating: FloatingElement, update: () => void, options?: AutoUpdateOptions): () => void;
+
+export declare interface AutoUpdateOptions {
+    /**
+     * Whether to update the position when an overflow ancestor is scrolled.
+     * @default true
+     */
+    ancestorScroll?: boolean;
+    /**
+     * Whether to update the position when an overflow ancestor is resized. This
+     * uses the native `resize` event.
+     * @default true
+     */
+    ancestorResize?: boolean;
+    /**
+     * Whether to update the position when either the reference or floating
+     * elements resized. This uses a `ResizeObserver`.
+     * @default true
+     */
+    elementResize?: boolean;
+    /**
+     * Whether to update the position when the reference relocated on the screen
+     * due to layout shift.
+     * @default true
+     */
+    layoutShift?: boolean;
+    /**
+     * Whether to update on every animation frame if necessary. Only use if you
+     * need to update the position in response to an animation using transforms.
+     * @default false
+     */
+    animationFrame?: boolean;
+}
+
+export { Axis }
+
+/**
+ * The clipping boundary area of the floating element.
+ */
+export declare type Boundary = 'clippingAncestors' | Element | Array<Element> | Rect;
+
+export { ClientRectObject }
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ */
+export declare const computePosition: (reference: ReferenceElement, floating: FloatingElement, options?: Partial<ComputePositionConfig>) => Promise<ComputePositionReturn>;
+
+export declare type ComputePositionConfig = Prettify<Omit<ComputePositionConfig_2, 'middleware' | 'platform'> & {
+    /**
+     * Array of middleware objects to modify the positioning or provide data for
+     * rendering.
+     */
+    middleware?: Array<Middleware | null | undefined | false>;
+    /**
+     * Custom or extended platform object.
+     */
+    platform?: Platform;
+}>;
+
+export { ComputePositionReturn }
+
+export { Coords }
+
+export declare type Derivable<T> = (state: MiddlewareState) => T;
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+export declare const detectOverflow: (state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>) => Promise<SideObject>;
+
+export declare type DetectOverflowOptions = Prettify<Omit<DetectOverflowOptions_2, 'boundary'> & {
+    boundary?: Boundary;
+}>;
+
+export { Dimensions }
+
+export { ElementContext }
+
+export { ElementRects }
+
+export declare interface Elements {
+    reference: ReferenceElement;
+    floating: FloatingElement;
+}
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+export declare const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
+
+export declare type FlipOptions = Prettify<Omit<FlipOptions_2, 'boundary'> & DetectOverflowOptions>;
+
+export declare type FloatingElement = HTMLElement;
+
+export { getOverflowAncestors }
+
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+export declare const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
+
+export declare type HideOptions = Prettify<Omit<HideOptions_2, 'boundary'> & DetectOverflowOptions>;
+
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+export declare const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
+
+export { InlineOptions }
+
+export { Length }
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+export declare const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
+    options: any;
+    fn: (state: MiddlewareState) => Coords;
+};
+
+export { LimitShiftOptions }
+
+export declare type Middleware = Prettify<Omit<Middleware_2, 'fn'> & {
+    fn(state: MiddlewareState): Promisable<MiddlewareReturn>;
+}>;
+
+/**
+ * @deprecated use `MiddlewareState` instead.
+ */
+export declare type MiddlewareArguments = MiddlewareState;
+
+export { MiddlewareData }
+
+export { MiddlewareReturn }
+
+export declare type MiddlewareState = Prettify<Omit<MiddlewareState_2, 'elements'> & {
+    elements: Elements;
+}>;
+
+export declare interface NodeScroll {
+    scrollLeft: number;
+    scrollTop: number;
+}
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+export declare const offset: (options?: OffsetOptions) => Middleware;
+
+export declare type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
+
+declare type OffsetValue = number | {
+    /**
+     * The axis that runs along the side of the floating element. Represents
+     * the distance (gutter or margin) between the reference and floating
+     * element.
+     * @default 0
+     */
+    mainAxis?: number;
+    /**
+     * The axis that runs along the alignment of the floating element.
+     * Represents the skidding between the reference and floating element.
+     * @default 0
+     */
+    crossAxis?: number;
+    /**
+     * The same axis as `crossAxis` but applies only to aligned placements
+     * and inverts the `end` alignment. When set to a number, it overrides the
+     * `crossAxis` value.
+     *
+     * A positive number will move the floating element in the direction of
+     * the opposite edge to the one that is aligned, while a negative number
+     * the reverse.
+     * @default null
+     */
+    alignmentAxis?: number | null;
+};
+
+export { Padding }
+
+export { Placement }
+
+export declare interface Platform {
+    getElementRects: (args: {
+        reference: ReferenceElement;
+        floating: FloatingElement;
+        strategy: Strategy;
+    }) => Promisable<ElementRects>;
+    getClippingRect: (args: {
+        element: Element;
+        boundary: Boundary;
+        rootBoundary: RootBoundary;
+        strategy: Strategy;
+    }) => Promisable<Rect>;
+    getDimensions: (element: Element) => Promisable<Dimensions>;
+    convertOffsetParentRelativeRectToViewportRelativeRect: (args: {
+        elements?: Elements;
+        rect: Rect;
+        offsetParent: Element;
+        strategy: Strategy;
+    }) => Promisable<Rect>;
+    getOffsetParent: (element: Element, polyfill?: (element: HTMLElement) => Element | null) => Promisable<Element | Window>;
+    isElement: (value: unknown) => Promisable<boolean>;
+    getDocumentElement: (element: Element) => Promisable<HTMLElement>;
+    getClientRects: (element: Element) => Promisable<Array<ClientRectObject>>;
+    isRTL: (element: Element) => Promisable<boolean>;
+    getScale: (element: HTMLElement) => Promisable<{
+        x: number;
+        y: number;
+    }>;
+}
+
+export declare const platform: Platform;
+
+declare type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+declare type Promisable<T> = T | Promise<T>;
+
+export { Rect }
+
+export declare type ReferenceElement = Element | VirtualElement;
+
+export { RootBoundary }
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+export declare const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
+
+export declare type ShiftOptions = Prettify<Omit<ShiftOptions_2, 'boundary'> & DetectOverflowOptions>;
+
+export { Side }
+
+export { SideObject }
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+export declare const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
+
+export declare type SizeOptions = Prettify<Omit<SizeOptions_2, 'apply' | 'boundary'> & DetectOverflowOptions & {
+    /**
+     * Function that is called to perform style mutations to the floating element
+     * to change its size.
+     * @default undefined
+     */
+    apply?(args: MiddlewareState & {
+        availableWidth: number;
+        availableHeight: number;
+    }): Promisable<void>;
+}>;
+
+export { Strategy }
+
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+export declare interface VirtualElement {
+    getBoundingClientRect(): ClientRectObject;
+    getClientRects?(): Array<ClientRectObject> | DOMRectList;
+    contextElement?: Element;
+}
+
+export { }

node_modules/@floating-ui/dom/dist/floating-ui.dom.esm.js

@@ -0,0 +1,752 @@
+import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';
+import { round, createCoords, max, min, floor } from '@floating-ui/utils';
+import { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getNodeScroll, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';
+export { getOverflowAncestors } from '@floating-ui/utils/dom';
+
+function getCssDimensions(element) {
+  const css = getComputedStyle(element);
+  // In testing environments, the `width` and `height` properties are empty
+  // strings for SVG elements, returning NaN. Fallback to `0` in this case.
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
+  };
+}
+
+function unwrapElement(element) {
+  return !isElement(element) ? element.contextElement : element;
+}
+
+function getScale(element) {
+  const domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
+  }
+  const rect = domElement.getBoundingClientRect();
+  const {
+    width,
+    height,
+    $
+  } = getCssDimensions(domElement);
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
+
+  // 0, NaN, or Infinity should always fallback to 1.
+
+  if (!x || !Number.isFinite(x)) {
+    x = 1;
+  }
+  if (!y || !Number.isFinite(y)) {
+    y = 1;
+  }
+  return {
+    x,
+    y
+  };
+}
+
+const noOffsets = /*#__PURE__*/createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+    return false;
+  }
+  return isFixed;
+}
+
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement(element);
+  let scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement(offsetParent)) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
+    }
+  }
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement) {
+    const win = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentWin = win;
+    let currentIFrame = getFrameElement(currentWin);
+    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x *= iframeScale.x;
+      y *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x += left;
+      y += top;
+      currentWin = getWindow(currentIFrame);
+      currentIFrame = getFrameElement(currentWin);
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x,
+    y
+  });
+}
+
+// If <html> has a CSS width greater than the viewport, then this will be
+// incorrect for RTL.
+function getWindowScrollBarX(element, rect) {
+  const leftScroll = getNodeScroll(element).scrollLeft;
+  if (!rect) {
+    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+  }
+  return rect.left + leftScroll;
+}
+
+function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
+  if (ignoreScrollbarX === void 0) {
+    ignoreScrollbarX = false;
+  }
+  const htmlRect = documentElement.getBoundingClientRect();
+  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :
+  // RTL <body> scrollbar.
+  getWindowScrollBarX(documentElement, htmlRect));
+  const y = htmlRect.top + scroll.scrollTop;
+  return {
+    x,
+    y
+  };
+}
+
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isFixed = strategy === 'fixed';
+  const documentElement = getDocumentElement(offsetParent);
+  const topLayer = elements ? isTopLayer(elements.floating) : false;
+  if (offsetParent === documentElement || topLayer && isFixed) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
+  return {
+    width: rect.width * scale.x,
+    height: rect.height * scale.y,
+    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+  };
+}
+
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+
+// Gets the entire size of the scrollable document area, even extending outside
+// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
+function getDocumentRect(element) {
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = element.ownerDocument.body;
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle(body).direction === 'rtl') {
+    x += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+
+function getViewportRect(element, strategy) {
+  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 visualViewportBased = isWebKit();
+    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+
+// Returns the inner client rect, subtracting scrollbars if present.
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const width = element.clientWidth * scale.x;
+  const height = element.clientHeight * scale.y;
+  const x = left * scale.x;
+  const y = top * scale.y;
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  let rect;
+  if (clippingAncestor === 'viewport') {
+    rect = getViewportRect(element, strategy);
+  } else if (clippingAncestor === 'document') {
+    rect = getDocumentRect(getDocumentElement(element));
+  } else if (isElement(clippingAncestor)) {
+    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+  } else {
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y,
+      width: clippingAncestor.width,
+      height: clippingAncestor.height
+    };
+  }
+  return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+  const parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
+}
+
+// A "clipping ancestor" is an `overflow` element with the characteristic of
+// clipping (or hiding) child elements. This returns all clipping ancestors
+// of the given element up the tree.
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
+  let currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle(element).position === 'fixed';
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    const computedStyle = getComputedStyle(currentNode);
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
+      currentContainingBlockComputedStyle = null;
+    }
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    if (shouldDropCurrentNode) {
+      // Drop non-containing blocks.
+      result = result.filter(ancestor => ancestor !== currentNode);
+    } else {
+      // Record last containing block for next iteration.
+      currentContainingBlockComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
+}
+
+// Gets the maximum area that the element is visible in due to any number of
+// clipping ancestors.
+function getClippingRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+  const firstClippingAncestor = clippingAncestors[0];
+  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  return {
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
+  };
+}
+
+function getDimensions(element) {
+  const {
+    width,
+    height
+  } = getCssDimensions(element);
+  return {
+    width,
+    height
+  };
+}
+
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === 'fixed';
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      // If the <body> scrollbar appears on the left (e.g. RTL systems). Use
+      // Firefox with layout.scrollbar.side = 3 in about:config to test this.
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
+  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+  return {
+    x,
+    y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+
+function isStaticPositioned(element) {
+  return getComputedStyle(element).position === 'static';
+}
+
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  let rawOffsetParent = element.offsetParent;
+
+  // Firefox returns the <html> element as the offsetParent if it's non-static,
+  // while Chrome and Safari return the <body> element. The <body> element must
+  // be used to perform the correct calculations even if the <html> element is
+  // non-static.
+  if (getDocumentElement(element) === rawOffsetParent) {
+    rawOffsetParent = rawOffsetParent.ownerDocument.body;
+  }
+  return rawOffsetParent;
+}
+
+// Gets the closest ancestor positioned element. Handles some edge cases,
+// such as table ancestors and cross browser bugs.
+function getOffsetParent(element, polyfill) {
+  const win = getWindow(element);
+  if (isTopLayer(element)) {
+    return win;
+  }
+  if (!isHTMLElement(element)) {
+    let svgOffsetParent = getParentNode(element);
+    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+        return svgOffsetParent;
+      }
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+    return win;
+  }
+  return offsetParent || getContainingBlock(element) || win;
+}
+
+const getElementRects = async function (data) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
+  const floatingDimensions = await getDimensionsFn(data.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: floatingDimensions.width,
+      height: floatingDimensions.height
+    }
+  };
+};
+
+function isRTL(element) {
+  return getComputedStyle(element).direction === 'rtl';
+}
+
+const platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+
+function rectsAreEqual(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+
+// https://samthor.au/2021/observing-dom/
+function observeMove(element, onMove) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId);
+    (_io = io) == null || _io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    const elementRectForRootMargin = element.getBoundingClientRect();
+    const {
+      left,
+      top,
+      width,
+      height
+    } = elementRectForRootMargin;
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          // If the reference is clipped, the ratio is 0. Throttle the refresh
+          // to prevent an infinite loop of updates.
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 1000);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
+        // It's possible that even though the ratio is reported as 1, the
+        // element is not actually fully within the IntersectionObserver's root
+        // area anymore. This can happen under performance constraints. This may
+        // be a bug in the browser's IntersectionObserver implementation. To
+        // work around this, we compare the element's bounding rect now with
+        // what it was at the time we created the IntersectionObserver. If they
+        // are not equal then the element moved, so we refresh.
+        refresh();
+      }
+      isFirstUpdate = false;
+    }
+
+    // Older browsers don't support a `document` as the root and will throw an
+    // error.
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root.ownerDocument
+      });
+    } catch (e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  refresh(true);
+  return cleanup;
+}
+
+/**
+ * Automatically updates the position of the floating element when necessary.
+ * Should only be called when the floating element is mounted on the DOM or
+ * visible on the screen.
+ * @returns cleanup function that should be invoked when the floating element is
+ * removed from the DOM or hidden from the screen.
+ * @see https://floating-ui.com/docs/autoUpdate
+ */
+function autoUpdate(reference, floating, update, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    ancestorScroll = true,
+    ancestorResize = true,
+    elementResize = typeof ResizeObserver === 'function',
+    layoutShift = typeof IntersectionObserver === 'function',
+    animationFrame = false
+  } = options;
+  const referenceEl = unwrapElement(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
+  ancestors.forEach(ancestor => {
+    ancestorScroll && ancestor.addEventListener('scroll', update, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener('resize', update);
+  });
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver(_ref => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        // Prevent update loops when using the `size` middleware.
+        // https://github.com/floating-ui/floating-ui/issues/1740
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          var _resizeObserver;
+          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+        });
+      }
+      update();
+    });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
+    }
+    resizeObserver.observe(floating);
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference);
+    if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
+      update();
+    }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  update();
+  return () => {
+    var _resizeObserver2;
+    ancestors.forEach(ancestor => {
+      ancestorScroll && ancestor.removeEventListener('scroll', update);
+      ancestorResize && ancestor.removeEventListener('resize', update);
+    });
+    cleanupIo == null || cleanupIo();
+    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
+  };
+}
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+const detectOverflow = detectOverflow$1;
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+const offset = offset$1;
+
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+const autoPlacement = autoPlacement$1;
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+const shift = shift$1;
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip = flip$1;
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+const size = size$1;
+
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+const hide = hide$1;
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow = arrow$1;
+
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+const inline = inline$1;
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+const limitShift = limitShift$1;
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ */
+const computePosition = (reference, floating, options) => {
+  // This caches the expensive `getClippingElementAncestors` function so that
+  // multiple lifecycle resets re-use the same result. It only lives for a
+  // single call. If other functions become expensive, we can add them as well.
+  const cache = new Map();
+  const mergedOptions = {
+    platform,
+    ...options
+  };
+  const platformWithCache = {
+    ...mergedOptions.platform,
+    _c: cache
+  };
+  return computePosition$1(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
+  });
+};
+
+export { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };

node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs

@@ -0,0 +1,752 @@
+import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';
+import { round, createCoords, max, min, floor } from '@floating-ui/utils';
+import { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getNodeScroll, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';
+export { getOverflowAncestors } from '@floating-ui/utils/dom';
+
+function getCssDimensions(element) {
+  const css = getComputedStyle(element);
+  // In testing environments, the `width` and `height` properties are empty
+  // strings for SVG elements, returning NaN. Fallback to `0` in this case.
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
+  };
+}
+
+function unwrapElement(element) {
+  return !isElement(element) ? element.contextElement : element;
+}
+
+function getScale(element) {
+  const domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
+  }
+  const rect = domElement.getBoundingClientRect();
+  const {
+    width,
+    height,
+    $
+  } = getCssDimensions(domElement);
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
+
+  // 0, NaN, or Infinity should always fallback to 1.
+
+  if (!x || !Number.isFinite(x)) {
+    x = 1;
+  }
+  if (!y || !Number.isFinite(y)) {
+    y = 1;
+  }
+  return {
+    x,
+    y
+  };
+}
+
+const noOffsets = /*#__PURE__*/createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+    return false;
+  }
+  return isFixed;
+}
+
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement(element);
+  let scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement(offsetParent)) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
+    }
+  }
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement) {
+    const win = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentWin = win;
+    let currentIFrame = getFrameElement(currentWin);
+    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x *= iframeScale.x;
+      y *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x += left;
+      y += top;
+      currentWin = getWindow(currentIFrame);
+      currentIFrame = getFrameElement(currentWin);
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x,
+    y
+  });
+}
+
+// If <html> has a CSS width greater than the viewport, then this will be
+// incorrect for RTL.
+function getWindowScrollBarX(element, rect) {
+  const leftScroll = getNodeScroll(element).scrollLeft;
+  if (!rect) {
+    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+  }
+  return rect.left + leftScroll;
+}
+
+function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
+  if (ignoreScrollbarX === void 0) {
+    ignoreScrollbarX = false;
+  }
+  const htmlRect = documentElement.getBoundingClientRect();
+  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :
+  // RTL <body> scrollbar.
+  getWindowScrollBarX(documentElement, htmlRect));
+  const y = htmlRect.top + scroll.scrollTop;
+  return {
+    x,
+    y
+  };
+}
+
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isFixed = strategy === 'fixed';
+  const documentElement = getDocumentElement(offsetParent);
+  const topLayer = elements ? isTopLayer(elements.floating) : false;
+  if (offsetParent === documentElement || topLayer && isFixed) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
+  return {
+    width: rect.width * scale.x,
+    height: rect.height * scale.y,
+    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+  };
+}
+
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+
+// Gets the entire size of the scrollable document area, even extending outside
+// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
+function getDocumentRect(element) {
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = element.ownerDocument.body;
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle(body).direction === 'rtl') {
+    x += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+
+function getViewportRect(element, strategy) {
+  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 visualViewportBased = isWebKit();
+    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+
+// Returns the inner client rect, subtracting scrollbars if present.
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const width = element.clientWidth * scale.x;
+  const height = element.clientHeight * scale.y;
+  const x = left * scale.x;
+  const y = top * scale.y;
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  let rect;
+  if (clippingAncestor === 'viewport') {
+    rect = getViewportRect(element, strategy);
+  } else if (clippingAncestor === 'document') {
+    rect = getDocumentRect(getDocumentElement(element));
+  } else if (isElement(clippingAncestor)) {
+    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+  } else {
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y,
+      width: clippingAncestor.width,
+      height: clippingAncestor.height
+    };
+  }
+  return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+  const parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
+}
+
+// A "clipping ancestor" is an `overflow` element with the characteristic of
+// clipping (or hiding) child elements. This returns all clipping ancestors
+// of the given element up the tree.
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
+  let currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle(element).position === 'fixed';
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    const computedStyle = getComputedStyle(currentNode);
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
+      currentContainingBlockComputedStyle = null;
+    }
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    if (shouldDropCurrentNode) {
+      // Drop non-containing blocks.
+      result = result.filter(ancestor => ancestor !== currentNode);
+    } else {
+      // Record last containing block for next iteration.
+      currentContainingBlockComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
+}
+
+// Gets the maximum area that the element is visible in due to any number of
+// clipping ancestors.
+function getClippingRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+  const firstClippingAncestor = clippingAncestors[0];
+  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  return {
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
+  };
+}
+
+function getDimensions(element) {
+  const {
+    width,
+    height
+  } = getCssDimensions(element);
+  return {
+    width,
+    height
+  };
+}
+
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === 'fixed';
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      // If the <body> scrollbar appears on the left (e.g. RTL systems). Use
+      // Firefox with layout.scrollbar.side = 3 in about:config to test this.
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
+  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+  return {
+    x,
+    y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+
+function isStaticPositioned(element) {
+  return getComputedStyle(element).position === 'static';
+}
+
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  let rawOffsetParent = element.offsetParent;
+
+  // Firefox returns the <html> element as the offsetParent if it's non-static,
+  // while Chrome and Safari return the <body> element. The <body> element must
+  // be used to perform the correct calculations even if the <html> element is
+  // non-static.
+  if (getDocumentElement(element) === rawOffsetParent) {
+    rawOffsetParent = rawOffsetParent.ownerDocument.body;
+  }
+  return rawOffsetParent;
+}
+
+// Gets the closest ancestor positioned element. Handles some edge cases,
+// such as table ancestors and cross browser bugs.
+function getOffsetParent(element, polyfill) {
+  const win = getWindow(element);
+  if (isTopLayer(element)) {
+    return win;
+  }
+  if (!isHTMLElement(element)) {
+    let svgOffsetParent = getParentNode(element);
+    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+        return svgOffsetParent;
+      }
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+    return win;
+  }
+  return offsetParent || getContainingBlock(element) || win;
+}
+
+const getElementRects = async function (data) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
+  const floatingDimensions = await getDimensionsFn(data.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: floatingDimensions.width,
+      height: floatingDimensions.height
+    }
+  };
+};
+
+function isRTL(element) {
+  return getComputedStyle(element).direction === 'rtl';
+}
+
+const platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+
+function rectsAreEqual(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+
+// https://samthor.au/2021/observing-dom/
+function observeMove(element, onMove) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId);
+    (_io = io) == null || _io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    const elementRectForRootMargin = element.getBoundingClientRect();
+    const {
+      left,
+      top,
+      width,
+      height
+    } = elementRectForRootMargin;
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          // If the reference is clipped, the ratio is 0. Throttle the refresh
+          // to prevent an infinite loop of updates.
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 1000);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
+        // It's possible that even though the ratio is reported as 1, the
+        // element is not actually fully within the IntersectionObserver's root
+        // area anymore. This can happen under performance constraints. This may
+        // be a bug in the browser's IntersectionObserver implementation. To
+        // work around this, we compare the element's bounding rect now with
+        // what it was at the time we created the IntersectionObserver. If they
+        // are not equal then the element moved, so we refresh.
+        refresh();
+      }
+      isFirstUpdate = false;
+    }
+
+    // Older browsers don't support a `document` as the root and will throw an
+    // error.
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root.ownerDocument
+      });
+    } catch (e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  refresh(true);
+  return cleanup;
+}
+
+/**
+ * Automatically updates the position of the floating element when necessary.
+ * Should only be called when the floating element is mounted on the DOM or
+ * visible on the screen.
+ * @returns cleanup function that should be invoked when the floating element is
+ * removed from the DOM or hidden from the screen.
+ * @see https://floating-ui.com/docs/autoUpdate
+ */
+function autoUpdate(reference, floating, update, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    ancestorScroll = true,
+    ancestorResize = true,
+    elementResize = typeof ResizeObserver === 'function',
+    layoutShift = typeof IntersectionObserver === 'function',
+    animationFrame = false
+  } = options;
+  const referenceEl = unwrapElement(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
+  ancestors.forEach(ancestor => {
+    ancestorScroll && ancestor.addEventListener('scroll', update, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener('resize', update);
+  });
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver(_ref => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        // Prevent update loops when using the `size` middleware.
+        // https://github.com/floating-ui/floating-ui/issues/1740
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          var _resizeObserver;
+          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+        });
+      }
+      update();
+    });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
+    }
+    resizeObserver.observe(floating);
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference);
+    if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
+      update();
+    }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  update();
+  return () => {
+    var _resizeObserver2;
+    ancestors.forEach(ancestor => {
+      ancestorScroll && ancestor.removeEventListener('scroll', update);
+      ancestorResize && ancestor.removeEventListener('resize', update);
+    });
+    cleanupIo == null || cleanupIo();
+    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
+  };
+}
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+const detectOverflow = detectOverflow$1;
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+const offset = offset$1;
+
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+const autoPlacement = autoPlacement$1;
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+const shift = shift$1;
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip = flip$1;
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+const size = size$1;
+
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+const hide = hide$1;
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow = arrow$1;
+
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+const inline = inline$1;
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+const limitShift = limitShift$1;
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ */
+const computePosition = (reference, floating, options) => {
+  // This caches the expensive `getClippingElementAncestors` function so that
+  // multiple lifecycle resets re-use the same result. It only lives for a
+  // single call. If other functions become expensive, we can add them as well.
+  const cache = new Map();
+  const mergedOptions = {
+    platform,
+    ...options
+  };
+  const platformWithCache = {
+    ...mergedOptions.platform,
+    _c: cache
+  };
+  return computePosition$1(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
+  });
+};
+
+export { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };

node_modules/@floating-ui/dom/dist/floating-ui.dom.umd.js

@@ -0,0 +1,935 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@floating-ui/core')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@floating-ui/core'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIDOM = {}, global.FloatingUICore));
+})(this, (function (exports, core) { 'use strict';
+
+  /**
+   * Custom positioning reference element.
+   * @see https://floating-ui.com/docs/virtual-elements
+   */
+
+  const min = Math.min;
+  const max = Math.max;
+  const round = Math.round;
+  const floor = Math.floor;
+  const createCoords = v => ({
+    x: v,
+    y: v
+  });
+
+  function hasWindow() {
+    return typeof window !== 'undefined';
+  }
+  function getNodeName(node) {
+    if (isNode(node)) {
+      return (node.nodeName || '').toLowerCase();
+    }
+    // Mocked nodes in testing environments may not be instances of Node. By
+    // returning `#document` an infinite loop won't occur.
+    // https://github.com/floating-ui/floating-ui/issues/2317
+    return '#document';
+  }
+  function getWindow(node) {
+    var _node$ownerDocument;
+    return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+  }
+  function getDocumentElement(node) {
+    var _ref;
+    return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+  }
+  function isNode(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof Node || value instanceof getWindow(value).Node;
+  }
+  function isElement(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof Element || value instanceof getWindow(value).Element;
+  }
+  function isHTMLElement(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+  }
+  function isShadowRoot(value) {
+    if (!hasWindow() || typeof ShadowRoot === 'undefined') {
+      return false;
+    }
+    return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+  }
+  function isOverflowElement(element) {
+    const {
+      overflow,
+      overflowX,
+      overflowY,
+      display
+    } = getComputedStyle(element);
+    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+  }
+  function isTableElement(element) {
+    return ['table', 'td', 'th'].includes(getNodeName(element));
+  }
+  function isTopLayer(element) {
+    return [':popover-open', ':modal'].some(selector => {
+      try {
+        return element.matches(selector);
+      } catch (e) {
+        return false;
+      }
+    });
+  }
+  function isContainingBlock(elementOrCss) {
+    const webkit = isWebKit();
+    const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    // https://drafts.csswg.org/css-transforms-2/#individual-transforms
+    return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+  }
+  function getContainingBlock(element) {
+    let currentNode = getParentNode(element);
+    while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+      if (isContainingBlock(currentNode)) {
+        return currentNode;
+      } else if (isTopLayer(currentNode)) {
+        return null;
+      }
+      currentNode = getParentNode(currentNode);
+    }
+    return null;
+  }
+  function isWebKit() {
+    if (typeof CSS === 'undefined' || !CSS.supports) return false;
+    return CSS.supports('-webkit-backdrop-filter', 'none');
+  }
+  function isLastTraversableNode(node) {
+    return ['html', 'body', '#document'].includes(getNodeName(node));
+  }
+  function getComputedStyle(element) {
+    return getWindow(element).getComputedStyle(element);
+  }
+  function getNodeScroll(element) {
+    if (isElement(element)) {
+      return {
+        scrollLeft: element.scrollLeft,
+        scrollTop: element.scrollTop
+      };
+    }
+    return {
+      scrollLeft: element.scrollX,
+      scrollTop: element.scrollY
+    };
+  }
+  function getParentNode(node) {
+    if (getNodeName(node) === 'html') {
+      return node;
+    }
+    const result =
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot ||
+    // DOM Element detected.
+    node.parentNode ||
+    // ShadowRoot detected.
+    isShadowRoot(node) && node.host ||
+    // Fallback.
+    getDocumentElement(node);
+    return isShadowRoot(result) ? result.host : result;
+  }
+  function getNearestOverflowAncestor(node) {
+    const parentNode = getParentNode(node);
+    if (isLastTraversableNode(parentNode)) {
+      return node.ownerDocument ? node.ownerDocument.body : node.body;
+    }
+    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+      return parentNode;
+    }
+    return getNearestOverflowAncestor(parentNode);
+  }
+  function getOverflowAncestors(node, list, traverseIframes) {
+    var _node$ownerDocument2;
+    if (list === void 0) {
+      list = [];
+    }
+    if (traverseIframes === void 0) {
+      traverseIframes = true;
+    }
+    const scrollableAncestor = getNearestOverflowAncestor(node);
+    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+    const win = getWindow(scrollableAncestor);
+    if (isBody) {
+      const frameElement = getFrameElement(win);
+      return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+    }
+    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+  }
+  function getFrameElement(win) {
+    return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+  }
+
+  function getCssDimensions(element) {
+    const css = getComputedStyle(element);
+    // In testing environments, the `width` and `height` properties are empty
+    // strings for SVG elements, returning NaN. Fallback to `0` in this case.
+    let width = parseFloat(css.width) || 0;
+    let height = parseFloat(css.height) || 0;
+    const hasOffset = isHTMLElement(element);
+    const offsetWidth = hasOffset ? element.offsetWidth : width;
+    const offsetHeight = hasOffset ? element.offsetHeight : height;
+    const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+    if (shouldFallback) {
+      width = offsetWidth;
+      height = offsetHeight;
+    }
+    return {
+      width,
+      height,
+      $: shouldFallback
+    };
+  }
+
+  function unwrapElement(element) {
+    return !isElement(element) ? element.contextElement : element;
+  }
+
+  function getScale(element) {
+    const domElement = unwrapElement(element);
+    if (!isHTMLElement(domElement)) {
+      return createCoords(1);
+    }
+    const rect = domElement.getBoundingClientRect();
+    const {
+      width,
+      height,
+      $
+    } = getCssDimensions(domElement);
+    let x = ($ ? round(rect.width) : rect.width) / width;
+    let y = ($ ? round(rect.height) : rect.height) / height;
+
+    // 0, NaN, or Infinity should always fallback to 1.
+
+    if (!x || !Number.isFinite(x)) {
+      x = 1;
+    }
+    if (!y || !Number.isFinite(y)) {
+      y = 1;
+    }
+    return {
+      x,
+      y
+    };
+  }
+
+  const noOffsets = /*#__PURE__*/createCoords(0);
+  function getVisualOffsets(element) {
+    const win = getWindow(element);
+    if (!isWebKit() || !win.visualViewport) {
+      return noOffsets;
+    }
+    return {
+      x: win.visualViewport.offsetLeft,
+      y: win.visualViewport.offsetTop
+    };
+  }
+  function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+    if (isFixed === void 0) {
+      isFixed = false;
+    }
+    if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+      return false;
+    }
+    return isFixed;
+  }
+
+  function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+    if (includeScale === void 0) {
+      includeScale = false;
+    }
+    if (isFixedStrategy === void 0) {
+      isFixedStrategy = false;
+    }
+    const clientRect = element.getBoundingClientRect();
+    const domElement = unwrapElement(element);
+    let scale = createCoords(1);
+    if (includeScale) {
+      if (offsetParent) {
+        if (isElement(offsetParent)) {
+          scale = getScale(offsetParent);
+        }
+      } else {
+        scale = getScale(element);
+      }
+    }
+    const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+    let x = (clientRect.left + visualOffsets.x) / scale.x;
+    let y = (clientRect.top + visualOffsets.y) / scale.y;
+    let width = clientRect.width / scale.x;
+    let height = clientRect.height / scale.y;
+    if (domElement) {
+      const win = getWindow(domElement);
+      const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+      let currentWin = win;
+      let currentIFrame = getFrameElement(currentWin);
+      while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+        const iframeScale = getScale(currentIFrame);
+        const iframeRect = currentIFrame.getBoundingClientRect();
+        const css = getComputedStyle(currentIFrame);
+        const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+        const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+        x *= iframeScale.x;
+        y *= iframeScale.y;
+        width *= iframeScale.x;
+        height *= iframeScale.y;
+        x += left;
+        y += top;
+        currentWin = getWindow(currentIFrame);
+        currentIFrame = getFrameElement(currentWin);
+      }
+    }
+    return core.rectToClientRect({
+      width,
+      height,
+      x,
+      y
+    });
+  }
+
+  // If <html> has a CSS width greater than the viewport, then this will be
+  // incorrect for RTL.
+  function getWindowScrollBarX(element, rect) {
+    const leftScroll = getNodeScroll(element).scrollLeft;
+    if (!rect) {
+      return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+    }
+    return rect.left + leftScroll;
+  }
+
+  function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
+    if (ignoreScrollbarX === void 0) {
+      ignoreScrollbarX = false;
+    }
+    const htmlRect = documentElement.getBoundingClientRect();
+    const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 :
+    // RTL <body> scrollbar.
+    getWindowScrollBarX(documentElement, htmlRect));
+    const y = htmlRect.top + scroll.scrollTop;
+    return {
+      x,
+      y
+    };
+  }
+
+  function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+    let {
+      elements,
+      rect,
+      offsetParent,
+      strategy
+    } = _ref;
+    const isFixed = strategy === 'fixed';
+    const documentElement = getDocumentElement(offsetParent);
+    const topLayer = elements ? isTopLayer(elements.floating) : false;
+    if (offsetParent === documentElement || topLayer && isFixed) {
+      return rect;
+    }
+    let scroll = {
+      scrollLeft: 0,
+      scrollTop: 0
+    };
+    let scale = createCoords(1);
+    const offsets = createCoords(0);
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+      if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+        scroll = getNodeScroll(offsetParent);
+      }
+      if (isHTMLElement(offsetParent)) {
+        const offsetRect = getBoundingClientRect(offsetParent);
+        scale = getScale(offsetParent);
+        offsets.x = offsetRect.x + offsetParent.clientLeft;
+        offsets.y = offsetRect.y + offsetParent.clientTop;
+      }
+    }
+    const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
+    return {
+      width: rect.width * scale.x,
+      height: rect.height * scale.y,
+      x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+      y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+    };
+  }
+
+  function getClientRects(element) {
+    return Array.from(element.getClientRects());
+  }
+
+  // Gets the entire size of the scrollable document area, even extending outside
+  // of the `<html>` and `<body>` rect bounds if horizontally scrollable.
+  function getDocumentRect(element) {
+    const html = getDocumentElement(element);
+    const scroll = getNodeScroll(element);
+    const body = element.ownerDocument.body;
+    const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+    const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+    const y = -scroll.scrollTop;
+    if (getComputedStyle(body).direction === 'rtl') {
+      x += max(html.clientWidth, body.clientWidth) - width;
+    }
+    return {
+      width,
+      height,
+      x,
+      y
+    };
+  }
+
+  function getViewportRect(element, strategy) {
+    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 visualViewportBased = isWebKit();
+      if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
+        x = visualViewport.offsetLeft;
+        y = visualViewport.offsetTop;
+      }
+    }
+    return {
+      width,
+      height,
+      x,
+      y
+    };
+  }
+
+  // Returns the inner client rect, subtracting scrollbars if present.
+  function getInnerBoundingClientRect(element, strategy) {
+    const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
+    const top = clientRect.top + element.clientTop;
+    const left = clientRect.left + element.clientLeft;
+    const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+    const width = element.clientWidth * scale.x;
+    const height = element.clientHeight * scale.y;
+    const x = left * scale.x;
+    const y = top * scale.y;
+    return {
+      width,
+      height,
+      x,
+      y
+    };
+  }
+  function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+    let rect;
+    if (clippingAncestor === 'viewport') {
+      rect = getViewportRect(element, strategy);
+    } else if (clippingAncestor === 'document') {
+      rect = getDocumentRect(getDocumentElement(element));
+    } else if (isElement(clippingAncestor)) {
+      rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+    } else {
+      const visualOffsets = getVisualOffsets(element);
+      rect = {
+        x: clippingAncestor.x - visualOffsets.x,
+        y: clippingAncestor.y - visualOffsets.y,
+        width: clippingAncestor.width,
+        height: clippingAncestor.height
+      };
+    }
+    return core.rectToClientRect(rect);
+  }
+  function hasFixedPositionAncestor(element, stopNode) {
+    const parentNode = getParentNode(element);
+    if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+      return false;
+    }
+    return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
+  }
+
+  // A "clipping ancestor" is an `overflow` element with the characteristic of
+  // clipping (or hiding) child elements. This returns all clipping ancestors
+  // of the given element up the tree.
+  function getClippingElementAncestors(element, cache) {
+    const cachedResult = cache.get(element);
+    if (cachedResult) {
+      return cachedResult;
+    }
+    let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
+    let currentContainingBlockComputedStyle = null;
+    const elementIsFixed = getComputedStyle(element).position === 'fixed';
+    let currentNode = elementIsFixed ? getParentNode(element) : element;
+
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+      const computedStyle = getComputedStyle(currentNode);
+      const currentNodeIsContaining = isContainingBlock(currentNode);
+      if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
+        currentContainingBlockComputedStyle = null;
+      }
+      const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+      if (shouldDropCurrentNode) {
+        // Drop non-containing blocks.
+        result = result.filter(ancestor => ancestor !== currentNode);
+      } else {
+        // Record last containing block for next iteration.
+        currentContainingBlockComputedStyle = computedStyle;
+      }
+      currentNode = getParentNode(currentNode);
+    }
+    cache.set(element, result);
+    return result;
+  }
+
+  // Gets the maximum area that the element is visible in due to any number of
+  // clipping ancestors.
+  function getClippingRect(_ref) {
+    let {
+      element,
+      boundary,
+      rootBoundary,
+      strategy
+    } = _ref;
+    const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+    const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+    const firstClippingAncestor = clippingAncestors[0];
+    const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+      const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+      accRect.top = max(rect.top, accRect.top);
+      accRect.right = min(rect.right, accRect.right);
+      accRect.bottom = min(rect.bottom, accRect.bottom);
+      accRect.left = max(rect.left, accRect.left);
+      return accRect;
+    }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+    return {
+      width: clippingRect.right - clippingRect.left,
+      height: clippingRect.bottom - clippingRect.top,
+      x: clippingRect.left,
+      y: clippingRect.top
+    };
+  }
+
+  function getDimensions(element) {
+    const {
+      width,
+      height
+    } = getCssDimensions(element);
+    return {
+      width,
+      height
+    };
+  }
+
+  function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    const documentElement = getDocumentElement(offsetParent);
+    const isFixed = strategy === 'fixed';
+    const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+    let scroll = {
+      scrollLeft: 0,
+      scrollTop: 0
+    };
+    const offsets = createCoords(0);
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+      if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+        scroll = getNodeScroll(offsetParent);
+      }
+      if (isOffsetParentAnElement) {
+        const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+        offsets.x = offsetRect.x + offsetParent.clientLeft;
+        offsets.y = offsetRect.y + offsetParent.clientTop;
+      } else if (documentElement) {
+        // If the <body> scrollbar appears on the left (e.g. RTL systems). Use
+        // Firefox with layout.scrollbar.side = 3 in about:config to test this.
+        offsets.x = getWindowScrollBarX(documentElement);
+      }
+    }
+    const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+    const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
+    const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+    return {
+      x,
+      y,
+      width: rect.width,
+      height: rect.height
+    };
+  }
+
+  function isStaticPositioned(element) {
+    return getComputedStyle(element).position === 'static';
+  }
+
+  function getTrueOffsetParent(element, polyfill) {
+    if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
+      return null;
+    }
+    if (polyfill) {
+      return polyfill(element);
+    }
+    let rawOffsetParent = element.offsetParent;
+
+    // Firefox returns the <html> element as the offsetParent if it's non-static,
+    // while Chrome and Safari return the <body> element. The <body> element must
+    // be used to perform the correct calculations even if the <html> element is
+    // non-static.
+    if (getDocumentElement(element) === rawOffsetParent) {
+      rawOffsetParent = rawOffsetParent.ownerDocument.body;
+    }
+    return rawOffsetParent;
+  }
+
+  // Gets the closest ancestor positioned element. Handles some edge cases,
+  // such as table ancestors and cross browser bugs.
+  function getOffsetParent(element, polyfill) {
+    const win = getWindow(element);
+    if (isTopLayer(element)) {
+      return win;
+    }
+    if (!isHTMLElement(element)) {
+      let svgOffsetParent = getParentNode(element);
+      while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+        if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+          return svgOffsetParent;
+        }
+        svgOffsetParent = getParentNode(svgOffsetParent);
+      }
+      return win;
+    }
+    let offsetParent = getTrueOffsetParent(element, polyfill);
+    while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+      offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+    }
+    if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+      return win;
+    }
+    return offsetParent || getContainingBlock(element) || win;
+  }
+
+  const getElementRects = async function (data) {
+    const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+    const getDimensionsFn = this.getDimensions;
+    const floatingDimensions = await getDimensionsFn(data.floating);
+    return {
+      reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+      floating: {
+        x: 0,
+        y: 0,
+        width: floatingDimensions.width,
+        height: floatingDimensions.height
+      }
+    };
+  };
+
+  function isRTL(element) {
+    return getComputedStyle(element).direction === 'rtl';
+  }
+
+  const platform = {
+    convertOffsetParentRelativeRectToViewportRelativeRect,
+    getDocumentElement,
+    getClippingRect,
+    getOffsetParent,
+    getElementRects,
+    getClientRects,
+    getDimensions,
+    getScale,
+    isElement,
+    isRTL
+  };
+
+  function rectsAreEqual(a, b) {
+    return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+  }
+
+  // https://samthor.au/2021/observing-dom/
+  function observeMove(element, onMove) {
+    let io = null;
+    let timeoutId;
+    const root = getDocumentElement(element);
+    function cleanup() {
+      var _io;
+      clearTimeout(timeoutId);
+      (_io = io) == null || _io.disconnect();
+      io = null;
+    }
+    function refresh(skip, threshold) {
+      if (skip === void 0) {
+        skip = false;
+      }
+      if (threshold === void 0) {
+        threshold = 1;
+      }
+      cleanup();
+      const elementRectForRootMargin = element.getBoundingClientRect();
+      const {
+        left,
+        top,
+        width,
+        height
+      } = elementRectForRootMargin;
+      if (!skip) {
+        onMove();
+      }
+      if (!width || !height) {
+        return;
+      }
+      const insetTop = floor(top);
+      const insetRight = floor(root.clientWidth - (left + width));
+      const insetBottom = floor(root.clientHeight - (top + height));
+      const insetLeft = floor(left);
+      const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+      const options = {
+        rootMargin,
+        threshold: max(0, min(1, threshold)) || 1
+      };
+      let isFirstUpdate = true;
+      function handleObserve(entries) {
+        const ratio = entries[0].intersectionRatio;
+        if (ratio !== threshold) {
+          if (!isFirstUpdate) {
+            return refresh();
+          }
+          if (!ratio) {
+            // If the reference is clipped, the ratio is 0. Throttle the refresh
+            // to prevent an infinite loop of updates.
+            timeoutId = setTimeout(() => {
+              refresh(false, 1e-7);
+            }, 1000);
+          } else {
+            refresh(false, ratio);
+          }
+        }
+        if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
+          // It's possible that even though the ratio is reported as 1, the
+          // element is not actually fully within the IntersectionObserver's root
+          // area anymore. This can happen under performance constraints. This may
+          // be a bug in the browser's IntersectionObserver implementation. To
+          // work around this, we compare the element's bounding rect now with
+          // what it was at the time we created the IntersectionObserver. If they
+          // are not equal then the element moved, so we refresh.
+          refresh();
+        }
+        isFirstUpdate = false;
+      }
+
+      // Older browsers don't support a `document` as the root and will throw an
+      // error.
+      try {
+        io = new IntersectionObserver(handleObserve, {
+          ...options,
+          // Handle <iframe>s
+          root: root.ownerDocument
+        });
+      } catch (e) {
+        io = new IntersectionObserver(handleObserve, options);
+      }
+      io.observe(element);
+    }
+    refresh(true);
+    return cleanup;
+  }
+
+  /**
+   * Automatically updates the position of the floating element when necessary.
+   * Should only be called when the floating element is mounted on the DOM or
+   * visible on the screen.
+   * @returns cleanup function that should be invoked when the floating element is
+   * removed from the DOM or hidden from the screen.
+   * @see https://floating-ui.com/docs/autoUpdate
+   */
+  function autoUpdate(reference, floating, update, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    const {
+      ancestorScroll = true,
+      ancestorResize = true,
+      elementResize = typeof ResizeObserver === 'function',
+      layoutShift = typeof IntersectionObserver === 'function',
+      animationFrame = false
+    } = options;
+    const referenceEl = unwrapElement(reference);
+    const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
+    ancestors.forEach(ancestor => {
+      ancestorScroll && ancestor.addEventListener('scroll', update, {
+        passive: true
+      });
+      ancestorResize && ancestor.addEventListener('resize', update);
+    });
+    const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+    let reobserveFrame = -1;
+    let resizeObserver = null;
+    if (elementResize) {
+      resizeObserver = new ResizeObserver(_ref => {
+        let [firstEntry] = _ref;
+        if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+          // Prevent update loops when using the `size` middleware.
+          // https://github.com/floating-ui/floating-ui/issues/1740
+          resizeObserver.unobserve(floating);
+          cancelAnimationFrame(reobserveFrame);
+          reobserveFrame = requestAnimationFrame(() => {
+            var _resizeObserver;
+            (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+          });
+        }
+        update();
+      });
+      if (referenceEl && !animationFrame) {
+        resizeObserver.observe(referenceEl);
+      }
+      resizeObserver.observe(floating);
+    }
+    let frameId;
+    let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+    if (animationFrame) {
+      frameLoop();
+    }
+    function frameLoop() {
+      const nextRefRect = getBoundingClientRect(reference);
+      if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
+        update();
+      }
+      prevRefRect = nextRefRect;
+      frameId = requestAnimationFrame(frameLoop);
+    }
+    update();
+    return () => {
+      var _resizeObserver2;
+      ancestors.forEach(ancestor => {
+        ancestorScroll && ancestor.removeEventListener('scroll', update);
+        ancestorResize && ancestor.removeEventListener('resize', update);
+      });
+      cleanupIo == null || cleanupIo();
+      (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+      resizeObserver = null;
+      if (animationFrame) {
+        cancelAnimationFrame(frameId);
+      }
+    };
+  }
+
+  /**
+   * Resolves with an object of overflow side offsets that determine how much the
+   * element is overflowing a given clipping boundary on each side.
+   * - positive = overflowing the boundary by that number of pixels
+   * - negative = how many pixels left before it will overflow
+   * - 0 = lies flush with the boundary
+   * @see https://floating-ui.com/docs/detectOverflow
+   */
+  const detectOverflow = core.detectOverflow;
+
+  /**
+   * Modifies the placement by translating the floating element along the
+   * specified axes.
+   * A number (shorthand for `mainAxis` or distance), or an axes configuration
+   * object may be passed.
+   * @see https://floating-ui.com/docs/offset
+   */
+  const offset = core.offset;
+
+  /**
+   * Optimizes the visibility of the floating element by choosing the placement
+   * that has the most space available automatically, without needing to specify a
+   * preferred placement. Alternative to `flip`.
+   * @see https://floating-ui.com/docs/autoPlacement
+   */
+  const autoPlacement = core.autoPlacement;
+
+  /**
+   * Optimizes the visibility of the floating element by shifting it in order to
+   * keep it in view when it will overflow the clipping boundary.
+   * @see https://floating-ui.com/docs/shift
+   */
+  const shift = core.shift;
+
+  /**
+   * Optimizes the visibility of the floating element by flipping the `placement`
+   * in order to keep it in view when the preferred placement(s) will overflow the
+   * clipping boundary. Alternative to `autoPlacement`.
+   * @see https://floating-ui.com/docs/flip
+   */
+  const flip = core.flip;
+
+  /**
+   * Provides data that allows you to change the size of the floating element —
+   * for instance, prevent it from overflowing the clipping boundary or match the
+   * width of the reference element.
+   * @see https://floating-ui.com/docs/size
+   */
+  const size = core.size;
+
+  /**
+   * Provides data to hide the floating element in applicable situations, such as
+   * when it is not in the same clipping context as the reference element.
+   * @see https://floating-ui.com/docs/hide
+   */
+  const hide = core.hide;
+
+  /**
+   * Provides data to position an inner element of the floating element so that it
+   * appears centered to the reference element.
+   * @see https://floating-ui.com/docs/arrow
+   */
+  const arrow = core.arrow;
+
+  /**
+   * Provides improved positioning for inline reference elements that can span
+   * over multiple lines, such as hyperlinks or range selections.
+   * @see https://floating-ui.com/docs/inline
+   */
+  const inline = core.inline;
+
+  /**
+   * Built-in `limiter` that will stop `shift()` at a certain point.
+   */
+  const limitShift = core.limitShift;
+
+  /**
+   * Computes the `x` and `y` coordinates that will place the floating element
+   * next to a given reference element.
+   */
+  const computePosition = (reference, floating, options) => {
+    // This caches the expensive `getClippingElementAncestors` function so that
+    // multiple lifecycle resets re-use the same result. It only lives for a
+    // single call. If other functions become expensive, we can add them as well.
+    const cache = new Map();
+    const mergedOptions = {
+      platform,
+      ...options
+    };
+    const platformWithCache = {
+      ...mergedOptions.platform,
+      _c: cache
+    };
+    return core.computePosition(reference, floating, {
+      ...mergedOptions,
+      platform: platformWithCache
+    });
+  };
+
+  exports.arrow = arrow;
+  exports.autoPlacement = autoPlacement;
+  exports.autoUpdate = autoUpdate;
+  exports.computePosition = computePosition;
+  exports.detectOverflow = detectOverflow;
+  exports.flip = flip;
+  exports.getOverflowAncestors = getOverflowAncestors;
+  exports.hide = hide;
+  exports.inline = inline;
+  exports.limitShift = limitShift;
+  exports.offset = offset;
+  exports.platform = platform;
+  exports.shift = shift;
+  exports.size = size;
+
+}));

node_modules/@floating-ui/dom/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@floating-ui/dom",
+  "version": "1.6.13",
+  "description": "Floating UI for the web",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/floating-ui.dom.umd.js",
+  "module": "./dist/floating-ui.dom.esm.js",
+  "unpkg": "./dist/floating-ui.dom.umd.min.js",
+  "types": "./dist/floating-ui.dom.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/floating-ui.dom.d.mts",
+        "default": "./dist/floating-ui.dom.mjs"
+      },
+      "types": "./dist/floating-ui.dom.d.ts",
+      "module": "./dist/floating-ui.dom.esm.js",
+      "default": "./dist/floating-ui.dom.umd.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "author": "atomiks",
+  "license": "MIT",
+  "bugs": "https://github.com/floating-ui/floating-ui",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/floating-ui/floating-ui.git",
+    "directory": "packages/dom"
+  },
+  "homepage": "https://floating-ui.com",
+  "keywords": [
+    "tooltip",
+    "popover",
+    "dropdown",
+    "menu",
+    "popup",
+    "positioning"
+  ],
+  "dependencies": {
+    "@floating-ui/core": "^1.6.0",
+    "@floating-ui/utils": "^0.2.9"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.46",
+    "@types/react-dom": "^18.2.18",
+    "@vitejs/plugin-react": "^4.2.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.21.1",
+    "config": "0.0.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "clean": "rimraf dist out-tsc test-results",
+    "dev": "vite",
+    "build": "rollup -c",
+    "build:api": "build-api --tsc tsconfig.lib.json",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "publint": "publint",
+    "playwright": "playwright test ./test/functional",
+    "typecheck": "tsc -b"
+  }
+}

node_modules/@floating-ui/utils/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2021-present Floating UI contributors
+
+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.

node_modules/@floating-ui/utils/README.md

@@ -0,0 +1,4 @@
+# @floating-ui/utils
+
+Utility functions shared across Floating UI packages. You may use these
+functions in your own projects, but are subject to breaking changes.

node_modules/@floating-ui/utils/dist/floating-ui.utils.d.mts

@@ -0,0 +1,103 @@
+export declare type AlignedPlacement = `${Side}-${Alignment}`;
+
+export declare type Alignment = 'start' | 'end';
+
+export declare const alignments: Alignment[];
+
+export declare type Axis = 'x' | 'y';
+
+export declare function clamp(start: number, value: number, end: number): number;
+
+export declare type ClientRectObject = Prettify<Rect & SideObject>;
+
+export declare type Coords = {
+    [key in Axis]: number;
+};
+
+export declare const createCoords: (v: number) => {
+    x: number;
+    y: number;
+};
+
+export declare type Dimensions = {
+    [key in Length]: number;
+};
+
+export declare interface ElementRects {
+    reference: Rect;
+    floating: Rect;
+}
+
+export declare function evaluate<T, P>(value: T | ((param: P) => T), param: P): T;
+
+export declare function expandPaddingObject(padding: Partial<SideObject>): SideObject;
+
+export declare const floor: (x: number) => number;
+
+export declare function getAlignment(placement: Placement): Alignment | undefined;
+
+export declare function getAlignmentAxis(placement: Placement): Axis;
+
+export declare function getAlignmentSides(placement: Placement, rects: ElementRects, rtl?: boolean): [Side, Side];
+
+export declare function getAxisLength(axis: Axis): Length;
+
+export declare function getExpandedPlacements(placement: Placement): Array<Placement>;
+
+export declare function getOppositeAlignmentPlacement<T extends string>(placement: T): T;
+
+export declare function getOppositeAxis(axis: Axis): Axis;
+
+export declare function getOppositeAxisPlacements(placement: Placement, flipAlignment: boolean, direction: 'none' | Alignment, rtl?: boolean): Placement[];
+
+export declare function getOppositePlacement<T extends string>(placement: T): T;
+
+export declare function getPaddingObject(padding: Padding): SideObject;
+
+export declare function getSide(placement: Placement): Side;
+
+export declare function getSideAxis(placement: Placement): Axis;
+
+export declare type Length = 'width' | 'height';
+
+export declare const max: (...values: number[]) => number;
+
+export declare const min: (...values: number[]) => number;
+
+export declare type Padding = number | Prettify<Partial<SideObject>>;
+
+export declare type Placement = Prettify<Side | AlignedPlacement>;
+
+export declare const placements: Placement[];
+
+declare type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+export declare type Rect = Prettify<Coords & Dimensions>;
+
+export declare function rectToClientRect(rect: Rect): ClientRectObject;
+
+export declare const round: (x: number) => number;
+
+export declare type Side = 'top' | 'right' | 'bottom' | 'left';
+
+export declare type SideObject = {
+    [key in Side]: number;
+};
+
+export declare const sides: Side[];
+
+export declare type Strategy = 'absolute' | 'fixed';
+
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+export declare interface VirtualElement {
+    getBoundingClientRect(): ClientRectObject;
+    getClientRects?(): Array<ClientRectObject>;
+    contextElement?: any;
+}
+
+export { }

node_modules/@floating-ui/utils/dist/floating-ui.utils.d.ts

@@ -0,0 +1,103 @@
+export declare type AlignedPlacement = `${Side}-${Alignment}`;
+
+export declare type Alignment = 'start' | 'end';
+
+export declare const alignments: Alignment[];
+
+export declare type Axis = 'x' | 'y';
+
+export declare function clamp(start: number, value: number, end: number): number;
+
+export declare type ClientRectObject = Prettify<Rect & SideObject>;
+
+export declare type Coords = {
+    [key in Axis]: number;
+};
+
+export declare const createCoords: (v: number) => {
+    x: number;
+    y: number;
+};
+
+export declare type Dimensions = {
+    [key in Length]: number;
+};
+
+export declare interface ElementRects {
+    reference: Rect;
+    floating: Rect;
+}
+
+export declare function evaluate<T, P>(value: T | ((param: P) => T), param: P): T;
+
+export declare function expandPaddingObject(padding: Partial<SideObject>): SideObject;
+
+export declare const floor: (x: number) => number;
+
+export declare function getAlignment(placement: Placement): Alignment | undefined;
+
+export declare function getAlignmentAxis(placement: Placement): Axis;
+
+export declare function getAlignmentSides(placement: Placement, rects: ElementRects, rtl?: boolean): [Side, Side];
+
+export declare function getAxisLength(axis: Axis): Length;
+
+export declare function getExpandedPlacements(placement: Placement): Array<Placement>;
+
+export declare function getOppositeAlignmentPlacement<T extends string>(placement: T): T;
+
+export declare function getOppositeAxis(axis: Axis): Axis;
+
+export declare function getOppositeAxisPlacements(placement: Placement, flipAlignment: boolean, direction: 'none' | Alignment, rtl?: boolean): Placement[];
+
+export declare function getOppositePlacement<T extends string>(placement: T): T;
+
+export declare function getPaddingObject(padding: Padding): SideObject;
+
+export declare function getSide(placement: Placement): Side;
+
+export declare function getSideAxis(placement: Placement): Axis;
+
+export declare type Length = 'width' | 'height';
+
+export declare const max: (...values: number[]) => number;
+
+export declare const min: (...values: number[]) => number;
+
+export declare type Padding = number | Prettify<Partial<SideObject>>;
+
+export declare type Placement = Prettify<Side | AlignedPlacement>;
+
+export declare const placements: Placement[];
+
+declare type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+export declare type Rect = Prettify<Coords & Dimensions>;
+
+export declare function rectToClientRect(rect: Rect): ClientRectObject;
+
+export declare const round: (x: number) => number;
+
+export declare type Side = 'top' | 'right' | 'bottom' | 'left';
+
+export declare type SideObject = {
+    [key in Side]: number;
+};
+
+export declare const sides: Side[];
+
+export declare type Strategy = 'absolute' | 'fixed';
+
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+export declare interface VirtualElement {
+    getBoundingClientRect(): ClientRectObject;
+    getClientRects?(): Array<ClientRectObject>;
+    contextElement?: any;
+}
+
+export { }

node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.d.mts

@@ -0,0 +1,47 @@
+declare function getComputedStyle_2(element: Element): CSSStyleDeclaration;
+export { getComputedStyle_2 as getComputedStyle }
+
+export declare function getContainingBlock(element: Element): HTMLElement | null;
+
+export declare function getDocumentElement(node: Node | Window): HTMLElement;
+
+export declare function getFrameElement(win: Window): Element | null;
+
+export declare function getNearestOverflowAncestor(node: Node): HTMLElement;
+
+export declare function getNodeName(node: Node | Window): string;
+
+export declare function getNodeScroll(element: Element | Window): {
+    scrollLeft: number;
+    scrollTop: number;
+};
+
+export declare function getOverflowAncestors(node: Node, list?: OverflowAncestors, traverseIframes?: boolean): OverflowAncestors;
+
+export declare function getParentNode(node: Node): Node;
+
+export declare function getWindow(node: any): typeof window;
+
+export declare function isContainingBlock(elementOrCss: Element | CSSStyleDeclaration): boolean;
+
+export declare function isElement(value: unknown): value is Element;
+
+export declare function isHTMLElement(value: unknown): value is HTMLElement;
+
+export declare function isLastTraversableNode(node: Node): boolean;
+
+export declare function isNode(value: unknown): value is Node;
+
+export declare function isOverflowElement(element: Element): boolean;
+
+export declare function isShadowRoot(value: unknown): value is ShadowRoot;
+
+export declare function isTableElement(element: Element): boolean;
+
+export declare function isTopLayer(element: Element): boolean;
+
+export declare function isWebKit(): boolean;
+
+declare type OverflowAncestors = Array<Element | Window | VisualViewport>;
+
+export { }

node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.d.ts

@@ -0,0 +1,47 @@
+declare function getComputedStyle_2(element: Element): CSSStyleDeclaration;
+export { getComputedStyle_2 as getComputedStyle }
+
+export declare function getContainingBlock(element: Element): HTMLElement | null;
+
+export declare function getDocumentElement(node: Node | Window): HTMLElement;
+
+export declare function getFrameElement(win: Window): Element | null;
+
+export declare function getNearestOverflowAncestor(node: Node): HTMLElement;
+
+export declare function getNodeName(node: Node | Window): string;
+
+export declare function getNodeScroll(element: Element | Window): {
+    scrollLeft: number;
+    scrollTop: number;
+};
+
+export declare function getOverflowAncestors(node: Node, list?: OverflowAncestors, traverseIframes?: boolean): OverflowAncestors;
+
+export declare function getParentNode(node: Node): Node;
+
+export declare function getWindow(node: any): typeof window;
+
+export declare function isContainingBlock(elementOrCss: Element | CSSStyleDeclaration): boolean;
+
+export declare function isElement(value: unknown): value is Element;
+
+export declare function isHTMLElement(value: unknown): value is HTMLElement;
+
+export declare function isLastTraversableNode(node: Node): boolean;
+
+export declare function isNode(value: unknown): value is Node;
+
+export declare function isOverflowElement(element: Element): boolean;
+
+export declare function isShadowRoot(value: unknown): value is ShadowRoot;
+
+export declare function isTableElement(element: Element): boolean;
+
+export declare function isTopLayer(element: Element): boolean;
+
+export declare function isWebKit(): boolean;
+
+declare type OverflowAncestors = Array<Element | Window | VisualViewport>;
+
+export { }

node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.esm.js

@@ -0,0 +1,154 @@
+function hasWindow() {
+  return typeof window !== 'undefined';
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || '').toLowerCase();
+  }
+  // Mocked nodes in testing environments may not be instances of Node. By
+  // returning `#document` an infinite loop won't occur.
+  // https://github.com/floating-ui/floating-ui/issues/2317
+  return '#document';
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+}
+function isTableElement(element) {
+  return ['table', 'td', 'th'].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [':popover-open', ':modal'].some(selector => {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
+  return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === 'undefined' || !CSS.supports) return false;
+  return CSS.supports('-webkit-backdrop-filter', 'none');
+}
+function isLastTraversableNode(node) {
+  return ['html', 'body', '#document'].includes(getNodeName(node));
+}
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === 'html') {
+    return node;
+  }
+  const result =
+  // Step into the shadow DOM of the parent of a slotted node.
+  node.assignedSlot ||
+  // DOM Element detected.
+  node.parentNode ||
+  // ShadowRoot detected.
+  isShadowRoot(node) && node.host ||
+  // Fallback.
+  getDocumentElement(node);
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+
+export { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };

node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs

@@ -0,0 +1,154 @@
+function hasWindow() {
+  return typeof window !== 'undefined';
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || '').toLowerCase();
+  }
+  // Mocked nodes in testing environments may not be instances of Node. By
+  // returning `#document` an infinite loop won't occur.
+  // https://github.com/floating-ui/floating-ui/issues/2317
+  return '#document';
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+}
+function isTableElement(element) {
+  return ['table', 'td', 'th'].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [':popover-open', ':modal'].some(selector => {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
+  return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === 'undefined' || !CSS.supports) return false;
+  return CSS.supports('-webkit-backdrop-filter', 'none');
+}
+function isLastTraversableNode(node) {
+  return ['html', 'body', '#document'].includes(getNodeName(node));
+}
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === 'html') {
+    return node;
+  }
+  const result =
+  // Step into the shadow DOM of the parent of a slotted node.
+  node.assignedSlot ||
+  // DOM Element detected.
+  node.parentNode ||
+  // ShadowRoot detected.
+  isShadowRoot(node) && node.host ||
+  // Fallback.
+  getDocumentElement(node);
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+
+export { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };

node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.umd.js

@@ -0,0 +1,181 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIUtilsDOM = {}));
+})(this, (function (exports) { 'use strict';
+
+  function hasWindow() {
+    return typeof window !== 'undefined';
+  }
+  function getNodeName(node) {
+    if (isNode(node)) {
+      return (node.nodeName || '').toLowerCase();
+    }
+    // Mocked nodes in testing environments may not be instances of Node. By
+    // returning `#document` an infinite loop won't occur.
+    // https://github.com/floating-ui/floating-ui/issues/2317
+    return '#document';
+  }
+  function getWindow(node) {
+    var _node$ownerDocument;
+    return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+  }
+  function getDocumentElement(node) {
+    var _ref;
+    return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+  }
+  function isNode(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof Node || value instanceof getWindow(value).Node;
+  }
+  function isElement(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof Element || value instanceof getWindow(value).Element;
+  }
+  function isHTMLElement(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+  }
+  function isShadowRoot(value) {
+    if (!hasWindow() || typeof ShadowRoot === 'undefined') {
+      return false;
+    }
+    return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+  }
+  function isOverflowElement(element) {
+    const {
+      overflow,
+      overflowX,
+      overflowY,
+      display
+    } = getComputedStyle(element);
+    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+  }
+  function isTableElement(element) {
+    return ['table', 'td', 'th'].includes(getNodeName(element));
+  }
+  function isTopLayer(element) {
+    return [':popover-open', ':modal'].some(selector => {
+      try {
+        return element.matches(selector);
+      } catch (e) {
+        return false;
+      }
+    });
+  }
+  function isContainingBlock(elementOrCss) {
+    const webkit = isWebKit();
+    const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    // https://drafts.csswg.org/css-transforms-2/#individual-transforms
+    return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+  }
+  function getContainingBlock(element) {
+    let currentNode = getParentNode(element);
+    while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+      if (isContainingBlock(currentNode)) {
+        return currentNode;
+      } else if (isTopLayer(currentNode)) {
+        return null;
+      }
+      currentNode = getParentNode(currentNode);
+    }
+    return null;
+  }
+  function isWebKit() {
+    if (typeof CSS === 'undefined' || !CSS.supports) return false;
+    return CSS.supports('-webkit-backdrop-filter', 'none');
+  }
+  function isLastTraversableNode(node) {
+    return ['html', 'body', '#document'].includes(getNodeName(node));
+  }
+  function getComputedStyle(element) {
+    return getWindow(element).getComputedStyle(element);
+  }
+  function getNodeScroll(element) {
+    if (isElement(element)) {
+      return {
+        scrollLeft: element.scrollLeft,
+        scrollTop: element.scrollTop
+      };
+    }
+    return {
+      scrollLeft: element.scrollX,
+      scrollTop: element.scrollY
+    };
+  }
+  function getParentNode(node) {
+    if (getNodeName(node) === 'html') {
+      return node;
+    }
+    const result =
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot ||
+    // DOM Element detected.
+    node.parentNode ||
+    // ShadowRoot detected.
+    isShadowRoot(node) && node.host ||
+    // Fallback.
+    getDocumentElement(node);
+    return isShadowRoot(result) ? result.host : result;
+  }
+  function getNearestOverflowAncestor(node) {
+    const parentNode = getParentNode(node);
+    if (isLastTraversableNode(parentNode)) {
+      return node.ownerDocument ? node.ownerDocument.body : node.body;
+    }
+    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+      return parentNode;
+    }
+    return getNearestOverflowAncestor(parentNode);
+  }
+  function getOverflowAncestors(node, list, traverseIframes) {
+    var _node$ownerDocument2;
+    if (list === void 0) {
+      list = [];
+    }
+    if (traverseIframes === void 0) {
+      traverseIframes = true;
+    }
+    const scrollableAncestor = getNearestOverflowAncestor(node);
+    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+    const win = getWindow(scrollableAncestor);
+    if (isBody) {
+      const frameElement = getFrameElement(win);
+      return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+    }
+    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+  }
+  function getFrameElement(win) {
+    return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+  }
+
+  exports.getComputedStyle = getComputedStyle;
+  exports.getContainingBlock = getContainingBlock;
+  exports.getDocumentElement = getDocumentElement;
+  exports.getFrameElement = getFrameElement;
+  exports.getNearestOverflowAncestor = getNearestOverflowAncestor;
+  exports.getNodeName = getNodeName;
+  exports.getNodeScroll = getNodeScroll;
+  exports.getOverflowAncestors = getOverflowAncestors;
+  exports.getParentNode = getParentNode;
+  exports.getWindow = getWindow;
+  exports.isContainingBlock = isContainingBlock;
+  exports.isElement = isElement;
+  exports.isHTMLElement = isHTMLElement;
+  exports.isLastTraversableNode = isLastTraversableNode;
+  exports.isNode = isNode;
+  exports.isOverflowElement = isOverflowElement;
+  exports.isShadowRoot = isShadowRoot;
+  exports.isTableElement = isTableElement;
+  exports.isTopLayer = isTopLayer;
+  exports.isWebKit = isWebKit;
+
+}));

node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.umd.min.js

@@ -0,0 +1 @@
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).FloatingUIUtilsDOM={})}(this,(function(e){"use strict";function n(){return"undefined"!=typeof window}function t(e){return i(e)?(e.nodeName||"").toLowerCase():"#document"}function o(e){var n;return(null==e||null==(n=e.ownerDocument)?void 0:n.defaultView)||window}function r(e){var n;return null==(n=(i(e)?e.ownerDocument:e.document)||window.document)?void 0:n.documentElement}function i(e){return!!n()&&(e instanceof Node||e instanceof o(e).Node)}function l(e){return!!n()&&(e instanceof Element||e instanceof o(e).Element)}function c(e){return!!n()&&(e instanceof HTMLElement||e instanceof o(e).HTMLElement)}function u(e){return!(!n()||"undefined"==typeof ShadowRoot)&&(e instanceof ShadowRoot||e instanceof o(e).ShadowRoot)}function s(e){const{overflow:n,overflowX:t,overflowY:o,display:r}=p(e);return/auto|scroll|overlay|hidden|clip/.test(n+o+t)&&!["inline","contents"].includes(r)}function f(e){return[":popover-open",":modal"].some((n=>{try{return e.matches(n)}catch(e){return!1}}))}function a(e){const n=d(),t=l(e)?p(e):e;return["transform","translate","scale","rotate","perspective"].some((e=>!!t[e]&&"none"!==t[e]))||!!t.containerType&&"normal"!==t.containerType||!n&&!!t.backdropFilter&&"none"!==t.backdropFilter||!n&&!!t.filter&&"none"!==t.filter||["transform","translate","scale","rotate","perspective","filter"].some((e=>(t.willChange||"").includes(e)))||["paint","layout","strict","content"].some((e=>(t.contain||"").includes(e)))}function d(){return!("undefined"==typeof CSS||!CSS.supports)&&CSS.supports("-webkit-backdrop-filter","none")}function m(e){return["html","body","#document"].includes(t(e))}function p(e){return o(e).getComputedStyle(e)}function w(e){if("html"===t(e))return e;const n=e.assignedSlot||e.parentNode||u(e)&&e.host||r(e);return u(n)?n.host:n}function y(e){const n=w(e);return m(n)?e.ownerDocument?e.ownerDocument.body:e.body:c(n)&&s(n)?n:y(n)}function v(e){return e.parent&&Object.getPrototypeOf(e.parent)?e.frameElement:null}e.getComputedStyle=p,e.getContainingBlock=function(e){let n=w(e);for(;c(n)&&!m(n);){if(a(n))return n;if(f(n))return null;n=w(n)}return null},e.getDocumentElement=r,e.getFrameElement=v,e.getNearestOverflowAncestor=y,e.getNodeName=t,e.getNodeScroll=function(e){return l(e)?{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}:{scrollLeft:e.scrollX,scrollTop:e.scrollY}},e.getOverflowAncestors=function e(n,t,r){var i;void 0===t&&(t=[]),void 0===r&&(r=!0);const l=y(n),c=l===(null==(i=n.ownerDocument)?void 0:i.body),u=o(l);if(c){const n=v(u);return t.concat(u,u.visualViewport||[],s(l)?l:[],n&&r?e(n):[])}return t.concat(l,e(l,[],r))},e.getParentNode=w,e.getWindow=o,e.isContainingBlock=a,e.isElement=l,e.isHTMLElement=c,e.isLastTraversableNode=m,e.isNode=i,e.isOverflowElement=s,e.isShadowRoot=u,e.isTableElement=function(e){return["table","td","th"].includes(t(e))},e.isTopLayer=f,e.isWebKit=d}));

node_modules/@floating-ui/utils/dist/floating-ui.utils.esm.js

@@ -0,0 +1,138 @@
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+
+const sides = ['top', 'right', 'bottom', 'left'];
+const alignments = ['start', 'end'];
+const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = v => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: 'right',
+  right: 'left',
+  bottom: 'top',
+  top: 'bottom'
+};
+const oppositeAlignmentMap = {
+  start: 'end',
+  end: 'start'
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === 'function' ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split('-')[0];
+}
+function getAlignment(placement) {
+  return placement.split('-')[1];
+}
+function getOppositeAxis(axis) {
+  return axis === 'x' ? 'y' : 'x';
+}
+function getAxisLength(axis) {
+  return axis === 'y' ? 'height' : 'width';
+}
+function getSideAxis(placement) {
+  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
+}
+function getSideList(side, isStart, rtl) {
+  const lr = ['left', 'right'];
+  const rl = ['right', 'left'];
+  const tb = ['top', 'bottom'];
+  const bt = ['bottom', 'top'];
+  switch (side) {
+    case 'top':
+    case 'bottom':
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case 'left':
+    case 'right':
+      return isStart ? tb : bt;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === 'start', rtl);
+  if (alignment) {
+    list = list.map(side => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+
+export { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };

node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs

@@ -0,0 +1,138 @@
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+
+const sides = ['top', 'right', 'bottom', 'left'];
+const alignments = ['start', 'end'];
+const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = v => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: 'right',
+  right: 'left',
+  bottom: 'top',
+  top: 'bottom'
+};
+const oppositeAlignmentMap = {
+  start: 'end',
+  end: 'start'
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === 'function' ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split('-')[0];
+}
+function getAlignment(placement) {
+  return placement.split('-')[1];
+}
+function getOppositeAxis(axis) {
+  return axis === 'x' ? 'y' : 'x';
+}
+function getAxisLength(axis) {
+  return axis === 'y' ? 'height' : 'width';
+}
+function getSideAxis(placement) {
+  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
+}
+function getSideList(side, isStart, rtl) {
+  const lr = ['left', 'right'];
+  const rl = ['right', 'left'];
+  const tb = ['top', 'bottom'];
+  const bt = ['bottom', 'top'];
+  switch (side) {
+    case 'top':
+    case 'bottom':
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case 'left':
+    case 'right':
+      return isStart ? tb : bt;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === 'start', rtl);
+  if (alignment) {
+    list = list.map(side => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+
+export { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };

node_modules/@floating-ui/utils/dist/floating-ui.utils.umd.js

@@ -0,0 +1,169 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIUtils = {}));
+})(this, (function (exports) { 'use strict';
+
+  /**
+   * Custom positioning reference element.
+   * @see https://floating-ui.com/docs/virtual-elements
+   */
+
+  const sides = ['top', 'right', 'bottom', 'left'];
+  const alignments = ['start', 'end'];
+  const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
+  const min = Math.min;
+  const max = Math.max;
+  const round = Math.round;
+  const floor = Math.floor;
+  const createCoords = v => ({
+    x: v,
+    y: v
+  });
+  const oppositeSideMap = {
+    left: 'right',
+    right: 'left',
+    bottom: 'top',
+    top: 'bottom'
+  };
+  const oppositeAlignmentMap = {
+    start: 'end',
+    end: 'start'
+  };
+  function clamp(start, value, end) {
+    return max(start, min(value, end));
+  }
+  function evaluate(value, param) {
+    return typeof value === 'function' ? value(param) : value;
+  }
+  function getSide(placement) {
+    return placement.split('-')[0];
+  }
+  function getAlignment(placement) {
+    return placement.split('-')[1];
+  }
+  function getOppositeAxis(axis) {
+    return axis === 'x' ? 'y' : 'x';
+  }
+  function getAxisLength(axis) {
+    return axis === 'y' ? 'height' : 'width';
+  }
+  function getSideAxis(placement) {
+    return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
+  }
+  function getAlignmentAxis(placement) {
+    return getOppositeAxis(getSideAxis(placement));
+  }
+  function getAlignmentSides(placement, rects, rtl) {
+    if (rtl === void 0) {
+      rtl = false;
+    }
+    const alignment = getAlignment(placement);
+    const alignmentAxis = getAlignmentAxis(placement);
+    const length = getAxisLength(alignmentAxis);
+    let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+    if (rects.reference[length] > rects.floating[length]) {
+      mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+    }
+    return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+  }
+  function getExpandedPlacements(placement) {
+    const oppositePlacement = getOppositePlacement(placement);
+    return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+  }
+  function getOppositeAlignmentPlacement(placement) {
+    return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
+  }
+  function getSideList(side, isStart, rtl) {
+    const lr = ['left', 'right'];
+    const rl = ['right', 'left'];
+    const tb = ['top', 'bottom'];
+    const bt = ['bottom', 'top'];
+    switch (side) {
+      case 'top':
+      case 'bottom':
+        if (rtl) return isStart ? rl : lr;
+        return isStart ? lr : rl;
+      case 'left':
+      case 'right':
+        return isStart ? tb : bt;
+      default:
+        return [];
+    }
+  }
+  function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+    const alignment = getAlignment(placement);
+    let list = getSideList(getSide(placement), direction === 'start', rtl);
+    if (alignment) {
+      list = list.map(side => side + "-" + alignment);
+      if (flipAlignment) {
+        list = list.concat(list.map(getOppositeAlignmentPlacement));
+      }
+    }
+    return list;
+  }
+  function getOppositePlacement(placement) {
+    return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
+  }
+  function expandPaddingObject(padding) {
+    return {
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      ...padding
+    };
+  }
+  function getPaddingObject(padding) {
+    return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+      top: padding,
+      right: padding,
+      bottom: padding,
+      left: padding
+    };
+  }
+  function rectToClientRect(rect) {
+    const {
+      x,
+      y,
+      width,
+      height
+    } = rect;
+    return {
+      width,
+      height,
+      top: y,
+      left: x,
+      right: x + width,
+      bottom: y + height,
+      x,
+      y
+    };
+  }
+
+  exports.alignments = alignments;
+  exports.clamp = clamp;
+  exports.createCoords = createCoords;
+  exports.evaluate = evaluate;
+  exports.expandPaddingObject = expandPaddingObject;
+  exports.floor = floor;
+  exports.getAlignment = getAlignment;
+  exports.getAlignmentAxis = getAlignmentAxis;
+  exports.getAlignmentSides = getAlignmentSides;
+  exports.getAxisLength = getAxisLength;
+  exports.getExpandedPlacements = getExpandedPlacements;
+  exports.getOppositeAlignmentPlacement = getOppositeAlignmentPlacement;
+  exports.getOppositeAxis = getOppositeAxis;
+  exports.getOppositeAxisPlacements = getOppositeAxisPlacements;
+  exports.getOppositePlacement = getOppositePlacement;
+  exports.getPaddingObject = getPaddingObject;
+  exports.getSide = getSide;
+  exports.getSideAxis = getSideAxis;
+  exports.max = max;
+  exports.min = min;
+  exports.placements = placements;
+  exports.rectToClientRect = rectToClientRect;
+  exports.round = round;
+  exports.sides = sides;
+
+}));

node_modules/@floating-ui/utils/dist/floating-ui.utils.umd.min.js

@@ -0,0 +1 @@
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).FloatingUIUtils={})}(this,(function(t){"use strict";const e=["top","right","bottom","left"],n=["start","end"],o=e.reduce(((t,e)=>t.concat(e,e+"-"+n[0],e+"-"+n[1])),[]),i=Math.min,r=Math.max,c=Math.round,u=Math.floor,f={left:"right",right:"left",bottom:"top",top:"bottom"},s={start:"end",end:"start"};function a(t){return t.split("-")[0]}function l(t){return t.split("-")[1]}function g(t){return"x"===t?"y":"x"}function p(t){return"y"===t?"height":"width"}function d(t){return["top","bottom"].includes(a(t))?"y":"x"}function m(t){return g(d(t))}function h(t){return t.replace(/start|end/g,(t=>s[t]))}function x(t){return t.replace(/left|right|bottom|top/g,(t=>f[t]))}function b(t){return{top:0,right:0,bottom:0,left:0,...t}}t.alignments=n,t.clamp=function(t,e,n){return r(t,i(e,n))},t.createCoords=t=>({x:t,y:t}),t.evaluate=function(t,e){return"function"==typeof t?t(e):t},t.expandPaddingObject=b,t.floor=u,t.getAlignment=l,t.getAlignmentAxis=m,t.getAlignmentSides=function(t,e,n){void 0===n&&(n=!1);const o=l(t),i=m(t),r=p(i);let c="x"===i?o===(n?"end":"start")?"right":"left":"start"===o?"bottom":"top";return e.reference[r]>e.floating[r]&&(c=x(c)),[c,x(c)]},t.getAxisLength=p,t.getExpandedPlacements=function(t){const e=x(t);return[h(t),e,h(e)]},t.getOppositeAlignmentPlacement=h,t.getOppositeAxis=g,t.getOppositeAxisPlacements=function(t,e,n,o){const i=l(t);let r=function(t,e,n){const o=["left","right"],i=["right","left"],r=["top","bottom"],c=["bottom","top"];switch(t){case"top":case"bottom":return n?e?i:o:e?o:i;case"left":case"right":return e?r:c;default:return[]}}(a(t),"start"===n,o);return i&&(r=r.map((t=>t+"-"+i)),e&&(r=r.concat(r.map(h)))),r},t.getOppositePlacement=x,t.getPaddingObject=function(t){return"number"!=typeof t?b(t):{top:t,right:t,bottom:t,left:t}},t.getSide=a,t.getSideAxis=d,t.max=r,t.min=i,t.placements=o,t.rectToClientRect=function(t){const{x:e,y:n,width:o,height:i}=t;return{width:o,height:i,top:n,left:e,right:e+o,bottom:n+i,x:e,y:n}},t.round=c,t.sides=e}));

node_modules/@floating-ui/utils/dom/floating-ui.utils.dom.d.ts

@@ -0,0 +1,47 @@
+declare function getComputedStyle_2(element: Element): CSSStyleDeclaration;
+export { getComputedStyle_2 as getComputedStyle }
+
+export declare function getContainingBlock(element: Element): HTMLElement | null;
+
+export declare function getDocumentElement(node: Node | Window): HTMLElement;
+
+export declare function getFrameElement(win: Window): Element | null;
+
+export declare function getNearestOverflowAncestor(node: Node): HTMLElement;
+
+export declare function getNodeName(node: Node | Window): string;
+
+export declare function getNodeScroll(element: Element | Window): {
+    scrollLeft: number;
+    scrollTop: number;
+};
+
+export declare function getOverflowAncestors(node: Node, list?: OverflowAncestors, traverseIframes?: boolean): OverflowAncestors;
+
+export declare function getParentNode(node: Node): Node;
+
+export declare function getWindow(node: any): typeof window;
+
+export declare function isContainingBlock(elementOrCss: Element | CSSStyleDeclaration): boolean;
+
+export declare function isElement(value: unknown): value is Element;
+
+export declare function isHTMLElement(value: unknown): value is HTMLElement;
+
+export declare function isLastTraversableNode(node: Node): boolean;
+
+export declare function isNode(value: unknown): value is Node;
+
+export declare function isOverflowElement(element: Element): boolean;
+
+export declare function isShadowRoot(value: unknown): value is ShadowRoot;
+
+export declare function isTableElement(element: Element): boolean;
+
+export declare function isTopLayer(element: Element): boolean;
+
+export declare function isWebKit(): boolean;
+
+declare type OverflowAncestors = Array<Element | Window | VisualViewport>;
+
+export { }

node_modules/@floating-ui/utils/dom/floating-ui.utils.dom.esm.js

@@ -0,0 +1,154 @@
+function hasWindow() {
+  return typeof window !== 'undefined';
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || '').toLowerCase();
+  }
+  // Mocked nodes in testing environments may not be instances of Node. By
+  // returning `#document` an infinite loop won't occur.
+  // https://github.com/floating-ui/floating-ui/issues/2317
+  return '#document';
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+}
+function isTableElement(element) {
+  return ['table', 'td', 'th'].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [':popover-open', ':modal'].some(selector => {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
+  return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === 'undefined' || !CSS.supports) return false;
+  return CSS.supports('-webkit-backdrop-filter', 'none');
+}
+function isLastTraversableNode(node) {
+  return ['html', 'body', '#document'].includes(getNodeName(node));
+}
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === 'html') {
+    return node;
+  }
+  const result =
+  // Step into the shadow DOM of the parent of a slotted node.
+  node.assignedSlot ||
+  // DOM Element detected.
+  node.parentNode ||
+  // ShadowRoot detected.
+  isShadowRoot(node) && node.host ||
+  // Fallback.
+  getDocumentElement(node);
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+
+export { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };

node_modules/@floating-ui/utils/dom/floating-ui.utils.dom.umd.js

@@ -0,0 +1,181 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIUtilsDOM = {}));
+})(this, (function (exports) { 'use strict';
+
+  function hasWindow() {
+    return typeof window !== 'undefined';
+  }
+  function getNodeName(node) {
+    if (isNode(node)) {
+      return (node.nodeName || '').toLowerCase();
+    }
+    // Mocked nodes in testing environments may not be instances of Node. By
+    // returning `#document` an infinite loop won't occur.
+    // https://github.com/floating-ui/floating-ui/issues/2317
+    return '#document';
+  }
+  function getWindow(node) {
+    var _node$ownerDocument;
+    return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+  }
+  function getDocumentElement(node) {
+    var _ref;
+    return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+  }
+  function isNode(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof Node || value instanceof getWindow(value).Node;
+  }
+  function isElement(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof Element || value instanceof getWindow(value).Element;
+  }
+  function isHTMLElement(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+  }
+  function isShadowRoot(value) {
+    if (!hasWindow() || typeof ShadowRoot === 'undefined') {
+      return false;
+    }
+    return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+  }
+  function isOverflowElement(element) {
+    const {
+      overflow,
+      overflowX,
+      overflowY,
+      display
+    } = getComputedStyle(element);
+    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+  }
+  function isTableElement(element) {
+    return ['table', 'td', 'th'].includes(getNodeName(element));
+  }
+  function isTopLayer(element) {
+    return [':popover-open', ':modal'].some(selector => {
+      try {
+        return element.matches(selector);
+      } catch (e) {
+        return false;
+      }
+    });
+  }
+  function isContainingBlock(elementOrCss) {
+    const webkit = isWebKit();
+    const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    // https://drafts.csswg.org/css-transforms-2/#individual-transforms
+    return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+  }
+  function getContainingBlock(element) {
+    let currentNode = getParentNode(element);
+    while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+      if (isContainingBlock(currentNode)) {
+        return currentNode;
+      } else if (isTopLayer(currentNode)) {
+        return null;
+      }
+      currentNode = getParentNode(currentNode);
+    }
+    return null;
+  }
+  function isWebKit() {
+    if (typeof CSS === 'undefined' || !CSS.supports) return false;
+    return CSS.supports('-webkit-backdrop-filter', 'none');
+  }
+  function isLastTraversableNode(node) {
+    return ['html', 'body', '#document'].includes(getNodeName(node));
+  }
+  function getComputedStyle(element) {
+    return getWindow(element).getComputedStyle(element);
+  }
+  function getNodeScroll(element) {
+    if (isElement(element)) {
+      return {
+        scrollLeft: element.scrollLeft,
+        scrollTop: element.scrollTop
+      };
+    }
+    return {
+      scrollLeft: element.scrollX,
+      scrollTop: element.scrollY
+    };
+  }
+  function getParentNode(node) {
+    if (getNodeName(node) === 'html') {
+      return node;
+    }
+    const result =
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot ||
+    // DOM Element detected.
+    node.parentNode ||
+    // ShadowRoot detected.
+    isShadowRoot(node) && node.host ||
+    // Fallback.
+    getDocumentElement(node);
+    return isShadowRoot(result) ? result.host : result;
+  }
+  function getNearestOverflowAncestor(node) {
+    const parentNode = getParentNode(node);
+    if (isLastTraversableNode(parentNode)) {
+      return node.ownerDocument ? node.ownerDocument.body : node.body;
+    }
+    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+      return parentNode;
+    }
+    return getNearestOverflowAncestor(parentNode);
+  }
+  function getOverflowAncestors(node, list, traverseIframes) {
+    var _node$ownerDocument2;
+    if (list === void 0) {
+      list = [];
+    }
+    if (traverseIframes === void 0) {
+      traverseIframes = true;
+    }
+    const scrollableAncestor = getNearestOverflowAncestor(node);
+    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+    const win = getWindow(scrollableAncestor);
+    if (isBody) {
+      const frameElement = getFrameElement(win);
+      return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+    }
+    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+  }
+  function getFrameElement(win) {
+    return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+  }
+
+  exports.getComputedStyle = getComputedStyle;
+  exports.getContainingBlock = getContainingBlock;
+  exports.getDocumentElement = getDocumentElement;
+  exports.getFrameElement = getFrameElement;
+  exports.getNearestOverflowAncestor = getNearestOverflowAncestor;
+  exports.getNodeName = getNodeName;
+  exports.getNodeScroll = getNodeScroll;
+  exports.getOverflowAncestors = getOverflowAncestors;
+  exports.getParentNode = getParentNode;
+  exports.getWindow = getWindow;
+  exports.isContainingBlock = isContainingBlock;
+  exports.isElement = isElement;
+  exports.isHTMLElement = isHTMLElement;
+  exports.isLastTraversableNode = isLastTraversableNode;
+  exports.isNode = isNode;
+  exports.isOverflowElement = isOverflowElement;
+  exports.isShadowRoot = isShadowRoot;
+  exports.isTableElement = isTableElement;
+  exports.isTopLayer = isTopLayer;
+  exports.isWebKit = isWebKit;
+
+}));

node_modules/@floating-ui/utils/dom/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "main": "floating-ui.utils.dom.umd.js",
+  "module": "floating-ui.utils.dom.esm.js",
+  "types": "floating-ui.utils.dom.d.ts"
+}

node_modules/@floating-ui/utils/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@floating-ui/utils",
+  "version": "0.2.9",
+  "description": "Utilities for Floating UI",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/floating-ui.utils.umd.js",
+  "module": "./dist/floating-ui.utils.esm.js",
+  "types": "./dist/floating-ui.utils.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "dom"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/floating-ui.utils.d.mts",
+        "default": "./dist/floating-ui.utils.mjs"
+      },
+      "types": "./dist/floating-ui.utils.d.ts",
+      "module": "./dist/floating-ui.utils.esm.js",
+      "default": "./dist/floating-ui.utils.umd.js"
+    },
+    "./dom": {
+      "import": {
+        "types": "./dist/floating-ui.utils.dom.d.mts",
+        "default": "./dist/floating-ui.utils.dom.mjs"
+      },
+      "types": "./dist/floating-ui.utils.dom.d.ts",
+      "module": "./dist/floating-ui.utils.dom.esm.js",
+      "default": "./dist/floating-ui.utils.dom.umd.js"
+    }
+  },
+  "author": "atomiks",
+  "license": "MIT",
+  "bugs": "https://github.com/floating-ui/floating-ui",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/floating-ui/floating-ui.git",
+    "directory": "packages/utils"
+  },
+  "homepage": "https://floating-ui.com",
+  "keywords": [
+    "tooltip",
+    "popover",
+    "dropdown",
+    "menu",
+    "popup",
+    "positioning"
+  ],
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.1.6",
+    "config": "0.0.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "clean": "rimraf dist out-tsc dom react",
+    "test": "vitest run --globals",
+    "test:watch": "vitest watch --globals",
+    "dev": "rollup -c -w",
+    "build": "rollup -c",
+    "build:api": "build-api --tsc tsconfig.lib.json --aec api-extractor.json --aec api-extractor.dom.json --aec api-extractor.react.json",
+    "publint": "publint",
+    "typecheck": "tsc -b"
+  }
+}

node_modules/@floating-ui/vue/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Floating UI contributors
+
+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.

node_modules/@floating-ui/vue/README.md

@@ -0,0 +1,3 @@
+# @floating-ui/vue
+
+This is the library to use Floating UI with Vue.

node_modules/@floating-ui/vue/dist/floating-ui.vue.d.mts

@@ -0,0 +1,270 @@
+import { AlignedPlacement } from '@floating-ui/dom';
+import { Alignment } from '@floating-ui/dom';
+import { autoPlacement } from '@floating-ui/dom';
+import { AutoPlacementOptions } from '@floating-ui/dom';
+import { autoUpdate } from '@floating-ui/dom';
+import { AutoUpdateOptions } from '@floating-ui/dom';
+import { Axis } from '@floating-ui/dom';
+import { Boundary } from '@floating-ui/dom';
+import { ClientRectObject } from '@floating-ui/dom';
+import type { ComponentPublicInstance } from 'vue-demi';
+import { computePosition } from '@floating-ui/dom';
+import { ComputePositionConfig } from '@floating-ui/dom';
+import { ComputePositionReturn } from '@floating-ui/dom';
+import { Coords } from '@floating-ui/dom';
+import { detectOverflow } from '@floating-ui/dom';
+import { DetectOverflowOptions } from '@floating-ui/dom';
+import { Dimensions } from '@floating-ui/dom';
+import { ElementContext } from '@floating-ui/dom';
+import { ElementRects } from '@floating-ui/dom';
+import { Elements } from '@floating-ui/dom';
+import { flip } from '@floating-ui/dom';
+import { FlipOptions } from '@floating-ui/dom';
+import { FloatingElement } from '@floating-ui/dom';
+import { getOverflowAncestors } from '@floating-ui/dom';
+import { hide } from '@floating-ui/dom';
+import { HideOptions } from '@floating-ui/dom';
+import { inline } from '@floating-ui/dom';
+import { InlineOptions } from '@floating-ui/dom';
+import { Length } from '@floating-ui/dom';
+import { limitShift } from '@floating-ui/dom';
+import { Middleware } from '@floating-ui/dom';
+import { MiddlewareArguments } from '@floating-ui/dom';
+import { MiddlewareData } from '@floating-ui/dom';
+import { MiddlewareReturn } from '@floating-ui/dom';
+import { MiddlewareState } from '@floating-ui/dom';
+import { NodeScroll } from '@floating-ui/dom';
+import { offset } from '@floating-ui/dom';
+import { OffsetOptions } from '@floating-ui/dom';
+import { Padding } from '@floating-ui/dom';
+import { Placement } from '@floating-ui/dom';
+import { Platform } from '@floating-ui/dom';
+import { platform } from '@floating-ui/dom';
+import { Rect } from '@floating-ui/dom';
+import type { Ref } from 'vue-demi';
+import { ReferenceElement } from '@floating-ui/dom';
+import { RootBoundary } from '@floating-ui/dom';
+import { shift } from '@floating-ui/dom';
+import { ShiftOptions } from '@floating-ui/dom';
+import { Side } from '@floating-ui/dom';
+import { SideObject } from '@floating-ui/dom';
+import { size } from '@floating-ui/dom';
+import { SizeOptions } from '@floating-ui/dom';
+import { Strategy } from '@floating-ui/dom';
+import { VirtualElement } from '@floating-ui/dom';
+
+export { AlignedPlacement }
+
+export { Alignment }
+
+/**
+ * Positions an inner element of the floating element such that it is centered to the reference element.
+ * @param options The arrow options.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export declare function arrow(options: ArrowOptions): Middleware;
+
+export declare type ArrowOptions = {
+    /**
+     * The arrow element or template ref to be positioned.
+     * @required
+     */
+    element: MaybeReadonlyRefOrGetter<MaybeElement<Element>>;
+    /**
+     * The padding between the arrow element and the floating element edges. Useful when the floating element has rounded corners.
+     * @default 0
+     */
+    padding?: Padding;
+};
+
+export { autoPlacement }
+
+export { AutoPlacementOptions }
+
+export { autoUpdate }
+
+export { AutoUpdateOptions }
+
+export { Axis }
+
+export { Boundary }
+
+export { ClientRectObject }
+
+export { computePosition }
+
+export { ComputePositionConfig }
+
+export { ComputePositionReturn }
+
+export { Coords }
+
+export { detectOverflow }
+
+export { DetectOverflowOptions }
+
+export { Dimensions }
+
+export { ElementContext }
+
+export { ElementRects }
+
+export { Elements }
+
+export { flip }
+
+export { FlipOptions }
+
+export { FloatingElement }
+
+export { getOverflowAncestors }
+
+export { hide }
+
+export { HideOptions }
+
+export { inline }
+
+export { InlineOptions }
+
+export { Length }
+
+export { limitShift }
+
+export declare type MaybeElement<T> = T | ComponentPublicInstance | null | undefined;
+
+export declare type MaybeReadonlyRef<T> = T | Readonly<Ref<T>>;
+
+export declare type MaybeReadonlyRefOrGetter<T> = MaybeReadonlyRef<T> | (() => T);
+
+export { Middleware }
+
+export { MiddlewareArguments }
+
+export { MiddlewareData }
+
+export { MiddlewareReturn }
+
+export { MiddlewareState }
+
+export { NodeScroll }
+
+export { offset }
+
+export { OffsetOptions }
+
+export { Padding }
+
+export { Placement }
+
+export { Platform }
+
+export { platform }
+
+export { Rect }
+
+export { ReferenceElement }
+
+export { RootBoundary }
+
+export { shift }
+
+export { ShiftOptions }
+
+export { Side }
+
+export { SideObject }
+
+export { size }
+
+export { SizeOptions }
+
+export { Strategy }
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element next to a reference element when it is given a certain CSS positioning strategy.
+ * @param reference The reference template ref.
+ * @param floating The floating template ref.
+ * @param options The floating options.
+ * @see https://floating-ui.com/docs/vue
+ */
+export declare function useFloating<T extends ReferenceElement = ReferenceElement>(reference: Readonly<Ref<MaybeElement<T>>>, floating: Readonly<Ref<MaybeElement<FloatingElement>>>, options?: UseFloatingOptions<T>): UseFloatingReturn;
+
+export declare type UseFloatingOptions<T extends ReferenceElement = ReferenceElement> = {
+    /**
+     * Represents the open/close state of the floating element.
+     * @default true
+     */
+    open?: MaybeReadonlyRefOrGetter<boolean | undefined>;
+    /**
+     * Where to place the floating element relative to its reference element.
+     * @default 'bottom'
+     */
+    placement?: MaybeReadonlyRefOrGetter<Placement | undefined>;
+    /**
+     * The type of CSS position property to use.
+     * @default 'absolute'
+     */
+    strategy?: MaybeReadonlyRefOrGetter<Strategy | undefined>;
+    /**
+     * These are plain objects that modify the positioning coordinates in some fashion, or provide useful data for the consumer to use.
+     * @default undefined
+     */
+    middleware?: MaybeReadonlyRefOrGetter<Middleware[] | undefined>;
+    /**
+     * Whether to use `transform` instead of `top` and `left` styles to
+     * position the floating element (`floatingStyles`).
+     * @default true
+     */
+    transform?: MaybeReadonlyRefOrGetter<boolean | undefined>;
+    /**
+     * Callback to handle mounting/unmounting of the elements.
+     * @default undefined
+     */
+    whileElementsMounted?: (reference: T, floating: FloatingElement, update: () => void) => () => void;
+};
+
+export declare type UseFloatingReturn = {
+    /**
+     * The x-coord of the floating element.
+     */
+    x: Readonly<Ref<number>>;
+    /**
+     * The y-coord of the floating element.
+     */
+    y: Readonly<Ref<number>>;
+    /**
+     * The stateful placement, which can be different from the initial `placement` passed as options.
+     */
+    placement: Readonly<Ref<Placement>>;
+    /**
+     * The type of CSS position property to use.
+     */
+    strategy: Readonly<Ref<Strategy>>;
+    /**
+     * Additional data from middleware.
+     */
+    middlewareData: Readonly<Ref<MiddlewareData>>;
+    /**
+     * The boolean that let you know if the floating element has been positioned.
+     */
+    isPositioned: Readonly<Ref<boolean>>;
+    /**
+     * CSS styles to apply to the floating element to position it.
+     */
+    floatingStyles: Readonly<Ref<{
+        position: Strategy;
+        top: string;
+        left: string;
+        transform?: string;
+        willChange?: string;
+    }>>;
+    /**
+     * The function to update floating position manually.
+     */
+    update: () => void;
+};
+
+export { VirtualElement }
+
+export { }

node_modules/@floating-ui/vue/dist/floating-ui.vue.d.ts

@@ -0,0 +1,270 @@
+import { AlignedPlacement } from '@floating-ui/dom';
+import { Alignment } from '@floating-ui/dom';
+import { autoPlacement } from '@floating-ui/dom';
+import { AutoPlacementOptions } from '@floating-ui/dom';
+import { autoUpdate } from '@floating-ui/dom';
+import { AutoUpdateOptions } from '@floating-ui/dom';
+import { Axis } from '@floating-ui/dom';
+import { Boundary } from '@floating-ui/dom';
+import { ClientRectObject } from '@floating-ui/dom';
+import type { ComponentPublicInstance } from 'vue-demi';
+import { computePosition } from '@floating-ui/dom';
+import { ComputePositionConfig } from '@floating-ui/dom';
+import { ComputePositionReturn } from '@floating-ui/dom';
+import { Coords } from '@floating-ui/dom';
+import { detectOverflow } from '@floating-ui/dom';
+import { DetectOverflowOptions } from '@floating-ui/dom';
+import { Dimensions } from '@floating-ui/dom';
+import { ElementContext } from '@floating-ui/dom';
+import { ElementRects } from '@floating-ui/dom';
+import { Elements } from '@floating-ui/dom';
+import { flip } from '@floating-ui/dom';
+import { FlipOptions } from '@floating-ui/dom';
+import { FloatingElement } from '@floating-ui/dom';
+import { getOverflowAncestors } from '@floating-ui/dom';
+import { hide } from '@floating-ui/dom';
+import { HideOptions } from '@floating-ui/dom';
+import { inline } from '@floating-ui/dom';
+import { InlineOptions } from '@floating-ui/dom';
+import { Length } from '@floating-ui/dom';
+import { limitShift } from '@floating-ui/dom';
+import { Middleware } from '@floating-ui/dom';
+import { MiddlewareArguments } from '@floating-ui/dom';
+import { MiddlewareData } from '@floating-ui/dom';
+import { MiddlewareReturn } from '@floating-ui/dom';
+import { MiddlewareState } from '@floating-ui/dom';
+import { NodeScroll } from '@floating-ui/dom';
+import { offset } from '@floating-ui/dom';
+import { OffsetOptions } from '@floating-ui/dom';
+import { Padding } from '@floating-ui/dom';
+import { Placement } from '@floating-ui/dom';
+import { Platform } from '@floating-ui/dom';
+import { platform } from '@floating-ui/dom';
+import { Rect } from '@floating-ui/dom';
+import type { Ref } from 'vue-demi';
+import { ReferenceElement } from '@floating-ui/dom';
+import { RootBoundary } from '@floating-ui/dom';
+import { shift } from '@floating-ui/dom';
+import { ShiftOptions } from '@floating-ui/dom';
+import { Side } from '@floating-ui/dom';
+import { SideObject } from '@floating-ui/dom';
+import { size } from '@floating-ui/dom';
+import { SizeOptions } from '@floating-ui/dom';
+import { Strategy } from '@floating-ui/dom';
+import { VirtualElement } from '@floating-ui/dom';
+
+export { AlignedPlacement }
+
+export { Alignment }
+
+/**
+ * Positions an inner element of the floating element such that it is centered to the reference element.
+ * @param options The arrow options.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export declare function arrow(options: ArrowOptions): Middleware;
+
+export declare type ArrowOptions = {
+    /**
+     * The arrow element or template ref to be positioned.
+     * @required
+     */
+    element: MaybeReadonlyRefOrGetter<MaybeElement<Element>>;
+    /**
+     * The padding between the arrow element and the floating element edges. Useful when the floating element has rounded corners.
+     * @default 0
+     */
+    padding?: Padding;
+};
+
+export { autoPlacement }
+
+export { AutoPlacementOptions }
+
+export { autoUpdate }
+
+export { AutoUpdateOptions }
+
+export { Axis }
+
+export { Boundary }
+
+export { ClientRectObject }
+
+export { computePosition }
+
+export { ComputePositionConfig }
+
+export { ComputePositionReturn }
+
+export { Coords }
+
+export { detectOverflow }
+
+export { DetectOverflowOptions }
+
+export { Dimensions }
+
+export { ElementContext }
+
+export { ElementRects }
+
+export { Elements }
+
+export { flip }
+
+export { FlipOptions }
+
+export { FloatingElement }
+
+export { getOverflowAncestors }
+
+export { hide }
+
+export { HideOptions }
+
+export { inline }
+
+export { InlineOptions }
+
+export { Length }
+
+export { limitShift }
+
+export declare type MaybeElement<T> = T | ComponentPublicInstance | null | undefined;
+
+export declare type MaybeReadonlyRef<T> = T | Readonly<Ref<T>>;
+
+export declare type MaybeReadonlyRefOrGetter<T> = MaybeReadonlyRef<T> | (() => T);
+
+export { Middleware }
+
+export { MiddlewareArguments }
+
+export { MiddlewareData }
+
+export { MiddlewareReturn }
+
+export { MiddlewareState }
+
+export { NodeScroll }
+
+export { offset }
+
+export { OffsetOptions }
+
+export { Padding }
+
+export { Placement }
+
+export { Platform }
+
+export { platform }
+
+export { Rect }
+
+export { ReferenceElement }
+
+export { RootBoundary }
+
+export { shift }
+
+export { ShiftOptions }
+
+export { Side }
+
+export { SideObject }
+
+export { size }
+
+export { SizeOptions }
+
+export { Strategy }
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element next to a reference element when it is given a certain CSS positioning strategy.
+ * @param reference The reference template ref.
+ * @param floating The floating template ref.
+ * @param options The floating options.
+ * @see https://floating-ui.com/docs/vue
+ */
+export declare function useFloating<T extends ReferenceElement = ReferenceElement>(reference: Readonly<Ref<MaybeElement<T>>>, floating: Readonly<Ref<MaybeElement<FloatingElement>>>, options?: UseFloatingOptions<T>): UseFloatingReturn;
+
+export declare type UseFloatingOptions<T extends ReferenceElement = ReferenceElement> = {
+    /**
+     * Represents the open/close state of the floating element.
+     * @default true
+     */
+    open?: MaybeReadonlyRefOrGetter<boolean | undefined>;
+    /**
+     * Where to place the floating element relative to its reference element.
+     * @default 'bottom'
+     */
+    placement?: MaybeReadonlyRefOrGetter<Placement | undefined>;
+    /**
+     * The type of CSS position property to use.
+     * @default 'absolute'
+     */
+    strategy?: MaybeReadonlyRefOrGetter<Strategy | undefined>;
+    /**
+     * These are plain objects that modify the positioning coordinates in some fashion, or provide useful data for the consumer to use.
+     * @default undefined
+     */
+    middleware?: MaybeReadonlyRefOrGetter<Middleware[] | undefined>;
+    /**
+     * Whether to use `transform` instead of `top` and `left` styles to
+     * position the floating element (`floatingStyles`).
+     * @default true
+     */
+    transform?: MaybeReadonlyRefOrGetter<boolean | undefined>;
+    /**
+     * Callback to handle mounting/unmounting of the elements.
+     * @default undefined
+     */
+    whileElementsMounted?: (reference: T, floating: FloatingElement, update: () => void) => () => void;
+};
+
+export declare type UseFloatingReturn = {
+    /**
+     * The x-coord of the floating element.
+     */
+    x: Readonly<Ref<number>>;
+    /**
+     * The y-coord of the floating element.
+     */
+    y: Readonly<Ref<number>>;
+    /**
+     * The stateful placement, which can be different from the initial `placement` passed as options.
+     */
+    placement: Readonly<Ref<Placement>>;
+    /**
+     * The type of CSS position property to use.
+     */
+    strategy: Readonly<Ref<Strategy>>;
+    /**
+     * Additional data from middleware.
+     */
+    middlewareData: Readonly<Ref<MiddlewareData>>;
+    /**
+     * The boolean that let you know if the floating element has been positioned.
+     */
+    isPositioned: Readonly<Ref<boolean>>;
+    /**
+     * CSS styles to apply to the floating element to position it.
+     */
+    floatingStyles: Readonly<Ref<{
+        position: Strategy;
+        top: string;
+        left: string;
+        transform?: string;
+        willChange?: string;
+    }>>;
+    /**
+     * The function to update floating position manually.
+     */
+    update: () => void;
+};
+
+export { VirtualElement }
+
+export { }

node_modules/@floating-ui/vue/dist/floating-ui.vue.esm.js

@@ -0,0 +1,190 @@
+import { arrow as arrow$1, computePosition } from '@floating-ui/dom';
+export { autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/dom';
+import { isNode, getNodeName } from '@floating-ui/utils/dom';
+import { unref, computed, ref, shallowRef, watch, getCurrentScope, onScopeDispose, shallowReadonly } from 'vue-demi';
+
+function isComponentPublicInstance(target) {
+  return target != null && typeof target === 'object' && '$el' in target;
+}
+function unwrapElement(target) {
+  if (isComponentPublicInstance(target)) {
+    const element = target.$el;
+    return isNode(element) && getNodeName(element) === '#comment' ? null : element;
+  }
+  return target;
+}
+
+function toValue(source) {
+  return typeof source === 'function' ? source() : unref(source);
+}
+
+/**
+ * Positions an inner element of the floating element such that it is centered to the reference element.
+ * @param options The arrow options.
+ * @see https://floating-ui.com/docs/arrow
+ */
+function arrow(options) {
+  return {
+    name: 'arrow',
+    options,
+    fn(args) {
+      const element = unwrapElement(toValue(options.element));
+      if (element == null) {
+        return {};
+      }
+      return arrow$1({
+        element,
+        padding: options.padding
+      }).fn(args);
+    }
+  };
+}
+
+function getDPR(element) {
+  if (typeof window === 'undefined') {
+    return 1;
+  }
+  const win = element.ownerDocument.defaultView || window;
+  return win.devicePixelRatio || 1;
+}
+
+function roundByDPR(element, value) {
+  const dpr = getDPR(element);
+  return Math.round(value * dpr) / dpr;
+}
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element next to a reference element when it is given a certain CSS positioning strategy.
+ * @param reference The reference template ref.
+ * @param floating The floating template ref.
+ * @param options The floating options.
+ * @see https://floating-ui.com/docs/vue
+ */
+function useFloating(reference, floating, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const whileElementsMountedOption = options.whileElementsMounted;
+  const openOption = computed(() => {
+    var _toValue;
+    return (_toValue = toValue(options.open)) != null ? _toValue : true;
+  });
+  const middlewareOption = computed(() => toValue(options.middleware));
+  const placementOption = computed(() => {
+    var _toValue2;
+    return (_toValue2 = toValue(options.placement)) != null ? _toValue2 : 'bottom';
+  });
+  const strategyOption = computed(() => {
+    var _toValue3;
+    return (_toValue3 = toValue(options.strategy)) != null ? _toValue3 : 'absolute';
+  });
+  const transformOption = computed(() => {
+    var _toValue4;
+    return (_toValue4 = toValue(options.transform)) != null ? _toValue4 : true;
+  });
+  const referenceElement = computed(() => unwrapElement(reference.value));
+  const floatingElement = computed(() => unwrapElement(floating.value));
+  const x = ref(0);
+  const y = ref(0);
+  const strategy = ref(strategyOption.value);
+  const placement = ref(placementOption.value);
+  const middlewareData = shallowRef({});
+  const isPositioned = ref(false);
+  const floatingStyles = computed(() => {
+    const initialStyles = {
+      position: strategy.value,
+      left: '0',
+      top: '0'
+    };
+    if (!floatingElement.value) {
+      return initialStyles;
+    }
+    const xVal = roundByDPR(floatingElement.value, x.value);
+    const yVal = roundByDPR(floatingElement.value, y.value);
+    if (transformOption.value) {
+      return {
+        ...initialStyles,
+        transform: "translate(" + xVal + "px, " + yVal + "px)",
+        ...(getDPR(floatingElement.value) >= 1.5 && {
+          willChange: 'transform'
+        })
+      };
+    }
+    return {
+      position: strategy.value,
+      left: xVal + "px",
+      top: yVal + "px"
+    };
+  });
+  let whileElementsMountedCleanup;
+  function update() {
+    if (referenceElement.value == null || floatingElement.value == null) {
+      return;
+    }
+    const open = openOption.value;
+    computePosition(referenceElement.value, floatingElement.value, {
+      middleware: middlewareOption.value,
+      placement: placementOption.value,
+      strategy: strategyOption.value
+    }).then(position => {
+      x.value = position.x;
+      y.value = position.y;
+      strategy.value = position.strategy;
+      placement.value = position.placement;
+      middlewareData.value = position.middlewareData;
+      /**
+       * The floating element's position may be recomputed while it's closed
+       * but still mounted (such as when transitioning out). To ensure
+       * `isPositioned` will be `false` initially on the next open, avoid
+       * setting it to `true` when `open === false` (must be specified).
+       */
+      isPositioned.value = open !== false;
+    });
+  }
+  function cleanup() {
+    if (typeof whileElementsMountedCleanup === 'function') {
+      whileElementsMountedCleanup();
+      whileElementsMountedCleanup = undefined;
+    }
+  }
+  function attach() {
+    cleanup();
+    if (whileElementsMountedOption === undefined) {
+      update();
+      return;
+    }
+    if (referenceElement.value != null && floatingElement.value != null) {
+      whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
+      return;
+    }
+  }
+  function reset() {
+    if (!openOption.value) {
+      isPositioned.value = false;
+    }
+  }
+  watch([middlewareOption, placementOption, strategyOption, openOption], update, {
+    flush: 'sync'
+  });
+  watch([referenceElement, floatingElement], attach, {
+    flush: 'sync'
+  });
+  watch(openOption, reset, {
+    flush: 'sync'
+  });
+  if (getCurrentScope()) {
+    onScopeDispose(cleanup);
+  }
+  return {
+    x: shallowReadonly(x),
+    y: shallowReadonly(y),
+    strategy: shallowReadonly(strategy),
+    placement: shallowReadonly(placement),
+    middlewareData: shallowReadonly(middlewareData),
+    isPositioned: shallowReadonly(isPositioned),
+    floatingStyles,
+    update
+  };
+}
+
+export { arrow, useFloating };

node_modules/@floating-ui/vue/dist/floating-ui.vue.mjs

@@ -0,0 +1,190 @@
+import { arrow as arrow$1, computePosition } from '@floating-ui/dom';
+export { autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/dom';
+import { isNode, getNodeName } from '@floating-ui/utils/dom';
+import { unref, computed, ref, shallowRef, watch, getCurrentScope, onScopeDispose, shallowReadonly } from 'vue-demi';
+
+function isComponentPublicInstance(target) {
+  return target != null && typeof target === 'object' && '$el' in target;
+}
+function unwrapElement(target) {
+  if (isComponentPublicInstance(target)) {
+    const element = target.$el;
+    return isNode(element) && getNodeName(element) === '#comment' ? null : element;
+  }
+  return target;
+}
+
+function toValue(source) {
+  return typeof source === 'function' ? source() : unref(source);
+}
+
+/**
+ * Positions an inner element of the floating element such that it is centered to the reference element.
+ * @param options The arrow options.
+ * @see https://floating-ui.com/docs/arrow
+ */
+function arrow(options) {
+  return {
+    name: 'arrow',
+    options,
+    fn(args) {
+      const element = unwrapElement(toValue(options.element));
+      if (element == null) {
+        return {};
+      }
+      return arrow$1({
+        element,
+        padding: options.padding
+      }).fn(args);
+    }
+  };
+}
+
+function getDPR(element) {
+  if (typeof window === 'undefined') {
+    return 1;
+  }
+  const win = element.ownerDocument.defaultView || window;
+  return win.devicePixelRatio || 1;
+}
+
+function roundByDPR(element, value) {
+  const dpr = getDPR(element);
+  return Math.round(value * dpr) / dpr;
+}
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element next to a reference element when it is given a certain CSS positioning strategy.
+ * @param reference The reference template ref.
+ * @param floating The floating template ref.
+ * @param options The floating options.
+ * @see https://floating-ui.com/docs/vue
+ */
+function useFloating(reference, floating, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const whileElementsMountedOption = options.whileElementsMounted;
+  const openOption = computed(() => {
+    var _toValue;
+    return (_toValue = toValue(options.open)) != null ? _toValue : true;
+  });
+  const middlewareOption = computed(() => toValue(options.middleware));
+  const placementOption = computed(() => {
+    var _toValue2;
+    return (_toValue2 = toValue(options.placement)) != null ? _toValue2 : 'bottom';
+  });
+  const strategyOption = computed(() => {
+    var _toValue3;
+    return (_toValue3 = toValue(options.strategy)) != null ? _toValue3 : 'absolute';
+  });
+  const transformOption = computed(() => {
+    var _toValue4;
+    return (_toValue4 = toValue(options.transform)) != null ? _toValue4 : true;
+  });
+  const referenceElement = computed(() => unwrapElement(reference.value));
+  const floatingElement = computed(() => unwrapElement(floating.value));
+  const x = ref(0);
+  const y = ref(0);
+  const strategy = ref(strategyOption.value);
+  const placement = ref(placementOption.value);
+  const middlewareData = shallowRef({});
+  const isPositioned = ref(false);
+  const floatingStyles = computed(() => {
+    const initialStyles = {
+      position: strategy.value,
+      left: '0',
+      top: '0'
+    };
+    if (!floatingElement.value) {
+      return initialStyles;
+    }
+    const xVal = roundByDPR(floatingElement.value, x.value);
+    const yVal = roundByDPR(floatingElement.value, y.value);
+    if (transformOption.value) {
+      return {
+        ...initialStyles,
+        transform: "translate(" + xVal + "px, " + yVal + "px)",
+        ...(getDPR(floatingElement.value) >= 1.5 && {
+          willChange: 'transform'
+        })
+      };
+    }
+    return {
+      position: strategy.value,
+      left: xVal + "px",
+      top: yVal + "px"
+    };
+  });
+  let whileElementsMountedCleanup;
+  function update() {
+    if (referenceElement.value == null || floatingElement.value == null) {
+      return;
+    }
+    const open = openOption.value;
+    computePosition(referenceElement.value, floatingElement.value, {
+      middleware: middlewareOption.value,
+      placement: placementOption.value,
+      strategy: strategyOption.value
+    }).then(position => {
+      x.value = position.x;
+      y.value = position.y;
+      strategy.value = position.strategy;
+      placement.value = position.placement;
+      middlewareData.value = position.middlewareData;
+      /**
+       * The floating element's position may be recomputed while it's closed
+       * but still mounted (such as when transitioning out). To ensure
+       * `isPositioned` will be `false` initially on the next open, avoid
+       * setting it to `true` when `open === false` (must be specified).
+       */
+      isPositioned.value = open !== false;
+    });
+  }
+  function cleanup() {
+    if (typeof whileElementsMountedCleanup === 'function') {
+      whileElementsMountedCleanup();
+      whileElementsMountedCleanup = undefined;
+    }
+  }
+  function attach() {
+    cleanup();
+    if (whileElementsMountedOption === undefined) {
+      update();
+      return;
+    }
+    if (referenceElement.value != null && floatingElement.value != null) {
+      whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
+      return;
+    }
+  }
+  function reset() {
+    if (!openOption.value) {
+      isPositioned.value = false;
+    }
+  }
+  watch([middlewareOption, placementOption, strategyOption, openOption], update, {
+    flush: 'sync'
+  });
+  watch([referenceElement, floatingElement], attach, {
+    flush: 'sync'
+  });
+  watch(openOption, reset, {
+    flush: 'sync'
+  });
+  if (getCurrentScope()) {
+    onScopeDispose(cleanup);
+  }
+  return {
+    x: shallowReadonly(x),
+    y: shallowReadonly(y),
+    strategy: shallowReadonly(strategy),
+    placement: shallowReadonly(placement),
+    middlewareData: shallowReadonly(middlewareData),
+    isPositioned: shallowReadonly(isPositioned),
+    floatingStyles,
+    update
+  };
+}
+
+export { arrow, useFloating };

node_modules/@floating-ui/vue/dist/floating-ui.vue.umd.js

@@ -0,0 +1,246 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@floating-ui/dom'), require('@floating-ui/utils/dom'), require('vue-demi')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@floating-ui/dom', '@floating-ui/utils/dom', 'vue-demi'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIVue = {}, global.FloatingUIDOM, global.FloatingUIUtilsDOM, global.VueDemi));
+})(this, (function (exports, dom, dom$1, vueDemi) { 'use strict';
+
+  function isComponentPublicInstance(target) {
+    return target != null && typeof target === 'object' && '$el' in target;
+  }
+  function unwrapElement(target) {
+    if (isComponentPublicInstance(target)) {
+      const element = target.$el;
+      return dom$1.isNode(element) && dom$1.getNodeName(element) === '#comment' ? null : element;
+    }
+    return target;
+  }
+
+  function toValue(source) {
+    return typeof source === 'function' ? source() : vueDemi.unref(source);
+  }
+
+  /**
+   * Positions an inner element of the floating element such that it is centered to the reference element.
+   * @param options The arrow options.
+   * @see https://floating-ui.com/docs/arrow
+   */
+  function arrow(options) {
+    return {
+      name: 'arrow',
+      options,
+      fn(args) {
+        const element = unwrapElement(toValue(options.element));
+        if (element == null) {
+          return {};
+        }
+        return dom.arrow({
+          element,
+          padding: options.padding
+        }).fn(args);
+      }
+    };
+  }
+
+  function getDPR(element) {
+    if (typeof window === 'undefined') {
+      return 1;
+    }
+    const win = element.ownerDocument.defaultView || window;
+    return win.devicePixelRatio || 1;
+  }
+
+  function roundByDPR(element, value) {
+    const dpr = getDPR(element);
+    return Math.round(value * dpr) / dpr;
+  }
+
+  /**
+   * Computes the `x` and `y` coordinates that will place the floating element next to a reference element when it is given a certain CSS positioning strategy.
+   * @param reference The reference template ref.
+   * @param floating The floating template ref.
+   * @param options The floating options.
+   * @see https://floating-ui.com/docs/vue
+   */
+  function useFloating(reference, floating, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    const whileElementsMountedOption = options.whileElementsMounted;
+    const openOption = vueDemi.computed(() => {
+      var _toValue;
+      return (_toValue = toValue(options.open)) != null ? _toValue : true;
+    });
+    const middlewareOption = vueDemi.computed(() => toValue(options.middleware));
+    const placementOption = vueDemi.computed(() => {
+      var _toValue2;
+      return (_toValue2 = toValue(options.placement)) != null ? _toValue2 : 'bottom';
+    });
+    const strategyOption = vueDemi.computed(() => {
+      var _toValue3;
+      return (_toValue3 = toValue(options.strategy)) != null ? _toValue3 : 'absolute';
+    });
+    const transformOption = vueDemi.computed(() => {
+      var _toValue4;
+      return (_toValue4 = toValue(options.transform)) != null ? _toValue4 : true;
+    });
+    const referenceElement = vueDemi.computed(() => unwrapElement(reference.value));
+    const floatingElement = vueDemi.computed(() => unwrapElement(floating.value));
+    const x = vueDemi.ref(0);
+    const y = vueDemi.ref(0);
+    const strategy = vueDemi.ref(strategyOption.value);
+    const placement = vueDemi.ref(placementOption.value);
+    const middlewareData = vueDemi.shallowRef({});
+    const isPositioned = vueDemi.ref(false);
+    const floatingStyles = vueDemi.computed(() => {
+      const initialStyles = {
+        position: strategy.value,
+        left: '0',
+        top: '0'
+      };
+      if (!floatingElement.value) {
+        return initialStyles;
+      }
+      const xVal = roundByDPR(floatingElement.value, x.value);
+      const yVal = roundByDPR(floatingElement.value, y.value);
+      if (transformOption.value) {
+        return {
+          ...initialStyles,
+          transform: "translate(" + xVal + "px, " + yVal + "px)",
+          ...(getDPR(floatingElement.value) >= 1.5 && {
+            willChange: 'transform'
+          })
+        };
+      }
+      return {
+        position: strategy.value,
+        left: xVal + "px",
+        top: yVal + "px"
+      };
+    });
+    let whileElementsMountedCleanup;
+    function update() {
+      if (referenceElement.value == null || floatingElement.value == null) {
+        return;
+      }
+      const open = openOption.value;
+      dom.computePosition(referenceElement.value, floatingElement.value, {
+        middleware: middlewareOption.value,
+        placement: placementOption.value,
+        strategy: strategyOption.value
+      }).then(position => {
+        x.value = position.x;
+        y.value = position.y;
+        strategy.value = position.strategy;
+        placement.value = position.placement;
+        middlewareData.value = position.middlewareData;
+        /**
+         * The floating element's position may be recomputed while it's closed
+         * but still mounted (such as when transitioning out). To ensure
+         * `isPositioned` will be `false` initially on the next open, avoid
+         * setting it to `true` when `open === false` (must be specified).
+         */
+        isPositioned.value = open !== false;
+      });
+    }
+    function cleanup() {
+      if (typeof whileElementsMountedCleanup === 'function') {
+        whileElementsMountedCleanup();
+        whileElementsMountedCleanup = undefined;
+      }
+    }
+    function attach() {
+      cleanup();
+      if (whileElementsMountedOption === undefined) {
+        update();
+        return;
+      }
+      if (referenceElement.value != null && floatingElement.value != null) {
+        whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
+        return;
+      }
+    }
+    function reset() {
+      if (!openOption.value) {
+        isPositioned.value = false;
+      }
+    }
+    vueDemi.watch([middlewareOption, placementOption, strategyOption, openOption], update, {
+      flush: 'sync'
+    });
+    vueDemi.watch([referenceElement, floatingElement], attach, {
+      flush: 'sync'
+    });
+    vueDemi.watch(openOption, reset, {
+      flush: 'sync'
+    });
+    if (vueDemi.getCurrentScope()) {
+      vueDemi.onScopeDispose(cleanup);
+    }
+    return {
+      x: vueDemi.shallowReadonly(x),
+      y: vueDemi.shallowReadonly(y),
+      strategy: vueDemi.shallowReadonly(strategy),
+      placement: vueDemi.shallowReadonly(placement),
+      middlewareData: vueDemi.shallowReadonly(middlewareData),
+      isPositioned: vueDemi.shallowReadonly(isPositioned),
+      floatingStyles,
+      update
+    };
+  }
+
+  Object.defineProperty(exports, "autoPlacement", {
+    enumerable: true,
+    get: function () { return dom.autoPlacement; }
+  });
+  Object.defineProperty(exports, "autoUpdate", {
+    enumerable: true,
+    get: function () { return dom.autoUpdate; }
+  });
+  Object.defineProperty(exports, "computePosition", {
+    enumerable: true,
+    get: function () { return dom.computePosition; }
+  });
+  Object.defineProperty(exports, "detectOverflow", {
+    enumerable: true,
+    get: function () { return dom.detectOverflow; }
+  });
+  Object.defineProperty(exports, "flip", {
+    enumerable: true,
+    get: function () { return dom.flip; }
+  });
+  Object.defineProperty(exports, "getOverflowAncestors", {
+    enumerable: true,
+    get: function () { return dom.getOverflowAncestors; }
+  });
+  Object.defineProperty(exports, "hide", {
+    enumerable: true,
+    get: function () { return dom.hide; }
+  });
+  Object.defineProperty(exports, "inline", {
+    enumerable: true,
+    get: function () { return dom.inline; }
+  });
+  Object.defineProperty(exports, "limitShift", {
+    enumerable: true,
+    get: function () { return dom.limitShift; }
+  });
+  Object.defineProperty(exports, "offset", {
+    enumerable: true,
+    get: function () { return dom.offset; }
+  });
+  Object.defineProperty(exports, "platform", {
+    enumerable: true,
+    get: function () { return dom.platform; }
+  });
+  Object.defineProperty(exports, "shift", {
+    enumerable: true,
+    get: function () { return dom.shift; }
+  });
+  Object.defineProperty(exports, "size", {
+    enumerable: true,
+    get: function () { return dom.size; }
+  });
+  exports.arrow = arrow;
+  exports.useFloating = useFloating;
+
+}));

node_modules/@floating-ui/vue/dist/floating-ui.vue.umd.min.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("@floating-ui/dom"),require("@floating-ui/utils/dom"),require("vue-demi")):"function"==typeof define&&define.amd?define(["exports","@floating-ui/dom","@floating-ui/utils/dom","vue-demi"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).FloatingUIVue={},e.FloatingUIDOM,e.FloatingUIUtilsDOM,e.VueDemi)}(this,(function(e,t,n,u){"use strict";function o(e){if(function(e){return null!=e&&"object"==typeof e&&"$el"in e}(e)){const t=e.$el;return n.isNode(t)&&"#comment"===n.getNodeName(t)?null:t}return e}function r(e){return"function"==typeof e?e():u.unref(e)}function l(e){if("undefined"==typeof window)return 1;return(e.ownerDocument.defaultView||window).devicePixelRatio||1}function i(e,t){const n=l(e);return Math.round(t*n)/n}Object.defineProperty(e,"autoPlacement",{enumerable:!0,get:function(){return t.autoPlacement}}),Object.defineProperty(e,"autoUpdate",{enumerable:!0,get:function(){return t.autoUpdate}}),Object.defineProperty(e,"computePosition",{enumerable:!0,get:function(){return t.computePosition}}),Object.defineProperty(e,"detectOverflow",{enumerable:!0,get:function(){return t.detectOverflow}}),Object.defineProperty(e,"flip",{enumerable:!0,get:function(){return t.flip}}),Object.defineProperty(e,"getOverflowAncestors",{enumerable:!0,get:function(){return t.getOverflowAncestors}}),Object.defineProperty(e,"hide",{enumerable:!0,get:function(){return t.hide}}),Object.defineProperty(e,"inline",{enumerable:!0,get:function(){return t.inline}}),Object.defineProperty(e,"limitShift",{enumerable:!0,get:function(){return t.limitShift}}),Object.defineProperty(e,"offset",{enumerable:!0,get:function(){return t.offset}}),Object.defineProperty(e,"platform",{enumerable:!0,get:function(){return t.platform}}),Object.defineProperty(e,"shift",{enumerable:!0,get:function(){return t.shift}}),Object.defineProperty(e,"size",{enumerable:!0,get:function(){return t.size}}),e.arrow=function(e){return{name:"arrow",options:e,fn(n){const u=o(r(e.element));return null==u?{}:t.arrow({element:u,padding:e.padding}).fn(n)}}},e.useFloating=function(e,n,a){void 0===a&&(a={});const f=a.whileElementsMounted,c=u.computed((()=>{var e;return null==(e=r(a.open))||e})),d=u.computed((()=>r(a.middleware))),s=u.computed((()=>{var e;return null!=(e=r(a.placement))?e:"bottom"})),p=u.computed((()=>{var e;return null!=(e=r(a.strategy))?e:"absolute"})),m=u.computed((()=>{var e;return null==(e=r(a.transform))||e})),v=u.computed((()=>o(e.value))),y=u.computed((()=>o(n.value))),g=u.ref(0),b=u.ref(0),w=u.ref(p.value),h=u.ref(s.value),P=u.shallowRef({}),O=u.ref(!1),j=u.computed((()=>{const e={position:w.value,left:"0",top:"0"};if(!y.value)return e;const t=i(y.value,g.value),n=i(y.value,b.value);return m.value?{...e,transform:"translate("+t+"px, "+n+"px)",...l(y.value)>=1.5&&{willChange:"transform"}}:{position:w.value,left:t+"px",top:n+"px"}}));let x;function R(){if(null==v.value||null==y.value)return;const e=c.value;t.computePosition(v.value,y.value,{middleware:d.value,placement:s.value,strategy:p.value}).then((t=>{g.value=t.x,b.value=t.y,w.value=t.strategy,h.value=t.placement,P.value=t.middlewareData,O.value=!1!==e}))}function D(){"function"==typeof x&&(x(),x=void 0)}return u.watch([d,s,p,c],R,{flush:"sync"}),u.watch([v,y],(function(){D(),void 0!==f?null==v.value||null==y.value||(x=f(v.value,y.value,R)):R()}),{flush:"sync"}),u.watch(c,(function(){c.value||(O.value=!1)}),{flush:"sync"}),u.getCurrentScope()&&u.onScopeDispose(D),{x:u.shallowReadonly(g),y:u.shallowReadonly(b),strategy:u.shallowReadonly(w),placement:u.shallowReadonly(h),middlewareData:u.shallowReadonly(P),isPositioned:u.shallowReadonly(O),floatingStyles:j,update:R}}}));

node_modules/@floating-ui/vue/node_modules/.bin/vue-demi-fix

@@ -0,0 +1 @@
+../vue-demi/bin/vue-demi-fix.js

node_modules/@floating-ui/vue/node_modules/.bin/vue-demi-switch

@@ -0,0 +1 @@
+../vue-demi/bin/vue-demi-switch.js

node_modules/@floating-ui/vue/node_modules/vue-demi/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present, Anthony Fu
+
+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.

node_modules/@floating-ui/vue/node_modules/vue-demi/README.md

@@ -0,0 +1,229 @@
+<p align="center">
+<img src="https://github.com/vueuse/vue-demi/blob/main/assets/banner.png?raw=true" width="600"/>
+<br>
+<a href='https://www.npmjs.com/package/vue-demi'><img src='https://img.shields.io/npm/v/vue-demi?color=42b883' alt='npm'></a>
+</p>
+
+<p align="center">
+<b>Vue Demi</b> (<i>half</i> in French) is a developing utility<br> allows you to write <b>Universal Vue Libraries</b> for Vue 2 & 3<br>
+<i>See more details in <a href='https://antfu.me/posts/make-libraries-working-with-vue-2-and-3'>this blog post</a></i>
+</p>
+
+<br>
+
+<br>
+
+## Strategies
+
+- `<=2.6`: exports from `vue` + `@vue/composition-api` with plugin auto installing.
+- `2.7`: exports from `vue` (Composition API is built-in in Vue 2.7).
+- `>=3.0`: exports from `vue`, with polyfill of Vue 2's `set` and `del` API.
+
+## Usage
+
+Install this as your plugin's dependency:
+
+```bash
+npm i vue-demi
+# or
+yarn add vue-demi
+# or 
+pnpm i vue-demi
+```
+
+Add `vue` and `@vue/composition-api` to your plugin's peer dependencies to specify what versions you support.
+
+```jsonc
+{
+  "dependencies": {
+    "vue-demi": "latest"
+  },
+  "peerDependencies": {
+    "@vue/composition-api": "^1.0.0-rc.1",
+    "vue": "^2.0.0 || >=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@vue/composition-api": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "vue": "^3.0.0" // or "^2.6.0" base on your preferred working environment
+  },
+}
+```
+
+Import everything related to Vue from it, it will redirect to `vue@2` + `@vue/composition-api` or `vue@3` based on users' environments.
+
+```ts
+import { ref, reactive, defineComponent } from 'vue-demi'
+```
+
+Publish your plugin and all is done!
+
+> When using with [Vite](https://vitejs.dev), you will need to opt-out the pre-bundling to get `vue-demi` work properly by
+> ```js
+> // vite.config.js
+> export default defineConfig({
+>   optimizeDeps: {
+>     exclude: ['vue-demi']
+>  }
+> })
+> ```
+
+### Extra APIs
+
+`Vue Demi` provides extra APIs to help distinguish users' environments and to do some version-specific logic.
+
+### `isVue2` `isVue3`
+
+```ts
+import { isVue2, isVue3 } from 'vue-demi'
+
+if (isVue2) {
+  // Vue 2 only
+} else {
+  // Vue 3 only
+}
+```
+
+### `Vue2`
+
+To avoid bringing in all the tree-shakable modules, we provide a `Vue2` export to support access to Vue 2's global API. (See [#41](https://github.com/vueuse/vue-demi/issues/41).)
+
+```ts
+import { Vue2 } from 'vue-demi'
+
+if (Vue2) {
+  Vue2.config.ignoredElements.push('x-foo')
+}
+```
+
+### `install()`
+
+Composition API in Vue 2 is provided as a plugin and needs to be installed on the Vue instance before using. Normally, `vue-demi` will try to install it automatically. For some usages where you might need to ensure the plugin gets installed correctly, the `install()` API is exposed to as a safe version of `Vue.use(CompositionAPI)`. `install()` in the Vue 3 environment will be an empty function (no-op).
+
+```ts
+import { install } from 'vue-demi'
+
+install()
+```
+
+## CLI
+
+### Manually Switch Versions
+
+To explicitly switch the redirecting version, you can use these commands in your project's root.
+
+```bash
+npx vue-demi-switch 2
+# or
+npx vue-demi-switch 3
+```
+
+### Package Aliasing
+
+If you would like to import `vue` under an alias, you can use the following command 
+
+```bash
+npx vue-demi-switch 2 vue2
+# or
+npx vue-demi-switch 3 vue3
+```
+
+Then `vue-demi` will redirect APIs from the alias name you specified, for example:
+
+```ts
+import * as Vue from 'vue3'
+
+var isVue2 = false
+var isVue3 = true
+var Vue2 = undefined
+
+export * from 'vue3'
+export {
+  Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+}
+```
+
+### Auto Fix
+
+If the `postinstall` hook doesn't get triggered or you have updated the Vue version, try to run the following command to resolve the redirecting.
+
+```bash
+npx vue-demi-fix
+```
+
+### Isomorphic Testings
+
+You can support testing for both versions by adding npm alias in your dev dependencies. For example:
+
+```json
+{
+  "scripts": {
+    "test:2": "vue-demi-switch 2 vue2 && jest",
+    "test:3": "vue-demi-switch 3 && jest",
+  },
+  "devDependencies": {
+    "vue": "^3.0.0",
+    "vue2": "npm:vue@2"
+  },
+}
+```
+
+or
+
+```json
+{
+  "scripts": {
+    "test:2": "vue-demi-switch 2 && jest",
+    "test:3": "vue-demi-switch 3 vue3 && jest",
+  },
+  "devDependencies": {
+    "vue": "^2.6.0",
+    "vue3": "npm:vue@3"
+  },
+}
+```
+
+## Examples
+
+See [examples](./examples).
+
+## Who is using this?
+
+- [VueUse](https://github.com/vueuse/vueuse) - Collection of Composition API utils
+- [@vue/apollo-composable](https://github.com/vuejs/vue-apollo/tree/v4/packages/vue-apollo-composable) - Apollo GraphQL functions for Vue Composition API
+- [vuelidate](https://github.com/vuelidate/vuelidate) - Simple, lightweight model-based validation
+- [vue-composition-test-utils](https://github.com/ariesjia/vue-composition-test-utils) - Simple vue composition api unit test utilities
+- [vue-use-stripe](https://github.com/frandiox/vue-use-stripe) - Stripe Elements wrapper for Vue.js
+- [@opd/g2plot-vue](https://github.com/open-data-plan/g2plot-vue) - G2plot for vue
+- [vue-echarts](https://github.com/ecomfe/vue-echarts) - Vue.js component for Apache ECharts.
+- [fluent-vue](https://github.com/Demivan/fluent-vue) - Vue.js integration for [Fluent.js](https://github.com/projectfluent/fluent.js) - JavaScript implementation of [Project Fluent](https://projectfluent.org)  
+- [vue-datatable-url-sync](https://github.com/socotecio/vue-datatable-url-sync) - Synchronize datatable options and filters with the url to keep user preference even after refresh or navigation
+- [vue-insta-stories](https://github.com/UnevenSoftware/vue-insta-stories) - Instagram stories in your vue projects.
+- [vue-tiny-validate](https://github.com/FrontLabsOfficial/vue-tiny-validate) - Tiny Vue Validate Composition
+- [v-perfect-signature](https://github.com/wobsoriano/v-perfect-signature) - Pressure-sensitive signature drawing for Vue 2 and 3
+- [vue-winbox](https://github.com/wobsoriano/vue-winbox) - A wrapper component for WinBox.js that adds the ability to mount Vue components.
+- [vue-word-highlighter](https://github.com/kawamataryo/vue-word-highlighter) - The word highlighter library for Vue 2 and Vue 3
+- [vue-chart-3](https://github.com/victorgarciaesgi/vue-chart-3) - Vue.js component for Chart.js
+- [json-editor-vue](https://github.com/cloydlau/json-editor-vue) - JSON editor & viewer for Vue 2 and 3.
+- [kidar-echarts](https://github.com/kidarjs/kidar-echarts) - A simpler echarts component for Vue 2 and 3.
+- [vue3-sketch-ruler](https://github.com/kakajun/vue3-sketch-ruler) - The zoom operation used for page presentation for Vue 2 and 3( Replace render function with template )
+- [vue-rough-notation](https://github.com/Leecason/vue-rough-notation) - RoughNotation wrapper component for Vue 2 and 3.
+- [vue-request](https://github.com/AttoJS/vue-request) - Vue composition API for data fetching, supports SWR, polling, error retry, cache request, pagination, etc.
+- [vue3-lazyload](https://github.com/murongg/vue3-lazyload) - A vue3.x image lazyload plugin.
+- [vue-codemirror6](https://github.com/logue/vue-codemirror6) - CodeMirror6 component for Vue2 and 3.
+- [@tanstack/vue-query](https://github.com/TanStack/query) - TanStack Query for Vue.
+> open a PR to add your library ;)
+
+## Underhood
+
+See [the blog post](https://antfu.me/posts/make-libraries-working-with-vue-2-and-3/#-introducing-vue-demi).
+
+## License
+
+MIT License © 2020 [Anthony Fu](https://github.com/antfu)

node_modules/@floating-ui/vue/node_modules/vue-demi/bin/vue-demi-fix.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+'use strict'
+require('../scripts/postinstall')

node_modules/@floating-ui/vue/node_modules/vue-demi/bin/vue-demi-switch.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+'use strict'
+require('../scripts/switch-cli')

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/index.cjs

@@ -0,0 +1,29 @@
+var Vue = require('vue')
+
+Object.keys(Vue).forEach(function(key) {
+  exports[key] = Vue[key]
+})
+
+exports.set = function(target, key, val) {
+  if (Array.isArray(target)) {
+    target.length = Math.max(target.length, key)
+    target.splice(key, 1, val)
+    return val
+  }
+  target[key] = val
+  return val
+}
+
+exports.del = function(target, key) {
+  if (Array.isArray(target)) {
+    target.splice(key, 1)
+    return
+  }
+  delete target[key]
+}
+
+exports.Vue = Vue
+exports.Vue2 = undefined
+exports.isVue2 = false
+exports.isVue3 = true
+exports.install = function(){}

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/index.d.ts

@@ -0,0 +1,22 @@
+import * as Vue from 'vue'
+declare const isVue2: boolean
+declare const isVue3: boolean
+declare const Vue2: any
+declare const install: (vue?: any) => void
+/** 
+ * @deprecated To avoid bringing in all the tree-shakable modules, this API has been deprecated. Use `Vue2` or named exports instead.
+ * Refer to https://github.com/vueuse/vue-demi/issues/41
+ */
+declare const V: typeof Vue
+
+export function set<T>(target: any, key: any, val: T): T
+export function del(target: any, key: any): void
+
+export * from 'vue'
+export {
+  V as Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+  install,
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/index.iife.js

@@ -0,0 +1,126 @@
+var _VueDemiGlobal = typeof globalThis !== 'undefined' 
+  ? globalThis
+  : typeof global !== 'undefined'
+    ? global
+    : typeof self !== 'undefined'
+      ? self
+      : this
+var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
+  if (VueDemi.install) {
+    return VueDemi
+  }
+  if (!Vue) {
+    console.error('[vue-demi] no Vue instance found, please be sure to import `vue` before `vue-demi`.')
+    return VueDemi
+  }
+
+  // Vue 2.7
+  if (Vue.version.slice(0, 4) === '2.7.') {
+    for (var key in Vue) {
+      VueDemi[key] = Vue[key]
+    }
+    VueDemi.isVue2 = true
+    VueDemi.isVue3 = false
+    VueDemi.install = function () {}
+    VueDemi.Vue = Vue
+    VueDemi.Vue2 = Vue
+    VueDemi.version = Vue.version
+    VueDemi.warn = Vue.util.warn
+    VueDemi.hasInjectionContext = function() {
+      return !!VueDemi.getCurrentInstance()
+    }
+    function createApp(rootComponent, rootProps) {
+      var vm
+      var provide = {}
+      var app = {
+        config: Vue.config,
+        use: Vue.use.bind(Vue),
+        mixin: Vue.mixin.bind(Vue),
+        component: Vue.component.bind(Vue),
+        provide: function (key, value) {
+          provide[key] = value
+          return this
+        },
+        directive: function (name, dir) {
+          if (dir) {
+            Vue.directive(name, dir)
+            return app
+          } else {
+            return Vue.directive(name)
+          }
+        },
+        mount: function (el, hydrating) {
+          if (!vm) {
+            vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
+            vm.$mount(el, hydrating)
+            return vm
+          } else {
+            return vm
+          }
+        },
+        unmount: function () {
+          if (vm) {
+            vm.$destroy()
+            vm = undefined
+          }
+        },
+      }
+      return app
+    }
+    VueDemi.createApp = createApp
+  }
+  // Vue 2.6.x
+  else if (Vue.version.slice(0, 2) === '2.') {
+    if (VueCompositionAPI) {
+      for (var key in VueCompositionAPI) {
+        VueDemi[key] = VueCompositionAPI[key]
+      }
+      VueDemi.isVue2 = true
+      VueDemi.isVue3 = false
+      VueDemi.install = function () {}
+      VueDemi.Vue = Vue
+      VueDemi.Vue2 = Vue
+      VueDemi.version = Vue.version
+      VueDemi.hasInjectionContext = function() {
+        return !!VueDemi.getCurrentInstance()
+      }
+    } else {
+      console.error('[vue-demi] no VueCompositionAPI instance found, please be sure to import `@vue/composition-api` before `vue-demi`.')
+    }
+  }
+  // Vue 3
+  else if (Vue.version.slice(0, 2) === '3.') {
+    for (var key in Vue) {
+      VueDemi[key] = Vue[key]
+    }
+    VueDemi.isVue2 = false
+    VueDemi.isVue3 = true
+    VueDemi.install = function () {}
+    VueDemi.Vue = Vue
+    VueDemi.Vue2 = undefined
+    VueDemi.version = Vue.version
+    VueDemi.set = function (target, key, val) {
+      if (Array.isArray(target)) {
+        target.length = Math.max(target.length, key)
+        target.splice(key, 1, val)
+        return val
+      }
+      target[key] = val
+      return val
+    }
+    VueDemi.del = function (target, key) {
+      if (Array.isArray(target)) {
+        target.splice(key, 1)
+        return
+      }
+      delete target[key]
+    }
+  } else {
+    console.error('[vue-demi] Vue version ' + Vue.version + ' is unsupported.')
+  }
+  return VueDemi
+})(
+  (_VueDemiGlobal.VueDemi = _VueDemiGlobal.VueDemi || (typeof VueDemi !== 'undefined' ? VueDemi : {})),
+  _VueDemiGlobal.Vue || (typeof Vue !== 'undefined' ? Vue : undefined),
+  _VueDemiGlobal.VueCompositionAPI || (typeof VueCompositionAPI !== 'undefined' ? VueCompositionAPI : undefined)
+);

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/index.mjs

@@ -0,0 +1,34 @@
+import * as Vue from 'vue'
+
+var isVue2 = false
+var isVue3 = true
+var Vue2 = undefined
+
+function install() {}
+
+export function set(target, key, val) {
+  if (Array.isArray(target)) {
+    target.length = Math.max(target.length, key)
+    target.splice(key, 1, val)
+    return val
+  }
+  target[key] = val
+  return val
+}
+
+export function del(target, key) {
+  if (Array.isArray(target)) {
+    target.splice(key, 1)
+    return
+  }
+  delete target[key]
+}
+
+export * from 'vue'
+export {
+  Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+  install,
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/v2.7/index.cjs

@@ -0,0 +1,60 @@
+var VueModule = require('vue')
+
+// get the real Vue https://github.com/vueuse/vue-demi/issues/192
+var Vue = VueModule.default || VueModule
+
+exports.Vue = Vue
+exports.Vue2 = Vue
+exports.isVue2 = true
+exports.isVue3 = false
+exports.install = function () {}
+exports.warn = Vue.util.warn
+
+// createApp polyfill
+exports.createApp = function (rootComponent, rootProps) {
+  var vm
+  var provide = {}
+  var app = {
+    config: Vue.config,
+    use: Vue.use.bind(Vue),
+    mixin: Vue.mixin.bind(Vue),
+    component: Vue.component.bind(Vue),
+    provide: function (key, value) {
+      provide[key] = value
+      return this
+    },
+    directive: function (name, dir) {
+      if (dir) {
+        Vue.directive(name, dir)
+        return app
+      } else {
+        return Vue.directive(name)
+      }
+    },
+    mount: function (el, hydrating) {
+      if (!vm) {
+        vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
+        vm.$mount(el, hydrating)
+        return vm
+      } else {
+        return vm
+      }
+    },
+    unmount: function () {
+      if (vm) {
+        vm.$destroy()
+        vm = undefined
+      }
+    },
+  }
+  return app
+}
+
+Object.keys(VueModule).forEach(function (key) {
+  exports[key] = VueModule[key]
+})
+
+// Not implemented https://github.com/vuejs/core/pull/8111, falls back to getCurrentInstance()
+exports.hasInjectionContext = function() {
+  return !!VueModule.getCurrentInstance()
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/v2.7/index.d.ts

@@ -0,0 +1,38 @@
+import Vue from 'vue'
+import type { PluginFunction, PluginObject, VueConstructor, Directive, InjectionKey, Component } from 'vue'
+
+declare const isVue2: boolean
+declare const isVue3: boolean
+declare const Vue2: typeof Vue | undefined
+declare const version: string
+declare const install: (vue?: typeof Vue) => void
+export declare function warn(msg: string, vm?: Component | null): void
+/**
+ * @deprecated To avoid bringing in all the tree-shakable modules, this API has been deprecated. Use `Vue2` or named exports instead.
+ * Refer to https://github.com/vueuse/vue-demi/issues/41
+ */
+declare const V: typeof Vue
+
+// accept no generic because Vue 3 doesn't accept any
+// https://github.com/vuejs/vue-next/pull/2758/
+export declare type Plugin = PluginObject<any> | PluginFunction<any>
+export type { VNode } from 'vue'
+export * from 'vue'
+export { V as Vue, Vue2, isVue2, isVue3, version, install }
+
+// #region createApp polyfill
+export interface App<T = any> {
+  config: VueConstructor['config']
+  use: VueConstructor['use']
+  mixin: VueConstructor['mixin']
+  component: VueConstructor['component']
+  directive(name: string): Directive | undefined
+  directive(name: string, directive: Directive): this
+  provide<T>(key: InjectionKey<T> | string, value: T): this
+  mount: Vue['$mount']
+  unmount: Vue['$destroy']
+}
+export declare function createApp(rootComponent: any, rootProps?: any): App
+// #endregion
+
+export declare function hasInjectionContext(): boolean

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/v2.7/index.mjs

@@ -0,0 +1,80 @@
+import Vue from 'vue'
+import { getCurrentInstance } from 'vue'
+
+var isVue2 = true
+var isVue3 = false
+var Vue2 = Vue
+var warn = Vue.util.warn
+
+function install() {}
+
+// createApp polyfill
+export function createApp(rootComponent, rootProps) {
+  var vm
+  var provide = {}
+  var app = {
+    config: Vue.config,
+    use: Vue.use.bind(Vue),
+    mixin: Vue.mixin.bind(Vue),
+    component: Vue.component.bind(Vue),
+    provide: function (key, value) {
+      provide[key] = value
+      return this
+    },
+    directive: function (name, dir) {
+      if (dir) {
+        Vue.directive(name, dir)
+        return app
+      } else {
+        return Vue.directive(name)
+      }
+    },
+    mount: function (el, hydrating) {
+      if (!vm) {
+        vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
+        vm.$mount(el, hydrating)
+        return vm
+      } else {
+        return vm
+      }
+    },
+    unmount: function () {
+      if (vm) {
+        vm.$destroy()
+        vm = undefined
+      }
+    },
+  }
+  return app
+}
+
+export {
+  Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+  install,
+  warn
+}
+
+// Vue 3 components mock
+function createMockComponent(name) {
+  return {
+    setup() {
+      throw new Error('[vue-demi] ' + name + ' is not supported in Vue 2. It\'s provided to avoid compiler errors.')
+    }
+  }
+}
+export var Fragment = /*#__PURE__*/ createMockComponent('Fragment')
+export var Transition = /*#__PURE__*/ createMockComponent('Transition')
+export var TransitionGroup = /*#__PURE__*/ createMockComponent('TransitionGroup')
+export var Teleport = /*#__PURE__*/ createMockComponent('Teleport')
+export var Suspense = /*#__PURE__*/ createMockComponent('Suspense')
+export var KeepAlive = /*#__PURE__*/ createMockComponent('KeepAlive')
+
+export * from 'vue'
+
+// Not implemented https://github.com/vuejs/core/pull/8111, falls back to getCurrentInstance()
+export function hasInjectionContext() {
+  return !!getCurrentInstance()
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/v2/index.cjs

@@ -0,0 +1,34 @@
+var Vue = require('vue')
+var VueCompositionAPI = require('@vue/composition-api')
+
+function install(_vue) {
+  var vueLib = _vue || Vue
+  if (vueLib && 'default' in vueLib) {
+    vueLib = vueLib.default
+  }
+
+  if (vueLib && !vueLib['__composition_api_installed__']) {
+    if (VueCompositionAPI && 'default' in VueCompositionAPI)
+      vueLib.use(VueCompositionAPI.default)
+    else if (VueCompositionAPI)
+      vueLib.use(VueCompositionAPI)
+  }
+}
+
+install(Vue)
+
+Object.keys(VueCompositionAPI).forEach(function(key) {
+  exports[key] = VueCompositionAPI[key]
+})
+
+exports.Vue = Vue
+exports.Vue2 = Vue
+exports.isVue2 = true
+exports.isVue3 = false
+exports.install = install
+exports.version = Vue.version
+
+// Not implemented https://github.com/vuejs/core/pull/8111, falls back to getCurrentInstance()
+exports.hasInjectionContext = function () {
+  return !!VueCompositionAPI.getCurrentInstance()
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/v2/index.d.ts

@@ -0,0 +1,33 @@
+import Vue from 'vue'
+import type { PluginFunction, PluginObject } from 'vue'
+declare const isVue2: boolean
+declare const isVue3: boolean
+declare const Vue2: typeof Vue | undefined
+declare const version: string
+declare const install: (vue?: typeof Vue) => void
+/**
+ * @deprecated To avoid bringing in all the tree-shakable modules, this API has been deprecated. Use `Vue2` or named exports instead.
+ * Refer to https://github.com/vueuse/vue-demi/issues/41
+ */
+declare const V: typeof Vue
+
+/**
+ * DebuggerEvent is a Vue 3 development only feature. This type cannot exist in Vue 2.
+ */
+export declare type DebuggerEvent = never
+
+// accept no generic because Vue 3 doesn't accept any
+// https://github.com/vuejs/vue-next/pull/2758/
+export declare type Plugin = PluginObject<any> | PluginFunction<any>
+export type { VNode } from 'vue'
+export * from '@vue/composition-api'
+export {
+  V as Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+  version,
+  install,
+}
+
+export declare function hasInjectionContext(): boolean

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/v2/index.mjs

@@ -0,0 +1,49 @@
+import Vue from 'vue'
+import VueCompositionAPI, { getCurrentInstance } from '@vue/composition-api/dist/vue-composition-api.mjs'
+
+function install(_vue) {
+  _vue = _vue || Vue
+  if (_vue && !_vue['__composition_api_installed__'])
+    _vue.use(VueCompositionAPI)
+}
+
+install(Vue)
+
+var isVue2 = true
+var isVue3 = false
+var Vue2 = Vue
+var version = Vue.version
+
+/**VCA-EXPORTS**/
+export * from '@vue/composition-api/dist/vue-composition-api.mjs'
+/**VCA-EXPORTS**/
+
+export {
+  Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+  version,
+  install,
+}
+
+
+// Vue 3 components mock
+function createMockComponent(name) {
+  return {
+    setup() {
+      throw new Error('[vue-demi] ' + name + ' is not supported in Vue 2. It\'s provided to avoid compiler errors.')
+    }
+  }
+}
+export var Fragment = /*#__PURE__*/ createMockComponent('Fragment')
+export var Transition = /*#__PURE__*/ createMockComponent('Transition')
+export var TransitionGroup = /*#__PURE__*/ createMockComponent('TransitionGroup')
+export var Teleport = /*#__PURE__*/ createMockComponent('Teleport')
+export var Suspense = /*#__PURE__*/ createMockComponent('Suspense')
+export var KeepAlive = /*#__PURE__*/ createMockComponent('KeepAlive')
+
+// Not implemented https://github.com/vuejs/core/pull/8111, falls back to getCurrentInstance()
+export function hasInjectionContext() {
+  return !!getCurrentInstance()
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/v3/index.cjs

@@ -0,0 +1,29 @@
+var Vue = require('vue')
+
+Object.keys(Vue).forEach(function(key) {
+  exports[key] = Vue[key]
+})
+
+exports.set = function(target, key, val) {
+  if (Array.isArray(target)) {
+    target.length = Math.max(target.length, key)
+    target.splice(key, 1, val)
+    return val
+  }
+  target[key] = val
+  return val
+}
+
+exports.del = function(target, key) {
+  if (Array.isArray(target)) {
+    target.splice(key, 1)
+    return
+  }
+  delete target[key]
+}
+
+exports.Vue = Vue
+exports.Vue2 = undefined
+exports.isVue2 = false
+exports.isVue3 = true
+exports.install = function(){}

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/v3/index.d.ts

@@ -0,0 +1,22 @@
+import * as Vue from 'vue'
+declare const isVue2: boolean
+declare const isVue3: boolean
+declare const Vue2: any
+declare const install: (vue?: any) => void
+/** 
+ * @deprecated To avoid bringing in all the tree-shakable modules, this API has been deprecated. Use `Vue2` or named exports instead.
+ * Refer to https://github.com/vueuse/vue-demi/issues/41
+ */
+declare const V: typeof Vue
+
+export function set<T>(target: any, key: any, val: T): T
+export function del(target: any, key: any): void
+
+export * from 'vue'
+export {
+  V as Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+  install,
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/lib/v3/index.mjs

@@ -0,0 +1,34 @@
+import * as Vue from 'vue'
+
+var isVue2 = false
+var isVue3 = true
+var Vue2 = undefined
+
+function install() {}
+
+export function set(target, key, val) {
+  if (Array.isArray(target)) {
+    target.length = Math.max(target.length, key)
+    target.splice(key, 1, val)
+    return val
+  }
+  target[key] = val
+  return val
+}
+
+export function del(target, key) {
+  if (Array.isArray(target)) {
+    target.splice(key, 1)
+    return
+  }
+  delete target[key]
+}
+
+export * from 'vue'
+export {
+  Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+  install,
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "vue-demi",
+  "version": "0.14.10",
+  "engines": {
+    "node": ">=12"
+  },
+  "repository": "https://github.com/antfu/vue-demi.git",
+  "funding": "https://github.com/sponsors/antfu",
+  "license": "MIT",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "main": "lib/index.cjs",
+  "jsdelivr": "lib/index.iife.js",
+  "unpkg": "lib/index.iife.js",
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.cjs",
+      "import": "./lib/index.mjs",
+      "browser": "./lib/index.mjs"
+    },
+    "./*": "./*"
+  },
+  "bin": {
+    "vue-demi-fix": "bin/vue-demi-fix.js",
+    "vue-demi-switch": "bin/vue-demi-switch.js"
+  },
+  "files": [
+    "lib",
+    "bin",
+    "scripts"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"try{require('./scripts/postinstall.js')}catch(e){}\"",
+    "release": "npx bumpp --tag --commit --push && npm publish"
+  },
+  "peerDependencies": {
+    "@vue/composition-api": "^1.0.0-rc.1",
+    "vue": "^3.0.0-0 || ^2.6.0"
+  },
+  "peerDependenciesMeta": {
+    "@vue/composition-api": {
+      "optional": true
+    }
+  }
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/scripts/postinstall.js

@@ -0,0 +1,19 @@
+const { switchVersion, loadModule } = require('./utils')
+
+const Vue = loadModule('vue')
+
+if (!Vue || typeof Vue.version !== 'string') {
+  console.warn('[vue-demi] Vue is not found. Please run "npm install vue" to install.')
+}
+else if (Vue.version.startsWith('2.7.')) {
+  switchVersion(2.7)
+}
+else if (Vue.version.startsWith('2.')) {
+  switchVersion(2)
+}
+else if (Vue.version.startsWith('3.')) {
+  switchVersion(3)
+}
+else {
+  console.warn(`[vue-demi] Vue version v${Vue.version} is not supported.`)
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/scripts/switch-cli.js

@@ -0,0 +1,18 @@
+const { switchVersion } = require('./utils')
+
+const version = process.argv[2]
+const vueEntry = process.argv[3] || 'vue'
+
+if (version === '2.7') {
+  switchVersion(2.7, vueEntry)
+  console.log(`[vue-demi] Switched for Vue 2.7 (entry: "${vueEntry}")`)
+} else if (version === '2') {
+  switchVersion(2, vueEntry)
+  console.log(`[vue-demi] Switched for Vue 2 (entry: "${vueEntry}")`)
+} else if (version === '3') {
+  switchVersion(3, vueEntry)
+  console.log(`[vue-demi] Switched for Vue 3 (entry: "${vueEntry}")`)
+} else {
+  console.warn(`[vue-demi] expecting version "2" or "2.7" or "3" but got "${version}"`)
+  process.exit(1)
+}

node_modules/@floating-ui/vue/node_modules/vue-demi/scripts/utils.js

@@ -0,0 +1,62 @@
+const fs = require('fs')
+const path = require('path')
+
+const dir = path.resolve(__dirname, '..', 'lib')
+
+function loadModule(name) {
+  try {
+    return require(name)
+  } catch (e) {
+    return undefined
+  }
+}
+
+function copy(name, version, vue) {
+  vue = vue || 'vue'
+  const src = path.join(dir, `v${version}`, name)
+  const dest = path.join(dir, name)
+  let content = fs.readFileSync(src, 'utf-8')
+  content = content.replace(/'vue'/g, `'${vue}'`)
+  // unlink for pnpm, #92
+  try {
+    fs.unlinkSync(dest)
+  } catch (error) { }
+  fs.writeFileSync(dest, content, 'utf-8')
+}
+
+function updateVue2API() {
+  const ignoreList = ['version', 'default']
+  const VCA = loadModule('@vue/composition-api')
+  if (!VCA) {
+    console.warn('[vue-demi] Composition API plugin is not found. Please run "npm install @vue/composition-api" to install.')
+    return
+  }
+
+  const exports = Object.keys(VCA).filter(i => !ignoreList.includes(i))
+
+  const esmPath = path.join(dir, 'index.mjs')
+  let content = fs.readFileSync(esmPath, 'utf-8')
+
+  content = content.replace(
+    /\/\*\*VCA-EXPORTS\*\*\/[\s\S]+\/\*\*VCA-EXPORTS\*\*\//m,
+`/**VCA-EXPORTS**/
+export { ${exports.join(', ')} } from '@vue/composition-api/dist/vue-composition-api.mjs'
+/**VCA-EXPORTS**/`
+    )
+
+  fs.writeFileSync(esmPath, content, 'utf-8')
+  
+}
+
+function switchVersion(version, vue) {
+  copy('index.cjs', version, vue)
+  copy('index.mjs', version, vue)
+  copy('index.d.ts', version, vue)
+
+  if (version === 2)
+    updateVue2API()
+}
+
+
+module.exports.loadModule = loadModule
+module.exports.switchVersion = switchVersion

node_modules/@floating-ui/vue/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@floating-ui/vue",
+  "version": "1.1.6",
+  "description": "Floating UI for Vue",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/floating-ui.vue.umd.js",
+  "module": "./dist/floating-ui.vue.esm.js",
+  "unpkg": "./dist/floating-ui.vue.umd.min.js",
+  "types": "./dist/floating-ui.vue.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/floating-ui.vue.d.mts",
+        "default": "./dist/floating-ui.vue.mjs"
+      },
+      "types": "./dist/floating-ui.vue.d.ts",
+      "module": "./dist/floating-ui.vue.esm.js",
+      "default": "./dist/floating-ui.vue.umd.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "author": "lozinsky",
+  "license": "MIT",
+  "bugs": "https://github.com/floating-ui/floating-ui",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/floating-ui/floating-ui.git",
+    "directory": "packages/vue"
+  },
+  "homepage": "https://floating-ui.com/docs/vue",
+  "keywords": [
+    "tooltip",
+    "popover",
+    "dropdown",
+    "menu",
+    "popup",
+    "positioning",
+    "vue"
+  ],
+  "dependencies": {
+    "@floating-ui/dom": "^1.0.0",
+    "vue-demi": ">=0.13.0",
+    "@floating-ui/utils": "^0.2.9"
+  },
+  "devDependencies": {
+    "@parcel/transformer-vue": "^2.10.3",
+    "@testing-library/jest-dom": "^6.1.6",
+    "@testing-library/vue": "^6.6.1",
+    "@vitejs/plugin-vue": "^5.0.2",
+    "vue": "^3.4.4",
+    "config": "0.0.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "clean": "rimraf dist out-tsc",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "build": "rollup -c",
+    "build:api": "build-api --tsc tsconfig.lib.json",
+    "dev": "vite",
+    "publint": "publint",
+    "typecheck": "tsc -b"
+  }
+}