elements-kit 0.0.8 → 0.0.10

package/dist/signals/lib/event-driven.d.mts

@@ -0,0 +1,47 @@
+import { n as Signal, t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/event-driven.d.ts
+/**
+ * A subscribe function: registers a `notify` callback and returns an
+ * unsubscribe cleanup. Same contract as `useSyncExternalStore`.
+ */
+type Subscribe = (notify: () => void) => () => void;
+/**
+ * Returns a `Subscribe` for one or more DOM events on a target.
+ *
+ * @example
+ * ```ts
+ * const [playing, stop] = sync(fromEvent(el, ["play", "pause"]), () => !el.paused);
+ * ```
+ */
+declare function fromEvent(target: EventTarget, events: string | string[]): Subscribe;
+/**
+ * Keeps a reactive value in sync with an external source by re-reading
+ * `getter` whenever `subscribe` notifies of a change.
+ *
+ * Returns a `[value, cleanup]` tuple.
+ *
+ * Without `setter` → value is `Computed<T>` (read-only).
+ * With `setter`    → value is `Signal<T>` (writable).
+ *
+ * @example
+ * ```ts
+ * const [playing, stop] = sync(fromEvent(el, ["play", "pause"]), () => !el.paused);
+ *
+ * const [volume, stopVolume] = sync(
+ *   fromEvent(el, "volumechange"),
+ *   () => el.volume,
+ *   (v) => { el.volume = v; },
+ * );
+ *
+ * // Any external store
+ * const [data, unsub] = sync(
+ *   (notify) => { store.on("change", notify); return () => store.off("change", notify); },
+ *   () => store.getSnapshot(),
+ * );
+ * ```
+ */
+declare function sync<T>(subscribe: Subscribe, getter: () => T): [Computed<T>, () => void];
+declare function sync<T>(subscribe: Subscribe, getter: () => T, setter: (value: T) => void): [Signal<T>, () => void];
+//#endregion
+export { Subscribe, fromEvent, sync };

package/dist/signals/lib/event-driven.mjs

@@ -0,0 +1,38 @@
+import { d as onCleanup, f as signal, i as computed, p as trigger } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/event-driven.ts
+/**
+* Returns a `Subscribe` for one or more DOM events on a target.
+*
+* @example
+* ```ts
+* const [playing, stop] = sync(fromEvent(el, ["play", "pause"]), () => !el.paused);
+* ```
+*/
+function fromEvent(target, events) {
+	return (notify) => {
+		const evts = Array.isArray(events) ? events : [events];
+		evts.forEach((ev) => target.addEventListener(ev, notify));
+		return () => evts.forEach((ev) => target.removeEventListener(ev, notify));
+	};
+}
+function sync(subscribe, getter, setter) {
+	const tick = signal(void 0);
+	const value = computed(() => {
+		tick();
+		return getter();
+	});
+	value();
+	const cleanup = subscribe(() => trigger(tick));
+	onCleanup(cleanup);
+	if (setter) {
+		const proxy = (v) => {
+			if (v === void 0) return value();
+			setter(v);
+			return v;
+		};
+		return [proxy, cleanup];
+	}
+	return [value, cleanup];
+}
+//#endregion
+export { fromEvent, sync };

package/dist/signals/lib/event-listener.d.mts

@@ -0,0 +1,14 @@
+//#region src/signals/lib/event-listener.d.ts
+/**
+ * Attaches a type-safe event listener to a target, with automatic cleanup.
+ *
+ * When called inside an `effect` or `effectScope` the listener is removed
+ * when the scope is disposed.  When the target is a reactive getter the
+ * listener is re-registered whenever the target changes.
+ */
+declare function createEventListener<K extends keyof HTMLElementEventMap>(target: HTMLElement | (() => HTMLElement | null), type: K, handler: (e: HTMLElementEventMap[K]) => void, options?: AddEventListenerOptions): () => void;
+declare function createEventListener<K extends keyof DocumentEventMap>(target: Document | (() => Document | null), type: K, handler: (e: DocumentEventMap[K]) => void, options?: AddEventListenerOptions): () => void;
+declare function createEventListener<K extends keyof WindowEventMap>(target: Window | (() => Window | null), type: K, handler: (e: WindowEventMap[K]) => void, options?: AddEventListenerOptions): () => void;
+declare function createEventListener(target: EventTarget | (() => EventTarget | null), type: string, handler: EventListener, options?: AddEventListenerOptions): () => void;
+//#endregion
+export { createEventListener };

package/dist/signals/lib/event-listener.mjs

@@ -0,0 +1,28 @@
+import { a as effect, d as onCleanup } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/event-listener.ts
+function createEventListener(target, type, handler, options) {
+	const add = (t) => options !== void 0 ? t.addEventListener(type, handler, options) : t.addEventListener(type, handler);
+	const del = (t) => options !== void 0 ? t.removeEventListener(type, handler, options) : t.removeEventListener(type, handler);
+	if (typeof target === "function") {
+		let currentRemove = () => {};
+		const stopEffect = effect(() => {
+			const el = target();
+			if (!el) return;
+			add(el);
+			const remove = () => del(el);
+			onCleanup(remove);
+			currentRemove = remove;
+		});
+		return () => {
+			stopEffect();
+			currentRemove();
+		};
+	} else {
+		const remove = () => del(target);
+		add(target);
+		onCleanup(remove);
+		return remove;
+	}
+}
+//#endregion
+export { createEventListener };

package/dist/signals/lib/event-listener.test.d.mts

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

package/dist/signals/lib/event-listener.test.mjs

@@ -0,0 +1,58 @@
+import { a as effect, f as signal, o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createEventListener } from "./event-listener.mjs";
+//#region src/signals/lib/event-listener.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+describe("createEventListener", () => {
+	it("fires the handler when the event is dispatched", () => {
+		const el = document.createElement("div");
+		document.body.appendChild(el);
+		const handler = vi.fn();
+		effect(() => {
+			createEventListener(el, "click", handler);
+		});
+		el.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+		globalExpect(handler).toHaveBeenCalledOnce();
+	});
+	it("removes the listener when the enclosing effect is disposed", () => {
+		const el = document.createElement("div");
+		document.body.appendChild(el);
+		const handler = vi.fn();
+		effect(() => {
+			createEventListener(el, "click", handler);
+		})();
+		el.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+		globalExpect(handler).not.toHaveBeenCalled();
+	});
+	it("removes the listener when the enclosing scope is disposed", () => {
+		const el = document.createElement("div");
+		document.body.appendChild(el);
+		const handler = vi.fn();
+		effectScope(() => {
+			createEventListener(el, "click", handler);
+		})();
+		el.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+		globalExpect(handler).not.toHaveBeenCalled();
+	});
+	it("re-registers the listener when a reactive target changes", () => {
+		const el1 = document.createElement("div");
+		const el2 = document.createElement("div");
+		document.body.append(el1, el2);
+		const target = signal(el1);
+		const handler = vi.fn();
+		effectScope(() => {
+			createEventListener(() => target(), "click", handler);
+		});
+		el1.dispatchEvent(new MouseEvent("click"));
+		globalExpect(handler).toHaveBeenCalledTimes(1);
+		target(el2);
+		el1.dispatchEvent(new MouseEvent("click"));
+		globalExpect(handler).toHaveBeenCalledTimes(1);
+		el2.dispatchEvent(new MouseEvent("click"));
+		globalExpect(handler).toHaveBeenCalledTimes(2);
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/favicon.d.mts

@@ -0,0 +1,10 @@
+import { n as Signal } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/favicon.d.ts
+/**
+ * Returns a writable `Signal<string>` whose value is reflected as the page's
+ * favicon `href`.  Writing the signal swaps the `<link rel="icon">` element.
+ */
+declare function createFavicon(initial?: string): Signal<string>;
+//#endregion
+export { createFavicon };

package/dist/signals/lib/favicon.mjs

@@ -0,0 +1,24 @@
+import { a as effect, f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/favicon.ts
+/**
+* Returns a writable `Signal<string>` whose value is reflected as the page's
+* favicon `href`.  Writing the signal swaps the `<link rel="icon">` element.
+*/
+function createFavicon(initial) {
+	const getLink = () => {
+		let link = document.querySelector("link[rel~='icon']");
+		if (!link) {
+			link = document.createElement("link");
+			link.rel = "icon";
+			document.head.appendChild(link);
+		}
+		return link;
+	};
+	const href = signal(initial ?? (typeof document !== "undefined" ? getLink().href || "" : ""));
+	effect(() => {
+		if (typeof document !== "undefined") getLink().href = href();
+	});
+	return href;
+}
+//#endregion
+export { createFavicon };

package/dist/signals/lib/favicon.test.d.mts

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

package/dist/signals/lib/favicon.test.mjs

@@ -0,0 +1,28 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createFavicon } from "./favicon.mjs";
+//#region src/signals/lib/favicon.test.ts
+afterEach(() => {
+	document.head.innerHTML = "";
+	document.body.innerHTML = "";
+});
+describe("createFavicon", () => {
+	it("creates a link element if none exists", () => {
+		effectScope(() => {
+			createFavicon("/icon.png");
+		});
+		const link = document.querySelector("link[rel~='icon']");
+		globalExpect(link).not.toBeNull();
+		globalExpect(link?.href).toContain("/icon.png");
+	});
+	it("updates favicon href when signal changes", () => {
+		let fav;
+		effectScope(() => {
+			fav = createFavicon("/old.png");
+		});
+		fav("/new.png");
+		globalExpect(document.querySelector("link[rel~='icon']")?.href).toContain("/new.png");
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/finite-state-machine.d.mts

@@ -0,0 +1,22 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/finite-state-machine.d.ts
+type Transitions<S extends string, E extends string> = Partial<Record<S, Partial<Record<E, S>>>>;
+type StateHooks<S extends string> = Partial<Record<S, {
+  enter?: () => void;
+  exit?: () => void;
+}>>;
+type FSMResult<S extends string, E extends string> = {
+  state: Computed<S>;
+  send(event: E): void;
+  can(event: E): boolean;
+};
+/**
+ * Type-safe finite state machine with optional `enter` / `exit` lifecycle
+ * hooks per state.
+ */
+declare function createFiniteStateMachine<S extends string, E extends string>(initial: S, transitions: Transitions<S, E>, options?: {
+  on?: StateHooks<S>;
+}): FSMResult<S, E>;
+//#endregion
+export { createFiniteStateMachine };

package/dist/signals/lib/finite-state-machine.mjs

@@ -0,0 +1,26 @@
+import { f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/finite-state-machine.ts
+/**
+* Type-safe finite state machine with optional `enter` / `exit` lifecycle
+* hooks per state.
+*/
+function createFiniteStateMachine(initial, transitions, options) {
+	const state = signal(initial);
+	options?.on?.[initial]?.enter?.();
+	const send = (event) => {
+		const current = state();
+		const next = transitions[current]?.[event];
+		if (next === void 0 || next === current) return;
+		options?.on?.[current]?.exit?.();
+		state(next);
+		options?.on?.[next]?.enter?.();
+	};
+	const can = (event) => transitions[state()]?.[event] !== void 0;
+	return {
+		state,
+		send,
+		can
+	};
+}
+//#endregion
+export { createFiniteStateMachine };

package/dist/signals/lib/finite-state-machine.test.d.mts

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

package/dist/signals/lib/finite-state-machine.test.mjs

@@ -0,0 +1,66 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createFiniteStateMachine } from "./finite-state-machine.mjs";
+//#region src/signals/lib/finite-state-machine.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+});
+const transitions = {
+	red: { GO: "green" },
+	green: { SLOW: "yellow" },
+	yellow: { STOP: "red" }
+};
+describe("createFiniteStateMachine", () => {
+	it("starts in the initial state", () => {
+		let fsm;
+		effectScope(() => {
+			fsm = createFiniteStateMachine("red", transitions);
+		});
+		globalExpect(fsm.state()).toBe("red");
+	});
+	it("transitions on valid event", () => {
+		let fsm;
+		effectScope(() => {
+			fsm = createFiniteStateMachine("red", transitions);
+		});
+		fsm.send("GO");
+		globalExpect(fsm.state()).toBe("green");
+	});
+	it("does not transition on invalid event", () => {
+		let fsm;
+		effectScope(() => {
+			fsm = createFiniteStateMachine("red", transitions);
+		});
+		fsm.send("SLOW");
+		globalExpect(fsm.state()).toBe("red");
+	});
+	it("can() returns true for valid transition", () => {
+		let fsm;
+		effectScope(() => {
+			fsm = createFiniteStateMachine("red", transitions);
+		});
+		globalExpect(fsm.can("GO")).toBe(true);
+		globalExpect(fsm.can("SLOW")).toBe(false);
+	});
+	it("calls enter/exit hooks on transition", () => {
+		const enterRed = vi.fn();
+		const exitRed = vi.fn();
+		const enterGreen = vi.fn();
+		let fsm;
+		effectScope(() => {
+			fsm = createFiniteStateMachine("red", transitions, { on: {
+				red: {
+					enter: enterRed,
+					exit: exitRed
+				},
+				green: { enter: enterGreen }
+			} });
+		});
+		globalExpect(enterRed).toHaveBeenCalledOnce();
+		fsm.send("GO");
+		globalExpect(exitRed).toHaveBeenCalledOnce();
+		globalExpect(enterGreen).toHaveBeenCalledOnce();
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/fullscreen.d.mts

@@ -0,0 +1,15 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/fullscreen.d.ts
+type FullscreenResult = {
+  isFullscreen: Computed<boolean>;
+  enter(): Promise<void>;
+  exit(): Promise<void>;
+  toggle(): Promise<void>;
+} & Disposable;
+/**
+ * Wraps the Fullscreen API.  `target` defaults to `document.documentElement`.
+ */
+declare function createFullscreen(target?: Element | (() => Element | null)): FullscreenResult;
+//#endregion
+export { createFullscreen };

package/dist/signals/lib/fullscreen.mjs

@@ -0,0 +1,24 @@
+import { fromEvent, sync } from "./event-driven.mjs";
+//#region src/signals/lib/fullscreen.ts
+/**
+* Wraps the Fullscreen API.  `target` defaults to `document.documentElement`.
+*/
+function createFullscreen(target) {
+	const getTarget = () => {
+		if (!target) return document.documentElement;
+		return typeof target === "function" ? target() ?? document.documentElement : target;
+	};
+	const [isFullscreen, cleanup] = sync(fromEvent(document, "fullscreenchange"), () => !!document.fullscreenElement);
+	const enter = () => getTarget().requestFullscreen();
+	const exit = () => document.exitFullscreen();
+	const toggle = () => isFullscreen() ? exit() : enter();
+	return {
+		isFullscreen,
+		enter,
+		exit,
+		toggle,
+		[Symbol.dispose]: cleanup
+	};
+}
+//#endregion
+export { createFullscreen };

package/dist/signals/lib/fullscreen.test.d.mts

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

package/dist/signals/lib/fullscreen.test.mjs

@@ -0,0 +1,48 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createFullscreen } from "./fullscreen.mjs";
+//#region src/signals/lib/fullscreen.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	vi.restoreAllMocks();
+});
+describe("createFullscreen", () => {
+	it("starts with current fullscreen state", () => {
+		Object.defineProperty(document, "fullscreenElement", {
+			configurable: true,
+			get: () => null
+		});
+		let f;
+		effectScope(() => {
+			f = createFullscreen();
+		});
+		globalExpect(f.isFullscreen()).toBe(false);
+	});
+	it("updates isFullscreen on fullscreenchange event", () => {
+		Object.defineProperty(document, "fullscreenElement", {
+			configurable: true,
+			get: () => null
+		});
+		let f;
+		effectScope(() => {
+			f = createFullscreen();
+		});
+		Object.defineProperty(document, "fullscreenElement", {
+			configurable: true,
+			get: () => document.documentElement
+		});
+		document.dispatchEvent(new Event("fullscreenchange"));
+		globalExpect(f.isFullscreen()).toBe(true);
+	});
+	it("removes event listener on Symbol.dispose", () => {
+		const removeSpy = vi.spyOn(document, "removeEventListener");
+		let f;
+		effectScope(() => {
+			f = createFullscreen();
+		});
+		f[Symbol.dispose]();
+		globalExpect(removeSpy).toHaveBeenCalledWith("fullscreenchange", globalExpect.any(Function));
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/geolocation.d.mts

@@ -0,0 +1,15 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/geolocation.d.ts
+type GeolocationResult = {
+  position: Computed<GeolocationPosition | null>;
+  error: Computed<GeolocationPositionError | null>;
+  loading: Computed<boolean>;
+} & Disposable;
+/**
+ * Exposes the Geolocation API as reactive signals.
+ * Begins watching the position immediately.
+ */
+declare function createGeolocation(options?: PositionOptions): GeolocationResult;
+//#endregion
+export { createGeolocation };

package/dist/signals/lib/geolocation.mjs

@@ -0,0 +1,30 @@
+import { d as onCleanup, f as signal } from "../../signals-CLAPw8kk.mjs";
+//#region src/signals/lib/geolocation.ts
+/**
+* Exposes the Geolocation API as reactive signals.
+* Begins watching the position immediately.
+*/
+function createGeolocation(options) {
+	const position = signal(null);
+	const error = signal(null);
+	const loading = signal(true);
+	const onSuccess = (pos) => {
+		position(pos);
+		error(null);
+		loading(false);
+	};
+	const onError = (err) => {
+		error(err);
+		loading(false);
+	};
+	const watchId = navigator.geolocation.watchPosition(onSuccess, onError, options);
+	const cleanup = () => navigator.geolocation.clearWatch(watchId);
+	onCleanup(cleanup);
+	return Object.assign({
+		position,
+		error,
+		loading
+	}, { [Symbol.dispose]: cleanup });
+}
+//#endregion
+export { createGeolocation };

package/dist/signals/lib/geolocation.test.d.mts

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

package/dist/signals/lib/geolocation.test.mjs

@@ -0,0 +1,37 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createGeolocation } from "./geolocation.mjs";
+//#region src/signals/lib/geolocation.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	vi.unstubAllGlobals();
+});
+describe("createGeolocation", () => {
+	it("starts with null position and loading true", () => {
+		vi.stubGlobal("navigator", { geolocation: {
+			watchPosition: vi.fn().mockReturnValue(1),
+			clearWatch: vi.fn()
+		} });
+		let g;
+		effectScope(() => {
+			g = createGeolocation();
+		});
+		globalExpect(g.position()).toBeNull();
+		globalExpect(g.loading()).toBe(true);
+	});
+	it("calls clearWatch on Symbol.dispose", () => {
+		const clearWatch = vi.fn();
+		vi.stubGlobal("navigator", { geolocation: {
+			watchPosition: vi.fn().mockReturnValue(42),
+			clearWatch
+		} });
+		let g;
+		effectScope(() => {
+			g = createGeolocation();
+		});
+		g[Symbol.dispose]();
+		globalExpect(clearWatch).toHaveBeenCalledWith(42);
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/hash.d.mts

@@ -0,0 +1,10 @@
+import { n as Signal } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/hash.d.ts
+/**
+ * Returns a writable `Signal<string>` that stays in sync with `location.hash`
+ * (including the leading `#`).  Writing the signal updates `location.hash`.
+ */
+declare function createHash(): Signal<string> & Disposable;
+//#endregion
+export { createHash };

package/dist/signals/lib/hash.mjs

@@ -0,0 +1,14 @@
+import { fromEvent, sync } from "./event-driven.mjs";
+//#region src/signals/lib/hash.ts
+/**
+* Returns a writable `Signal<string>` that stays in sync with `location.hash`
+* (including the leading `#`).  Writing the signal updates `location.hash`.
+*/
+function createHash() {
+	const [hash, cleanup] = sync(fromEvent(window, "hashchange"), () => typeof location !== "undefined" ? location.hash : "", (v) => {
+		location.hash = v;
+	});
+	return Object.assign(hash, { [Symbol.dispose]: cleanup });
+}
+//#endregion
+export { createHash };

package/dist/signals/lib/hash.test.d.mts

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

package/dist/signals/lib/hash.test.mjs

@@ -0,0 +1,46 @@
+import { o as effectScope } from "../../signals-CLAPw8kk.mjs";
+import { a as describe, n as vi, o as it, r as afterEach, t as globalExpect } from "../../test.BmQO5GaM-CR2qjV1t.mjs";
+import { createHash } from "./hash.mjs";
+//#region src/signals/lib/hash.test.ts
+afterEach(() => {
+	document.body.innerHTML = "";
+	location.hash = "";
+	vi.useRealTimers();
+});
+describe("createHash", () => {
+	it("reads the current location.hash", () => {
+		let h;
+		effectScope(() => {
+			h = createHash();
+		});
+		globalExpect(typeof h()).toBe("string");
+	});
+	it("updates when hash changes via hashchange event", () => {
+		let h;
+		effectScope(() => {
+			h = createHash();
+		});
+		location.hash = "#section";
+		window.dispatchEvent(new HashChangeEvent("hashchange"));
+		globalExpect(h()).toBe("#section");
+	});
+	it("writing the signal updates location.hash", () => {
+		let h;
+		effectScope(() => {
+			h = createHash();
+		});
+		h("#new");
+		globalExpect(location.hash).toBe("#new");
+	});
+	it("removes event listener on Symbol.dispose", () => {
+		const removeSpy = vi.spyOn(window, "removeEventListener");
+		let h;
+		effectScope(() => {
+			h = createHash();
+		});
+		h[Symbol.dispose]();
+		globalExpect(removeSpy).toHaveBeenCalledWith("hashchange", globalExpect.any(Function));
+	});
+});
+//#endregion
+export {};

package/dist/signals/lib/hover.d.mts

@@ -0,0 +1,11 @@
+import { t as Computed } from "../../index-BtqiEEfc.mjs";
+
+//#region src/signals/lib/hover.d.ts
+/**
+ * Returns a `Computed<boolean>` that is `true` while the pointer is over
+ * `target`.  Uses `pointerenter` / `pointerleave` so it works for both mouse
+ * and touch/stylus input.
+ */
+declare function createHover(target: Element | (() => Element | null)): Computed<boolean> & Disposable;
+//#endregion
+export { createHover };