Saving all progress

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"
+  }
+}