@youcan/celeste 0.6.102 → 0.7.1

package/dist/cjs/chunks/PopperRoot.cjs

@@ -0,0 +1,32 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Popper/PopperRoot.js
+var [injectPopperRootContext, providePopperRootContext] = /* @__PURE__ */ require_createContext.createContext("PopperRoot");
+var PopperRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	inheritAttrs: false,
+	__name: "PopperRoot",
+	setup(__props) {
+		const anchor = (0, vue.ref)();
+		providePopperRootContext({
+			anchor,
+			onAnchorChange: (element) => anchor.value = element
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.renderSlot)(_ctx.$slots, "default");
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "PopperRoot_default", {
+	enumerable: true,
+	get: function() {
+		return PopperRoot_default;
+	}
+});
+Object.defineProperty(exports, "injectPopperRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectPopperRootContext;
+	}
+});

package/dist/cjs/chunks/Presence.cjs

@@ -0,0 +1,194 @@
+require("./chunk.cjs");
+const require_dist = require("./dist.cjs");
+const require_Primitive = require("./Primitive.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/shared/useStateMachine.js
+/**
+* The `useStateMachine` function is a TypeScript function that creates a state machine and returns the
+* current state and a dispatch function to update the state based on events.
+* @param initialState - The `initialState` parameter is the initial state of the state machine. It
+* represents the starting point of the state machine's state.
+* @param machine - The `machine` parameter is an object that represents a state machine. It should
+* have keys that correspond to the possible states of the machine, and the values should be objects
+* that represent the possible events and their corresponding next states.
+* @returns The `useStateMachine` function returns an object with two properties: `state` and
+* `dispatch`.
+*/
+function useStateMachine(initialState, machine) {
+	const state = (0, vue.ref)(initialState);
+	function reducer(event) {
+		return machine[state.value][event] ?? state.value;
+	}
+	const dispatch = (event) => {
+		state.value = reducer(event);
+	};
+	return {
+		state,
+		dispatch
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Presence/usePresence.js
+function usePresence(present, node) {
+	const stylesRef = (0, vue.ref)({});
+	const prevAnimationNameRef = (0, vue.ref)("none");
+	const prevPresentRef = (0, vue.ref)(present);
+	const initialState = present.value ? "mounted" : "unmounted";
+	let timeoutId;
+	const ownerWindow = node.value?.ownerDocument.defaultView ?? require_dist.defaultWindow;
+	const { state, dispatch } = useStateMachine(initialState, {
+		mounted: {
+			UNMOUNT: "unmounted",
+			ANIMATION_OUT: "unmountSuspended"
+		},
+		unmountSuspended: {
+			MOUNT: "mounted",
+			ANIMATION_END: "unmounted"
+		},
+		unmounted: { MOUNT: "mounted" }
+	});
+	const dispatchCustomEvent = (name) => {
+		if (require_dist.isClient) {
+			const customEvent = new CustomEvent(name, {
+				bubbles: false,
+				cancelable: false
+			});
+			node.value?.dispatchEvent(customEvent);
+		}
+	};
+	(0, vue.watch)(present, async (currentPresent, prevPresent) => {
+		const hasPresentChanged = prevPresent !== currentPresent;
+		await (0, vue.nextTick)();
+		if (hasPresentChanged) {
+			const prevAnimationName = prevAnimationNameRef.value;
+			const currentAnimationName = getAnimationName(node.value);
+			if (currentPresent) {
+				dispatch("MOUNT");
+				dispatchCustomEvent("enter");
+				if (currentAnimationName === "none") dispatchCustomEvent("after-enter");
+			} else if (currentAnimationName === "none" || currentAnimationName === "undefined" || stylesRef.value?.display === "none") {
+				dispatch("UNMOUNT");
+				dispatchCustomEvent("leave");
+				dispatchCustomEvent("after-leave");
+			} else if (prevPresent && prevAnimationName !== currentAnimationName) {
+				dispatch("ANIMATION_OUT");
+				dispatchCustomEvent("leave");
+			} else {
+				dispatch("UNMOUNT");
+				dispatchCustomEvent("after-leave");
+			}
+		}
+	}, { immediate: true });
+	/**
+	* Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`
+	* event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we
+	* make sure we only trigger ANIMATION_END for the currently active animation.
+	*/
+	const handleAnimationEnd = (event) => {
+		const currentAnimationName = getAnimationName(node.value);
+		const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
+		const directionName = state.value === "mounted" ? "enter" : "leave";
+		if (event.target === node.value && isCurrentAnimation) {
+			dispatchCustomEvent(`after-${directionName}`);
+			dispatch("ANIMATION_END");
+			if (!prevPresentRef.value) {
+				const currentFillMode = node.value.style.animationFillMode;
+				node.value.style.animationFillMode = "forwards";
+				timeoutId = ownerWindow?.setTimeout(() => {
+					if (node.value?.style.animationFillMode === "forwards") node.value.style.animationFillMode = currentFillMode;
+				});
+			}
+		}
+		if (event.target === node.value && currentAnimationName === "none") dispatch("ANIMATION_END");
+	};
+	const handleAnimationStart = (event) => {
+		if (event.target === node.value) prevAnimationNameRef.value = getAnimationName(node.value);
+	};
+	const watcher = (0, vue.watch)(node, (newNode, oldNode) => {
+		if (newNode) {
+			stylesRef.value = getComputedStyle(newNode);
+			newNode.addEventListener("animationstart", handleAnimationStart);
+			newNode.addEventListener("animationcancel", handleAnimationEnd);
+			newNode.addEventListener("animationend", handleAnimationEnd);
+		} else {
+			dispatch("ANIMATION_END");
+			if (timeoutId !== void 0) ownerWindow?.clearTimeout(timeoutId);
+			oldNode?.removeEventListener("animationstart", handleAnimationStart);
+			oldNode?.removeEventListener("animationcancel", handleAnimationEnd);
+			oldNode?.removeEventListener("animationend", handleAnimationEnd);
+		}
+	}, { immediate: true });
+	const stateWatcher = (0, vue.watch)(state, () => {
+		const currentAnimationName = getAnimationName(node.value);
+		prevAnimationNameRef.value = state.value === "mounted" ? currentAnimationName : "none";
+	});
+	(0, vue.onUnmounted)(() => {
+		watcher();
+		stateWatcher();
+		if (node.value) {
+			node.value.removeEventListener("animationstart", handleAnimationStart);
+			node.value.removeEventListener("animationcancel", handleAnimationEnd);
+			node.value.removeEventListener("animationend", handleAnimationEnd);
+		}
+		if (timeoutId !== void 0) ownerWindow?.clearTimeout(timeoutId);
+	});
+	return { isPresent: (0, vue.computed)(() => ["mounted", "unmountSuspended"].includes(state.value)) };
+}
+function getAnimationName(node) {
+	return node ? getComputedStyle(node).animationName || "none" : "none";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Presence/Presence.js
+var Presence_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	name: "Presence",
+	props: {
+		present: {
+			type: Boolean,
+			required: true
+		},
+		forceMount: { type: Boolean }
+	},
+	slots: {},
+	setup(props, { slots, expose }) {
+		const { present, forceMount } = (0, vue.toRefs)(props);
+		const node = (0, vue.ref)();
+		const { isPresent } = usePresence(present, node);
+		expose({ present: isPresent });
+		let children = slots.default({ present: isPresent.value });
+		children = require_Primitive.renderSlotFragments(children || []);
+		const instance = (0, vue.getCurrentInstance)();
+		if (children && children?.length > 1) {
+			const componentName = instance?.parent?.type.name ? `<${instance.parent.type.name} />` : "component";
+			throw new Error([
+				`Detected an invalid children for \`${componentName}\` for  \`Presence\` component.`,
+				"",
+				"Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",
+				"You can apply a few solutions:",
+				["Provide a single child element so that `presence` directive attach correctly.", "Ensure the first child is an actual element instead of a raw text node or comment node."].map((line) => `  - ${line}`).join("\n")
+			].join("\n"));
+		}
+		return () => {
+			if (forceMount.value || present.value || isPresent.value) return (0, vue.h)(slots.default({ present: isPresent.value })[0], { ref: (v) => {
+				const el = require_dist.unrefElement(v);
+				if (typeof el?.hasAttribute === "undefined") return el;
+				if (el?.hasAttribute("data-reka-popper-content-wrapper")) node.value = el.firstElementChild;
+				else node.value = el;
+				return el;
+			} });
+			else return null;
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "Presence_default", {
+	enumerable: true,
+	get: function() {
+		return Presence_default;
+	}
+});
+Object.defineProperty(exports, "useStateMachine", {
+	enumerable: true,
+	get: function() {
+		return useStateMachine;
+	}
+});

package/dist/cjs/chunks/Primitive.cjs

@@ -0,0 +1,80 @@
+require("./chunk.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/shared/renderSlotFragments.js
+function renderSlotFragments(children) {
+	if (!children) return [];
+	return children.flatMap((child) => {
+		if (child.type === vue.Fragment) return renderSlotFragments(child.children);
+		return [child];
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Primitive/Slot.js
+var Slot = /* @__PURE__ */ (0, vue.defineComponent)({
+	name: "PrimitiveSlot",
+	inheritAttrs: false,
+	setup(_, { attrs, slots }) {
+		return () => {
+			if (!slots.default) return null;
+			const children = renderSlotFragments(slots.default());
+			const firstNonCommentChildrenIndex = children.findIndex((child) => child.type !== vue.Comment);
+			if (firstNonCommentChildrenIndex === -1) return children;
+			const firstNonCommentChildren = children[firstNonCommentChildrenIndex];
+			delete firstNonCommentChildren.props?.ref;
+			const mergedProps = firstNonCommentChildren.props ? (0, vue.mergeProps)(attrs, firstNonCommentChildren.props) : attrs;
+			const cloned = (0, vue.cloneVNode)({
+				...firstNonCommentChildren,
+				props: {}
+			}, mergedProps);
+			if (children.length === 1) return cloned;
+			children[firstNonCommentChildrenIndex] = cloned;
+			return children;
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Primitive/Primitive.js
+var SELF_CLOSING_TAGS = [
+	"area",
+	"img",
+	"input"
+];
+var Primitive = /* @__PURE__ */ (0, vue.defineComponent)({
+	name: "Primitive",
+	inheritAttrs: false,
+	props: {
+		asChild: {
+			type: Boolean,
+			default: false
+		},
+		as: {
+			type: [String, Object],
+			default: "div"
+		}
+	},
+	setup(props, { attrs, slots }) {
+		const asTag = props.asChild ? "template" : props.as;
+		if (typeof asTag === "string" && SELF_CLOSING_TAGS.includes(asTag)) return () => (0, vue.h)(asTag, attrs);
+		if (asTag !== "template") return () => (0, vue.h)(props.as, attrs, { default: slots.default });
+		return () => (0, vue.h)(Slot, attrs, { default: slots.default });
+	}
+});
+//#endregion
+Object.defineProperty(exports, "Primitive", {
+	enumerable: true,
+	get: function() {
+		return Primitive;
+	}
+});
+Object.defineProperty(exports, "Slot", {
+	enumerable: true,
+	get: function() {
+		return Slot;
+	}
+});
+Object.defineProperty(exports, "renderSlotFragments", {
+	enumerable: true,
+	get: function() {
+		return renderSlotFragments;
+	}
+});

package/dist/cjs/chunks/ProgressIndicator.cjs

@@ -0,0 +1,161 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_nullish = require("./nullish.cjs");
+const require_dist = require("./dist.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Progress/ProgressRoot.js
+var DEFAULT_MAX = 100;
+var [injectProgressRootContext, provideProgressRootContext] = /* @__PURE__ */ require_createContext.createContext("ProgressRoot");
+var isNumber = (v) => typeof v === "number";
+function validateValue(value, max) {
+	if (require_nullish.isNullish(value) || isNumber(value) && !Number.isNaN(value) && value <= max && value >= 0) return value;
+	console.error(`Invalid prop \`value\` of value \`${value}\` supplied to \`ProgressRoot\`. The \`value\` prop must be:
+  - a positive number
+  - less than the value passed to \`max\` (or ${DEFAULT_MAX} if no \`max\` prop is set)
+  - \`null\`  or \`undefined\` if the progress is indeterminate.
+
+Defaulting to \`null\`.`);
+	return null;
+}
+function validateMax(max) {
+	if (isNumber(max) && !Number.isNaN(max) && max > 0) return max;
+	console.error(`Invalid prop \`max\` of value \`${max}\` supplied to \`ProgressRoot\`. Only numbers greater than 0 are valid max values. Defaulting to \`${DEFAULT_MAX}\`.`);
+	return DEFAULT_MAX;
+}
+var ProgressRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "ProgressRoot",
+	props: {
+		modelValue: {
+			type: [Number, null],
+			required: false
+		},
+		max: {
+			type: Number,
+			required: false,
+			default: DEFAULT_MAX
+		},
+		getValueLabel: {
+			type: Function,
+			required: false,
+			default: (value, max) => isNumber(value) ? `${Math.round(value / max * DEFAULT_MAX)}%` : void 0
+		},
+		getValueText: {
+			type: Function,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["update:modelValue", "update:max"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		require_useForwardExpose.useForwardExpose();
+		const modelValue = require_dist.useVModel(props, "modelValue", emit, { passive: props.modelValue === void 0 });
+		const max = require_dist.useVModel(props, "max", emit, { passive: props.max === void 0 });
+		(0, vue.watch)(() => modelValue.value, async (value) => {
+			const correctedValue = validateValue(value, props.max);
+			if (correctedValue !== value) {
+				await (0, vue.nextTick)();
+				modelValue.value = correctedValue;
+			}
+		}, { immediate: true });
+		(0, vue.watch)(() => props.max, (newMax) => {
+			const correctedMax = validateMax(props.max);
+			if (correctedMax !== newMax) max.value = correctedMax;
+		}, { immediate: true });
+		const progressState = (0, vue.computed)(() => {
+			if (require_nullish.isNullish(modelValue.value)) return "indeterminate";
+			if (modelValue.value === max.value) return "complete";
+			return "loading";
+		});
+		provideProgressRootContext({
+			modelValue,
+			max,
+			progressState
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				"as-child": _ctx.asChild,
+				as: _ctx.as,
+				"aria-valuemax": (0, vue.unref)(max),
+				"aria-valuemin": 0,
+				"aria-valuenow": isNumber((0, vue.unref)(modelValue)) ? (0, vue.unref)(modelValue) : void 0,
+				"aria-valuetext": _ctx.getValueText?.((0, vue.unref)(modelValue), (0, vue.unref)(max)),
+				"aria-label": _ctx.getValueLabel((0, vue.unref)(modelValue), (0, vue.unref)(max)),
+				role: "progressbar",
+				"data-state": progressState.value,
+				"data-value": (0, vue.unref)(modelValue) ?? void 0,
+				"data-max": (0, vue.unref)(max)
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { modelValue: (0, vue.unref)(modelValue) })]),
+				_: 3
+			}, 8, [
+				"as-child",
+				"as",
+				"aria-valuemax",
+				"aria-valuenow",
+				"aria-valuetext",
+				"aria-label",
+				"data-state",
+				"data-value",
+				"data-max"
+			]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Progress/ProgressIndicator.js
+var ProgressIndicator_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "ProgressIndicator",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = injectProgressRootContext();
+		require_useForwardExpose.useForwardExpose();
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), (0, vue.mergeProps)(props, {
+				"data-state": (0, vue.unref)(rootContext).progressState.value,
+				"data-value": (0, vue.unref)(rootContext).modelValue?.value ?? void 0,
+				"data-max": (0, vue.unref)(rootContext).max.value
+			}), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, [
+				"data-state",
+				"data-value",
+				"data-max"
+			]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "ProgressIndicator_default", {
+	enumerable: true,
+	get: function() {
+		return ProgressIndicator_default;
+	}
+});
+Object.defineProperty(exports, "ProgressRoot_default", {
+	enumerable: true,
+	get: function() {
+		return ProgressRoot_default;
+	}
+});

package/dist/cjs/chunks/RadioGroupRoot.cjs

@@ -0,0 +1,143 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useDirection = require("./useDirection.cjs");
+const require_useFormControl = require("./useFormControl.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_VisuallyHiddenInput = require("./VisuallyHiddenInput.cjs");
+const require_RovingFocusGroup = require("./RovingFocusGroup.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RadioGroup/RadioGroupRoot.js
+var [injectRadioGroupRootContext, provideRadioGroupRootContext] = /* @__PURE__ */ require_createContext.createContext("RadioGroupRoot");
+var RadioGroupRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "RadioGroupRoot",
+	props: {
+		modelValue: {
+			type: null,
+			required: false
+		},
+		defaultValue: {
+			type: null,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		orientation: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		loop: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false,
+			default: false
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { forwardRef, currentElement } = require_useForwardExpose.useForwardExpose();
+		const modelValue = require_dist.useVModel(props, "modelValue", emits, {
+			defaultValue: props.defaultValue,
+			passive: props.modelValue === void 0
+		});
+		const { disabled, loop, orientation, name, required, dir: propDir } = (0, vue.toRefs)(props);
+		const dir = require_useDirection.useDirection(propDir);
+		const isFormControl = require_useFormControl.useFormControl(currentElement);
+		provideRadioGroupRootContext({
+			modelValue,
+			changeModelValue: (value) => {
+				modelValue.value = value;
+			},
+			disabled,
+			loop,
+			orientation,
+			name: name?.value,
+			required
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_RovingFocusGroup.RovingFocusGroup_default), {
+				"as-child": "",
+				orientation: (0, vue.unref)(orientation),
+				dir: (0, vue.unref)(dir),
+				loop: (0, vue.unref)(loop)
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_Primitive.Primitive), {
+					ref: (0, vue.unref)(forwardRef),
+					role: "radiogroup",
+					"data-disabled": (0, vue.unref)(disabled) ? "" : void 0,
+					"as-child": _ctx.asChild,
+					as: _ctx.as,
+					"aria-orientation": (0, vue.unref)(orientation),
+					"aria-required": (0, vue.unref)(required),
+					dir: (0, vue.unref)(dir)
+				}, {
+					default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { modelValue: (0, vue.unref)(modelValue) }), (0, vue.unref)(isFormControl) && (0, vue.unref)(name) ? ((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHiddenInput.VisuallyHiddenInput_default), {
+						key: 0,
+						required: (0, vue.unref)(required),
+						disabled: (0, vue.unref)(disabled),
+						value: (0, vue.unref)(modelValue),
+						name: (0, vue.unref)(name)
+					}, null, 8, [
+						"required",
+						"disabled",
+						"value",
+						"name"
+					])) : (0, vue.createCommentVNode)("v-if", true)]),
+					_: 3
+				}, 8, [
+					"data-disabled",
+					"as-child",
+					"as",
+					"aria-orientation",
+					"aria-required",
+					"dir"
+				])]),
+				_: 3
+			}, 8, [
+				"orientation",
+				"dir",
+				"loop"
+			]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "RadioGroupRoot_default", {
+	enumerable: true,
+	get: function() {
+		return RadioGroupRoot_default;
+	}
+});
+Object.defineProperty(exports, "injectRadioGroupRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectRadioGroupRootContext;
+	}
+});