@poveste/vendors 0.1.0

package/dist/client/node_modules/@floating-ui/dom/src/index.d.ts

@@ -0,0 +1,11 @@
+import type { ComputePositionConfig, FloatingElement, ReferenceElement } from './types';
+/**
+ * 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.
+ */
+export declare const computePosition: (reference: ReferenceElement, floating: FloatingElement, options?: Partial<ComputePositionConfig>) => Promise<import("@floating-ui/core").ComputePositionReturn>;
+export { autoUpdate } from './autoUpdate';
+export { platform } from './platform';
+export { getOverflowAncestors } from './utils/getOverflowAncestors';
+export { arrow, autoPlacement, detectOverflow, flip, hide, inline, limitShift, offset, shift, size, } from '@floating-ui/core';

package/dist/client/node_modules/@floating-ui/dom/src/platform.d.ts

@@ -0,0 +1,2 @@
+import type { Platform } from './types';
+export declare const platform: Platform;

package/dist/client/node_modules/@floating-ui/dom/src/types.d.ts

@@ -0,0 +1,128 @@
+import type { AutoPlacementOptions, ClientRectObject, ComputePositionConfig as CoreComputePositionConfig, DetectOverflowOptions as CoreDetectOverflowOptions, Dimensions, ElementRects, FlipOptions, HideOptions, Middleware as CoreMiddleware, MiddlewareArguments as CoreMiddlewareArguments, MiddlewareReturn, Padding, Rect, RootBoundary, ShiftOptions, SideObject, SizeOptions as CoreSizeOptions, Strategy } from '@floating-ui/core';
+type Promisable<T> = T | Promise<T>;
+export 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: {
+        rect: Rect;
+        offsetParent: Element;
+        strategy: Strategy;
+    }) => Promisable<Rect>;
+    getOffsetParent?: (element: Element) => 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 interface NodeScroll {
+    scrollLeft: number;
+    scrollTop: number;
+}
+export type Boundary = 'clippingAncestors' | Element | Array<Element>;
+export type DetectOverflowOptions = Omit<CoreDetectOverflowOptions, 'boundary'> & {
+    boundary: Boundary;
+};
+export type SizeOptions = Omit<CoreSizeOptions, 'apply'> & {
+    /**
+     * Function that is called to perform style mutations to the floating element
+     * to change its size.
+     * @default undefined
+     */
+    apply(args: MiddlewareArguments & {
+        availableWidth: number;
+        availableHeight: number;
+    }): Promisable<void>;
+};
+export type ComputePositionConfig = Omit<CoreComputePositionConfig, 'middleware' | 'platform'> & {
+    middleware?: Array<Middleware | null | undefined | false>;
+    platform?: Platform;
+};
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+export interface VirtualElement {
+    getBoundingClientRect(): ClientRectObject;
+    contextElement?: Element;
+}
+export type ReferenceElement = Element | VirtualElement;
+export type FloatingElement = HTMLElement;
+export interface Elements {
+    reference: ReferenceElement;
+    floating: FloatingElement;
+}
+export type MiddlewareArguments = Omit<CoreMiddlewareArguments, 'elements'> & {
+    elements: Elements;
+};
+export type Middleware = Omit<CoreMiddleware, 'fn'> & {
+    fn(args: MiddlewareArguments): Promisable<MiddlewareReturn>;
+};
+/**
+ * Automatically chooses the `placement` which has the most space available.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+declare const autoPlacement: (options?: Partial<AutoPlacementOptions & DetectOverflowOptions>) => Middleware;
+/**
+ * Shifts the floating element in order to keep it in view when it will overflow
+ * a clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+declare const shift: (options?: Partial<ShiftOptions & DetectOverflowOptions>) => Middleware;
+/**
+ * Changes the placement of the floating element to one that will fit if the
+ * initially specified `placement` does not.
+ * @see https://floating-ui.com/docs/flip
+ */
+declare const flip: (options?: Partial<FlipOptions & DetectOverflowOptions>) => Middleware;
+/**
+ * Provides data to change the size of the floating element. For instance,
+ * prevent it from overflowing its clipping boundary or match the width of the
+ * reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+declare const size: (options?: Partial<SizeOptions & DetectOverflowOptions>) => Middleware;
+/**
+ * Positions an inner element of the floating element such that it is centered
+ * to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+declare const arrow: (options: {
+    element: Element;
+    padding?: Padding;
+}) => Middleware;
+/**
+ * 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
+ */
+declare const hide: (options?: Partial<HideOptions & DetectOverflowOptions>) => Middleware;
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary.
+ * - 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
+ */
+declare const detectOverflow: (middlewareArguments: MiddlewareArguments, options?: Partial<DetectOverflowOptions>) => Promise<SideObject>;
+export { arrow, autoPlacement, detectOverflow, flip, hide, shift, size };
+export { computePosition } from './';
+export { autoUpdate, Options as AutoUpdateOptions } from './autoUpdate';
+export { platform } from './platform';
+export { getOverflowAncestors } from './utils/getOverflowAncestors';
+export type { AlignedPlacement, Alignment, Axis, ClientRectObject, ComputePositionReturn, Coords, Dimensions, ElementContext, ElementRects, Length, MiddlewareData, MiddlewareReturn, Padding, Placement, Rect, RootBoundary, Side, SideObject, Strategy, } from '@floating-ui/core';
+export { inline, limitShift, offset } from '@floating-ui/core';

package/dist/client/node_modules/@floating-ui/dom/src/utils/convertOffsetParentRelativeRectToViewportRelativeRect.d.ts

@@ -0,0 +1,6 @@
+import type { Rect, Strategy } from '@floating-ui/core';
+export declare function convertOffsetParentRelativeRectToViewportRelativeRect({ rect, offsetParent, strategy, }: {
+    rect: Rect;
+    offsetParent: Element | Window;
+    strategy: Strategy;
+}): Rect;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getBoundingClientRect.d.ts

@@ -0,0 +1,2 @@
+import type { ClientRectObject, VirtualElement } from '@floating-ui/core';
+export declare function getBoundingClientRect(element: Element | VirtualElement, includeScale?: boolean, isFixedStrategy?: boolean, offsetParent?: Element | Window): ClientRectObject;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getClippingRect.d.ts

@@ -0,0 +1,12 @@
+import type { Boundary, Rect, RootBoundary, Strategy } from '@floating-ui/core';
+import { Platform, ReferenceElement } from '../types';
+type PlatformWithCache = Platform & {
+    _c: Map<ReferenceElement, Element[]>;
+};
+export declare function getClippingRect(this: PlatformWithCache, { element, boundary, rootBoundary, strategy, }: {
+    element: Element;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    strategy: Strategy;
+}): Rect;
+export {};

package/dist/client/node_modules/@floating-ui/dom/src/utils/getComputedStyle.d.ts

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

package/dist/client/node_modules/@floating-ui/dom/src/utils/getCssDimensions.d.ts

@@ -0,0 +1,4 @@
+import type { Dimensions } from '@floating-ui/core';
+export declare function getCssDimensions(element: HTMLElement): Dimensions & {
+    fallback: boolean;
+};

package/dist/client/node_modules/@floating-ui/dom/src/utils/getDimensions.d.ts

@@ -0,0 +1,2 @@
+import type { Dimensions } from '@floating-ui/core';
+export declare function getDimensions(element: Element): Dimensions;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getDocumentElement.d.ts

@@ -0,0 +1 @@
+export declare function getDocumentElement(node: Node | Window): HTMLElement;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getDocumentRect.d.ts

@@ -0,0 +1,2 @@
+import type { Rect } from '@floating-ui/core';
+export declare function getDocumentRect(element: HTMLElement): Rect;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getNearestOverflowAncestor.d.ts

@@ -0,0 +1 @@
+export declare function getNearestOverflowAncestor(node: Node): HTMLElement;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getNodeName.d.ts

@@ -0,0 +1 @@
+export declare function getNodeName(node: Node | Window): string;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getNodeScroll.d.ts

@@ -0,0 +1,2 @@
+import { NodeScroll } from '../types';
+export declare function getNodeScroll(element: Element | Window): NodeScroll;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getOffsetParent.d.ts

@@ -0,0 +1 @@
+export declare function getOffsetParent(element: Element): Element | Window;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getOverflowAncestors.d.ts

@@ -0,0 +1,3 @@
+type OverflowAncestors = Array<Element | Window | VisualViewport>;
+export declare function getOverflowAncestors(node: Node, list?: OverflowAncestors): OverflowAncestors;
+export {};

package/dist/client/node_modules/@floating-ui/dom/src/utils/getParentNode.d.ts

@@ -0,0 +1 @@
+export declare function getParentNode(node: Node): Node;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getRectRelativeToOffsetParent.d.ts

@@ -0,0 +1,2 @@
+import type { Rect, Strategy, VirtualElement } from '@floating-ui/core';
+export declare function getRectRelativeToOffsetParent(element: Element | VirtualElement, offsetParent: Element | Window, strategy: Strategy): Rect;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getScale.d.ts

@@ -0,0 +1,7 @@
+import type { Coords } from '@floating-ui/core';
+import type { VirtualElement } from '../types';
+export declare const FALLBACK_SCALE: {
+    x: number;
+    y: number;
+};
+export declare function getScale(element: Element | VirtualElement): Coords;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getViewportRect.d.ts

@@ -0,0 +1,2 @@
+import type { Rect, Strategy } from '@floating-ui/core';
+export declare function getViewportRect(element: Element, strategy: Strategy): Rect;

package/dist/client/node_modules/@floating-ui/dom/src/utils/getWindowScrollBarX.d.ts

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

package/dist/client/node_modules/@floating-ui/dom/src/utils/is.d.ts

@@ -0,0 +1,17 @@
+declare global {
+    interface Window {
+        HTMLElement: any;
+        Element: any;
+        Node: any;
+        ShadowRoot: any;
+    }
+}
+export declare function isHTMLElement(value: any): value is HTMLElement;
+export declare function isElement(value: any): value is Element;
+export declare function isNode(value: any): value is Node;
+export declare function isShadowRoot(node: Node): node is ShadowRoot;
+export declare function isOverflowElement(element: Element): boolean;
+export declare function isTableElement(element: Element): boolean;
+export declare function isContainingBlock(element: Element): boolean;
+export declare function isLayoutViewport(): boolean;
+export declare function isLastTraversableNode(node: Node): boolean;

package/dist/client/node_modules/@floating-ui/dom/src/utils/math.d.ts

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

package/dist/client/node_modules/@floating-ui/dom/src/utils/unwrapElement.d.ts

@@ -0,0 +1,2 @@
+import type { VirtualElement } from '../types';
+export declare function unwrapElement(element: Element | VirtualElement): Element | undefined;

package/dist/client/node_modules/@floating-ui/dom/src/utils/userAgent.d.ts

@@ -0,0 +1 @@
+export declare function getUAString(): string;

package/dist/client/node_modules/@floating-ui/dom/src/utils/window.d.ts

@@ -0,0 +1 @@
+export declare function getWindow(node: Node): Window;

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

@@ -0,0 +1,105 @@
+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: Exclude<Padding, number>): 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<{
+    [K in Side]?: number | undefined;
+}>;
+
+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>) | undefined;
+    contextElement?: any;
+}
+
+export { }

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

@@ -0,0 +1,105 @@
+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: Exclude<Padding, number>): 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<{
+    [K in Side]?: number | undefined;
+}>;
+
+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>) | undefined;
+    contextElement?: any;
+}
+
+export { }

package/dist/client/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 { }

package/dist/client/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 { }

package/dist/client/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 { }

package/dist/client/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"
+}