@greypan/web-ui 11.2.0 → 12.0.0

package/dist/components/radio-group/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/components/radio-group/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2Ia,wBAAwB;SACnB,sBAAM;EACqB;EACC;EACA;EACiC;EACJ;MAGrE;MAGA,UAAU;UAKN;UAES;UAET;UAMA;UAMA;UAOA;mBAwDS;;;;;;UAmDT;UACA;UACA;UACA;UACA;UACA;mBACS;mBACA;UAKT;UAeA;MASJ;MAIA,MAAM;cAOE;mBAIK;mBAkBA;EAER;EAUA;EAYA;UAID;UAOA;UAiCA;UA8BA;UAaA;EAaC,qBAAqB;UAKtB;EAUC,wBAAM;WAIE;IACf,OAAO;IACP,QAAQ;;;QAIJ;YACI;IACR,sBAAsB"}

package/dist/components/radio-group/index.js

@@ -1,16 +1,18 @@
-import e from "../../_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorate.js";
-import { FormAssociated as t, FormAssociationController as n, defineFormAssociation as r } from "../../shared/form-association/index.js";
-import { GroupController as i, defineGroupCoordinator as a } from "../../shared/group-management/index.js";
-import { normalizeLiteral as o } from "../../shared/normalize/index.js";
-import { activateRadio as s, focusRadio as c, isRadioDisabled as l } from "../radio/interaction.js";
-import u from "./style.js";
-import { LitElement as d, html as f, unsafeCSS as p } from "lit";
-import { customElement as m, property as h, state as g } from "lit/decorators.js";
-//#region src/components/radio-group/index.ts
-var _ = ["horizontal", "vertical"], v = {
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
+import { FormAssociated, FormAssociationController, defineFormAssociation } from "../../shared/form-association/index.js";
+import { GroupController, defineGroupCoordinator } from "../../shared/group-management/index.js";
+import { normalizeLiteral } from "../../shared/normalize/index.js";
+import { activateRadio, focusRadio, isRadioDisabled } from "../radio/interaction.js";
+import style_default from "./style.js";
+import { LitElement, html, unsafeCSS } from "lit";
+import { customElement, property, state } from "lit/decorators.js";
+// src/components/radio-group/index.ts
+const ALLOWED_DIRECTIONS = ["horizontal", "vertical"];
+const RADIO_GROUP_KEYS = {
 	next: ["ArrowRight", "ArrowDown"],
 	previous: ["ArrowLeft", "ArrowUp"]
-}, y = [
+};
+const AVAILABILITY_ATTRIBUTES = [
 	"hidden",
 	"inert",
 	"aria-hidden",
@@ -19,298 +21,396 @@ var _ = ["horizontal", "vertical"], v = {
 	"open",
 	"popover",
 	"slot"
-], b = /* @__PURE__ */ new WeakMap();
-function x(e, t) {
-	let n = e.defaultView;
-	if (!n) return () => {};
-	let r = b.get(e);
-	if (!r) {
-		let t = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map(), a = () => t.forEach((e) => e()), o = (e) => {
-			let t = e.trim();
-			if (t && t !== "all" && !i.has(t)) try {
-				let e = n.matchMedia(t);
-				e.addEventListener("change", a), i.set(t, e);
+];
+const documentAvailabilityObservers = /* @__PURE__ */ new WeakMap();
+function subscribeToDocumentAvailability(document, callback) {
+	const view = document.defaultView;
+	if (!view) return () => {};
+	let state = documentAvailabilityObservers.get(document);
+	if (!state) {
+		const subscribers = /* @__PURE__ */ new Set();
+		const mediaQueries = /* @__PURE__ */ new Map();
+		const notify = () => subscribers.forEach((subscriber) => subscriber());
+		const subscribeMediaQuery = (query) => {
+			const normalized = query.trim();
+			if (!normalized || normalized === "all" || mediaQueries.has(normalized)) return;
+			try {
+				const mediaQuery = view.matchMedia(normalized);
+				mediaQuery.addEventListener("change", notify);
+				mediaQueries.set(normalized, mediaQuery);
 			} catch {}
-		}, s = (e, t = /* @__PURE__ */ new Set()) => {
-			for (let n of Array.from(e)) {
-				if (n instanceof CSSMediaRule && o(n.conditionText), n instanceof CSSImportRule && n.styleSheet && !t.has(n.styleSheet)) {
-					t.add(n.styleSheet), o(n.media.mediaText);
+		};
+		const scanRules = (rules, visited = /* @__PURE__ */ new Set()) => {
+			for (const rule of Array.from(rules)) {
+				if (rule instanceof CSSMediaRule) subscribeMediaQuery(rule.conditionText);
+				if (rule instanceof CSSImportRule && rule.styleSheet && !visited.has(rule.styleSheet)) {
+					visited.add(rule.styleSheet);
+					subscribeMediaQuery(rule.media.mediaText);
 					try {
-						s(n.styleSheet.cssRules, t);
+						scanRules(rule.styleSheet.cssRules, visited);
 					} catch {}
 				}
-				if ("cssRules" in n) try {
-					s(n.cssRules, t);
+				if ("cssRules" in rule) try {
+					scanRules(rule.cssRules, visited);
 				} catch {}
 			}
-		}, c = () => {
-			for (let e of i.values()) e.removeEventListener("change", a);
-			i.clear();
-			for (let t of Array.from(e.styleSheets)) {
-				o(t.media.mediaText);
+		};
+		const refreshMediaQueries = () => {
+			for (const mediaQuery of mediaQueries.values()) mediaQuery.removeEventListener("change", notify);
+			mediaQueries.clear();
+			for (const styleSheet of Array.from(document.styleSheets)) {
+				subscribeMediaQuery(styleSheet.media.mediaText);
 				try {
-					s(t.cssRules, /* @__PURE__ */ new Set([t]));
+					scanRules(styleSheet.cssRules, /* @__PURE__ */ new Set([styleSheet]));
 				} catch {}
 			}
-		}, l = (e) => {
-			let t = e.target;
-			t instanceof HTMLLinkElement && t.relList.contains("stylesheet") && (c(), a());
-		}, u = (e) => {
-			e.key === "Tab" && (c(), a());
-		}, d = new MutationObserver(() => {
-			c(), a();
-		}), f = e.head ?? e.documentElement;
-		d.observe(f, {
-			attributes: !0,
-			childList: !0,
-			characterData: !0,
-			subtree: !0
-		}), n.addEventListener("resize", a), e.addEventListener("load", l, !0), e.addEventListener("keydown", u, !0), r = {
-			subscribers: t,
-			mediaQueries: i,
-			observer: d,
-			view: n,
-			notify: a,
-			refreshMediaQueries: c,
-			handleStylesheetLoad: l,
-			handleTabKeydown: u
-		}, b.set(e, r), c();
+		};
+		const handleStylesheetLoad = (event) => {
+			const target = event.target;
+			if (!(target instanceof HTMLLinkElement) || !target.relList.contains("stylesheet")) return;
+			refreshMediaQueries();
+			notify();
+		};
+		const handleTabKeydown = (event) => {
+			if (event.key === "Tab") {
+				refreshMediaQueries();
+				notify();
+			}
+		};
+		const observer = new MutationObserver(() => {
+			refreshMediaQueries();
+			notify();
+		});
+		const styleRoot = document.head ?? document.documentElement;
+		observer.observe(styleRoot, {
+			attributes: true,
+			childList: true,
+			characterData: true,
+			subtree: true
+		});
+		view.addEventListener("resize", notify);
+		document.addEventListener("load", handleStylesheetLoad, true);
+		document.addEventListener("keydown", handleTabKeydown, true);
+		state = {
+			subscribers,
+			mediaQueries,
+			observer,
+			view,
+			notify,
+			refreshMediaQueries,
+			handleStylesheetLoad,
+			handleTabKeydown
+		};
+		documentAvailabilityObservers.set(document, state);
+		refreshMediaQueries();
 	}
-	return r.subscribers.add(t), () => {
-		let n = b.get(e);
-		if (n && (n.subscribers.delete(t), !(n.subscribers.size > 0))) {
-			n.observer.disconnect(), n.view.removeEventListener("resize", n.notify), e.removeEventListener("load", n.handleStylesheetLoad, !0), e.removeEventListener("keydown", n.handleTabKeydown, !0);
-			for (let e of n.mediaQueries.values()) e.removeEventListener("change", n.notify);
-			n.mediaQueries.clear(), b.delete(e);
-		}
+	state.subscribers.add(callback);
+	return () => {
+		const current = documentAvailabilityObservers.get(document);
+		if (!current) return;
+		current.subscribers.delete(callback);
+		if (current.subscribers.size > 0) return;
+		current.observer.disconnect();
+		current.view.removeEventListener("resize", current.notify);
+		document.removeEventListener("load", current.handleStylesheetLoad, true);
+		document.removeEventListener("keydown", current.handleTabKeydown, true);
+		for (const mediaQuery of current.mediaQueries.values()) mediaQuery.removeEventListener("change", current.notify);
+		current.mediaQueries.clear();
+		documentAvailabilityObservers.delete(document);
 	};
 }
-var S = class extends t(d) {
-	constructor(...e) {
-		super(...e), this.name = "", this.disabled = !1, this.required = !1, this.ariaLabel = null, this._direction = "vertical", this._value = "", this._groupController = new i(this, a({
+let WebUiRadioGroup = class WebUiRadioGroup extends FormAssociated(LitElement) {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "";
+		this.disabled = false;
+		this.required = false;
+		this.ariaLabel = null;
+		this._direction = "vertical";
+		this._value = "";
+		this._groupController = new GroupController(this, defineGroupCoordinator({
 			host: this,
 			getItems: () => this._getRadios(),
 			getValue: () => this._value,
-			setValue: (e) => {
-				this.value = e;
+			setValue: (value) => {
+				this.value = value;
 			},
 			getDisabled: () => this._isDisabled,
-			isItem: (e) => e instanceof HTMLElement && e.matches("web-ui-radio") && e.closest("web-ui-radio-group") === this,
-			isItemSelected: (e, t) => e === this._findSelectedRadio(this._getRadios(), t),
-			getItemSelected: (e) => e.checked,
-			getNextValue: (e, t) => e.checked ? e.value : t,
-			valuesEqual: (e, t) => e === t,
-			copyValue: (e) => e,
-			setItemSelected: (e, t) => {
-				e.checked = t;
+			isItem: (target) => target instanceof HTMLElement && target.matches("web-ui-radio") && target.closest("web-ui-radio-group") === this,
+			isItemSelected: (radio, value) => radio === this._findSelectedRadio(this._getRadios(), value),
+			getItemSelected: (radio) => radio.checked,
+			getNextValue: (radio, value) => radio.checked ? radio.value : value,
+			valuesEqual: (a, b) => a === b,
+			copyValue: (value) => value,
+			setItemSelected: (radio, selected) => {
+				radio.checked = selected;
 			},
-			getRovingTabStop: (e, t, n, r) => this._getRovingTabStop(e, n, r),
-			handleKeyDown: (e) => this._handleKeyDown(e),
-			resyncOnUnchangedValue: (e) => {
-				for (let t of this._getRadios()) t.checked = t === e;
+			getRovingTabStop: (radio, _index, radios, value) => this._getRovingTabStop(radio, radios, value),
+			handleKeyDown: (event) => this._handleKeyDown(event),
+			resyncOnUnchangedValue: (clicked) => {
+				for (const radio of this._getRadios()) radio.checked = radio === clicked;
 				this._groupController.sync();
 			},
 			dispatchValueChange: () => {
 				this.dispatchEvent(new Event("input", {
-					bubbles: !0,
-					composed: !0
-				})), this.dispatchEvent(new Event("change", {
-					bubbles: !0,
-					composed: !0
+					bubbles: true,
+					composed: true
+				}));
+				this.dispatchEvent(new Event("change", {
+					bubbles: true,
+					composed: true
 				}));
 			}
 		}).make(), {
-			observeAttributes: ["disabled", ...y],
+			observeAttributes: ["disabled", ...AVAILABILITY_ATTRIBUTES],
 			afterSync: () => this._pruneRemovedMembers()
-		}), this._knownMemberValues = /* @__PURE__ */ new Set(), this._availabilityObserver = null, this._availabilityResizeObserver = null, this._availabilityToggleTargets = /* @__PURE__ */ new Set(), this._availabilitySlotTargets = /* @__PURE__ */ new Set(), this._unsubscribeDocumentAvailability = null, this._handleAvailabilityToggle = () => this._groupController.sync(), this._handleAvailabilitySlotChange = () => {
-			this._observeAvailabilityAncestors(), this._groupController.sync();
-		}, this._formAssociation = r({
+		});
+		this._knownMemberValues = /* @__PURE__ */ new Set();
+		this._availabilityObserver = null;
+		this._availabilityResizeObserver = null;
+		this._availabilityToggleTargets = /* @__PURE__ */ new Set();
+		this._availabilitySlotTargets = /* @__PURE__ */ new Set();
+		this._unsubscribeDocumentAvailability = null;
+		this._handleAvailabilityToggle = () => this._groupController.sync();
+		this._handleAvailabilitySlotChange = () => {
+			this._observeAvailabilityAncestors();
+			this._groupController.sync();
+		};
+		this._formAssociation = defineFormAssociation({
 			host: this,
 			initialize: () => {
-				let e = this.getAttribute("value");
-				e !== null && (this.value = e);
+				const attributeValue = this.getAttribute("value");
+				if (attributeValue !== null) this.value = attributeValue;
 			},
 			getState: () => this._value,
-			setState: (e) => {
-				this.value = e;
+			setState: (value) => {
+				this.value = value;
 			},
 			getFormValue: () => this.name && this._value ? this._value : null,
 			getFormState: () => this._value,
-			restoreState: (e) => {
-				typeof e == "string" && (this.value = e);
+			restoreState: (state) => {
+				if (typeof state === "string") this.value = state;
 			},
 			syncValidity: () => this._syncValidity()
-		}).make(), this._formAssociationController = new n(this, this._formAssociation);
+		}).make();
+		this._formAssociationController = new FormAssociationController(this, this._formAssociation);
 	}
 	static {
-		this.styles = p(u);
+		this.styles = unsafeCSS(style_default);
 	}
 	get direction() {
 		return this._direction;
 	}
-	set direction(e) {
-		let t = this._direction;
-		this._direction = o(e, _, "vertical"), this.requestUpdate("direction", t);
+	set direction(v) {
+		const old = this._direction;
+		this._direction = normalizeLiteral(v, ALLOWED_DIRECTIONS, "vertical");
+		this.requestUpdate("direction", old);
 	}
 	_getRadios() {
-		return [...this.querySelectorAll("web-ui-radio")].filter((e) => e.closest("web-ui-radio-group") === this);
+		return [...this.querySelectorAll("web-ui-radio")].filter((radio) => radio.closest("web-ui-radio-group") === this);
 	}
-	_findSelectedRadio(e, t) {
-		if (!t) return;
-		let n = e.filter((e) => e.value === t);
-		return n.find((e) => e.checked) ?? n[0];
+	_findSelectedRadio(radios, value) {
+		if (!value) return void 0;
+		const matching = radios.filter((radio) => radio.value === value);
+		return matching.find((radio) => radio.checked) ?? matching[0];
 	}
-	_getRovingTabStop(e, t, n) {
-		if (this._isDisabled || this._isRadioUnavailable(e)) return !1;
-		let r = t.filter((e) => !this._isRadioUnavailable(e));
-		return e === (r.find((e) => e.checked) ?? this._findSelectedRadio(r, n) ?? r[0]);
+	_getRovingTabStop(radio, radios, value) {
+		if (this._isDisabled || this._isRadioUnavailable(radio)) return false;
+		const enabled = radios.filter((item) => !this._isRadioUnavailable(item));
+		return radio === (enabled.find((item) => item.checked) ?? this._findSelectedRadio(enabled, value) ?? enabled[0]);
 	}
-	_handleKeyDown(e) {
-		if (this._isDisabled || e.defaultPrevented || e.altKey || e.ctrlKey || e.metaKey) return;
-		let t = e.composedPath().find((e) => e instanceof HTMLElement && e.matches("web-ui-radio"));
-		if (!t || t.closest("web-ui-radio-group") !== this) return;
-		let n = this._getRadios(), r = n.indexOf(t);
-		if (r < 0) return;
-		let i = n.filter((e) => !this._isRadioUnavailable(e));
-		if (i.length === 0) return;
-		let a = i.indexOf(t), o = v.next.some((t) => e.key === t) ? 1 : v.previous.some((t) => e.key === t) ? -1 : 0;
-		o && this.direction === "horizontal" && (e.key === "ArrowLeft" || e.key === "ArrowRight") && getComputedStyle(this).direction === "rtl" && (o *= -1);
-		let l;
-		if (o) {
-			if (a >= 0) l = i[(a + o + i.length) % i.length];
-			else for (let e = 1; e <= n.length; e++) {
-				let t = n[((r + o * e) % n.length + n.length) % n.length];
-				if (t && !this._isRadioUnavailable(t)) {
-					l = t;
+	_handleKeyDown(event) {
+		if (this._isDisabled || event.defaultPrevented || event.altKey || event.ctrlKey || event.metaKey) return;
+		const target = event.composedPath().find((node) => node instanceof HTMLElement && node.matches("web-ui-radio"));
+		if (!target || target.closest("web-ui-radio-group") !== this) return;
+		const radios = this._getRadios();
+		const targetIndex = radios.indexOf(target);
+		if (targetIndex < 0) return;
+		const enabledRadios = radios.filter((radio) => !this._isRadioUnavailable(radio));
+		if (enabledRadios.length === 0) return;
+		const currentIndex = enabledRadios.indexOf(target);
+		let delta = RADIO_GROUP_KEYS.next.some((key) => event.key === key) ? 1 : RADIO_GROUP_KEYS.previous.some((key) => event.key === key) ? -1 : 0;
+		if (delta && this.direction === "horizontal" && (event.key === "ArrowLeft" || event.key === "ArrowRight") && getComputedStyle(this).direction === "rtl") delta *= -1;
+		let nextRadio;
+		if (delta) {
+			if (currentIndex >= 0) nextRadio = enabledRadios[(currentIndex + delta + enabledRadios.length) % enabledRadios.length];
+			else for (let step = 1; step <= radios.length; step++) {
+				const candidate = radios[((targetIndex + delta * step) % radios.length + radios.length) % radios.length];
+				if (candidate && !this._isRadioUnavailable(candidate)) {
+					nextRadio = candidate;
 					break;
 				}
 			}
-		} else if (e.key === "Home") l = i[0];
-		else if (e.key === "End") l = i[i.length - 1];
+		} else if (event.key === "Home") nextRadio = enabledRadios[0];
+		else if (event.key === "End") nextRadio = enabledRadios[enabledRadios.length - 1];
 		else return;
-		l && (e.preventDefault(), c(l), l.checked || s(l));
+		if (!nextRadio) return;
+		event.preventDefault();
+		focusRadio(nextRadio);
+		if (!nextRadio.checked) activateRadio(nextRadio);
 	}
-	_getComposedAncestors(e) {
-		let t = [], n = /* @__PURE__ */ new Set(), r = e;
-		for (; r && !n.has(r);) {
-			n.add(r), t.push(r);
-			let e = r.getRootNode();
-			r = r.assignedSlot ?? r.parentElement ?? (e instanceof ShadowRoot ? e.host : null);
+	_getComposedAncestors(element) {
+		const ancestors = [];
+		const visited = /* @__PURE__ */ new Set();
+		let current = element;
+		while (current && !visited.has(current)) {
+			visited.add(current);
+			ancestors.push(current);
+			const root = current.getRootNode();
+			current = current.assignedSlot ?? current.parentElement ?? (root instanceof ShadowRoot ? root.host : null);
 		}
-		return t;
+		return ancestors;
 	}
 	_pruneRemovedMembers() {
 		if (!this._value) return;
-		let e = this._getRadios();
-		if (e.length === 0) return;
-		let t = new Set(e.map((e) => e.value));
-		!t.has(this._value) && this._knownMemberValues.has(this._value) && (this.value = ""), this._knownMemberValues = t;
+		const items = this._getRadios();
+		if (items.length === 0) return;
+		const alive = new Set(items.map((item) => item.value));
+		if (!alive.has(this._value) && this._knownMemberValues.has(this._value)) this.value = "";
+		this._knownMemberValues = alive;
 	}
 	get value() {
 		return this._value;
 	}
-	set value(e) {
-		let t = this._value;
-		this._value = e, this._formAssociation.sync(), this.requestUpdate("value", t);
+	set value(v) {
+		const old = this._value;
+		this._value = v;
+		this._formAssociation.sync();
+		this.requestUpdate("value", old);
 	}
 	get _isDisabled() {
 		return this.disabled || this._formAssociation.isFormDisabled();
 	}
 	connectedCallback() {
-		this._syncHostSemantics(), this._observeAvailabilityAncestors(), this._unsubscribeDocumentAvailability?.(), this._unsubscribeDocumentAvailability = x(this.ownerDocument, () => this._groupController.sync()), super.connectedCallback();
+		this._syncHostSemantics();
+		this._observeAvailabilityAncestors();
+		this._unsubscribeDocumentAvailability?.();
+		this._unsubscribeDocumentAvailability = subscribeToDocumentAvailability(this.ownerDocument, () => this._groupController.sync());
+		super.connectedCallback();
 	}
 	disconnectedCallback() {
-		this._availabilityObserver?.disconnect(), this._availabilityObserver = null, this._availabilityResizeObserver?.disconnect(), this._availabilityResizeObserver = null, this._syncAvailabilityToggleTargets([]), this._syncAvailabilitySlotTargets([]), this._unsubscribeDocumentAvailability?.(), this._unsubscribeDocumentAvailability = null, super.disconnectedCallback();
+		this._availabilityObserver?.disconnect();
+		this._availabilityObserver = null;
+		this._availabilityResizeObserver?.disconnect();
+		this._availabilityResizeObserver = null;
+		this._syncAvailabilityToggleTargets([]);
+		this._syncAvailabilitySlotTargets([]);
+		this._unsubscribeDocumentAvailability?.();
+		this._unsubscribeDocumentAvailability = null;
+		super.disconnectedCallback();
 	}
 	updated() {
 		this._syncHostSemantics();
 	}
 	_syncHostSemantics() {
-		this.setAttribute("role", "radiogroup"), this.setAttribute("aria-orientation", this.direction), this.setAttribute("aria-disabled", String(this._isDisabled)), this.setAttribute("aria-required", String(this.required));
+		this.setAttribute("role", "radiogroup");
+		this.setAttribute("aria-orientation", this.direction);
+		this.setAttribute("aria-disabled", String(this._isDisabled));
+		this.setAttribute("aria-required", String(this.required));
 	}
-	_isRadioUnavailable(e) {
-		if (l(e) || e.matches(":disabled")) return !0;
-		let t = this._getComposedAncestors(e), n = (e) => {
-			let n = [...e.children].find((e) => e.localName === "summary");
-			return n !== void 0 && t.includes(n);
+	_isRadioUnavailable(radio) {
+		if (isRadioDisabled(radio) || radio.matches(":disabled")) return true;
+		const ancestors = this._getComposedAncestors(radio);
+		const isInVisibleSummary = (details) => {
+			const summary = [...details.children].find((child) => child.localName === "summary");
+			return summary !== void 0 && ancestors.includes(summary);
 		};
-		if (t.some((e) => e.hasAttribute("hidden") || e.hasAttribute("inert") || e.getAttribute("aria-hidden")?.toLowerCase() === "true" || e.localName === "details" && !e.hasAttribute("open") && !n(e))) return !0;
-		let r = e.ownerDocument.defaultView;
-		if (!r) return !1;
-		let i = r.getComputedStyle(e).visibility;
-		if (i === "hidden" || i === "collapse") return !0;
-		for (let e of t) {
-			let t = r.getComputedStyle(e);
-			if (t.display === "none" || t.getPropertyValue("content-visibility") === "hidden") return !0;
+		if (ancestors.some((element) => element.hasAttribute("hidden") || element.hasAttribute("inert") || element.getAttribute("aria-hidden")?.toLowerCase() === "true" || element.localName === "details" && !element.hasAttribute("open") && !isInVisibleSummary(element))) return true;
+		const view = radio.ownerDocument.defaultView;
+		if (!view) return false;
+		const radioVisibility = view.getComputedStyle(radio).visibility;
+		if (radioVisibility === "hidden" || radioVisibility === "collapse") return true;
+		for (const element of ancestors) {
+			const style = view.getComputedStyle(element);
+			if (style.display === "none" || style.getPropertyValue("content-visibility") === "hidden") return true;
 		}
-		return !1;
+		return false;
 	}
 	_observeAvailabilityAncestors() {
-		this._availabilityObserver?.disconnect(), this._availabilityObserver = null, this._availabilityResizeObserver?.disconnect(), this._availabilityResizeObserver = null;
-		let e = this._getComposedAncestors(this);
-		if (this._syncAvailabilityToggleTargets(e), this._syncAvailabilitySlotTargets(e), e.length !== 0) {
-			this._availabilityObserver = new MutationObserver((e) => {
-				e.some((e) => e.attributeName === "popover" || e.attributeName === "slot") && this._observeAvailabilityAncestors(), this._groupController.sync();
-			});
-			for (let t of e) this._availabilityObserver.observe(t, {
-				attributes: !0,
-				attributeFilter: [...y]
-			});
-			if (typeof ResizeObserver < "u") {
-				this._availabilityResizeObserver = new ResizeObserver(() => this._groupController.sync());
-				for (let t of e) this._availabilityResizeObserver.observe(t);
-			}
+		this._availabilityObserver?.disconnect();
+		this._availabilityObserver = null;
+		this._availabilityResizeObserver?.disconnect();
+		this._availabilityResizeObserver = null;
+		const ancestors = this._getComposedAncestors(this);
+		this._syncAvailabilityToggleTargets(ancestors);
+		this._syncAvailabilitySlotTargets(ancestors);
+		if (ancestors.length === 0) return;
+		this._availabilityObserver = new MutationObserver((records) => {
+			if (records.some((record) => record.attributeName === "popover" || record.attributeName === "slot")) this._observeAvailabilityAncestors();
+			this._groupController.sync();
+		});
+		for (const ancestor of ancestors) this._availabilityObserver.observe(ancestor, {
+			attributes: true,
+			attributeFilter: [...AVAILABILITY_ATTRIBUTES]
+		});
+		if (typeof ResizeObserver !== "undefined") {
+			this._availabilityResizeObserver = new ResizeObserver(() => this._groupController.sync());
+			for (const ancestor of ancestors) this._availabilityResizeObserver.observe(ancestor);
 		}
 	}
-	_syncAvailabilityToggleTargets(e) {
-		for (let e of this._availabilityToggleTargets) e.removeEventListener("toggle", this._handleAvailabilityToggle);
+	_syncAvailabilityToggleTargets(ancestors) {
+		for (const target of this._availabilityToggleTargets) target.removeEventListener("toggle", this._handleAvailabilityToggle);
 		this._availabilityToggleTargets.clear();
-		for (let t of e) t.hasAttribute("popover") && (t.addEventListener("toggle", this._handleAvailabilityToggle), this._availabilityToggleTargets.add(t));
+		for (const ancestor of ancestors) {
+			if (!ancestor.hasAttribute("popover")) continue;
+			ancestor.addEventListener("toggle", this._handleAvailabilityToggle);
+			this._availabilityToggleTargets.add(ancestor);
+		}
 	}
-	_syncAvailabilitySlotTargets(e) {
-		for (let e of this._availabilitySlotTargets) e.removeEventListener("slotchange", this._handleAvailabilitySlotChange);
+	_syncAvailabilitySlotTargets(ancestors) {
+		for (const target of this._availabilitySlotTargets) target.removeEventListener("slotchange", this._handleAvailabilitySlotChange);
 		this._availabilitySlotTargets.clear();
-		for (let t of e) t.localName === "slot" && (t.addEventListener("slotchange", this._handleAvailabilitySlotChange), this._availabilitySlotTargets.add(t));
+		for (const ancestor of ancestors) {
+			if (ancestor.localName !== "slot") continue;
+			ancestor.addEventListener("slotchange", this._handleAvailabilitySlotChange);
+			this._availabilitySlotTargets.add(ancestor);
+		}
 	}
-	formDisabledCallback(e) {
-		this._formAssociation.setDisabled(e), this._groupController.sync();
+	formDisabledCallback(disabled) {
+		this._formAssociation.setDisabled(disabled);
+		this._groupController.sync();
 	}
 	_syncValidity() {
-		let e = this._formAssociation.getInternals();
-		if (e && typeof e.setValidity == "function") {
-			if (this._isDisabled || !this.required || this._value) {
-				e.setValidity({});
-				return;
-			}
-			e.setValidity({ valueMissing: !0 }, "Select an option");
+		const internals = this._formAssociation.getInternals();
+		if (!internals || typeof internals.setValidity !== "function") return;
+		if (this._isDisabled || !this.required || this._value) {
+			internals.setValidity({});
+			return;
 		}
+		internals.setValidity({ valueMissing: true }, "Select an option");
 	}
 	render() {
-		return f`<div class="wui-radio-group"><slot></slot></div>`;
+		return html`<div class="wui-radio-group"><slot></slot></div>`;
 	}
 };
-e([h({
+__decorate([property({
 	type: String,
-	reflect: !0
-})], S.prototype, "name", void 0), e([h({
+	reflect: true
+})], WebUiRadioGroup.prototype, "name", void 0);
+__decorate([property({
 	type: Boolean,
-	reflect: !0
-})], S.prototype, "disabled", void 0), e([h({
+	reflect: true
+})], WebUiRadioGroup.prototype, "disabled", void 0);
+__decorate([property({
 	type: Boolean,
-	reflect: !0
-})], S.prototype, "required", void 0), e([h({
+	reflect: true
+})], WebUiRadioGroup.prototype, "required", void 0);
+__decorate([property({
 	type: String,
 	attribute: "aria-label",
-	reflect: !0
-})], S.prototype, "ariaLabel", void 0), e([h({
+	reflect: true
+})], WebUiRadioGroup.prototype, "ariaLabel", void 0);
+__decorate([property({
 	type: String,
 	attribute: "aria-labelledby",
-	reflect: !0
-})], S.prototype, "ariaLabelledby", void 0), e([h({
+	reflect: true
+})], WebUiRadioGroup.prototype, "ariaLabelledby", void 0);
+__decorate([property({
 	type: String,
-	reflect: !0
-})], S.prototype, "direction", null), e([g()], S.prototype, "_value", void 0), S = e([m("web-ui-radio-group")], S);
-//#endregion
-export { S as WebUiRadioGroup };
+	reflect: true
+})], WebUiRadioGroup.prototype, "direction", null);
+__decorate([state()], WebUiRadioGroup.prototype, "_value", void 0);
+WebUiRadioGroup = __decorate([customElement("web-ui-radio-group")], WebUiRadioGroup);
+export { WebUiRadioGroup };
 
 //# sourceMappingURL=index.js.map