@wirekyt/dom 0.0.1 → 0.0.2

package/dist/popper-DzBZzAe4.js

@@ -0,0 +1,464 @@
+import { S as getWindow, k as isHTMLElement } from "./dom-query-e7fh0TEH.js";
+import { t as getComputedStyle } from "./computed-style-B1MKlCoo.js";
+import { i as raf } from "./raf-Dhvm7f1e.js";
+import { $ as isNull, U as noop, t as compact } from "./utils-Cht5XaHf.js";
+import { arrow, autoUpdate, computePosition, flip, hide, limitShift, offset, shift, size } from "@floating-ui/dom";
+//#region src/common/popper/get-anchor.ts
+function createDOMRect(x = 0, y = 0, width = 0, height = 0) {
+	if (typeof DOMRect === "function") return new DOMRect(x, y, width, height);
+	const rect = {
+		x,
+		y,
+		width,
+		height,
+		top: y,
+		right: x + width,
+		bottom: y + height,
+		left: x
+	};
+	return {
+		...rect,
+		toJSON: () => rect
+	};
+}
+function getDOMRect(anchorRect) {
+	if (!anchorRect) return createDOMRect();
+	const { x, y, width, height } = anchorRect;
+	return createDOMRect(x, y, width, height);
+}
+function getAnchorElement(anchorElement, getAnchorRect) {
+	return {
+		contextElement: isHTMLElement(anchorElement) ? anchorElement : anchorElement?.contextElement,
+		getBoundingClientRect: () => {
+			const anchor = anchorElement;
+			const anchorRect = getAnchorRect?.(anchor);
+			if (anchorRect || !anchor) return getDOMRect(anchorRect);
+			return anchor.getBoundingClientRect();
+		}
+	};
+}
+//#endregion
+//#region src/common/popper/middleware.ts
+const toVar = (value) => ({
+	variable: value,
+	reference: `var(${value})`
+});
+const cssVars = {
+	arrowSize: toVar("--arrow-size"),
+	arrowSizeHalf: toVar("--arrow-size-half"),
+	arrowBg: toVar("--arrow-background"),
+	transformOrigin: toVar("--transform-origin"),
+	arrowOffset: toVar("--arrow-offset")
+};
+const getSideAxis = (side) => side === "top" || side === "bottom" ? "y" : "x";
+function createTransformOriginMiddleware(opts, arrowEl) {
+	return {
+		name: "transformOrigin",
+		fn(state) {
+			const { elements, middlewareData, placement, rects, y } = state;
+			const side = placement.split("-")[0];
+			const axis = getSideAxis(side);
+			const arrowX = middlewareData.arrow?.x || 0;
+			const arrowY = middlewareData.arrow?.y || 0;
+			const arrowWidth = arrowEl?.clientWidth || 0;
+			const arrowHeight = arrowEl?.clientHeight || 0;
+			const transformX = arrowX + arrowWidth / 2;
+			const transformY = arrowY + arrowHeight / 2;
+			const shiftY = Math.abs(middlewareData.shift?.y || 0);
+			const halfAnchorHeight = rects.reference.height / 2;
+			const arrowOffset = arrowHeight / 2;
+			const gutter = opts.offset?.mainAxis ?? opts.gutter;
+			const sideOffsetValue = typeof gutter === "number" ? gutter + arrowOffset : gutter ?? arrowOffset;
+			const isOverlappingAnchor = shiftY > sideOffsetValue;
+			const adjacentTransformOrigin = {
+				top: `${transformX}px calc(100% + ${sideOffsetValue}px)`,
+				bottom: `${transformX}px ${-sideOffsetValue}px`,
+				left: `calc(100% + ${sideOffsetValue}px) ${transformY}px`,
+				right: `${-sideOffsetValue}px ${transformY}px`
+			}[side];
+			const overlapTransformOrigin = `${transformX}px ${rects.reference.y + halfAnchorHeight - y}px`;
+			const useOverlap = Boolean(opts.overlap) && axis === "y" && isOverlappingAnchor;
+			elements.floating.style.setProperty(cssVars.transformOrigin.variable, useOverlap ? overlapTransformOrigin : adjacentTransformOrigin);
+			return { data: { transformOrigin: useOverlap ? overlapTransformOrigin : adjacentTransformOrigin } };
+		}
+	};
+}
+const rectMiddleware = {
+	name: "rects",
+	fn({ rects }) {
+		return { data: rects };
+	}
+};
+const shiftArrowMiddleware = (arrowEl) => {
+	if (!arrowEl) return;
+	return {
+		name: "shiftArrow",
+		fn({ placement, middlewareData }) {
+			if (!middlewareData.arrow) return {};
+			const { x, y } = middlewareData.arrow;
+			const dir = placement.split("-")[0];
+			Object.assign(arrowEl.style, {
+				left: x != null ? `${x}px` : "",
+				top: y != null ? `${y}px` : "",
+				[dir]: `calc(100% + ${cssVars.arrowOffset.reference})`
+			});
+			return {};
+		}
+	};
+};
+//#endregion
+//#region src/common/popper/placement.ts
+function isValidPlacement(v) {
+	return /^(?:top|bottom|left|right)(?:-(?:start|end))?$/.test(v);
+}
+function getPlacementDetails(placement) {
+	const [side, align] = placement.split("-");
+	return {
+		side,
+		align,
+		hasAlign: align != null
+	};
+}
+function getPlacementSide(placement) {
+	return placement.split("-")[0];
+}
+//#endregion
+//#region src/common/popper/get-placement.ts
+const defaultOptions = {
+	strategy: "absolute",
+	placement: "bottom",
+	listeners: true,
+	restoreStyles: false,
+	gutter: 8,
+	flip: true,
+	slide: true,
+	overlap: false,
+	sameWidth: false,
+	fitViewport: false,
+	overflowPadding: 8,
+	arrowPadding: 4
+};
+function roundByDpr(win, value) {
+	const dpr = win.devicePixelRatio || 1;
+	return Math.round(value * dpr) / dpr;
+}
+function isApproximatelyEqual(a, b) {
+	return a != null && Math.abs(a - b) < .5;
+}
+function resolveBoundaryOption(boundary) {
+	if (typeof boundary === "function") return boundary();
+	if (boundary === "clipping-ancestors") return "clippingAncestors";
+	return boundary;
+}
+function getArrowMiddleware(arrowElement, doc, opts) {
+	return arrow({
+		element: arrowElement || doc.createElement("div"),
+		padding: opts.arrowPadding
+	});
+}
+function getOffsetMiddleware(arrowElement, opts) {
+	if (isNull(opts.offset ?? opts.gutter)) return;
+	return offset(({ placement }) => {
+		const arrowOffset = (arrowElement?.clientHeight || 0) / 2;
+		const gutter = opts.offset?.mainAxis ?? opts.gutter;
+		const mainAxis = typeof gutter === "number" ? gutter + arrowOffset : gutter ?? arrowOffset;
+		const { hasAlign } = getPlacementDetails(placement);
+		const shift = !hasAlign ? opts.shift : void 0;
+		return compact({
+			crossAxis: opts.offset?.crossAxis ?? shift,
+			mainAxis,
+			alignmentAxis: opts.shift
+		});
+	});
+}
+function getFlipMiddleware(opts) {
+	if (!opts.flip) return;
+	return flip(() => {
+		const boundary = resolveBoundaryOption(opts.boundary);
+		return {
+			...boundary ? { boundary } : void 0,
+			padding: opts.overflowPadding,
+			fallbackPlacements: opts.flip === true ? void 0 : opts.flip
+		};
+	});
+}
+function getShiftMiddleware(opts) {
+	if (!opts.slide && !opts.overlap) return;
+	return shift(() => {
+		const boundary = resolveBoundaryOption(opts.boundary);
+		return {
+			...boundary ? { boundary } : void 0,
+			mainAxis: opts.slide,
+			crossAxis: opts.overlap,
+			padding: opts.overflowPadding,
+			limiter: limitShift()
+		};
+	});
+}
+function getSizeMiddleware(opts) {
+	if (opts.sizeMiddleware === false && !opts.sameWidth && !opts.fitViewport) return;
+	let lastReferenceWidth;
+	let lastReferenceHeight;
+	let lastAvailableWidth;
+	let lastAvailableHeight;
+	return size(() => {
+		const boundary = resolveBoundaryOption(opts.boundary);
+		return {
+			padding: opts.overflowPadding,
+			...boundary ? { boundary } : void 0,
+			apply({ elements, rects, availableHeight, availableWidth }) {
+				const floating = elements.floating;
+				const referenceWidth = Math.round(rects.reference.width);
+				const referenceHeight = Math.round(rects.reference.height);
+				availableWidth = Math.floor(availableWidth);
+				availableHeight = Math.floor(availableHeight);
+				if (!isApproximatelyEqual(lastReferenceWidth, referenceWidth)) {
+					floating.style.setProperty("--reference-width", `${referenceWidth}px`);
+					lastReferenceWidth = referenceWidth;
+				}
+				if (!isApproximatelyEqual(lastReferenceHeight, referenceHeight)) {
+					floating.style.setProperty("--reference-height", `${referenceHeight}px`);
+					lastReferenceHeight = referenceHeight;
+				}
+				if (!isApproximatelyEqual(lastAvailableWidth, availableWidth)) {
+					floating.style.setProperty("--available-width", `${availableWidth}px`);
+					lastAvailableWidth = availableWidth;
+				}
+				if (!isApproximatelyEqual(lastAvailableHeight, availableHeight)) {
+					floating.style.setProperty("--available-height", `${availableHeight}px`);
+					lastAvailableHeight = availableHeight;
+				}
+			}
+		};
+	});
+}
+function hideWhenDetachedMiddleware(opts) {
+	if (!opts.hideWhenDetached) return;
+	return hide(() => ({
+		strategy: "referenceHidden",
+		boundary: resolveBoundaryOption(opts.boundary) ?? "clippingAncestors"
+	}));
+}
+function getAutoUpdateOptions(opts) {
+	if (!opts) return {};
+	if (opts === true) return {
+		ancestorResize: true,
+		ancestorScroll: true,
+		elementResize: true,
+		layoutShift: true
+	};
+	return opts;
+}
+const floatingStyleProps = [
+	"transform",
+	"visibility",
+	"pointer-events",
+	"--x",
+	"--y",
+	"--z-index",
+	"--reference-width",
+	"--reference-height",
+	"--available-width",
+	"--available-height",
+	"--transform-origin"
+];
+const arrowStyleProps = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+function createStyleCleanup(el, props) {
+	if (!el) return noop;
+	const prev = new Map(props.map((prop) => [prop, el.style.getPropertyValue(prop)]));
+	return () => {
+		prev.forEach((value, prop) => {
+			if (value) el.style.setProperty(prop, value);
+			else el.style.removeProperty(prop);
+		});
+		if (el.style.length === 0) el.removeAttribute("style");
+	};
+}
+function anchorIdentity(anchor) {
+	if (anchor == null) return null;
+	if (isHTMLElement(anchor)) return anchor;
+	if (typeof anchor === "object" && anchor && "contextElement" in anchor && anchor.contextElement) return anchor.contextElement;
+	return anchor;
+}
+function getPlacementImpl(referenceOrVirtual, floatingOrVirtual, opts = {}) {
+	const resolveFloating = () => {
+		return (typeof floatingOrVirtual === "function" ? floatingOrVirtual() : floatingOrVirtual) ?? null;
+	};
+	const resolveAnchor = () => {
+		const raw = typeof referenceOrVirtual === "function" ? referenceOrVirtual() : referenceOrVirtual;
+		return opts.getAnchorElement?.() ?? raw;
+	};
+	const resolveReference = () => {
+		const anchor = resolveAnchor();
+		if (!anchor && !opts.getAnchorRect) return null;
+		return getAnchorElement(anchor, opts.getAnchorRect);
+	};
+	const options = Object.assign({}, defaultOptions, opts);
+	let middleware = [];
+	let cachedMiddlewareFloating = null;
+	let restoreFloatingStyles;
+	let restoreArrowStyles;
+	function rebuildMiddlewareForFloating(floating) {
+		restoreFloatingStyles?.();
+		restoreArrowStyles?.();
+		cachedMiddlewareFloating = floating;
+		restoreFloatingStyles = options.restoreStyles ? createStyleCleanup(floating, floatingStyleProps) : void 0;
+		const arrowEl = floating.querySelector("[data-part=arrow]");
+		restoreArrowStyles = options.restoreStyles ? createStyleCleanup(arrowEl, arrowStyleProps) : void 0;
+		middleware = [
+			getOffsetMiddleware(arrowEl, options),
+			getFlipMiddleware(options),
+			getShiftMiddleware(options),
+			getArrowMiddleware(arrowEl, floating.ownerDocument, options),
+			shiftArrowMiddleware(arrowEl),
+			createTransformOriginMiddleware({
+				gutter: options.gutter,
+				offset: options.offset,
+				overlap: options.overlap
+			}, arrowEl),
+			getSizeMiddleware(options),
+			hideWhenDetachedMiddleware(options),
+			rectMiddleware
+		];
+	}
+	const { placement, strategy, onComplete, onPositioned } = options;
+	let lastX;
+	let lastY;
+	let zIndexComputed = false;
+	let lastAnchorForObserve = void 0;
+	let lastFloatingForObserve = void 0;
+	let cancelAutoUpdate = noop;
+	const autoUpdateOptions = getAutoUpdateOptions(options.listeners);
+	function syncAutoUpdateObservers() {
+		if (!options.listeners) return;
+		const anchor = resolveAnchor();
+		const reference = resolveReference();
+		const floating = resolveFloating();
+		if (!reference || !floating) return;
+		if (anchorIdentity(anchor) !== anchorIdentity(lastAnchorForObserve) || floating !== lastFloatingForObserve) {
+			cancelAutoUpdate();
+			lastAnchorForObserve = anchor;
+			lastFloatingForObserve = floating;
+			cancelAutoUpdate = autoUpdate(reference, floating, runUpdate, autoUpdateOptions);
+		}
+	}
+	async function updatePosition() {
+		syncAutoUpdateObservers();
+		const floating = resolveFloating();
+		if (!floating) return;
+		if (floating !== cachedMiddlewareFloating) {
+			rebuildMiddlewareForFloating(floating);
+			zIndexComputed = false;
+		}
+		const reference = resolveReference();
+		if (!reference) return;
+		const pos = await computePosition(reference, floating, {
+			placement,
+			middleware,
+			strategy
+		});
+		onComplete?.(pos);
+		const win = getWindow(floating);
+		const x = roundByDpr(win, pos.x);
+		const y = roundByDpr(win, pos.y);
+		if (!isApproximatelyEqual(lastX, x)) {
+			floating.style.setProperty("--x", `${x}px`);
+			lastX = x;
+		}
+		if (!isApproximatelyEqual(lastY, y)) {
+			floating.style.setProperty("--y", `${y}px`);
+			lastY = y;
+		}
+		if (options.hideWhenDetached) if (pos.middlewareData.hide?.referenceHidden) {
+			floating.style.setProperty("visibility", "hidden");
+			floating.style.setProperty("pointer-events", "none");
+		} else {
+			floating.style.removeProperty("visibility");
+			floating.style.removeProperty("pointer-events");
+		}
+		if (!zIndexComputed) {
+			const contentEl = floating.firstElementChild;
+			if (contentEl) {
+				floating.style.setProperty("--z-index", getComputedStyle(contentEl).zIndex);
+				zIndexComputed = true;
+			}
+		}
+	}
+	async function runUpdate() {
+		if (opts.updatePosition) {
+			await opts.updatePosition({
+				updatePosition,
+				floatingElement: resolveFloating()
+			});
+			onPositioned?.({ placed: true });
+		} else await updatePosition();
+	}
+	runUpdate();
+	return () => {
+		cancelAutoUpdate();
+		restoreArrowStyles?.();
+		restoreFloatingStyles?.();
+		onPositioned?.({ placed: false });
+	};
+}
+function getPlacement(referenceOrFn, floatingOrFn, opts = {}) {
+	const { defer, ...options } = opts;
+	const func = defer ? raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		cleanups.push(getPlacementImpl(referenceOrFn, floatingOrFn, options));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+//#endregion
+//#region src/common/popper/get-styles.ts
+const ARROW_FLOATING_STYLE = {
+	bottom: "rotate(45deg)",
+	left: "rotate(135deg)",
+	top: "rotate(225deg)",
+	right: "rotate(315deg)"
+};
+function getPlacementStyles(options = {}) {
+	const { placement, sameWidth, fitViewport, strategy = "absolute" } = options;
+	return {
+		arrow: {
+			position: "absolute",
+			width: cssVars.arrowSize.reference,
+			height: cssVars.arrowSize.reference,
+			[cssVars.arrowSizeHalf.variable]: `calc(${cssVars.arrowSize.reference} / 2)`,
+			[cssVars.arrowOffset.variable]: `calc(${cssVars.arrowSizeHalf.reference} * -1)`
+		},
+		arrowTip: {
+			transform: placement ? ARROW_FLOATING_STYLE[placement.split("-")[0]] : void 0,
+			background: cssVars.arrowBg.reference,
+			top: "0",
+			left: "0",
+			width: "100%",
+			height: "100%",
+			position: "absolute",
+			zIndex: "inherit"
+		},
+		floating: {
+			position: strategy,
+			isolation: "isolate",
+			minWidth: sameWidth ? void 0 : "max-content",
+			width: sameWidth ? "var(--reference-width)" : void 0,
+			maxWidth: fitViewport ? "var(--available-width)" : void 0,
+			maxHeight: fitViewport ? "var(--available-height)" : void 0,
+			pointerEvents: !placement ? "none" : void 0,
+			top: "0px",
+			left: "0px",
+			transform: placement ? "translate3d(var(--x), var(--y), 0)" : "translate3d(0, -100vh, 0)",
+			zIndex: "var(--z-index)"
+		}
+	};
+}
+//#endregion
+export { isValidPlacement as i, getPlacement as n, getPlacementSide as r, getPlacementStyles as t };

package/dist/popper.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_popper = require("./popper-DkAAS9VE.cjs");
+exports.getPlacement = require_popper.getPlacement;
+exports.getPlacementSide = require_popper.getPlacementSide;
+exports.getPlacementStyles = require_popper.getPlacementStyles;
+exports.isValidPlacement = require_popper.isValidPlacement;

package/dist/popper.d.cts

@@ -0,0 +1,2 @@
+import { a as getPlacement, c as Boundary, d as PlacementAlign, f as PlacementSide, i as getPlacementStyles, l as ComputePositionReturn, n as isValidPlacement, o as AnchorRect, p as PositioningOptions, r as GetPlacementStylesOptions, s as AutoUpdateOptions, t as getPlacementSide, u as Placement } from "./index-3tNJficI.cjs";
+export { type AnchorRect, type AutoUpdateOptions, type Boundary, type ComputePositionReturn, type GetPlacementStylesOptions, type Placement, type PlacementAlign, type PlacementSide, type PositioningOptions, getPlacement, getPlacementSide, getPlacementStyles, isValidPlacement };

package/dist/popper.d.ts

@@ -0,0 +1,2 @@
+import { a as getPlacement, c as Boundary, d as PlacementAlign, f as PlacementSide, i as getPlacementStyles, l as ComputePositionReturn, n as isValidPlacement, o as AnchorRect, p as PositioningOptions, r as GetPlacementStylesOptions, s as AutoUpdateOptions, t as getPlacementSide, u as Placement } from "./index-3tNJficI.js";
+export { type AnchorRect, type AutoUpdateOptions, type Boundary, type ComputePositionReturn, type GetPlacementStylesOptions, type Placement, type PlacementAlign, type PlacementSide, type PositioningOptions, getPlacement, getPlacementSide, getPlacementStyles, isValidPlacement };

package/dist/popper.js

@@ -0,0 +1,2 @@
+import { i as isValidPlacement, n as getPlacement, r as getPlacementSide, t as getPlacementStyles } from "./popper-DzBZzAe4.js";
+export { getPlacement, getPlacementSide, getPlacementStyles, isValidPlacement };

package/dist/press-B7XLrLGR.js

@@ -0,0 +1,65 @@
+import { B as noop, C as isActiveElement, S as getWindow, V as pipe, p as contains } from "./dom-query-e7fh0TEH.js";
+import { i as getEventPoint, s as getEventTarget, t as addDomEvent } from "./event-bTItRgiw.js";
+//#region src/common/dom-query/press.ts
+function trackPress(options) {
+	const { pointerNode, keyboardNode = pointerNode, onPress, onPressStart, onPressEnd, isValidKey = (e) => e.key === "Enter" } = options;
+	if (!pointerNode) return noop;
+	const win = getWindow(pointerNode);
+	let removeStartListeners = noop;
+	let removeEndListeners = noop;
+	let removeAccessibleListeners = noop;
+	const getInfo = (event) => ({
+		point: getEventPoint(event),
+		event
+	});
+	function startPress(event) {
+		onPressStart?.(getInfo(event));
+	}
+	function cancelPress(event) {
+		onPressEnd?.(getInfo(event));
+	}
+	const startPointerPress = (startEvent) => {
+		removeEndListeners();
+		const endPointerPress = (endEvent) => {
+			const target = getEventTarget(endEvent);
+			if (contains(pointerNode, target)) onPress?.(getInfo(endEvent));
+			else onPressEnd?.(getInfo(endEvent));
+		};
+		removeEndListeners = pipe(addDomEvent(win, "pointerup", endPointerPress, {
+			passive: !onPress,
+			once: true
+		}), addDomEvent(win, "pointercancel", cancelPress, {
+			passive: !onPressEnd,
+			once: true
+		}));
+		if (isActiveElement(keyboardNode) && startEvent.pointerType === "mouse") startEvent.preventDefault();
+		startPress(startEvent);
+	};
+	removeStartListeners = pipe(addDomEvent(pointerNode, "pointerdown", startPointerPress, { passive: !onPressStart }), addDomEvent(keyboardNode, "focus", startAccessiblePress));
+	function startAccessiblePress() {
+		const handleKeydown = (keydownEvent) => {
+			if (!isValidKey(keydownEvent)) return;
+			const handleKeyup = (keyupEvent) => {
+				if (!isValidKey(keyupEvent)) return;
+				const evt = new win.PointerEvent("pointerup");
+				const info = getInfo(evt);
+				onPress?.(info);
+				onPressEnd?.(info);
+			};
+			removeEndListeners();
+			removeEndListeners = addDomEvent(keyboardNode, "keyup", handleKeyup);
+			startPress(new win.PointerEvent("pointerdown"));
+		};
+		const handleBlur = () => {
+			cancelPress(new win.PointerEvent("pointercancel"));
+		};
+		removeAccessibleListeners = pipe(addDomEvent(keyboardNode, "keydown", handleKeydown), addDomEvent(keyboardNode, "blur", handleBlur));
+	}
+	return () => {
+		removeStartListeners();
+		removeEndListeners();
+		removeAccessibleListeners();
+	};
+}
+//#endregion
+export { trackPress as t };

package/dist/press-BdD5suLQ.cjs

@@ -0,0 +1,70 @@
+const require_dom_query = require("./dom-query-CQzY93XU.cjs");
+const require_event = require("./event-DDz-mMhM.cjs");
+//#region src/common/dom-query/press.ts
+function trackPress(options) {
+	const { pointerNode, keyboardNode = pointerNode, onPress, onPressStart, onPressEnd, isValidKey = (e) => e.key === "Enter" } = options;
+	if (!pointerNode) return require_dom_query.noop;
+	const win = require_dom_query.getWindow(pointerNode);
+	let removeStartListeners = require_dom_query.noop;
+	let removeEndListeners = require_dom_query.noop;
+	let removeAccessibleListeners = require_dom_query.noop;
+	const getInfo = (event) => ({
+		point: require_event.getEventPoint(event),
+		event
+	});
+	function startPress(event) {
+		onPressStart?.(getInfo(event));
+	}
+	function cancelPress(event) {
+		onPressEnd?.(getInfo(event));
+	}
+	const startPointerPress = (startEvent) => {
+		removeEndListeners();
+		const endPointerPress = (endEvent) => {
+			const target = require_event.getEventTarget(endEvent);
+			if (require_dom_query.contains(pointerNode, target)) onPress?.(getInfo(endEvent));
+			else onPressEnd?.(getInfo(endEvent));
+		};
+		removeEndListeners = require_dom_query.pipe(require_event.addDomEvent(win, "pointerup", endPointerPress, {
+			passive: !onPress,
+			once: true
+		}), require_event.addDomEvent(win, "pointercancel", cancelPress, {
+			passive: !onPressEnd,
+			once: true
+		}));
+		if (require_dom_query.isActiveElement(keyboardNode) && startEvent.pointerType === "mouse") startEvent.preventDefault();
+		startPress(startEvent);
+	};
+	removeStartListeners = require_dom_query.pipe(require_event.addDomEvent(pointerNode, "pointerdown", startPointerPress, { passive: !onPressStart }), require_event.addDomEvent(keyboardNode, "focus", startAccessiblePress));
+	function startAccessiblePress() {
+		const handleKeydown = (keydownEvent) => {
+			if (!isValidKey(keydownEvent)) return;
+			const handleKeyup = (keyupEvent) => {
+				if (!isValidKey(keyupEvent)) return;
+				const evt = new win.PointerEvent("pointerup");
+				const info = getInfo(evt);
+				onPress?.(info);
+				onPressEnd?.(info);
+			};
+			removeEndListeners();
+			removeEndListeners = require_event.addDomEvent(keyboardNode, "keyup", handleKeyup);
+			startPress(new win.PointerEvent("pointerdown"));
+		};
+		const handleBlur = () => {
+			cancelPress(new win.PointerEvent("pointercancel"));
+		};
+		removeAccessibleListeners = require_dom_query.pipe(require_event.addDomEvent(keyboardNode, "keydown", handleKeydown), require_event.addDomEvent(keyboardNode, "blur", handleBlur));
+	}
+	return () => {
+		removeStartListeners();
+		removeEndListeners();
+		removeAccessibleListeners();
+	};
+}
+//#endregion
+Object.defineProperty(exports, "trackPress", {
+	enumerable: true,
+	get: function() {
+		return trackPress;
+	}
+});

package/dist/proxy-tab-focus-DWMXvAfO.js

@@ -0,0 +1,54 @@
+import { C as isActiveElement } from "./dom-query-e7fh0TEH.js";
+import { t as addDomEvent } from "./event-bTItRgiw.js";
+import { a as getNextTabbable, s as getTabbableEdges } from "./tabbable-CDA1YMjZ.js";
+import { i as raf } from "./raf-Dhvm7f1e.js";
+//#region src/common/dom-query/proxy-tab-focus.ts
+function proxyTabFocusImpl(container, options = {}) {
+	const { triggerElement, onFocus, onFocusEnter, getShadowRoot } = options;
+	const doc = container?.ownerDocument || document;
+	const body = doc.body;
+	function onKeyDown(event) {
+		if (event.key !== "Tab") return;
+		let elementToFocus = null;
+		const [firstTabbable, lastTabbable] = getTabbableEdges(container, {
+			includeContainer: true,
+			getShadowRoot
+		});
+		const nextTabbableAfterTrigger = getNextTabbable(body, {
+			current: triggerElement,
+			getShadowRoot
+		});
+		const noTabbableElements = !firstTabbable && !lastTabbable;
+		if (event.shiftKey && isActiveElement(nextTabbableAfterTrigger)) {
+			onFocusEnter?.();
+			elementToFocus = lastTabbable;
+		} else if (event.shiftKey && (isActiveElement(firstTabbable) || noTabbableElements)) elementToFocus = triggerElement;
+		else if (!event.shiftKey && isActiveElement(triggerElement)) {
+			onFocusEnter?.();
+			elementToFocus = firstTabbable;
+		} else if (!event.shiftKey && (isActiveElement(lastTabbable) || noTabbableElements)) elementToFocus = nextTabbableAfterTrigger;
+		if (!elementToFocus) return;
+		event.preventDefault();
+		if (typeof onFocus === "function") onFocus(elementToFocus);
+		else elementToFocus.focus();
+	}
+	return addDomEvent(doc, "keydown", onKeyDown, true);
+}
+function proxyTabFocus(container, options) {
+	const { defer, triggerElement, ...restOptions } = options;
+	const func = defer ? raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		const node = typeof container === "function" ? container() : container;
+		const trigger = typeof triggerElement === "function" ? triggerElement() : triggerElement;
+		cleanups.push(proxyTabFocusImpl(node, {
+			triggerElement: trigger,
+			...restOptions
+		}));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+//#endregion
+export { proxyTabFocus as t };