@wirekyt/dom 0.0.1 → 0.0.2

package/dist/focus-visible-DWdQf__4.js

@@ -0,0 +1,176 @@
+import { S as getWindow, g as getDocument, m as getActiveElement } from "./dom-query-e7fh0TEH.js";
+import { d as isMac } from "./platform-BDB0wXUk.js";
+import { b as isVirtualClick, s as getEventTarget } from "./event-bTItRgiw.js";
+//#region src/common/focus-visible/index.ts
+function isValidKey(e) {
+	return !(e.metaKey || !isMac() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+const nonTextInputTypes = /* @__PURE__ */ new Set([
+	"checkbox",
+	"radio",
+	"range",
+	"color",
+	"file",
+	"image",
+	"button",
+	"submit",
+	"reset"
+]);
+function isKeyboardFocusEvent(isTextInput, modality, e) {
+	const eventTarget = e ? getEventTarget(e) : null;
+	const doc = getDocument(eventTarget);
+	const win = getWindow(eventTarget);
+	const activeElement = getActiveElement(doc);
+	isTextInput = isTextInput || activeElement instanceof win.HTMLInputElement && !nonTextInputTypes.has(activeElement?.type) || activeElement instanceof win.HTMLTextAreaElement || activeElement instanceof win.HTMLElement && activeElement.isContentEditable;
+	return !(isTextInput && modality === "keyboard" && e instanceof win.KeyboardEvent && !Reflect.has(FOCUS_VISIBLE_INPUT_KEYS, e.key));
+}
+let currentModality = null;
+let changeHandlers = /* @__PURE__ */ new Set();
+let listenerMap = /* @__PURE__ */ new Map();
+let hasEventBeforeFocus = false;
+let hasBlurredWindowRecently = false;
+let ignoreFocusEvent = false;
+const FOCUS_VISIBLE_INPUT_KEYS = {
+	Tab: true,
+	Escape: true
+};
+function triggerChangeHandlers(modality, e) {
+	for (let handler of changeHandlers) handler(modality, e);
+}
+function handleKeyboardEvent(e) {
+	hasEventBeforeFocus = true;
+	if (isValidKey(e)) {
+		currentModality = "keyboard";
+		triggerChangeHandlers("keyboard", e);
+	}
+}
+function handlePointerEvent(e) {
+	currentModality = "pointer";
+	if (e.type === "mousedown" || e.type === "pointerdown") {
+		hasEventBeforeFocus = true;
+		triggerChangeHandlers("pointer", e);
+	}
+}
+function handleClickEvent(e) {
+	if (isVirtualClick(e)) {
+		hasEventBeforeFocus = true;
+		currentModality = "virtual";
+	}
+}
+function handleFocusEvent(e) {
+	const target = getEventTarget(e);
+	if (target === getWindow(target) || target === getDocument(target) || !e.isTrusted) return;
+	if (!hasEventBeforeFocus && !hasBlurredWindowRecently) {
+		currentModality = "virtual";
+		triggerChangeHandlers("virtual", e);
+	}
+	hasEventBeforeFocus = false;
+	hasBlurredWindowRecently = false;
+}
+function handleWindowBlur() {
+	hasEventBeforeFocus = false;
+	hasBlurredWindowRecently = true;
+}
+function setupGlobalFocusEvents(root) {
+	if (typeof window === "undefined" || listenerMap.get(getWindow(root))) return;
+	const win = getWindow(root);
+	const doc = getDocument(root);
+	let focus = win.HTMLElement.prototype.focus;
+	function patchedFocus() {
+		hasEventBeforeFocus = true;
+		focus.apply(this, arguments);
+	}
+	try {
+		Object.defineProperty(win.HTMLElement.prototype, "focus", {
+			configurable: true,
+			value: patchedFocus
+		});
+	} catch {}
+	doc.addEventListener("keydown", handleKeyboardEvent, true);
+	doc.addEventListener("keyup", handleKeyboardEvent, true);
+	doc.addEventListener("click", handleClickEvent, true);
+	win.addEventListener("focus", handleFocusEvent, true);
+	win.addEventListener("blur", handleWindowBlur, false);
+	if (typeof win.PointerEvent !== "undefined") {
+		doc.addEventListener("pointerdown", handlePointerEvent, true);
+		doc.addEventListener("pointermove", handlePointerEvent, true);
+		doc.addEventListener("pointerup", handlePointerEvent, true);
+	} else {
+		doc.addEventListener("mousedown", handlePointerEvent, true);
+		doc.addEventListener("mousemove", handlePointerEvent, true);
+		doc.addEventListener("mouseup", handlePointerEvent, true);
+	}
+	win.addEventListener("beforeunload", () => {
+		tearDownWindowFocusTracking(root);
+	}, { once: true });
+	listenerMap.set(win, { focus });
+}
+const tearDownWindowFocusTracking = (root, loadListener) => {
+	const win = getWindow(root);
+	const doc = getDocument(root);
+	if (loadListener) doc.removeEventListener("DOMContentLoaded", loadListener);
+	const listenerData = listenerMap.get(win);
+	if (!listenerData) return;
+	try {
+		Object.defineProperty(win.HTMLElement.prototype, "focus", {
+			configurable: true,
+			value: listenerData.focus
+		});
+	} catch {}
+	doc.removeEventListener("keydown", handleKeyboardEvent, true);
+	doc.removeEventListener("keyup", handleKeyboardEvent, true);
+	doc.removeEventListener("click", handleClickEvent, true);
+	win.removeEventListener("focus", handleFocusEvent, true);
+	win.removeEventListener("blur", handleWindowBlur, false);
+	if (typeof win.PointerEvent !== "undefined") {
+		doc.removeEventListener("pointerdown", handlePointerEvent, true);
+		doc.removeEventListener("pointermove", handlePointerEvent, true);
+		doc.removeEventListener("pointerup", handlePointerEvent, true);
+	} else {
+		doc.removeEventListener("mousedown", handlePointerEvent, true);
+		doc.removeEventListener("mousemove", handlePointerEvent, true);
+		doc.removeEventListener("mouseup", handlePointerEvent, true);
+	}
+	listenerMap.delete(win);
+};
+function getInteractionModality() {
+	return currentModality;
+}
+function setInteractionModality(modality) {
+	currentModality = modality;
+	triggerChangeHandlers(modality, null);
+}
+function trackInteractionModality(props) {
+	const { onChange, root } = props;
+	setupGlobalFocusEvents(root);
+	onChange({ modality: currentModality });
+	const handler = () => onChange({ modality: currentModality });
+	changeHandlers.add(handler);
+	return () => {
+		changeHandlers.delete(handler);
+	};
+}
+function isFocusVisible() {
+	return currentModality === "keyboard" || currentModality === "virtual";
+}
+function trackFocusVisible(props = {}) {
+	const { isTextInput, autoFocus, onChange, root } = props;
+	setupGlobalFocusEvents(root);
+	onChange?.({
+		isFocusVisible: autoFocus || isFocusVisible(),
+		modality: currentModality
+	});
+	const handler = (modality, e) => {
+		if (!isKeyboardFocusEvent(!!isTextInput, modality, e)) return;
+		onChange?.({
+			isFocusVisible: isFocusVisible(),
+			modality
+		});
+	};
+	changeHandlers.add(handler);
+	return () => {
+		changeHandlers.delete(handler);
+	};
+}
+//#endregion
+export { setInteractionModality as a, listenerMap as i, ignoreFocusEvent as n, trackFocusVisible as o, isFocusVisible as r, trackInteractionModality as s, getInteractionModality as t };

package/dist/focus-visible-G4cmlWqq.cjs

@@ -0,0 +1,217 @@
+const require_dom_query = require("./dom-query-CQzY93XU.cjs");
+const require_platform = require("./platform-BZS-dkZN.cjs");
+const require_event = require("./event-DDz-mMhM.cjs");
+//#region src/common/focus-visible/index.ts
+function isValidKey(e) {
+	return !(e.metaKey || !require_platform.isMac() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+const nonTextInputTypes = /* @__PURE__ */ new Set([
+	"checkbox",
+	"radio",
+	"range",
+	"color",
+	"file",
+	"image",
+	"button",
+	"submit",
+	"reset"
+]);
+function isKeyboardFocusEvent(isTextInput, modality, e) {
+	const eventTarget = e ? require_event.getEventTarget(e) : null;
+	const doc = require_dom_query.getDocument(eventTarget);
+	const win = require_dom_query.getWindow(eventTarget);
+	const activeElement = require_dom_query.getActiveElement(doc);
+	isTextInput = isTextInput || activeElement instanceof win.HTMLInputElement && !nonTextInputTypes.has(activeElement?.type) || activeElement instanceof win.HTMLTextAreaElement || activeElement instanceof win.HTMLElement && activeElement.isContentEditable;
+	return !(isTextInput && modality === "keyboard" && e instanceof win.KeyboardEvent && !Reflect.has(FOCUS_VISIBLE_INPUT_KEYS, e.key));
+}
+let currentModality = null;
+let changeHandlers = /* @__PURE__ */ new Set();
+let listenerMap = /* @__PURE__ */ new Map();
+let hasEventBeforeFocus = false;
+let hasBlurredWindowRecently = false;
+let ignoreFocusEvent = false;
+const FOCUS_VISIBLE_INPUT_KEYS = {
+	Tab: true,
+	Escape: true
+};
+function triggerChangeHandlers(modality, e) {
+	for (let handler of changeHandlers) handler(modality, e);
+}
+function handleKeyboardEvent(e) {
+	hasEventBeforeFocus = true;
+	if (isValidKey(e)) {
+		currentModality = "keyboard";
+		triggerChangeHandlers("keyboard", e);
+	}
+}
+function handlePointerEvent(e) {
+	currentModality = "pointer";
+	if (e.type === "mousedown" || e.type === "pointerdown") {
+		hasEventBeforeFocus = true;
+		triggerChangeHandlers("pointer", e);
+	}
+}
+function handleClickEvent(e) {
+	if (require_event.isVirtualClick(e)) {
+		hasEventBeforeFocus = true;
+		currentModality = "virtual";
+	}
+}
+function handleFocusEvent(e) {
+	const target = require_event.getEventTarget(e);
+	if (target === require_dom_query.getWindow(target) || target === require_dom_query.getDocument(target) || !e.isTrusted) return;
+	if (!hasEventBeforeFocus && !hasBlurredWindowRecently) {
+		currentModality = "virtual";
+		triggerChangeHandlers("virtual", e);
+	}
+	hasEventBeforeFocus = false;
+	hasBlurredWindowRecently = false;
+}
+function handleWindowBlur() {
+	hasEventBeforeFocus = false;
+	hasBlurredWindowRecently = true;
+}
+function setupGlobalFocusEvents(root) {
+	if (typeof window === "undefined" || listenerMap.get(require_dom_query.getWindow(root))) return;
+	const win = require_dom_query.getWindow(root);
+	const doc = require_dom_query.getDocument(root);
+	let focus = win.HTMLElement.prototype.focus;
+	function patchedFocus() {
+		hasEventBeforeFocus = true;
+		focus.apply(this, arguments);
+	}
+	try {
+		Object.defineProperty(win.HTMLElement.prototype, "focus", {
+			configurable: true,
+			value: patchedFocus
+		});
+	} catch {}
+	doc.addEventListener("keydown", handleKeyboardEvent, true);
+	doc.addEventListener("keyup", handleKeyboardEvent, true);
+	doc.addEventListener("click", handleClickEvent, true);
+	win.addEventListener("focus", handleFocusEvent, true);
+	win.addEventListener("blur", handleWindowBlur, false);
+	if (typeof win.PointerEvent !== "undefined") {
+		doc.addEventListener("pointerdown", handlePointerEvent, true);
+		doc.addEventListener("pointermove", handlePointerEvent, true);
+		doc.addEventListener("pointerup", handlePointerEvent, true);
+	} else {
+		doc.addEventListener("mousedown", handlePointerEvent, true);
+		doc.addEventListener("mousemove", handlePointerEvent, true);
+		doc.addEventListener("mouseup", handlePointerEvent, true);
+	}
+	win.addEventListener("beforeunload", () => {
+		tearDownWindowFocusTracking(root);
+	}, { once: true });
+	listenerMap.set(win, { focus });
+}
+const tearDownWindowFocusTracking = (root, loadListener) => {
+	const win = require_dom_query.getWindow(root);
+	const doc = require_dom_query.getDocument(root);
+	if (loadListener) doc.removeEventListener("DOMContentLoaded", loadListener);
+	const listenerData = listenerMap.get(win);
+	if (!listenerData) return;
+	try {
+		Object.defineProperty(win.HTMLElement.prototype, "focus", {
+			configurable: true,
+			value: listenerData.focus
+		});
+	} catch {}
+	doc.removeEventListener("keydown", handleKeyboardEvent, true);
+	doc.removeEventListener("keyup", handleKeyboardEvent, true);
+	doc.removeEventListener("click", handleClickEvent, true);
+	win.removeEventListener("focus", handleFocusEvent, true);
+	win.removeEventListener("blur", handleWindowBlur, false);
+	if (typeof win.PointerEvent !== "undefined") {
+		doc.removeEventListener("pointerdown", handlePointerEvent, true);
+		doc.removeEventListener("pointermove", handlePointerEvent, true);
+		doc.removeEventListener("pointerup", handlePointerEvent, true);
+	} else {
+		doc.removeEventListener("mousedown", handlePointerEvent, true);
+		doc.removeEventListener("mousemove", handlePointerEvent, true);
+		doc.removeEventListener("mouseup", handlePointerEvent, true);
+	}
+	listenerMap.delete(win);
+};
+function getInteractionModality() {
+	return currentModality;
+}
+function setInteractionModality(modality) {
+	currentModality = modality;
+	triggerChangeHandlers(modality, null);
+}
+function trackInteractionModality(props) {
+	const { onChange, root } = props;
+	setupGlobalFocusEvents(root);
+	onChange({ modality: currentModality });
+	const handler = () => onChange({ modality: currentModality });
+	changeHandlers.add(handler);
+	return () => {
+		changeHandlers.delete(handler);
+	};
+}
+function isFocusVisible() {
+	return currentModality === "keyboard" || currentModality === "virtual";
+}
+function trackFocusVisible(props = {}) {
+	const { isTextInput, autoFocus, onChange, root } = props;
+	setupGlobalFocusEvents(root);
+	onChange?.({
+		isFocusVisible: autoFocus || isFocusVisible(),
+		modality: currentModality
+	});
+	const handler = (modality, e) => {
+		if (!isKeyboardFocusEvent(!!isTextInput, modality, e)) return;
+		onChange?.({
+			isFocusVisible: isFocusVisible(),
+			modality
+		});
+	};
+	changeHandlers.add(handler);
+	return () => {
+		changeHandlers.delete(handler);
+	};
+}
+//#endregion
+Object.defineProperty(exports, "getInteractionModality", {
+	enumerable: true,
+	get: function() {
+		return getInteractionModality;
+	}
+});
+Object.defineProperty(exports, "ignoreFocusEvent", {
+	enumerable: true,
+	get: function() {
+		return ignoreFocusEvent;
+	}
+});
+Object.defineProperty(exports, "isFocusVisible", {
+	enumerable: true,
+	get: function() {
+		return isFocusVisible;
+	}
+});
+Object.defineProperty(exports, "listenerMap", {
+	enumerable: true,
+	get: function() {
+		return listenerMap;
+	}
+});
+Object.defineProperty(exports, "setInteractionModality", {
+	enumerable: true,
+	get: function() {
+		return setInteractionModality;
+	}
+});
+Object.defineProperty(exports, "trackFocusVisible", {
+	enumerable: true,
+	get: function() {
+		return trackFocusVisible;
+	}
+});
+Object.defineProperty(exports, "trackInteractionModality", {
+	enumerable: true,
+	get: function() {
+		return trackInteractionModality;
+	}
+});

package/dist/focus-visible.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_focus_visible = require("./focus-visible-G4cmlWqq.cjs");
+exports.getInteractionModality = require_focus_visible.getInteractionModality;
+exports.ignoreFocusEvent = require_focus_visible.ignoreFocusEvent;
+exports.isFocusVisible = require_focus_visible.isFocusVisible;
+exports.listenerMap = require_focus_visible.listenerMap;
+exports.setInteractionModality = require_focus_visible.setInteractionModality;
+exports.trackFocusVisible = require_focus_visible.trackFocusVisible;
+exports.trackInteractionModality = require_focus_visible.trackInteractionModality;

package/dist/focus-visible.d.cts

@@ -0,0 +1,32 @@
+//#region src/common/focus-visible/index.d.ts
+type Modality = "keyboard" | "pointer" | "virtual";
+type RootNode = Document | ShadowRoot | Node;
+interface GlobalListenerData {
+  focus: VoidFunction;
+}
+declare let listenerMap: Map<Window, GlobalListenerData>;
+declare let ignoreFocusEvent: boolean;
+declare function getInteractionModality(): Modality | null;
+declare function setInteractionModality(modality: Modality): void;
+interface InteractionModalityChangeDetails {
+  modality: Modality | null;
+}
+interface InteractionModalityProps {
+  root?: RootNode | undefined;
+  onChange: (details: InteractionModalityChangeDetails) => void;
+}
+declare function trackInteractionModality(props: InteractionModalityProps): VoidFunction;
+declare function isFocusVisible(): boolean;
+interface FocusVisibleChangeDetails {
+  isFocusVisible: boolean;
+  modality: Modality | null;
+}
+interface FocusVisibleProps {
+  root?: RootNode | undefined;
+  isTextInput?: boolean | undefined;
+  autoFocus?: boolean | undefined;
+  onChange?: ((details: FocusVisibleChangeDetails) => void) | undefined;
+}
+declare function trackFocusVisible(props?: FocusVisibleProps): VoidFunction;
+//#endregion
+export { FocusVisibleChangeDetails, FocusVisibleProps, InteractionModalityChangeDetails, InteractionModalityProps, Modality, getInteractionModality, ignoreFocusEvent, isFocusVisible, listenerMap, setInteractionModality, trackFocusVisible, trackInteractionModality };

package/dist/focus-visible.d.ts

@@ -0,0 +1,32 @@
+//#region src/common/focus-visible/index.d.ts
+type Modality = "keyboard" | "pointer" | "virtual";
+type RootNode = Document | ShadowRoot | Node;
+interface GlobalListenerData {
+  focus: VoidFunction;
+}
+declare let listenerMap: Map<Window, GlobalListenerData>;
+declare let ignoreFocusEvent: boolean;
+declare function getInteractionModality(): Modality | null;
+declare function setInteractionModality(modality: Modality): void;
+interface InteractionModalityChangeDetails {
+  modality: Modality | null;
+}
+interface InteractionModalityProps {
+  root?: RootNode | undefined;
+  onChange: (details: InteractionModalityChangeDetails) => void;
+}
+declare function trackInteractionModality(props: InteractionModalityProps): VoidFunction;
+declare function isFocusVisible(): boolean;
+interface FocusVisibleChangeDetails {
+  isFocusVisible: boolean;
+  modality: Modality | null;
+}
+interface FocusVisibleProps {
+  root?: RootNode | undefined;
+  isTextInput?: boolean | undefined;
+  autoFocus?: boolean | undefined;
+  onChange?: ((details: FocusVisibleChangeDetails) => void) | undefined;
+}
+declare function trackFocusVisible(props?: FocusVisibleProps): VoidFunction;
+//#endregion
+export { FocusVisibleChangeDetails, FocusVisibleProps, InteractionModalityChangeDetails, InteractionModalityProps, Modality, getInteractionModality, ignoreFocusEvent, isFocusVisible, listenerMap, setInteractionModality, trackFocusVisible, trackInteractionModality };

package/dist/focus-visible.js

@@ -0,0 +1,2 @@
+import { a as setInteractionModality, i as listenerMap, n as ignoreFocusEvent, o as trackFocusVisible, r as isFocusVisible, s as trackInteractionModality, t as getInteractionModality } from "./focus-visible-DWdQf__4.js";
+export { getInteractionModality, ignoreFocusEvent, isFocusVisible, listenerMap, setInteractionModality, trackFocusVisible, trackInteractionModality };

package/dist/form-B1DW_w_3.js

@@ -0,0 +1,89 @@
+import { S as getWindow } from "./dom-query-e7fh0TEH.js";
+//#region src/common/dom-query/form.ts
+function getDescriptor(el, options) {
+	const { type = "HTMLInputElement", property = "value" } = options;
+	const proto = getWindow(el)[type].prototype;
+	return Object.getOwnPropertyDescriptor(proto, property) ?? {};
+}
+function getElementType(el) {
+	if (el.localName === "input") return "HTMLInputElement";
+	if (el.localName === "textarea") return "HTMLTextAreaElement";
+	if (el.localName === "select") return "HTMLSelectElement";
+}
+function setElementValue(el, value, property = "value") {
+	if (!el) return;
+	const type = getElementType(el);
+	if (type) getDescriptor(el, {
+		type,
+		property
+	}).set?.call(el, value);
+	el.setAttribute(property, value);
+}
+function setElementChecked(el, checked) {
+	if (!el) return;
+	getDescriptor(el, {
+		type: "HTMLInputElement",
+		property: "checked"
+	}).set?.call(el, checked);
+	if (checked) el.setAttribute("checked", "");
+	else el.removeAttribute("checked");
+}
+function dispatchInputValueEvent(el, options) {
+	const { value, bubbles = true } = options;
+	if (!el) return;
+	const win = getWindow(el);
+	if (!(el instanceof win.HTMLInputElement)) return;
+	setElementValue(el, `${value}`);
+	const event = new win.Event("input", { bubbles });
+	el.dispatchEvent(markAsInternalChangeEvent(event));
+}
+function dispatchInputCheckedEvent(el, options) {
+	const { checked, bubbles = true } = options;
+	if (!el) return;
+	const win = getWindow(el);
+	if (!(el instanceof win.HTMLInputElement)) return;
+	setElementChecked(el, checked);
+	const event = new win.Event("click", { bubbles });
+	el.dispatchEvent(markAsInternalChangeEvent(event));
+}
+function isFormElement(el) {
+	return el.matches("textarea, input, select, button");
+}
+function trackFormReset(el, callback) {
+	if (!el) return;
+	const form = isFormElement(el) ? el.form : el.closest("form");
+	const onReset = (e) => {
+		if (e.defaultPrevented) return;
+		callback();
+	};
+	form?.addEventListener("reset", onReset, { passive: true });
+	return () => form?.removeEventListener("reset", onReset);
+}
+function trackFieldsetDisabled(el, callback) {
+	const fieldset = el?.closest("fieldset");
+	if (!fieldset) return;
+	callback(fieldset.disabled);
+	const obs = new (getWindow(fieldset)).MutationObserver(() => callback(fieldset.disabled));
+	obs.observe(fieldset, {
+		attributes: true,
+		attributeFilter: ["disabled"]
+	});
+	return () => obs.disconnect();
+}
+function trackFormControl(el, options) {
+	if (!el) return;
+	const { onFieldsetDisabledChange, onFormReset } = options;
+	const cleanups = [trackFormReset(el, onFormReset), trackFieldsetDisabled(el, onFieldsetDisabledChange)];
+	return () => cleanups.forEach((cleanup) => cleanup?.());
+}
+const INTERNAL_CHANGE_EVENT = Symbol.for("wire.changeEvent");
+function isInternalChangeEvent(e) {
+	return Object.prototype.hasOwnProperty.call(e, INTERNAL_CHANGE_EVENT);
+}
+function markAsInternalChangeEvent(event) {
+	if (isInternalChangeEvent(event)) return event;
+	Object.defineProperty(event, INTERNAL_CHANGE_EVENT, { value: true });
+	return event;
+}
+//#endregion
+export { setElementChecked as a, markAsInternalChangeEvent as i, dispatchInputValueEvent as n, setElementValue as o, isInternalChangeEvent as r, trackFormControl as s, dispatchInputCheckedEvent as t };

package/dist/form-CoupKpuP.cjs

@@ -0,0 +1,130 @@
+const require_dom_query = require("./dom-query-CQzY93XU.cjs");
+//#region src/common/dom-query/form.ts
+function getDescriptor(el, options) {
+	const { type = "HTMLInputElement", property = "value" } = options;
+	const proto = require_dom_query.getWindow(el)[type].prototype;
+	return Object.getOwnPropertyDescriptor(proto, property) ?? {};
+}
+function getElementType(el) {
+	if (el.localName === "input") return "HTMLInputElement";
+	if (el.localName === "textarea") return "HTMLTextAreaElement";
+	if (el.localName === "select") return "HTMLSelectElement";
+}
+function setElementValue(el, value, property = "value") {
+	if (!el) return;
+	const type = getElementType(el);
+	if (type) getDescriptor(el, {
+		type,
+		property
+	}).set?.call(el, value);
+	el.setAttribute(property, value);
+}
+function setElementChecked(el, checked) {
+	if (!el) return;
+	getDescriptor(el, {
+		type: "HTMLInputElement",
+		property: "checked"
+	}).set?.call(el, checked);
+	if (checked) el.setAttribute("checked", "");
+	else el.removeAttribute("checked");
+}
+function dispatchInputValueEvent(el, options) {
+	const { value, bubbles = true } = options;
+	if (!el) return;
+	const win = require_dom_query.getWindow(el);
+	if (!(el instanceof win.HTMLInputElement)) return;
+	setElementValue(el, `${value}`);
+	const event = new win.Event("input", { bubbles });
+	el.dispatchEvent(markAsInternalChangeEvent(event));
+}
+function dispatchInputCheckedEvent(el, options) {
+	const { checked, bubbles = true } = options;
+	if (!el) return;
+	const win = require_dom_query.getWindow(el);
+	if (!(el instanceof win.HTMLInputElement)) return;
+	setElementChecked(el, checked);
+	const event = new win.Event("click", { bubbles });
+	el.dispatchEvent(markAsInternalChangeEvent(event));
+}
+function isFormElement(el) {
+	return el.matches("textarea, input, select, button");
+}
+function trackFormReset(el, callback) {
+	if (!el) return;
+	const form = isFormElement(el) ? el.form : el.closest("form");
+	const onReset = (e) => {
+		if (e.defaultPrevented) return;
+		callback();
+	};
+	form?.addEventListener("reset", onReset, { passive: true });
+	return () => form?.removeEventListener("reset", onReset);
+}
+function trackFieldsetDisabled(el, callback) {
+	const fieldset = el?.closest("fieldset");
+	if (!fieldset) return;
+	callback(fieldset.disabled);
+	const obs = new (require_dom_query.getWindow(fieldset)).MutationObserver(() => callback(fieldset.disabled));
+	obs.observe(fieldset, {
+		attributes: true,
+		attributeFilter: ["disabled"]
+	});
+	return () => obs.disconnect();
+}
+function trackFormControl(el, options) {
+	if (!el) return;
+	const { onFieldsetDisabledChange, onFormReset } = options;
+	const cleanups = [trackFormReset(el, onFormReset), trackFieldsetDisabled(el, onFieldsetDisabledChange)];
+	return () => cleanups.forEach((cleanup) => cleanup?.());
+}
+const INTERNAL_CHANGE_EVENT = Symbol.for("wire.changeEvent");
+function isInternalChangeEvent(e) {
+	return Object.prototype.hasOwnProperty.call(e, INTERNAL_CHANGE_EVENT);
+}
+function markAsInternalChangeEvent(event) {
+	if (isInternalChangeEvent(event)) return event;
+	Object.defineProperty(event, INTERNAL_CHANGE_EVENT, { value: true });
+	return event;
+}
+//#endregion
+Object.defineProperty(exports, "dispatchInputCheckedEvent", {
+	enumerable: true,
+	get: function() {
+		return dispatchInputCheckedEvent;
+	}
+});
+Object.defineProperty(exports, "dispatchInputValueEvent", {
+	enumerable: true,
+	get: function() {
+		return dispatchInputValueEvent;
+	}
+});
+Object.defineProperty(exports, "isInternalChangeEvent", {
+	enumerable: true,
+	get: function() {
+		return isInternalChangeEvent;
+	}
+});
+Object.defineProperty(exports, "markAsInternalChangeEvent", {
+	enumerable: true,
+	get: function() {
+		return markAsInternalChangeEvent;
+	}
+});
+Object.defineProperty(exports, "setElementChecked", {
+	enumerable: true,
+	get: function() {
+		return setElementChecked;
+	}
+});
+Object.defineProperty(exports, "setElementValue", {
+	enumerable: true,
+	get: function() {
+		return setElementValue;
+	}
+});
+Object.defineProperty(exports, "trackFormControl", {
+	enumerable: true,
+	get: function() {
+		return trackFormControl;
+	}
+});