@sprawlify/primitives 0.0.1

package/dist/index-C9-feK5c.d.cts

@@ -0,0 +1,25 @@
+//#region src/shared/interact-outside/index.d.ts
+interface InteractOutsideHandlers {
+  onPointerDownOutside?: ((event: PointerDownOutsideEvent) => void) | undefined;
+  onFocusOutside?: ((event: FocusOutsideEvent) => void) | undefined;
+  onInteractOutside?: ((event: InteractOutsideEvent) => void) | undefined;
+}
+interface InteractOutsideOptions extends InteractOutsideHandlers {
+  exclude?: ((target: HTMLElement) => boolean) | undefined;
+  defer?: boolean | undefined;
+  followControlledElements?: boolean | undefined;
+}
+interface EventDetails<T> {
+  originalEvent: T;
+  contextmenu: boolean;
+  focusable: boolean;
+  target: EventTarget;
+}
+type PointerDownOutsideEvent = CustomEvent<EventDetails<PointerEvent>>;
+type FocusOutsideEvent = CustomEvent<EventDetails<FocusEvent>>;
+type InteractOutsideEvent = PointerDownOutsideEvent | FocusOutsideEvent;
+type MaybeElement = HTMLElement | null | undefined;
+type NodeOrFn = MaybeElement | (() => MaybeElement);
+declare function trackInteractOutside(nodeOrFn: NodeOrFn, options: InteractOutsideOptions): () => void;
+//#endregion
+export { InteractOutsideOptions as a, PointerDownOutsideEvent as c, InteractOutsideHandlers as i, trackInteractOutside as l, FocusOutsideEvent as n, MaybeElement as o, InteractOutsideEvent as r, NodeOrFn as s, EventDetails as t };

package/dist/index-CD5FN7kY.d.mts

@@ -0,0 +1,114 @@
+import * as _internationalized_date0 from "@internationalized/date";
+import { Calendar, DateDuration, DateFormatter, DateValue } from "@internationalized/date";
+
+//#region src/shared/date-utils/types.d.ts
+type DateGranularity = "day" | "hour" | "minute" | "second" | "year" | "month";
+type DateAlignment = "start" | "end" | "center";
+type DateAvailableFn = (date: DateValue, locale: string) => boolean;
+type DateAdjustFn = (options: {
+  startDate: DateValue;
+  focusedDate: DateValue;
+}) => {
+  startDate: DateValue;
+  focusedDate: DateValue;
+  endDate: DateValue;
+};
+type DateRangePreset = "thisWeek" | "lastWeek" | "thisMonth" | "lastMonth" | "thisQuarter" | "lastQuarter" | "thisYear" | "lastYear" | "last3Days" | "last7Days" | "last14Days" | "last30Days" | "last90Days";
+//#endregion
+//#region src/shared/date-utils/align.d.ts
+declare function alignDate(date: DateValue, alignment: DateAlignment, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): DateValue;
+declare function alignStartDate(date: DateValue, startDate: DateValue, endDate: DateValue, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): DateValue;
+//#endregion
+//#region src/shared/date-utils/assertion.d.ts
+declare function isDateEqual(dateA: DateValue | null | undefined, dateB?: DateValue | null): boolean;
+declare function isDateUnavailable(date: DateValue | null, isUnavailable: DateAvailableFn | undefined, locale: string, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isDateOutsideRange(date: DateValue, startDate?: DateValue | null, endDate?: DateValue | null): boolean;
+declare function isPreviousRangeInvalid(startDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isNextRangeInvalid(endDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+//#endregion
+//#region src/shared/date-utils/constrain.d.ts
+declare function alignCenter(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignStart(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignEnd(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainStart(date: DateValue, aligned: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainValue(date: DateValue, minValue?: DateValue, maxValue?: DateValue): DateValue;
+//#endregion
+//#region src/shared/date-utils/duration.d.ts
+declare function getUnitDuration(duration: DateDuration): {
+  years?: number;
+  months?: number;
+  weeks?: number;
+  days?: number;
+};
+declare function getEndDate(startDate: DateValue, duration: DateDuration): _internationalized_date0.CalendarDate | _internationalized_date0.CalendarDateTime | _internationalized_date0.ZonedDateTime;
+//#endregion
+//#region src/shared/date-utils/format.d.ts
+declare function formatRange(startDate: DateValue, endDate: DateValue, formatter: DateFormatter, toString: (start: string, end: string) => string, timeZone: string): string;
+declare function formatSelectedDate(startDate: DateValue | null | undefined, endDate: DateValue | null, locale: string, timeZone: string): string;
+declare function formatVisibleRange(startDate: DateValue, endDate: DateValue | null, locale: string, timeZone: string): string;
+//#endregion
+//#region src/shared/date-utils/formatter.d.ts
+declare function getDayFormatter(locale: string, timeZone: string): DateFormatter;
+declare function getMonthFormatter(locale: string, timeZone: string): DateFormatter;
+//#endregion
+//#region src/shared/date-utils/date-month.d.ts
+declare function getStartOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getEndOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getDaysInWeek(weekIndex: number, from: DateValue, locale: string, firstDayOfWeek?: number): DateValue[];
+declare function getMonthDays(from: DateValue, locale: string, numOfWeeks?: number, firstDayOfWeek?: number): DateValue[][];
+declare function getWeekdayFormats(locale: string, timeZone: string): <T extends DateValue | Date>(value: T) => {
+  value: T;
+  short: string;
+  long: string;
+  narrow: string;
+};
+declare function getWeekDays(date: DateValue, startOfWeekProp: number | undefined, timeZone: string, locale: string): {
+  value: _internationalized_date0.CalendarDate | _internationalized_date0.CalendarDateTime | _internationalized_date0.ZonedDateTime;
+  short: string;
+  long: string;
+  narrow: string;
+}[];
+declare function getMonthNames(locale: string, format?: Intl.DateTimeFormatOptions["month"]): string[];
+//#endregion
+//#region src/shared/date-utils/date-year.d.ts
+interface YearsRange {
+  from: number;
+  to: number;
+}
+declare function getYearsRange(range: YearsRange): number[];
+declare function normalizeYear(year: string | null | undefined): string | undefined;
+declare function getDecadeRange(year: number, opts?: {
+  strict?: boolean;
+}): number[];
+//#endregion
+//#region src/shared/date-utils/mutation.d.ts
+declare function getTodayDate(timeZone?: string): _internationalized_date0.CalendarDate;
+declare function setCalendar(date: DateValue, calendar: Calendar): _internationalized_date0.CalendarDateTime;
+declare function setDate(date: DateValue, startDate: DateValue, isDateUnavailable: DateAvailableFn, locale: string, minValue: DateValue, maxValue: DateValue): DateValue | undefined;
+declare function getPreviousAvailableDate(date: DateValue, minValue: DateValue, locale: string, isDateUnavailable?: DateAvailableFn): DateValue | undefined;
+//#endregion
+//#region src/shared/date-utils/pagination.d.ts
+interface AdjustDateParams {
+  startDate: DateValue;
+  focusedDate: DateValue;
+}
+interface AdjustDateReturn extends AdjustDateParams {
+  endDate: DateValue;
+}
+declare function getAdjustedDateFn(visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): (options: AdjustDateParams) => AdjustDateReturn;
+declare function getNextPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn;
+declare function getPreviousPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn;
+declare function getNextRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getPreviousRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getSectionStart(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getSectionEnd(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getNextSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getPreviousSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+//#endregion
+//#region src/shared/date-utils/parse-date.d.ts
+declare function parseDateString(date: string, locale: string, timeZone: string): DateValue | undefined;
+//#endregion
+//#region src/shared/date-utils/preset.d.ts
+declare function getDateRangePreset(preset: DateRangePreset, locale: string, timeZone: string): [DateValue, DateValue];
+//#endregion
+export { getMonthFormatter as A, constrainValue as B, getEndOfWeek as C, getWeekDays as D, getStartOfWeek as E, getUnitDuration as F, isPreviousRangeInvalid as G, isDateOutsideRange as H, alignCenter as I, DateAdjustFn as J, alignDate as K, alignEnd as L, formatSelectedDate as M, formatVisibleRange as N, getWeekdayFormats as O, getEndDate as P, alignStart as R, getDaysInWeek as S, getMonthNames as T, isDateUnavailable as U, isDateEqual as V, isNextRangeInvalid as W, DateRangePreset as X, DateGranularity as Y, setDate as _, getAdjustedDateFn as a, getYearsRange as b, getNextSection as c, getPreviousSection as d, getSectionEnd as f, setCalendar as g, getTodayDate as h, AdjustDateReturn as i, formatRange as j, getDayFormatter as k, getPreviousPage as l, getPreviousAvailableDate as m, parseDateString as n, getNextPage as o, getSectionStart as p, alignStartDate as q, AdjustDateParams as r, getNextRow as s, getDateRangePreset as t, getPreviousRow as u, YearsRange as v, getMonthDays as w, normalizeYear as x, getDecadeRange as y, constrainStart as z };

package/dist/index-CJji6wHl.d.cts

@@ -0,0 +1,15 @@
+//#region src/shared/live-region/index.d.ts
+interface LiveRegionOptions {
+  level: "polite" | "assertive";
+  document?: Document | undefined;
+  root?: HTMLElement | null | undefined;
+  delay?: number | undefined;
+}
+type LiveRegion = ReturnType<typeof createLiveRegion>;
+declare function createLiveRegion(opts?: Partial<LiveRegionOptions>): {
+  announce: (message: string, delay?: number) => void;
+  destroy: () => void;
+  toJSON(): string;
+};
+//#endregion
+export { LiveRegionOptions as n, createLiveRegion as r, LiveRegion as t };

package/dist/index-CNi5FkPe.d.mts

@@ -0,0 +1,15 @@
+//#region src/shared/live-region/index.d.ts
+interface LiveRegionOptions {
+  level: "polite" | "assertive";
+  document?: Document | undefined;
+  root?: HTMLElement | null | undefined;
+  delay?: number | undefined;
+}
+type LiveRegion = ReturnType<typeof createLiveRegion>;
+declare function createLiveRegion(opts?: Partial<LiveRegionOptions>): {
+  announce: (message: string, delay?: number) => void;
+  destroy: () => void;
+  toJSON(): string;
+};
+//#endregion
+export { LiveRegionOptions as n, createLiveRegion as r, LiveRegion as t };

package/dist/index-D96rs8B0.d.mts

@@ -0,0 +1,115 @@
+import { AutoUpdateOptions, Boundary, ComputePositionReturn, Placement, Placement as Placement$1, VirtualElement } from "@floating-ui/dom";
+
+//#region src/shared/popper/types.d.ts
+type MaybeRectElement = HTMLElement | VirtualElement | null;
+type MaybeElement = HTMLElement | null;
+type MaybeFn<T> = T | (() => T);
+type PlacementSide = "top" | "right" | "bottom" | "left";
+type PlacementAlign = "start" | "center" | "end";
+interface AnchorRect {
+  x?: number | undefined;
+  y?: number | undefined;
+  width?: number | undefined;
+  height?: number | undefined;
+}
+interface PositioningOptions {
+  hideWhenDetached?: boolean | undefined;
+  strategy?: "absolute" | "fixed" | undefined;
+  placement?: Placement$1 | undefined;
+  offset?: {
+    mainAxis?: number | undefined;
+    crossAxis?: number | undefined;
+  } | undefined;
+  gutter?: number | undefined;
+  shift?: number | undefined;
+  overflowPadding?: number | undefined;
+  arrowPadding?: number | undefined;
+  flip?: boolean | Placement$1[] | undefined;
+  slide?: boolean | undefined;
+  overlap?: boolean | undefined;
+  sameWidth?: boolean | undefined;
+  fitViewport?: boolean | undefined;
+  boundary?: (() => Boundary) | Boundary | "clipping-ancestors" | undefined;
+  listeners?: boolean | AutoUpdateOptions | undefined;
+  onComplete?: ((data: ComputePositionReturn) => void) | undefined;
+  onPositioned?: ((data: {
+    placed: boolean;
+  }) => void) | undefined;
+  getAnchorRect?: ((element: HTMLElement | VirtualElement | null) => AnchorRect | null) | undefined;
+  updatePosition?: ((data: {
+    updatePosition: () => Promise<void>;
+    floatingElement: HTMLElement | null;
+  }) => void | Promise<void>) | undefined;
+}
+//#endregion
+//#region src/shared/popper/get-placement.d.ts
+declare function getPlacement(referenceOrFn: MaybeFn<MaybeRectElement>, floatingOrFn: MaybeFn<MaybeElement>, opts?: PositioningOptions & {
+  defer?: boolean | undefined;
+}): () => void;
+//#endregion
+//#region src/shared/popper/middleware.d.ts
+declare const cssVars: {
+  arrowSize: {
+    variable: string;
+    reference: string;
+  };
+  arrowSizeHalf: {
+    variable: string;
+    reference: string;
+  };
+  arrowBg: {
+    variable: string;
+    reference: string;
+  };
+  transformOrigin: {
+    variable: string;
+    reference: string;
+  };
+  arrowOffset: {
+    variable: string;
+    reference: string;
+  };
+};
+//#endregion
+//#region src/shared/popper/get-styles.d.ts
+interface GetPlacementStylesOptions {
+  placement?: Placement | undefined;
+}
+declare function getPlacementStyles(options?: Pick<PositioningOptions, "placement" | "sameWidth" | "fitViewport" | "strategy">): {
+  arrow: {
+    readonly [cssVars.arrowSizeHalf.variable]: `calc(${string} / 2)`;
+    readonly [cssVars.arrowOffset.variable]: `calc(${string} * -1)`;
+    readonly position: "absolute";
+    readonly width: string;
+    readonly height: string;
+  };
+  arrowTip: {
+    readonly transform: any;
+    readonly background: string;
+    readonly top: "0";
+    readonly left: "0";
+    readonly width: "100%";
+    readonly height: "100%";
+    readonly position: "absolute";
+    readonly zIndex: "inherit";
+  };
+  floating: {
+    readonly position: "absolute" | "fixed";
+    readonly isolation: "isolate";
+    readonly minWidth: "max-content" | undefined;
+    readonly width: "var(--reference-width)" | undefined;
+    readonly maxWidth: "var(--available-width)" | undefined;
+    readonly maxHeight: "var(--available-height)" | undefined;
+    readonly pointerEvents: "none" | undefined;
+    readonly top: "0px";
+    readonly left: "0px";
+    readonly transform: "translate3d(var(--x), var(--y), 0)" | "translate3d(0, -100vh, 0)";
+    readonly zIndex: "var(--z-index)";
+  };
+};
+//#endregion
+//#region src/shared/popper/placement.d.ts
+declare function isValidPlacement(v: string): v is Placement;
+declare function getPlacementSide(placement: Placement): PlacementSide;
+//#endregion
+export { getPlacement as a, Boundary as c, PlacementAlign as d, PlacementSide as f, getPlacementStyles as i, ComputePositionReturn as l, isValidPlacement as n, AnchorRect as o, PositioningOptions as p, GetPlacementStylesOptions as r, AutoUpdateOptions as s, getPlacementSide as t, Placement$1 as u };

package/dist/index.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/interact-outside-BplxR9cR.mjs

@@ -0,0 +1,200 @@
+import { A as getNearestOverflowAncestor, Kt as isControlledElement, Qt as getDocument, U as raf, Xt as contains, et as isFocusable, ft as getEventTarget, ht as isContextMenuEvent, ln as isHTMLElement, pn as isShadowRoot, rn as getWindow, st as addDomEvent, zt as isTouchDevice } from "./dom-query-DFCRhyj1.mjs";
+import { W as callAll } from "./utils-BZyrxWWR.mjs";
+
+//#region src/shared/interact-outside/frame-utils.ts
+function getWindowFrames(win) {
+	const frames = {
+		each(cb) {
+			for (let i = 0; i < win.frames?.length; i += 1) {
+				const frame = win.frames[i];
+				if (frame) cb(frame);
+			}
+		},
+		addEventListener(event, listener, options) {
+			frames.each((frame) => {
+				try {
+					frame.document.addEventListener(event, listener, options);
+				} catch {}
+			});
+			return () => {
+				try {
+					frames.removeEventListener(event, listener, options);
+				} catch {}
+			};
+		},
+		removeEventListener(event, listener, options) {
+			frames.each((frame) => {
+				try {
+					frame.document.removeEventListener(event, listener, options);
+				} catch {}
+			});
+		}
+	};
+	return frames;
+}
+function getParentWindow(win) {
+	const parent = win.frameElement != null ? win.parent : null;
+	return {
+		addEventListener: (event, listener, options) => {
+			try {
+				parent?.addEventListener(event, listener, options);
+			} catch {}
+			return () => {
+				try {
+					parent?.removeEventListener(event, listener, options);
+				} catch {}
+			};
+		},
+		removeEventListener: (event, listener, options) => {
+			try {
+				parent?.removeEventListener(event, listener, options);
+			} catch {}
+		}
+	};
+}
+
+//#endregion
+//#region src/shared/interact-outside/index.ts
+const POINTER_OUTSIDE_EVENT = "pointerdown.outside";
+const FOCUS_OUTSIDE_EVENT = "focus.outside";
+function isComposedPathFocusable(composedPath) {
+	for (const node of composedPath) if (isHTMLElement(node) && isFocusable(node)) return true;
+	return false;
+}
+const isPointerEvent = (event) => "clientY" in event;
+function isEventPointWithin(node, event) {
+	if (!isPointerEvent(event) || !node) return false;
+	const rect = node.getBoundingClientRect();
+	if (rect.width === 0 || rect.height === 0) return false;
+	return rect.top <= event.clientY && event.clientY <= rect.top + rect.height && rect.left <= event.clientX && event.clientX <= rect.left + rect.width;
+}
+function isPointInRect(rect, point) {
+	return rect.y <= point.y && point.y <= rect.y + rect.height && rect.x <= point.x && point.x <= rect.x + rect.width;
+}
+function isEventWithinScrollbar(event, ancestor) {
+	if (!ancestor || !isPointerEvent(event)) return false;
+	const isScrollableY = ancestor.scrollHeight > ancestor.clientHeight;
+	const onScrollbarY = isScrollableY && event.clientX > ancestor.offsetLeft + ancestor.clientWidth;
+	const isScrollableX = ancestor.scrollWidth > ancestor.clientWidth;
+	const onScrollbarX = isScrollableX && event.clientY > ancestor.offsetTop + ancestor.clientHeight;
+	if (!isPointInRect({
+		x: ancestor.offsetLeft,
+		y: ancestor.offsetTop,
+		width: ancestor.clientWidth + (isScrollableY ? 16 : 0),
+		height: ancestor.clientHeight + (isScrollableX ? 16 : 0)
+	}, {
+		x: event.clientX,
+		y: event.clientY
+	})) return false;
+	return onScrollbarY || onScrollbarX;
+}
+function trackInteractOutsideImpl(node, options) {
+	const { exclude, onFocusOutside, onPointerDownOutside, onInteractOutside, defer, followControlledElements = true } = options;
+	if (!node) return;
+	const doc = getDocument(node);
+	const win = getWindow(node);
+	const frames = getWindowFrames(win);
+	const parentWin = getParentWindow(win);
+	function isEventOutside(event, target) {
+		if (!isHTMLElement(target)) return false;
+		if (!target.isConnected) return false;
+		if (contains(node, target)) return false;
+		if (isEventPointWithin(node, event)) return false;
+		if (followControlledElements && isControlledElement(node, target)) return false;
+		const triggerEl = doc.querySelector(`[aria-controls="${node.id}"]`);
+		if (triggerEl) {
+			if (isEventWithinScrollbar(event, getNearestOverflowAncestor(triggerEl))) return false;
+		}
+		if (isEventWithinScrollbar(event, getNearestOverflowAncestor(node))) return false;
+		return !exclude?.(target);
+	}
+	const pointerdownCleanups = /* @__PURE__ */ new Set();
+	const isInShadowRoot = isShadowRoot(node?.getRootNode());
+	function onPointerDown(event) {
+		function handler(clickEvent) {
+			const func = defer && !isTouchDevice() ? raf : (v) => v();
+			const evt = clickEvent ?? event;
+			const composedPath = evt?.composedPath?.() ?? [evt?.target];
+			func(() => {
+				const target = isInShadowRoot ? composedPath[0] : getEventTarget(event);
+				if (!node || !isEventOutside(event, target)) return;
+				if (onPointerDownOutside || onInteractOutside) {
+					const handler$1 = callAll(onPointerDownOutside, onInteractOutside);
+					node.addEventListener(POINTER_OUTSIDE_EVENT, handler$1, { once: true });
+				}
+				fireCustomEvent(node, POINTER_OUTSIDE_EVENT, {
+					bubbles: false,
+					cancelable: true,
+					detail: {
+						originalEvent: evt,
+						contextmenu: isContextMenuEvent(evt),
+						focusable: isComposedPathFocusable(composedPath),
+						target
+					}
+				});
+			});
+		}
+		if (event.pointerType === "touch") {
+			pointerdownCleanups.forEach((fn) => fn());
+			pointerdownCleanups.add(addDomEvent(doc, "click", handler, { once: true }));
+			pointerdownCleanups.add(parentWin.addEventListener("click", handler, { once: true }));
+			pointerdownCleanups.add(frames.addEventListener("click", handler, { once: true }));
+		} else handler();
+	}
+	const cleanups = /* @__PURE__ */ new Set();
+	const timer = setTimeout(() => {
+		cleanups.add(addDomEvent(doc, "pointerdown", onPointerDown, true));
+		cleanups.add(parentWin.addEventListener("pointerdown", onPointerDown, true));
+		cleanups.add(frames.addEventListener("pointerdown", onPointerDown, true));
+	}, 0);
+	function onFocusin(event) {
+		(defer ? raf : (v) => v())(() => {
+			const composedPath = event?.composedPath?.() ?? [event?.target];
+			const target = isInShadowRoot ? composedPath[0] : getEventTarget(event);
+			if (!node || !isEventOutside(event, target)) return;
+			if (onFocusOutside || onInteractOutside) {
+				const handler = callAll(onFocusOutside, onInteractOutside);
+				node.addEventListener(FOCUS_OUTSIDE_EVENT, handler, { once: true });
+			}
+			fireCustomEvent(node, FOCUS_OUTSIDE_EVENT, {
+				bubbles: false,
+				cancelable: true,
+				detail: {
+					originalEvent: event,
+					contextmenu: false,
+					focusable: isFocusable(target),
+					target
+				}
+			});
+		});
+	}
+	if (!isTouchDevice()) {
+		cleanups.add(addDomEvent(doc, "focusin", onFocusin, true));
+		cleanups.add(parentWin.addEventListener("focusin", onFocusin, true));
+		cleanups.add(frames.addEventListener("focusin", onFocusin, true));
+	}
+	return () => {
+		clearTimeout(timer);
+		pointerdownCleanups.forEach((fn) => fn());
+		cleanups.forEach((fn) => fn());
+	};
+}
+function trackInteractOutside(nodeOrFn, options) {
+	const { defer } = options;
+	const func = defer ? raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		const node = typeof nodeOrFn === "function" ? nodeOrFn() : nodeOrFn;
+		cleanups.push(trackInteractOutsideImpl(node, options));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+function fireCustomEvent(el, type, init) {
+	const event = new (el.ownerDocument.defaultView || window).CustomEvent(type, init);
+	return el.dispatchEvent(event);
+}
+
+//#endregion
+export { trackInteractOutside as t };