@soroush.tech/design-system 0.1.0

package/dist/MenuItem.d.cts

@@ -0,0 +1,51 @@
+import { o as Theme } from "./index-Bihpwn75.cjs";
+import { ElementType, ReactNode } from "react";
+//#region src/MenuItem/MenuItem.d.ts
+type MenuItemColor = keyof Theme['palette'];
+type MenuItemSize = keyof Theme['sizes'];
+type MenuItemTextColor = keyof Theme['text'];
+interface MenuItemProps {
+  /** The value this option represents — reported to `Select`'s `onChange`. */
+  value: string | number;
+  /** The option label. */
+  children: ReactNode;
+  /** The element used for the root node — a tag name or a component. Default: `'li'`. */
+  as?: ElementType;
+  /** Disables the option — it cannot be highlighted or selected. */
+  disabled?: boolean;
+  /** Marks the option as the current selection. Injected by `Select`. */
+  selected?: boolean;
+  /** Marks the option as the keyboard-highlighted row. Injected by `Select`. */
+  highlighted?: boolean;
+  /** Reserves a leading checkmark slot for multi-select menus. Injected by `Select`. */
+  multiple?: boolean;
+  /** Accent color — resolves to `theme.palette[color]`. Injected by `Select`; the item's own value wins. Default: 'primary', overridable via `theme.defaults.color`. */
+  color?: MenuItemColor;
+  /** Base text color of the row — resolves against `theme.text`. When unset, falls back to the accent color's `main`. Injected by `Select`; the item's own value wins. */
+  textColor?: MenuItemTextColor;
+  /** Density token — resolves against `theme.sizes`. Injected by `Select`. Default: 'md', overridable via `theme.defaults.size`. */
+  size?: MenuItemSize;
+  /** Compact vertical padding, independent of `size`. Default: `false`. */
+  dense?: boolean;
+  /** Remove the left and right padding. Default: `false`. */
+  disableGutters?: boolean;
+  /** Add a 1px bottom border to separate the row. Default: `false`. */
+  divider?: boolean;
+  /** Focus the row on first mount, and whenever `autoFocus` flips from `false` to `true`. Default: `false`. */
+  autoFocus?: boolean;
+  /** Class applied only while the row has keyboard focus — a `:focus-visible` hook. */
+  focusVisibleClassName?: string;
+  /** Fired with `value` when the option is chosen. Injected by `Select`. */
+  onSelect?: (value: string | number) => void;
+  id?: string;
+  className?: string;
+  'data-testid'?: string;
+}
+/**
+ * @description A single option row for `Select`'s listbox. Rendered as a semantic
+ * `<li role="option">` (override via `as`). Selection/highlight/density props are
+ * injected by `Select`; used on its own it renders a static, styled row.
+ */
+declare function MenuItem({ value, children, as, disabled, selected, highlighted, multiple, color: colorProp, textColor, size: sizeProp, dense, disableGutters, divider, autoFocus, focusVisibleClassName, onSelect, id, className, 'data-testid': dataTestid }: Readonly<MenuItemProps>): import("react").JSX.Element;
+//#endregion
+export { MenuItem, MenuItemColor, MenuItemProps, MenuItemSize, MenuItemTextColor };

package/dist/MenuItem.d.mts

@@ -0,0 +1,51 @@
+import { o as Theme } from "./index-Dm9HfgV6.mjs";
+import { ElementType, ReactNode } from "react";
+//#region src/MenuItem/MenuItem.d.ts
+type MenuItemColor = keyof Theme['palette'];
+type MenuItemSize = keyof Theme['sizes'];
+type MenuItemTextColor = keyof Theme['text'];
+interface MenuItemProps {
+  /** The value this option represents — reported to `Select`'s `onChange`. */
+  value: string | number;
+  /** The option label. */
+  children: ReactNode;
+  /** The element used for the root node — a tag name or a component. Default: `'li'`. */
+  as?: ElementType;
+  /** Disables the option — it cannot be highlighted or selected. */
+  disabled?: boolean;
+  /** Marks the option as the current selection. Injected by `Select`. */
+  selected?: boolean;
+  /** Marks the option as the keyboard-highlighted row. Injected by `Select`. */
+  highlighted?: boolean;
+  /** Reserves a leading checkmark slot for multi-select menus. Injected by `Select`. */
+  multiple?: boolean;
+  /** Accent color — resolves to `theme.palette[color]`. Injected by `Select`; the item's own value wins. Default: 'primary', overridable via `theme.defaults.color`. */
+  color?: MenuItemColor;
+  /** Base text color of the row — resolves against `theme.text`. When unset, falls back to the accent color's `main`. Injected by `Select`; the item's own value wins. */
+  textColor?: MenuItemTextColor;
+  /** Density token — resolves against `theme.sizes`. Injected by `Select`. Default: 'md', overridable via `theme.defaults.size`. */
+  size?: MenuItemSize;
+  /** Compact vertical padding, independent of `size`. Default: `false`. */
+  dense?: boolean;
+  /** Remove the left and right padding. Default: `false`. */
+  disableGutters?: boolean;
+  /** Add a 1px bottom border to separate the row. Default: `false`. */
+  divider?: boolean;
+  /** Focus the row on first mount, and whenever `autoFocus` flips from `false` to `true`. Default: `false`. */
+  autoFocus?: boolean;
+  /** Class applied only while the row has keyboard focus — a `:focus-visible` hook. */
+  focusVisibleClassName?: string;
+  /** Fired with `value` when the option is chosen. Injected by `Select`. */
+  onSelect?: (value: string | number) => void;
+  id?: string;
+  className?: string;
+  'data-testid'?: string;
+}
+/**
+ * @description A single option row for `Select`'s listbox. Rendered as a semantic
+ * `<li role="option">` (override via `as`). Selection/highlight/density props are
+ * injected by `Select`; used on its own it renders a static, styled row.
+ */
+declare function MenuItem({ value, children, as, disabled, selected, highlighted, multiple, color: colorProp, textColor, size: sizeProp, dense, disableGutters, divider, autoFocus, focusVisibleClassName, onSelect, id, className, 'data-testid': dataTestid }: Readonly<MenuItemProps>): import("react").JSX.Element;
+//#endregion
+export { MenuItem, MenuItemColor, MenuItemProps, MenuItemSize, MenuItemTextColor };

package/dist/MenuItem.mjs

@@ -0,0 +1,147 @@
+import { a as createShouldForwardProp, d as styled, l as src_exports, u as useTheme } from "./src-DcNT2aIK.mjs";
+import { t as themeDefault } from "./themeDefault-CjXaY3ok.mjs";
+import { t as Icon } from "./Icon-CAKRmFz3.mjs";
+import { useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/MenuItem/MenuItem.tsx
+const shouldForwardProp = createShouldForwardProp([
+	"color",
+	"textColor",
+	"sizeToken",
+	"selected",
+	"highlighted",
+	"disabled",
+	"dense",
+	"disableGutters",
+	"divider"
+]);
+const baseStyle = ({ theme }) => ({
+	display: "flex",
+	alignItems: "center",
+	gap: theme.space[1],
+	cursor: "pointer",
+	fontFamily: theme.fonts.body,
+	lineHeight: theme.lineHeights.base,
+	listStyle: "none",
+	userSelect: "none",
+	whiteSpace: "nowrap",
+	transition: "background-color 0.12s ease",
+	outline: "none"
+});
+const sizeVariants = ({ theme, sizeToken, dense, disableGutters }) => {
+	const s = theme.sizes[sizeToken];
+	const verticalPadding = dense ? theme.space[.5] : void 0;
+	return {
+		paddingTop: verticalPadding ?? theme.space[s.paddingTop],
+		paddingBottom: verticalPadding ?? theme.space[s.paddingBottom],
+		paddingLeft: disableGutters ? 0 : theme.space[s.paddingLeft],
+		paddingRight: disableGutters ? 0 : theme.space[s.paddingRight],
+		fontSize: theme.fontSizes[s.fontSize]
+	};
+};
+const dividerStyle = ({ theme, divider }) => divider ? {
+	borderBottomWidth: theme.borderWidths.thin,
+	borderBottomStyle: "solid",
+	borderBottomColor: (0, src_exports.get)(theme, "border.light")
+} : {};
+const interactionStyles = ({ theme, color, textColor, selected, highlighted, disabled }) => {
+	const main = (0, src_exports.get)(theme, `palette.${color}.main`);
+	const hoverBg = `${main}1F`;
+	const selectedBg = `${main}29`;
+	const activeSelectedBg = `${main}3D`;
+	if (disabled) return {
+		color: (0, src_exports.get)(theme, "text.disabled"),
+		cursor: "not-allowed",
+		pointerEvents: "none"
+	};
+	const baseColor = textColor ? (0, src_exports.get)(theme, `text.${textColor}`) : main;
+	return {
+		color: selected ? main : baseColor,
+		backgroundColor: selected ? highlighted ? activeSelectedBg : selectedBg : highlighted ? hoverBg : "transparent",
+		"&:hover": { backgroundColor: selected ? activeSelectedBg : hoverBg }
+	};
+};
+const MenuItemRoot = styled("li", {
+	name: "MenuItem",
+	label: "MenuItem",
+	shouldForwardProp
+})(baseStyle, sizeVariants, dividerStyle, interactionStyles);
+const CheckSlot = styled("span", {
+	name: "MenuItem",
+	slot: "check",
+	label: "MenuItemCheck"
+})({
+	display: "inline-flex",
+	width: "1.125rem",
+	flexShrink: 0
+});
+function isKeyboardFocus(element) {
+	try {
+		return element.matches(":focus-visible");
+	} catch {
+		return false;
+	}
+}
+/**
+* @description A single option row for `Select`'s listbox. Rendered as a semantic
+* `<li role="option">` (override via `as`). Selection/highlight/density props are
+* injected by `Select`; used on its own it renders a static, styled row.
+*/
+function MenuItem({ value, children, as, disabled = false, selected = false, highlighted = false, multiple = false, color: colorProp, textColor, size: sizeProp, dense = false, disableGutters = false, divider = false, autoFocus = false, focusVisibleClassName, onSelect, id, className, "data-testid": dataTestid }) {
+	const theme = useTheme();
+	const color = colorProp ?? themeDefault(theme, "color", "primary");
+	const size = sizeProp ?? themeDefault(theme, "size", "md");
+	const rootRef = useRef(null);
+	const [isFocusVisible, setIsFocusVisible] = useState(false);
+	useEffect(() => {
+		if (autoFocus) rootRef.current?.focus();
+	}, [autoFocus]);
+	const handleClick = () => {
+		if (!disabled) onSelect?.(value);
+	};
+	const handleMouseDown = (event) => {
+		event.preventDefault();
+	};
+	const handleFocus = (event) => {
+		if (focusVisibleClassName && isKeyboardFocus(event.currentTarget)) setIsFocusVisible(true);
+	};
+	const handleBlur = () => {
+		setIsFocusVisible(false);
+	};
+	const rootClassName = [className, isFocusVisible ? focusVisibleClassName : void 0].filter(Boolean).join(" ") || void 0;
+	return /* @__PURE__ */ jsxs(MenuItemRoot, {
+		as,
+		ref: rootRef,
+		id,
+		role: "option",
+		tabIndex: -1,
+		"aria-selected": selected,
+		"aria-disabled": disabled || void 0,
+		"data-value": value,
+		color,
+		textColor,
+		sizeToken: size,
+		selected,
+		highlighted,
+		disabled,
+		dense,
+		disableGutters,
+		divider,
+		className: rootClassName,
+		"data-testid": dataTestid,
+		onMouseDown: handleMouseDown,
+		onClick: handleClick,
+		onFocus: handleFocus,
+		onBlur: handleBlur,
+		children: [multiple && /* @__PURE__ */ jsx(CheckSlot, {
+			"aria-hidden": true,
+			children: selected && /* @__PURE__ */ jsx(Icon, {
+				name: "check",
+				size: "1.125rem",
+				color: "inherit"
+			})
+		}), children]
+	});
+}
+//#endregion
+export { MenuItem };

package/dist/Modal-BDMPTSXv.cjs

@@ -0,0 +1,351 @@
+const require_src = require("./src-BiocWFSR.cjs");
+const require_View = require("./View.cjs");
+const require_Backdrop = require("./Backdrop.cjs");
+const require_Portal = require("./Portal.cjs");
+const require_FocusTrap = require("./FocusTrap.cjs");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+let _soroush_tech_styled_system_should_forward_prop = require("@soroush.tech/styled-system/should-forward-prop");
+//#region src/utils/ownerDocument.ts
+/**
+* Returns the `Document` that owns the given node, falling back to the global
+* `document`. Lets the modal logic work across iframes / portaled containers.
+*/
+function ownerDocument(node) {
+	return node?.ownerDocument ?? document;
+}
+//#endregion
+//#region src/utils/ownerWindow.ts
+/**
+* Returns the `Window` that owns the given node, falling back to the global
+* `window`. Used to read viewport metrics for scroll-lock calculations.
+*/
+function ownerWindow(node) {
+	return ownerDocument(node).defaultView ?? window;
+}
+//#endregion
+//#region src/Modal/utils/getScrollbarSize.ts
+/**
+* Width of the vertical scrollbar for the given window, in pixels. Equal to the
+* gap between the inner window width and the document's client width. Used to
+* pad the container when scroll-lock hides the scrollbar, preventing layout jump.
+*/
+function getScrollbarSize(win) {
+	const documentWidth = win.document.documentElement.clientWidth;
+	return Math.abs(win.innerWidth - documentWidth);
+}
+//#endregion
+//#region src/Modal/ModalManager.ts
+const ARIA_HIDDEN_FORBIDDEN_TAGS = /* @__PURE__ */ new Set([
+	"TEMPLATE",
+	"SCRIPT",
+	"STYLE",
+	"LINK",
+	"MAP",
+	"META",
+	"NOSCRIPT",
+	"PICTURE",
+	"COL",
+	"COLGROUP",
+	"PARAM",
+	"SLOT",
+	"SOURCE",
+	"TRACK"
+]);
+function ariaHidden(element, hide) {
+	if (hide) element.setAttribute("aria-hidden", "true");
+	else element.removeAttribute("aria-hidden");
+}
+function isAriaHiddenForbidden(element) {
+	if (ARIA_HIDDEN_FORBIDDEN_TAGS.has(element.tagName)) return true;
+	return element.tagName === "INPUT" && element.getAttribute("type") === "hidden";
+}
+function ariaHiddenSiblings(container, mountElement, currentElement, hiddenSiblings, hide) {
+	const exclude = /* @__PURE__ */ new Set([
+		mountElement,
+		currentElement,
+		...hiddenSiblings
+	]);
+	Array.from(container.children).forEach((element) => {
+		if (!exclude.has(element) && !isAriaHiddenForbidden(element)) ariaHidden(element, hide);
+	});
+}
+function getHiddenSiblings(container) {
+	return Array.from(container.children).filter((element) => element.getAttribute("aria-hidden") === "true");
+}
+function isOverflowing(container) {
+	const doc = ownerDocument(container);
+	if (container === doc.body) return ownerWindow(container).innerWidth > doc.documentElement.clientWidth;
+	return container.scrollHeight > container.clientHeight;
+}
+function getPaddingRight(element) {
+	return Number.parseFloat(ownerWindow(element).getComputedStyle(element).paddingRight) || 0;
+}
+/**
+* Locks scrolling on the container, padding it by the scrollbar width so hiding
+* the scrollbar causes no horizontal layout shift. Returns a function that
+* restores the exact prior inline styles.
+*/
+function lockScroll(container) {
+	const restores = [];
+	const setStyle = (property, value) => {
+		const previous = container.style.getPropertyValue(property);
+		restores.push(() => {
+			if (previous) container.style.setProperty(property, previous);
+			else container.style.removeProperty(property);
+		});
+		container.style.setProperty(property, value);
+	};
+	if (isOverflowing(container)) {
+		const scrollbarSize = container === ownerDocument(container).body ? getScrollbarSize(ownerWindow(container)) : container.offsetWidth - container.clientWidth;
+		setStyle("padding-right", `${getPaddingRight(container) + scrollbarSize}px`);
+	}
+	setStyle("overflow", "hidden");
+	return () => restores.forEach((restore) => restore());
+}
+/**
+* Tracks every open modal and the containers they live in. A single shared
+* instance coordinates stacking (`isTopModal`), scroll-lock, and `aria-hidden`
+* on background siblings so assistive tech only sees the active modal.
+*/
+var ModalManager = class {
+	modals = [];
+	containers = [];
+	add(modal, container, disableAriaHidden = false) {
+		const existingIndex = this.modals.indexOf(modal);
+		if (existingIndex !== -1) return existingIndex;
+		const modalIndex = this.modals.length;
+		this.modals.push(modal);
+		ariaHidden(modal.modalRef, false);
+		const hiddenSiblings = getHiddenSiblings(container);
+		if (!disableAriaHidden) ariaHiddenSiblings(container, modal.mount, modal.modalRef, hiddenSiblings, true);
+		const containerState = this.containers.find((item) => item.container === container);
+		if (containerState) {
+			containerState.modals.push(modal);
+			if (!disableAriaHidden) containerState.ariaHiddenApplied = true;
+			return modalIndex;
+		}
+		this.containers.push({
+			container,
+			modals: [modal],
+			restore: null,
+			hiddenSiblings,
+			ariaHiddenApplied: !disableAriaHidden
+		});
+		return modalIndex;
+	}
+	mount(modal, props) {
+		const containerState = this.containers.find((item) => item.modals.includes(modal));
+		containerState.restore ??= props.disableScrollLock ? () => {} : lockScroll(containerState.container);
+	}
+	remove(modal, ariaHiddenState = true) {
+		const modalIndex = this.modals.indexOf(modal);
+		if (modalIndex === -1) return modalIndex;
+		const containerState = this.containers.find((item) => item.modals.includes(modal));
+		containerState.modals.splice(containerState.modals.indexOf(modal), 1);
+		this.modals.splice(modalIndex, 1);
+		if (containerState.modals.length === 0) {
+			if (containerState.restore) containerState.restore();
+			ariaHidden(modal.modalRef, ariaHiddenState);
+			if (containerState.ariaHiddenApplied) ariaHiddenSiblings(containerState.container, modal.mount, modal.modalRef, containerState.hiddenSiblings, false);
+			this.containers.splice(this.containers.indexOf(containerState), 1);
+		} else {
+			const nextTop = containerState.modals.at(-1);
+			ariaHidden(modal.modalRef, ariaHiddenState);
+			ariaHidden(nextTop.modalRef, false);
+		}
+		return modalIndex;
+	}
+	isTopModal(modal) {
+		return this.modals.at(-1) === modal;
+	}
+};
+//#endregion
+//#region src/Modal/hooks/useEventCallback.ts
+/**
+* Returns a stable function identity that always calls the latest `fn`. Lets
+* effects depend on the callback without re-running when the handler changes.
+*
+* Syncs the ref in `useEffect` (not `useLayoutEffect`) so it stays SSR-safe —
+* the timing difference is irrelevant for the user-triggered handlers it wraps.
+*/
+function useEventCallback(fn) {
+	const ref = (0, react.useRef)(fn);
+	(0, react.useEffect)(() => {
+		ref.current = fn;
+	});
+	return (0, react.useCallback)((...args) => ref.current(...args), []);
+}
+//#endregion
+//#region src/Modal/hooks/useMergedRefs.ts
+function assignRef(ref, value) {
+	if (typeof ref === "function") ref(value);
+	else if (ref) ref.current = value;
+}
+/**
+* Merges two refs into a single stable ref callback so one DOM node can be
+* tracked by both an internal ref and a forwarded `ref`. Returns `null` when
+* both refs are absent, so React skips attaching a callback ref entirely.
+*/
+function useMergedRefs(refA, refB) {
+	return (0, react.useMemo)(() => {
+		if (refA == null && refB == null) return null;
+		return (value) => {
+			assignRef(refA, value);
+			assignRef(refB, value);
+		};
+	}, [refA, refB]);
+}
+//#endregion
+//#region src/Modal/useModal.ts
+const modalManager = new ModalManager();
+function getContainer(container) {
+	return typeof container === "function" ? container() : container ?? null;
+}
+function useModal(parameters) {
+	const { isOpen, onClose, container, disableScrollLock = false, disableAriaHidden = false, rootRef } = parameters;
+	const modal = (0, react.useRef)({});
+	const mountNodeRef = (0, react.useRef)(null);
+	const modalRef = (0, react.useRef)(null);
+	const handleRef = useMergedRefs(modalRef, rootRef);
+	const getModal = () => {
+		modal.current.modalRef = modalRef.current;
+		modal.current.mount = mountNodeRef.current;
+		return modal.current;
+	};
+	const handleOpen = useEventCallback(() => {
+		const resolvedContainer = getContainer(container) ?? ownerDocument(mountNodeRef.current).body;
+		modalManager.add(getModal(), resolvedContainer, disableAriaHidden);
+		modalManager.mount(getModal(), { disableScrollLock });
+	});
+	const isTopModal = useEventCallback(() => modalManager.isTopModal(getModal()));
+	const handlePortalRef = useEventCallback((node) => {
+		mountNodeRef.current = node;
+	});
+	const handleClose = useEventCallback(() => {
+		modalManager.remove(modal.current);
+	});
+	(0, react.useEffect)(() => {
+		if (!isOpen) return;
+		handleOpen();
+		return () => handleClose();
+	}, [
+		isOpen,
+		container,
+		disableScrollLock,
+		handleOpen,
+		handleClose
+	]);
+	const createHandleKeyDown = (otherHandlers) => (event) => {
+		otherHandlers.onKeyDown?.(event);
+		if (event.key !== "Escape" || event.which === 229 || !isTopModal()) return;
+		event.stopPropagation();
+		onClose?.(event, "escapeKey");
+	};
+	const createHandleRootClick = (otherHandlers) => (event) => {
+		otherHandlers.onClick?.(event);
+		if (event.target !== event.currentTarget) return;
+		onClose?.(event, "backdropClick");
+	};
+	const getRootProps = (otherHandlers = {}) => {
+		return {
+			role: "presentation",
+			...otherHandlers,
+			onKeyDown: createHandleKeyDown(otherHandlers),
+			onClick: createHandleRootClick(otherHandlers),
+			ref: handleRef
+		};
+	};
+	const getBackdropProps = (otherHandlers = {}) => {
+		return {
+			"aria-hidden": true,
+			...otherHandlers,
+			open: isOpen
+		};
+	};
+	return {
+		getRootProps,
+		getBackdropProps,
+		rootRef: handleRef,
+		portalRef: handlePortalRef,
+		isTopModal
+	};
+}
+//#endregion
+//#region src/Modal/Modal.tsx
+const ModalRoot = require_src.styled(require_View.View, {
+	name: "Modal",
+	label: "Modal",
+	shouldForwardProp: (0, _soroush_tech_styled_system_should_forward_prop.createShouldForwardProp)(["scroll", "layer"])
+})(({ theme, scroll, layer }) => ({
+	position: "fixed",
+	inset: 0,
+	zIndex: theme.zOrder[layer],
+	display: "flex",
+	...scroll === "paper" ? {
+		alignItems: "center",
+		justifyContent: "center"
+	} : {
+		flexDirection: "column",
+		overflowY: "auto",
+		"& > :not([aria-hidden=\"true\"])": { margin: "auto" }
+	}
+}));
+/**
+* @description Accessible overlay primitive: portals its content, dims the page,
+* traps focus, locks scroll, and closes on Escape or backdrop click. The base for
+* higher-level overlays such as Drawer.
+*/
+function Modal({ isOpen, children, onClose, hasBackdrop = true, shouldKeepMounted = false, shouldUsePortal = true, portalContainer, shouldLockScroll = true, disableAriaHidden = false, shouldAutoFocus = true, shouldTrapFocus = true, shouldEnforceFocus = true, shouldRestoreFocus = true, scroll = "paper", layer = "modal" }) {
+	const { getRootProps, getBackdropProps } = useModal({
+		isOpen,
+		onClose,
+		container: portalContainer,
+		disableScrollLock: !shouldLockScroll,
+		disableAriaHidden
+	});
+	if (!shouldKeepMounted && !isOpen) return null;
+	const { open: _open, ...backdropProps } = getBackdropProps();
+	const content = /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(ModalRoot, {
+		scroll,
+		layer,
+		...getRootProps(),
+		children: [hasBackdrop ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_Backdrop.Backdrop, { ...backdropProps }) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_FocusTrap.FocusTrap, {
+			isEnabled: isOpen,
+			shouldAutoFocus,
+			shouldTrapFocus,
+			shouldEnforceFocus,
+			shouldRestoreFocus,
+			children
+		})]
+	});
+	return shouldUsePortal ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_Portal.Portal, {
+		container: portalContainer,
+		children: content
+	}) : content;
+}
+//#endregion
+Object.defineProperty(exports, "Modal", {
+	enumerable: true,
+	get: function() {
+		return Modal;
+	}
+});
+Object.defineProperty(exports, "ModalManager", {
+	enumerable: true,
+	get: function() {
+		return ModalManager;
+	}
+});
+Object.defineProperty(exports, "ariaHidden", {
+	enumerable: true,
+	get: function() {
+		return ariaHidden;
+	}
+});
+Object.defineProperty(exports, "useModal", {
+	enumerable: true,
+	get: function() {
+		return useModal;
+	}
+});