@vizejs/ui 0.387.0 → 0.388.0

package/dist/popover.mjs

@@ -0,0 +1,2 @@
+import { i as popover_root_default, n as popover_content_default, r as popover_arrow_default, t as popover_trigger_default } from "./popover-DeENBKXE.mjs";
+export { popover_root_default as Popover, popover_root_default as PopoverRoot, popover_arrow_default as PopoverArrow, popover_content_default as PopoverContent, popover_trigger_default as PopoverTrigger };

package/dist/portal-DeHaLxGL.mjs

@@ -0,0 +1,114 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { Teleport, computed, createBlock, createElementBlock, createElementVNode, defineComponent, inject, onMounted, onUnmounted, openBlock, provide, ref, renderSlot, shallowReadonly, shallowRef, unref, useTemplateRef } from "vue";
+//#region src/families/overlays/portal/portal-stack.ts
+/**
+* Injection key carrying the nesting depth of the closest portal ancestor.
+*
+* `Portal` provides `depth + 1` for its subtree, so nesting survives
+* relocation: injection follows the component tree, not the document.
+*/
+const portalDepthKey = Symbol("PortalDepth");
+let sequence = 0;
+const order = /* @__PURE__ */ new Map();
+const entries = shallowRef(Object.freeze([]));
+function sortedEntries() {
+	return Object.freeze([...order.keys()].sort((left, right) => {
+		if (left.depth !== right.depth) return left.depth - right.depth;
+		return (order.get(left) ?? 0) - (order.get(right) ?? 0);
+	}));
+}
+/**
+* Track one mounted portal layer and return its release callback.
+*
+* Registration happens client-side only (`Portal` registers on mount), so the
+* stack never accumulates request-global state during server rendering.
+*/
+function registerPortalLayer(entry) {
+	sequence += 1;
+	order.set(entry, sequence);
+	entries.value = sortedEntries();
+	return () => {
+		if (!order.delete(entry)) return;
+		entries.value = sortedEntries();
+	};
+}
+/**
+* Live, shared list of mounted portal layers.
+*
+* Entries are ordered shallow-to-deep (ties resolve by registration), so the
+* last entry is the layer that should sit on top.
+*/
+function usePortalStack() {
+	return shallowReadonly(entries);
+}
+/** The deepest (visually topmost) mounted portal layer, if any. */
+function topPortalLayer() {
+	return entries.value.at(-1) ?? null;
+}
+//#endregion
+//#region src/families/overlays/portal/portal.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = { "data-vize-ui": "portal-host" };
+const _hoisted_2 = ["data-vize-portal-depth"];
+//#endregion
+//#region src/families/overlays/portal/portal.vue
+var portal_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "portal",
+	props: {
+		to: {
+			type: null,
+			required: false,
+			default: "body"
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		defer: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const depth = inject(portalDepthKey, 0);
+		provide(portalDepthKey, depth + 1);
+		const hydrated = ref(false);
+		const element = useTemplateRef("element");
+		let releaseLayer = null;
+		onMounted(() => {
+			hydrated.value = true;
+			if (element.value) releaseLayer = registerPortalLayer({
+				depth,
+				element: element.value
+			});
+		});
+		onUnmounted(() => {
+			releaseLayer?.();
+			releaseLayer = null;
+		});
+		const teleportDisabled = computed(() => __props.disabled || !hydrated.value);
+		__expose({
+			depth,
+			element
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [(openBlock(), createBlock(Teleport, {
+				to: __props.to,
+				disabled: teleportDisabled.value,
+				defer: __props.defer
+			}, [createElementVNode("div", {
+				ref_key: "element",
+				ref: element,
+				"data-vize-ui": "portal",
+				"data-vize-portal-depth": unref(depth)
+			}, [renderSlot(_ctx.$slots, "default", {}, void 0, true)], 8, _hoisted_2)], 8, [
+				"to",
+				"disabled",
+				"defer"
+			]))]);
+		};
+	}
+}), [["__scopeId", "data-v-81fc0553"]]);
+//#endregion
+export { usePortalStack as a, topPortalLayer as i, portalDepthKey as n, registerPortalLayer as r, portal_default as t };

package/dist/portal-DhWXejr1.d.mts

@@ -0,0 +1,71 @@
+import { InjectionKey, ShallowRef } from "vue";
+
+//#region src/families/overlays/portal/portal-stack.d.ts
+/** One mounted portal layer tracked by the shared nested-portal stack. */
+interface PortalStackEntry {
+  /** Number of portal ancestors above this layer. Root portals report `0`. */
+  readonly depth: number;
+  /** Portalled node that hosts this layer's content. */
+  readonly element: HTMLElement;
+}
+/**
+ * Injection key carrying the nesting depth of the closest portal ancestor.
+ *
+ * `Portal` provides `depth + 1` for its subtree, so nesting survives
+ * relocation: injection follows the component tree, not the document.
+ */
+declare const portalDepthKey: InjectionKey<number>;
+/**
+ * Track one mounted portal layer and return its release callback.
+ *
+ * Registration happens client-side only (`Portal` registers on mount), so the
+ * stack never accumulates request-global state during server rendering.
+ */
+declare function registerPortalLayer(entry: PortalStackEntry): () => void;
+/**
+ * Live, shared list of mounted portal layers.
+ *
+ * Entries are ordered shallow-to-deep (ties resolve by registration), so the
+ * last entry is the layer that should sit on top.
+ */
+declare function usePortalStack(): Readonly<ShallowRef<readonly PortalStackEntry[]>>;
+/** The deepest (visually topmost) mounted portal layer, if any. */
+declare function topPortalLayer(): PortalStackEntry | null;
+//#endregion
+//#region src/families/overlays/portal/portal.vue.d.ts
+type __VLS_Props = {
+  /**
+   * CSS selector or element the content is moved into.
+   *
+   * @default "body"
+   */
+  readonly to?: string | HTMLElement;
+  /**
+   * Render in place instead of moving the content.
+   *
+   * @default false
+   */
+  readonly disabled?: boolean;
+  /**
+   * Keep content in place until the target exists, avoiding SSR mismatch.
+   *
+   * @default true
+   */
+  readonly defer?: boolean;
+};
+type __VLS_Slots = {
+  /** Portalled contents. */default(): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+  depth: number;
+  element: Readonly<import("vue").ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { topPortalLayer as a, registerPortalLayer as i, PortalStackEntry as n, usePortalStack as o, portalDepthKey as r, _default as t };

package/dist/portal.d.mts

@@ -0,0 +1,2 @@
+import { a as topPortalLayer, i as registerPortalLayer, n as PortalStackEntry, o as usePortalStack, r as portalDepthKey, t as _default } from "./portal-DhWXejr1.mjs";
+export { _default as Portal, type PortalStackEntry, portalDepthKey, registerPortalLayer, topPortalLayer, usePortalStack };

package/dist/portal.mjs

@@ -0,0 +1,2 @@
+import { a as usePortalStack, i as topPortalLayer, n as portalDepthKey, r as registerPortalLayer, t as portal_default } from "./portal-DeHaLxGL.mjs";
+export { portal_default as Portal, portalDepthKey, registerPortalLayer, topPortalLayer, usePortalStack };

package/dist/positioner-BYJVA3Uy.d.mts

@@ -0,0 +1,477 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/families/overlays/positioner/positioner-types.d.ts
+/** Axis a floating element prefers relative to its reference. */
+type PlacementSide = "bottom" | "left" | "right" | "top";
+/** Alignment along the cross axis. */
+type PlacementAlign = "center" | "end" | "start";
+/**
+ * Named placement used by the positioner.
+ *
+ * Spelled as an explicit union (rather than a template-literal cross of
+ * side and align) so SFC prop-default checking can evaluate membership.
+ */
+type Placement = PlacementSide | "bottom-center" | "bottom-end" | "bottom-start" | "left-center" | "left-end" | "left-start" | "right-center" | "right-end" | "right-start" | "top-center" | "top-end" | "top-start";
+/** How floating coordinates are published to CSS. */
+type PositionerStrategy = "absolute" | "fixed";
+/** Axis-aligned box in viewport coordinates. */
+interface Rect {
+  readonly height: number;
+  readonly width: number;
+  readonly x: number;
+  readonly y: number;
+}
+/** Per-edge insets applied to the active viewport. */
+interface SafeAreaInsets {
+  readonly bottom: number;
+  readonly left: number;
+  readonly right: number;
+  readonly top: number;
+}
+/** Space a floating element may occupy at a resolved placement. */
+interface AvailableSize {
+  readonly height: number;
+  readonly width: number;
+}
+/** Inputs for the pure available-space measurement. */
+interface AvailableSizeInput {
+  /**
+   * Viewport padding the floating element should not cross.
+   *
+   * @default 0
+   */
+  readonly collisionPadding?: number;
+  /**
+   * Gap on the main axis between reference and floating.
+   *
+   * @default 0
+   */
+  readonly offset?: number;
+  /** Placement after collision handling. */
+  readonly placement: Placement;
+  /** Reference box. */
+  readonly reference: Rect;
+  /** Visible viewport the floating element must stay inside. */
+  readonly viewport: Rect;
+}
+/** Measurement source accepted in place of a live element. */
+interface VirtualElement {
+  readonly getBoundingClientRect: () => Rect | DOMRect;
+}
+/** Reference or floating node the positioner can measure. */
+type PositionerElement = Element | VirtualElement;
+/** Inputs for the pure collision solver. */
+interface ComputePositionInput {
+  /**
+   * Arrow box used to clamp the arrow along the facing edge.
+   *
+   * @default null
+   */
+  readonly arrow?: Rect | null;
+  /**
+   * Inset kept between the arrow and floating edges.
+   *
+   * @default 0
+   */
+  readonly arrowPadding?: number;
+  /**
+   * Viewport padding the floating element should not cross.
+   *
+   * @default 0
+   */
+  readonly collisionPadding?: number;
+  /**
+   * Flip to the opposite side when the preferred side overflows more.
+   *
+   * @default true
+   */
+  readonly flip?: boolean;
+  /** Measured floating size. */
+  readonly floating: Pick<Rect, "height" | "width">;
+  /**
+   * Hide when the reference no longer intersects the viewport.
+   *
+   * @default true
+   */
+  readonly hide?: boolean;
+  /**
+   * Gap on the main axis between reference and floating.
+   *
+   * @default 0
+   */
+  readonly offset?: number;
+  /**
+   * Preferred placement before collision handling.
+   *
+   * @default "bottom"
+   */
+  readonly placement?: Placement;
+  /** Reference box. */
+  readonly reference: Rect;
+  /**
+   * Mirror start/end on horizontal placements.
+   *
+   * @default false
+   */
+  readonly rtl?: boolean;
+  /**
+   * Shift the floating box back into the viewport after flip.
+   *
+   * @default true
+   */
+  readonly shift?: boolean;
+  /** Visible viewport the floating element must stay inside. */
+  readonly viewport: Rect;
+}
+/** Result of {@link computePosition}. */
+interface ComputePositionResult {
+  readonly arrowX: number | null;
+  readonly arrowY: number | null;
+  readonly hidden: boolean;
+  readonly overflow: Readonly<{
+    readonly bottom: number;
+    readonly left: number;
+    readonly right: number;
+    readonly top: number;
+  }>;
+  readonly placement: Placement;
+  readonly x: number;
+  readonly y: number;
+}
+/** Options shared by {@link createPositioner} and {@link usePositioner}. */
+interface PositionerOptions {
+  /**
+   * Inset kept between the arrow and floating edges.
+   *
+   * @default 0
+   */
+  readonly arrowPadding?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Viewport padding the floating element should not cross.
+   *
+   * @default 0
+   */
+  readonly collisionPadding?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Writing direction used to resolve start/end alignment.
+   *
+   * @default "ltr"
+   */
+  readonly direction?: MaybeRefOrGetter<"ltr" | "rtl" | undefined>;
+  /**
+   * Flip to the opposite side when the preferred side overflows more.
+   *
+   * @default true
+   */
+  readonly flip?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Hide when the reference no longer intersects the viewport.
+   *
+   * @default true
+   */
+  readonly hide?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Gap on the main axis between reference and floating.
+   *
+   * @default 0
+   */
+  readonly offset?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Preferred placement before collision handling.
+   *
+   * @default "bottom"
+   */
+  readonly placement?: MaybeRefOrGetter<Placement | undefined>;
+  /**
+   * Inset the active viewport by `env(safe-area-inset-*)` before collision
+   * handling, keeping floating content clear of notches and rounded corners.
+   *
+   * @default false
+   */
+  readonly safeArea?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Shift the floating box back into the viewport after flip.
+   *
+   * @default true
+   */
+  readonly shift?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Constrain the floating host to the available space with
+   * `max-width`/`max-height` and publish
+   * `--vize-ui-positioner-available-width` and
+   * `--vize-ui-positioner-available-height` custom properties.
+   *
+   * @default false
+   */
+  readonly size?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * CSS positioning mode published on the floating host.
+   *
+   * @default "fixed"
+   */
+  readonly strategy?: MaybeRefOrGetter<PositionerStrategy | undefined>;
+  /**
+   * Recalculate when the document or visual viewport resizes.
+   *
+   * @default true
+   */
+  readonly updateOnResize?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Recalculate while ancestors scroll.
+   *
+   * @default true
+   */
+  readonly updateOnScroll?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Viewport used for flip, shift, and hide. Defaults to the visual viewport.
+   *
+   * @default undefined
+   */
+  readonly viewport?: MaybeRefOrGetter<Rect | undefined>;
+}
+/** Inline style string spread onto the floating host. */
+type PositionerStyle = string;
+/** Inline style string spread onto the arrow. */
+type PositionerArrowStyle = string;
+/** Stateful collision-aware floating placement controller. */
+interface PositionerController {
+  /** Arrow coordinates relative to the floating origin, when measured. */
+  readonly arrowX: Readonly<ShallowRef<number | null>>;
+  /** Available height at the resolved placement, once measured. */
+  readonly availableHeight: Readonly<ShallowRef<number | null>>;
+  /** Available width at the resolved placement, once measured. */
+  readonly availableWidth: Readonly<ShallowRef<number | null>>;
+  /** Arrow coordinates relative to the floating origin, when measured. */
+  readonly arrowY: Readonly<ShallowRef<number | null>>;
+  /** Stable inline styles for the arrow node. */
+  readonly arrowStyle: Readonly<ShallowRef<PositionerArrowStyle>>;
+  /** Release listeners and freeze the controller. */
+  readonly dispose: () => void;
+  /** Whether the reference is considered off-screen. */
+  readonly hidden: Readonly<ShallowRef<boolean>>;
+  /** Whether coordinates have been measured at least once. */
+  readonly ready: Readonly<ShallowRef<boolean>>;
+  /** Placement after flip. */
+  readonly resolvedPlacement: Readonly<ShallowRef<Placement>>;
+  /** Bind the arrow node used for clamping. */
+  readonly setArrow: (element: PositionerElement | null) => void;
+  /** Bind the floating node that occupies the positioned box. */
+  readonly setFloating: (element: PositionerElement | null) => void;
+  /** Bind the reference node or virtual element. */
+  readonly setReference: (element: PositionerElement | null) => void;
+  /** CSS strategy currently applied. */
+  readonly strategy: Readonly<ShallowRef<PositionerStrategy>>;
+  /** Stable inline styles for the floating host. */
+  readonly style: Readonly<ShallowRef<PositionerStyle>>;
+  /** Recompute from the latest measurements. */
+  readonly update: () => void;
+  /** Viewport-relative (or offset-parent-relative) x. */
+  readonly x: Readonly<ShallowRef<number>>;
+  /** Viewport-relative (or offset-parent-relative) y. */
+  readonly y: Readonly<ShallowRef<number>>;
+}
+//#endregion
+//#region src/families/overlays/positioner/positioner-geometry.d.ts
+/** Parse a placement token into side and alignment. */
+declare function parsePlacement(placement: Placement): {
+  readonly align: PlacementAlign;
+  readonly side: PlacementSide;
+};
+/**
+ * Place a floating box next to a reference, flipping and shifting to stay in view.
+ */
+declare function computePosition(input: ComputePositionInput): ComputePositionResult;
+/** Normalize DOMRect-like measurements into a plain {@link Rect}. */
+declare function readRect(value: Rect | DOMRect): Rect;
+//#endregion
+//#region src/families/overlays/positioner/positioner-runtime.d.ts
+/** Create an SSR-safe floating placement controller. */
+declare function createPositioner(options?: PositionerOptions): PositionerController;
+/** Create a positioner disposed with the current Vue effect scope. */
+declare function usePositioner(options?: PositionerOptions): PositionerController;
+//#endregion
+//#region src/families/overlays/positioner/positioner-size.d.ts
+/**
+ * Measure the space a floating element may occupy at a resolved placement.
+ *
+ * The main axis stops at the reference edge (minus the configured offset);
+ * the cross axis spans the viewport. Both respect the collision padding and
+ * never go negative, mirroring how flip and shift read the same viewport.
+ */
+declare function computeAvailableSize(input: AvailableSizeInput): AvailableSize;
+/**
+ * Publish available space as host constraints and CSS custom properties.
+ *
+ * The returned fragment is appended to the floating host style when the
+ * `size` strategy is enabled: `max-width`/`max-height` clamp the box while
+ * `--vize-ui-positioner-available-width` and
+ * `--vize-ui-positioner-available-height` stay consumable from consumer CSS.
+ */
+declare function sizeStyle(size: AvailableSize): string;
+//#endregion
+//#region src/families/overlays/positioner/positioner-viewport.d.ts
+/** Insets that leave the viewport untouched. */
+declare const zeroSafeAreaInsets: SafeAreaInsets;
+/**
+ * The visible viewport in page coordinates.
+ *
+ * `visualViewport` already excludes on-screen keyboards and follows
+ * pinch-zoom, so collision handling tracks what the user actually sees.
+ * Server rendering (no `document`) reports an empty box.
+ */
+declare function visualViewportRect(): Rect;
+/** Shrink a viewport box by per-edge insets, never below an empty box. */
+declare function insetViewport(viewport: Rect, insets: SafeAreaInsets): Rect;
+/**
+ * Read `env(safe-area-inset-*)` through a computed-style probe.
+ *
+ * CSS environment variables are not scriptable, so a hidden fixed probe is
+ * measured and removed synchronously. Environments without a document or
+ * without `env()` support report zero insets, keeping the read SSR-safe.
+ */
+declare function readSafeAreaInsets(targetDocument?: Document | null): SafeAreaInsets;
+//#endregion
+//#region src/families/overlays/positioner/positioner.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Reference element or virtual box the floating content is placed against.
+   *
+   * @default null
+   */
+  readonly reference?: PositionerElement | null;
+  /**
+   * Preferred placement before collision handling.
+   *
+   * @default "bottom"
+   */
+  readonly placement?: Placement;
+  /**
+   * CSS positioning mode published on the floating host.
+   *
+   * @default "fixed"
+   */
+  readonly strategy?: PositionerStrategy;
+  /**
+   * Gap on the main axis between reference and floating.
+   *
+   * @default 0
+   */
+  readonly offset?: number;
+  /**
+   * Viewport padding the floating element should not cross.
+   *
+   * @default 0
+   */
+  readonly collisionPadding?: number;
+  /**
+   * Inset kept between the arrow and floating edges.
+   *
+   * @default 0
+   */
+  readonly arrowPadding?: number;
+  /**
+   * Writing direction used to resolve start/end alignment.
+   *
+   * @default "ltr"
+   */
+  readonly direction?: "ltr" | "rtl";
+  /**
+   * Flip to the opposite side when the preferred side overflows more.
+   *
+   * @default true
+   */
+  readonly flip?: boolean;
+  /**
+   * Shift the floating box back into the viewport after flip.
+   *
+   * @default true
+   */
+  readonly shift?: boolean;
+  /**
+   * Constrain the host to the available space with `max-width`/`max-height`
+   * and publish `--vize-ui-positioner-available-width` and
+   * `--vize-ui-positioner-available-height` custom properties.
+   *
+   * @default false
+   */
+  readonly size?: boolean;
+  /**
+   * Inset the active viewport by `env(safe-area-inset-*)` before collision
+   * handling, keeping floating content clear of notches and rounded corners.
+   *
+   * @default false
+   */
+  readonly safeArea?: boolean;
+  /**
+   * Hide when the reference no longer intersects the viewport.
+   *
+   * @default true
+   */
+  readonly hide?: boolean;
+  /**
+   * Recalculate while ancestors scroll.
+   *
+   * @default true
+   */
+  readonly updateOnScroll?: boolean;
+  /**
+   * Recalculate when the document or visual viewport resizes.
+   *
+   * @default true
+   */
+  readonly updateOnResize?: boolean;
+  /**
+   * Viewport used for flip, shift, and hide. Defaults to the visual viewport.
+   *
+   * @default undefined
+   */
+  readonly viewport?: Rect;
+};
+type __VLS_Slots$1 = {
+  /** Floating contents. Receives resolved placement for styling hooks. */default(props: {
+    readonly placement: Placement;
+    readonly ready: boolean;
+  }): unknown;
+};
+declare const __VLS_base$1: import("vue").DefineComponent<__VLS_Props, {
+  arrowStyle: Readonly<import("vue").ShallowRef<string>>;
+  availableHeight: Readonly<import("vue").ShallowRef<number | null>>;
+  availableWidth: Readonly<import("vue").ShallowRef<number | null>>;
+  element: Readonly<import("vue").ShallowRef<HTMLDivElement | null>>;
+  hidden: Readonly<import("vue").ShallowRef<boolean>>;
+  ready: Readonly<import("vue").ShallowRef<boolean>>;
+  resolvedPlacement: Readonly<import("vue").ShallowRef<Placement>>;
+  style: Readonly<import("vue").ShallowRef<string>>;
+  update: () => void;
+  x: Readonly<import("vue").ShallowRef<number>>;
+  y: Readonly<import("vue").ShallowRef<number>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$1: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/overlays/positioner/positioner-arrow.vue.d.ts
+type __VLS_Slots = {
+  /** Decorative arrow contents. Receives coordinates for optional custom drawing. */default(props: {
+    readonly x: number | null;
+    readonly y: number | null;
+  }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {
+  element: Readonly<import("vue").ShallowRef<HTMLDivElement | null>>;
+  x: Readonly<import("vue").ShallowRef<number | null>>;
+  y: Readonly<import("vue").ShallowRef<number | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { PositionerElement as C, Rect as D, PositionerStyle as E, SafeAreaInsets as O, PositionerController as S, PositionerStrategy as T, ComputePositionResult as _, visualViewportRect as a, PlacementSide as b, sizeStyle as c, computePosition as d, parsePlacement as f, ComputePositionInput as g, AvailableSizeInput as h, readSafeAreaInsets as i, VirtualElement as k, createPositioner as l, AvailableSize as m, _default$1 as n, zeroSafeAreaInsets as o, readRect as p, insetViewport as r, computeAvailableSize as s, _default as t, usePositioner as u, Placement as v, PositionerOptions as w, PositionerArrowStyle as x, PlacementAlign as y };