@arc-ui/components 11.7.0 → 11.9.0

package/dist/Modal/Modal.cjs.js

@@ -2,159 +2,415 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var filterDataAttrs = require('../_shared/cjs/filter-data-attrs-a30dcf5f.js');
 var React = require('react');
-var index_module = require('../_shared/cjs/index.module-9b87a34d.js');
-var index = require('../_shared/cjs/index-31fbb076.js');
-var $7SXl2$reactdom = require('react-dom');
-var Icon = require('../_shared/cjs/Icon-e1dd45eb.js');
+var index$4 = require('../_shared/cjs/index-45bfb67b.js');
 var BtIconCrossAlt2Px = require('../_shared/cjs/BtIconCrossAlt2Px-30dc2688.js');
-var VisuallyHidden = require('../_shared/cjs/VisuallyHidden-e2c8b291.js');
+var _extends = require('../_shared/cjs/extends-bb8ffacd.js');
+var index = require('../_shared/cjs/index-952918c9.js');
+var index$1 = require('../_shared/cjs/index-fb4b8fda.js');
+var index$2 = require('../_shared/cjs/index-96c4d581.js');
+var index$3 = require('../_shared/cjs/index-ec260f5e.js');
+var Icon = require('../_shared/cjs/Icon-e1dd45eb.js');
 var Base = require('../_shared/cjs/Base-569e4334.js');
-var Heading = require('../_shared/cjs/Heading-ed1cb455.js');
-var Text = require('../_shared/cjs/Text-555a29a4.js');
-require('../_shared/cjs/filter-data-attrs-a30dcf5f.js');
-require('../_shared/cjs/index-45bfb67b.js');
+var Heading = require('../_shared/cjs/Heading-e3332dcf.js');
+var Button = require('../_shared/cjs/Button-5aaa6776.js');
+var Text = require('../_shared/cjs/Text-fa447e2d.js');
+var VerticalSpace = require('../_shared/cjs/VerticalSpace-86f697e7.js');
+require('react-dom');
 require('../_shared/cjs/suffix-modifier-1ee2da04.js');
 require('../_shared/cjs/Surface-b7c51b2b.js');
+require('../_shared/cjs/BtIconChevronLeftMid-df952a3e.js');
+require('../_shared/cjs/BtIconChevronRightMid-5a38d855.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
-function $fe963b355347cc68$export$3e6543de14f8614f(initialState, machine) {
-    return React.useReducer((state, event)=>{
-        const nextState = machine[state][event];
-        return nextState !== null && nextState !== void 0 ? nextState : state;
-    }, initialState);
-}
-
-
-const $921a889cee6df7e8$export$99c2b779aa4e8b8b = (props)=>{
-    const { present: present , children: children  } = props;
-    const presence = $921a889cee6df7e8$var$usePresence(present);
-    const child = typeof children === 'function' ? children({
-        present: presence.isPresent
-    }) : React.Children.only(children);
-    const ref = index_module.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(presence.ref, child.ref);
-    const forceMount = typeof children === 'function';
-    return forceMount || presence.isPresent ? /*#__PURE__*/ React.cloneElement(child, {
-        ref: ref
-    }) : null;
+const $d3863c46a17e8a28$var$AUTOFOCUS_ON_MOUNT = 'focusScope.autoFocusOnMount';
+const $d3863c46a17e8a28$var$AUTOFOCUS_ON_UNMOUNT = 'focusScope.autoFocusOnUnmount';
+const $d3863c46a17e8a28$var$EVENT_OPTIONS = {
+    bubbles: false,
+    cancelable: true
 };
-$921a889cee6df7e8$export$99c2b779aa4e8b8b.displayName = 'Presence';
-/* -------------------------------------------------------------------------------------------------
- * usePresence
- * -----------------------------------------------------------------------------------------------*/ function $921a889cee6df7e8$var$usePresence(present) {
-    const [node1, setNode] = React.useState();
-    const stylesRef = React.useRef({});
-    const prevPresentRef = React.useRef(present);
-    const prevAnimationNameRef = React.useRef('none');
-    const initialState = present ? 'mounted' : 'unmounted';
-    const [state, send] = $fe963b355347cc68$export$3e6543de14f8614f(initialState, {
-        mounted: {
-            UNMOUNT: 'unmounted',
-            ANIMATION_OUT: 'unmountSuspended'
+const $d3863c46a17e8a28$export$20e40289641fbbb6 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
+    const { loop: loop = false , trapped: trapped = false , onMountAutoFocus: onMountAutoFocusProp , onUnmountAutoFocus: onUnmountAutoFocusProp , ...scopeProps } = props;
+    const [container1, setContainer] = React.useState(null);
+    const onMountAutoFocus = index.$b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onMountAutoFocusProp);
+    const onUnmountAutoFocus = index.$b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onUnmountAutoFocusProp);
+    const lastFocusedElementRef = React.useRef(null);
+    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, (node)=>setContainer(node)
+    );
+    const focusScope = React.useRef({
+        paused: false,
+        pause () {
+            this.paused = true;
         },
-        unmountSuspended: {
-            MOUNT: 'mounted',
-            ANIMATION_END: 'unmounted'
-        },
-        unmounted: {
-            MOUNT: 'mounted'
+        resume () {
+            this.paused = false;
         }
-    });
+    }).current; // Takes care of trapping focus if focus is moved outside programmatically for example
     React.useEffect(()=>{
-        const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);
-        prevAnimationNameRef.current = state === 'mounted' ? currentAnimationName : 'none';
-    }, [
-        state
-    ]);
-    index_module.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        const styles = stylesRef.current;
-        const wasPresent = prevPresentRef.current;
-        const hasPresentChanged = wasPresent !== present;
-        if (hasPresentChanged) {
-            const prevAnimationName = prevAnimationNameRef.current;
-            const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(styles);
-            if (present) send('MOUNT');
-            else if (currentAnimationName === 'none' || (styles === null || styles === void 0 ? void 0 : styles.display) === 'none') // If there is no exit animation or the element is hidden, animations won't run
-            // so we unmount instantly
-            send('UNMOUNT');
-            else {
-                /**
-         * When `present` changes to `false`, we check changes to animation-name to
-         * determine whether an animation has started. We chose this approach (reading
-         * computed styles) because there is no `animationrun` event and `animationstart`
-         * fires after `animation-delay` has expired which would be too late.
-         */ const isAnimating = prevAnimationName !== currentAnimationName;
-                if (wasPresent && isAnimating) send('ANIMATION_OUT');
-                else send('UNMOUNT');
+        if (trapped) {
+            function handleFocusIn(event) {
+                if (focusScope.paused || !container1) return;
+                const target = event.target;
+                if (container1.contains(target)) lastFocusedElementRef.current = target;
+                else $d3863c46a17e8a28$var$focus(lastFocusedElementRef.current, {
+                    select: true
+                });
             }
-            prevPresentRef.current = present;
+            function handleFocusOut(event) {
+                if (focusScope.paused || !container1) return;
+                const relatedTarget = event.relatedTarget; // A `focusout` event with a `null` `relatedTarget` will happen in at least two cases:
+                //
+                // 1. When the user switches app/tabs/windows/the browser itself loses focus.
+                // 2. In Google Chrome, when the focused element is removed from the DOM.
+                //
+                // We let the browser do its thing here because:
+                //
+                // 1. The browser already keeps a memory of what's focused for when the page gets refocused.
+                // 2. In Google Chrome, if we try to focus the deleted focused element (as per below), it
+                //    throws the CPU to 100%, so we avoid doing anything for this reason here too.
+                if (relatedTarget === null) return; // If the focus has moved to an actual legitimate element (`relatedTarget !== null`)
+                // that is outside the container, we move focus to the last valid focused element inside.
+                if (!container1.contains(relatedTarget)) $d3863c46a17e8a28$var$focus(lastFocusedElementRef.current, {
+                    select: true
+                });
+            } // When the focused element gets removed from the DOM, browsers move focus
+            // back to the document.body. In this case, we move focus to the container
+            // to keep focus trapped correctly.
+            function handleMutations(mutations) {
+                const focusedElement = document.activeElement;
+                for (const mutation of mutations){
+                    if (mutation.removedNodes.length > 0) {
+                        if (!(container1 !== null && container1 !== void 0 && container1.contains(focusedElement))) $d3863c46a17e8a28$var$focus(container1);
+                    }
+                }
+            }
+            document.addEventListener('focusin', handleFocusIn);
+            document.addEventListener('focusout', handleFocusOut);
+            const mutationObserver = new MutationObserver(handleMutations);
+            if (container1) mutationObserver.observe(container1, {
+                childList: true,
+                subtree: true
+            });
+            return ()=>{
+                document.removeEventListener('focusin', handleFocusIn);
+                document.removeEventListener('focusout', handleFocusOut);
+                mutationObserver.disconnect();
+            };
         }
     }, [
-        present,
-        send
+        trapped,
+        container1,
+        focusScope.paused
     ]);
-    index_module.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        if (node1) {
-            /**
-       * 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 = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);
-                const isCurrentAnimation = currentAnimationName.includes(event.animationName);
-                if (event.target === node1 && isCurrentAnimation) // With React 18 concurrency this update is applied
-                // a frame after the animation ends, creating a flash of visible content.
-                // By manually flushing we ensure they sync within a frame, removing the flash.
-                $7SXl2$reactdom.flushSync(()=>send('ANIMATION_END')
-                );
-            };
-            const handleAnimationStart = (event)=>{
-                if (event.target === node1) // if animation occurred, store its name as the previous animation.
-                prevAnimationNameRef.current = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);
-            };
-            node1.addEventListener('animationstart', handleAnimationStart);
-            node1.addEventListener('animationcancel', handleAnimationEnd);
-            node1.addEventListener('animationend', handleAnimationEnd);
+    React.useEffect(()=>{
+        if (container1) {
+            $d3863c46a17e8a28$var$focusScopesStack.add(focusScope);
+            const previouslyFocusedElement = document.activeElement;
+            const hasFocusedCandidate = container1.contains(previouslyFocusedElement);
+            if (!hasFocusedCandidate) {
+                const mountEvent = new CustomEvent($d3863c46a17e8a28$var$AUTOFOCUS_ON_MOUNT, $d3863c46a17e8a28$var$EVENT_OPTIONS);
+                container1.addEventListener($d3863c46a17e8a28$var$AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
+                container1.dispatchEvent(mountEvent);
+                if (!mountEvent.defaultPrevented) {
+                    $d3863c46a17e8a28$var$focusFirst($d3863c46a17e8a28$var$removeLinks($d3863c46a17e8a28$var$getTabbableCandidates(container1)), {
+                        select: true
+                    });
+                    if (document.activeElement === previouslyFocusedElement) $d3863c46a17e8a28$var$focus(container1);
+                }
+            }
             return ()=>{
-                node1.removeEventListener('animationstart', handleAnimationStart);
-                node1.removeEventListener('animationcancel', handleAnimationEnd);
-                node1.removeEventListener('animationend', handleAnimationEnd);
+                container1.removeEventListener($d3863c46a17e8a28$var$AUTOFOCUS_ON_MOUNT, onMountAutoFocus); // We hit a react bug (fixed in v17) with focusing in unmount.
+                // We need to delay the focus a little to get around it for now.
+                // See: https://github.com/facebook/react/issues/17894
+                setTimeout(()=>{
+                    const unmountEvent = new CustomEvent($d3863c46a17e8a28$var$AUTOFOCUS_ON_UNMOUNT, $d3863c46a17e8a28$var$EVENT_OPTIONS);
+                    container1.addEventListener($d3863c46a17e8a28$var$AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+                    container1.dispatchEvent(unmountEvent);
+                    if (!unmountEvent.defaultPrevented) $d3863c46a17e8a28$var$focus(previouslyFocusedElement !== null && previouslyFocusedElement !== void 0 ? previouslyFocusedElement : document.body, {
+                        select: true
+                    });
+                     // we need to remove the listener after we `dispatchEvent`
+                    container1.removeEventListener($d3863c46a17e8a28$var$AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+                    $d3863c46a17e8a28$var$focusScopesStack.remove(focusScope);
+                }, 0);
             };
-        } else // Transition to the unmounted state if the node is removed prematurely.
-        // We avoid doing so during cleanup as the node may change but still exist.
-        send('ANIMATION_END');
+        }
+    }, [
+        container1,
+        onMountAutoFocus,
+        onUnmountAutoFocus,
+        focusScope
+    ]); // Takes care of looping focus (when tabbing whilst at the edges)
+    const handleKeyDown = React.useCallback((event)=>{
+        if (!loop && !trapped) return;
+        if (focusScope.paused) return;
+        const isTabKey = event.key === 'Tab' && !event.altKey && !event.ctrlKey && !event.metaKey;
+        const focusedElement = document.activeElement;
+        if (isTabKey && focusedElement) {
+            const container = event.currentTarget;
+            const [first, last] = $d3863c46a17e8a28$var$getTabbableEdges(container);
+            const hasTabbableElementsInside = first && last; // we can only wrap focus if we have tabbable edges
+            if (!hasTabbableElementsInside) {
+                if (focusedElement === container) event.preventDefault();
+            } else {
+                if (!event.shiftKey && focusedElement === last) {
+                    event.preventDefault();
+                    if (loop) $d3863c46a17e8a28$var$focus(first, {
+                        select: true
+                    });
+                } else if (event.shiftKey && focusedElement === first) {
+                    event.preventDefault();
+                    if (loop) $d3863c46a17e8a28$var$focus(last, {
+                        select: true
+                    });
+                }
+            }
+        }
     }, [
-        node1,
-        send
+        loop,
+        trapped,
+        focusScope.paused
     ]);
+    return /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, _extends._extends({
+        tabIndex: -1
+    }, scopeProps, {
+        ref: composedRefs,
+        onKeyDown: handleKeyDown
+    }));
+});
+/* -------------------------------------------------------------------------------------------------
+ * Utils
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * Attempts focusing the first element in a list of candidates.
+ * Stops when focus has actually moved.
+ */ function $d3863c46a17e8a28$var$focusFirst(candidates, { select: select = false  } = {}) {
+    const previouslyFocusedElement = document.activeElement;
+    for (const candidate of candidates){
+        $d3863c46a17e8a28$var$focus(candidate, {
+            select: select
+        });
+        if (document.activeElement !== previouslyFocusedElement) return;
+    }
+}
+/**
+ * Returns the first and last tabbable elements inside a container.
+ */ function $d3863c46a17e8a28$var$getTabbableEdges(container) {
+    const candidates = $d3863c46a17e8a28$var$getTabbableCandidates(container);
+    const first = $d3863c46a17e8a28$var$findVisible(candidates, container);
+    const last = $d3863c46a17e8a28$var$findVisible(candidates.reverse(), container);
+    return [
+        first,
+        last
+    ];
+}
+/**
+ * Returns a list of potential tabbable candidates.
+ *
+ * NOTE: This is only a close approximation. For example it doesn't take into account cases like when
+ * elements are not visible. This cannot be worked out easily by just reading a property, but rather
+ * necessitate runtime knowledge (computed styles, etc). We deal with these cases separately.
+ *
+ * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
+ * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1
+ */ function $d3863c46a17e8a28$var$getTabbableCandidates(container) {
+    const nodes = [];
+    const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+        acceptNode: (node)=>{
+            const isHiddenInput = node.tagName === 'INPUT' && node.type === 'hidden';
+            if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP; // `.tabIndex` is not the same as the `tabindex` attribute. It works on the
+            // runtime's understanding of tabbability, so this automatically accounts
+            // for any kind of element that could be tabbed to.
+            return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+        }
+    });
+    while(walker.nextNode())nodes.push(walker.currentNode); // we do not take into account the order of nodes with positive `tabIndex` as it
+    // hinders accessibility to have tab order different from visual order.
+    return nodes;
+}
+/**
+ * Returns the first visible element in a list.
+ * NOTE: Only checks visibility up to the `container`.
+ */ function $d3863c46a17e8a28$var$findVisible(elements, container) {
+    for (const element of elements){
+        // we stop checking if it's hidden at the `container` level (excluding)
+        if (!$d3863c46a17e8a28$var$isHidden(element, {
+            upTo: container
+        })) return element;
+    }
+}
+function $d3863c46a17e8a28$var$isHidden(node, { upTo: upTo  }) {
+    if (getComputedStyle(node).visibility === 'hidden') return true;
+    while(node){
+        // we stop at `upTo` (excluding it)
+        if (upTo !== undefined && node === upTo) return false;
+        if (getComputedStyle(node).display === 'none') return true;
+        node = node.parentElement;
+    }
+    return false;
+}
+function $d3863c46a17e8a28$var$isSelectableInput(element) {
+    return element instanceof HTMLInputElement && 'select' in element;
+}
+function $d3863c46a17e8a28$var$focus(element, { select: select = false  } = {}) {
+    // only focus if that element is focusable
+    if (element && element.focus) {
+        const previouslyFocusedElement = document.activeElement; // NOTE: we prevent scrolling on focus, to minimize jarring transitions for users
+        element.focus({
+            preventScroll: true
+        }); // only select if its not the same element, it supports selection and we need to select
+        if (element !== previouslyFocusedElement && $d3863c46a17e8a28$var$isSelectableInput(element) && select) element.select();
+    }
+}
+/* -------------------------------------------------------------------------------------------------
+ * FocusScope stack
+ * -----------------------------------------------------------------------------------------------*/ const $d3863c46a17e8a28$var$focusScopesStack = $d3863c46a17e8a28$var$createFocusScopesStack();
+function $d3863c46a17e8a28$var$createFocusScopesStack() {
+    /** A stack of focus scopes, with the active one at the top */ let stack = [];
     return {
-        isPresent: [
-            'mounted',
-            'unmountSuspended'
-        ].includes(state),
-        ref: React.useCallback((node)=>{
-            if (node) stylesRef.current = getComputedStyle(node);
-            setNode(node);
-        }, [])
+        add (focusScope) {
+            // pause the currently active focus scope (at the top of the stack)
+            const activeFocusScope = stack[0];
+            if (focusScope !== activeFocusScope) activeFocusScope === null || activeFocusScope === void 0 || activeFocusScope.pause();
+             // remove in case it already exists (because we'll re-add it at the top of the stack)
+            stack = $d3863c46a17e8a28$var$arrayRemove(stack, focusScope);
+            stack.unshift(focusScope);
+        },
+        remove (focusScope) {
+            var _stack$;
+            stack = $d3863c46a17e8a28$var$arrayRemove(stack, focusScope);
+            (_stack$ = stack[0]) === null || _stack$ === void 0 || _stack$.resume();
+        }
     };
 }
-/* -----------------------------------------------------------------------------------------------*/ function $921a889cee6df7e8$var$getAnimationName(styles) {
-    return (styles === null || styles === void 0 ? void 0 : styles.animationName) || 'none';
+function $d3863c46a17e8a28$var$arrayRemove(array, item) {
+    const updatedArray = [
+        ...array
+    ];
+    const index = updatedArray.indexOf(item);
+    if (index !== -1) updatedArray.splice(index, 1);
+    return updatedArray;
+}
+function $d3863c46a17e8a28$var$removeLinks(items) {
+    return items.filter((item)=>item.tagName !== 'A'
+    );
+}
+
+/** Number of components which have requested interest to have focus guards */ let $3db38b7d1fb3fe6a$var$count = 0;
+/**
+ * Injects a pair of focus guards at the edges of the whole DOM tree
+ * to ensure `focusin` & `focusout` events can be caught consistently.
+ */ function $3db38b7d1fb3fe6a$export$b7ece24a22aeda8c() {
+    React.useEffect(()=>{
+        var _edgeGuards$, _edgeGuards$2;
+        const edgeGuards = document.querySelectorAll('[data-radix-focus-guard]');
+        document.body.insertAdjacentElement('afterbegin', (_edgeGuards$ = edgeGuards[0]) !== null && _edgeGuards$ !== void 0 ? _edgeGuards$ : $3db38b7d1fb3fe6a$var$createFocusGuard());
+        document.body.insertAdjacentElement('beforeend', (_edgeGuards$2 = edgeGuards[1]) !== null && _edgeGuards$2 !== void 0 ? _edgeGuards$2 : $3db38b7d1fb3fe6a$var$createFocusGuard());
+        $3db38b7d1fb3fe6a$var$count++;
+        return ()=>{
+            if ($3db38b7d1fb3fe6a$var$count === 1) document.querySelectorAll('[data-radix-focus-guard]').forEach((node)=>node.remove()
+            );
+            $3db38b7d1fb3fe6a$var$count--;
+        };
+    }, []);
+}
+function $3db38b7d1fb3fe6a$var$createFocusGuard() {
+    const element = document.createElement('span');
+    element.setAttribute('data-radix-focus-guard', '');
+    element.tabIndex = 0;
+    element.style.cssText = 'outline: none; opacity: 0; position: fixed; pointer-events: none';
+    return element;
+}
+
+/* -------------------------------------------------------------------------------------------------
+ * Slot
+ * -----------------------------------------------------------------------------------------------*/ const $5e63c961fc1ce211$export$8c6ed5c666ac1360 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
+    const { children: children , ...slotProps } = props;
+    const childrenArray = React.Children.toArray(children);
+    const slottable = childrenArray.find($5e63c961fc1ce211$var$isSlottable);
+    if (slottable) {
+        // the new element to render is the one passed as a child of `Slottable`
+        const newElement = slottable.props.children;
+        const newChildren = childrenArray.map((child)=>{
+            if (child === slottable) {
+                // because the new element will be the one rendered, we are only interested
+                // in grabbing its children (`newElement.props.children`)
+                if (React.Children.count(newElement) > 1) return React.Children.only(null);
+                return /*#__PURE__*/ React.isValidElement(newElement) ? newElement.props.children : null;
+            } else return child;
+        });
+        return /*#__PURE__*/ React.createElement($5e63c961fc1ce211$var$SlotClone, _extends._extends({}, slotProps, {
+            ref: forwardedRef
+        }), /*#__PURE__*/ React.isValidElement(newElement) ? /*#__PURE__*/ React.cloneElement(newElement, undefined, newChildren) : null);
+    }
+    return /*#__PURE__*/ React.createElement($5e63c961fc1ce211$var$SlotClone, _extends._extends({}, slotProps, {
+        ref: forwardedRef
+    }), children);
+});
+$5e63c961fc1ce211$export$8c6ed5c666ac1360.displayName = 'Slot';
+/* -------------------------------------------------------------------------------------------------
+ * SlotClone
+ * -----------------------------------------------------------------------------------------------*/ const $5e63c961fc1ce211$var$SlotClone = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
+    const { children: children , ...slotProps } = props;
+    if (/*#__PURE__*/ React.isValidElement(children)) return /*#__PURE__*/ React.cloneElement(children, {
+        ...$5e63c961fc1ce211$var$mergeProps(slotProps, children.props),
+        ref: forwardedRef ? index.$6ed0406888f73fc4$export$43e446d32b3d21af(forwardedRef, children.ref) : children.ref
+    });
+    return React.Children.count(children) > 1 ? React.Children.only(null) : null;
+});
+$5e63c961fc1ce211$var$SlotClone.displayName = 'SlotClone';
+/* -------------------------------------------------------------------------------------------------
+ * Slottable
+ * -----------------------------------------------------------------------------------------------*/ const $5e63c961fc1ce211$export$d9f1ccf0bdb05d45 = ({ children: children  })=>{
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, children);
+};
+/* ---------------------------------------------------------------------------------------------- */ function $5e63c961fc1ce211$var$isSlottable(child) {
+    return /*#__PURE__*/ React.isValidElement(child) && child.type === $5e63c961fc1ce211$export$d9f1ccf0bdb05d45;
+}
+function $5e63c961fc1ce211$var$mergeProps(slotProps, childProps) {
+    // all child props should override
+    const overrideProps = {
+        ...childProps
+    };
+    for(const propName in childProps){
+        const slotPropValue = slotProps[propName];
+        const childPropValue = childProps[propName];
+        const isHandler = /^on[A-Z]/.test(propName);
+        if (isHandler) {
+            // if the handler exists on both, we compose them
+            if (slotPropValue && childPropValue) overrideProps[propName] = (...args)=>{
+                childPropValue(...args);
+                slotPropValue(...args);
+            };
+            else if (slotPropValue) overrideProps[propName] = slotPropValue;
+        } else if (propName === 'style') overrideProps[propName] = {
+            ...slotPropValue,
+            ...childPropValue
+        };
+        else if (propName === 'className') overrideProps[propName] = [
+            slotPropValue,
+            childPropValue
+        ].filter(Boolean).join(' ');
+    }
+    return {
+        ...slotProps,
+        ...overrideProps
+    };
 }
 
 /* -------------------------------------------------------------------------------------------------
  * Dialog
  * -----------------------------------------------------------------------------------------------*/ const $5d3850c4d0b4e6c7$var$DIALOG_NAME = 'Dialog';
-const [$5d3850c4d0b4e6c7$var$createDialogContext, $5d3850c4d0b4e6c7$export$cc702773b8ea3e41] = index_module.$c512c27ab02ef895$export$50c7b4e9d9f19c1($5d3850c4d0b4e6c7$var$DIALOG_NAME);
+const [$5d3850c4d0b4e6c7$var$createDialogContext, $5d3850c4d0b4e6c7$export$cc702773b8ea3e41] = index.$c512c27ab02ef895$export$50c7b4e9d9f19c1($5d3850c4d0b4e6c7$var$DIALOG_NAME);
 const [$5d3850c4d0b4e6c7$var$DialogProvider, $5d3850c4d0b4e6c7$var$useDialogContext] = $5d3850c4d0b4e6c7$var$createDialogContext($5d3850c4d0b4e6c7$var$DIALOG_NAME);
 const $5d3850c4d0b4e6c7$export$3ddf2d174ce01153 = (props)=>{
     const { __scopeDialog: __scopeDialog , children: children , open: openProp , defaultOpen: defaultOpen , onOpenChange: onOpenChange , modal: modal = true  } = props;
     const triggerRef = React.useRef(null);
     const contentRef = React.useRef(null);
-    const [open = false, setOpen] = index_module.$71cd76cc60e0454e$export$6f32135080cb4c3({
+    const [open = false, setOpen] = index.$71cd76cc60e0454e$export$6f32135080cb4c3({
         prop: openProp,
         defaultProp: defaultOpen,
         onChange: onOpenChange
@@ -163,9 +419,9 @@ const $5d3850c4d0b4e6c7$export$3ddf2d174ce01153 = (props)=>{
         scope: __scopeDialog,
         triggerRef: triggerRef,
         contentRef: contentRef,
-        contentId: index.$1746a345f3d73bb7$export$f680877a34711e37(),
-        titleId: index.$1746a345f3d73bb7$export$f680877a34711e37(),
-        descriptionId: index.$1746a345f3d73bb7$export$f680877a34711e37(),
+        contentId: index$1.$1746a345f3d73bb7$export$f680877a34711e37(),
+        titleId: index$1.$1746a345f3d73bb7$export$f680877a34711e37(),
+        descriptionId: index$1.$1746a345f3d73bb7$export$f680877a34711e37(),
         open: open,
         onOpenChange: setOpen,
         onOpenToggle: React.useCallback(()=>setOpen((prevOpen)=>!prevOpen
@@ -188,9 +444,9 @@ const $5d3850c4d0b4e6c7$export$dad7c95542bacce0 = (props)=>{
     return /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$PortalProvider, {
         scope: __scopeDialog,
         forceMount: forceMount
-    }, React.Children.map(children, (child)=>/*#__PURE__*/ React.createElement($921a889cee6df7e8$export$99c2b779aa4e8b8b, {
+    }, React.Children.map(children, (child)=>/*#__PURE__*/ React.createElement(index.$921a889cee6df7e8$export$99c2b779aa4e8b8b, {
             present: forceMount || context.open
-        }, /*#__PURE__*/ React.createElement(index.$f1701beae083dbae$export$602eac185826482c, {
+        }, /*#__PURE__*/ React.createElement(index$2.$f1701beae083dbae$export$602eac185826482c, {
             asChild: true,
             container: container
         }, child))
@@ -203,9 +459,9 @@ const $5d3850c4d0b4e6c7$export$bd1d06c79be19e17 = /*#__PURE__*/ React.forwardRef
     const portalContext = $5d3850c4d0b4e6c7$var$usePortalContext($5d3850c4d0b4e6c7$var$OVERLAY_NAME, props.__scopeDialog);
     const { forceMount: forceMount = portalContext.forceMount , ...overlayProps } = props;
     const context = $5d3850c4d0b4e6c7$var$useDialogContext($5d3850c4d0b4e6c7$var$OVERLAY_NAME, props.__scopeDialog);
-    return context.modal ? /*#__PURE__*/ React.createElement($921a889cee6df7e8$export$99c2b779aa4e8b8b, {
+    return context.modal ? /*#__PURE__*/ React.createElement(index.$921a889cee6df7e8$export$99c2b779aa4e8b8b, {
         present: forceMount || context.open
-    }, /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogOverlayImpl, index_module._extends({}, overlayProps, {
+    }, /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogOverlayImpl, _extends._extends({}, overlayProps, {
         ref: forwardedRef
     }))) : null;
 });
@@ -214,13 +470,13 @@ const $5d3850c4d0b4e6c7$var$DialogOverlayImpl = /*#__PURE__*/ React.forwardRef((
     const context = $5d3850c4d0b4e6c7$var$useDialogContext($5d3850c4d0b4e6c7$var$OVERLAY_NAME, __scopeDialog);
     return(/*#__PURE__*/ // Make sure `Content` is scrollable even when it doesn't live inside `RemoveScroll`
     // ie. when `Overlay` and `Content` are siblings
-    React.createElement(index.$01b9c$RemoveScroll, {
-        as: index_module.$5e63c961fc1ce211$export$8c6ed5c666ac1360,
+    React.createElement(index$3.$01b9c$RemoveScroll, {
+        as: $5e63c961fc1ce211$export$8c6ed5c666ac1360,
         allowPinchZoom: true,
         shards: [
             context.contentRef
         ]
-    }, /*#__PURE__*/ React.createElement(index_module.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index_module._extends({
+    }, /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, _extends._extends({
         "data-state": $5d3850c4d0b4e6c7$var$getState(context.open)
     }, overlayProps, {
         ref: forwardedRef // We re-enable pointer-events prevented by `Dialog.Content` to allow scrolling the overlay.
@@ -238,33 +494,33 @@ const $5d3850c4d0b4e6c7$export$b6d9565de1e068cf = /*#__PURE__*/ React.forwardRef
     const portalContext = $5d3850c4d0b4e6c7$var$usePortalContext($5d3850c4d0b4e6c7$var$CONTENT_NAME, props.__scopeDialog);
     const { forceMount: forceMount = portalContext.forceMount , ...contentProps } = props;
     const context = $5d3850c4d0b4e6c7$var$useDialogContext($5d3850c4d0b4e6c7$var$CONTENT_NAME, props.__scopeDialog);
-    return /*#__PURE__*/ React.createElement($921a889cee6df7e8$export$99c2b779aa4e8b8b, {
+    return /*#__PURE__*/ React.createElement(index.$921a889cee6df7e8$export$99c2b779aa4e8b8b, {
         present: forceMount || context.open
-    }, context.modal ? /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogContentModal, index_module._extends({}, contentProps, {
+    }, context.modal ? /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogContentModal, _extends._extends({}, contentProps, {
         ref: forwardedRef
-    })) : /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogContentNonModal, index_module._extends({}, contentProps, {
+    })) : /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogContentNonModal, _extends._extends({}, contentProps, {
         ref: forwardedRef
     })));
 });
 /* -----------------------------------------------------------------------------------------------*/ const $5d3850c4d0b4e6c7$var$DialogContentModal = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
     const context = $5d3850c4d0b4e6c7$var$useDialogContext($5d3850c4d0b4e6c7$var$CONTENT_NAME, props.__scopeDialog);
     const contentRef = React.useRef(null);
-    const composedRefs = index_module.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, context.contentRef, contentRef); // aria-hide everything except the content (better supported equivalent to setting aria-modal)
+    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, context.contentRef, contentRef); // aria-hide everything except the content (better supported equivalent to setting aria-modal)
     React.useEffect(()=>{
         const content = contentRef.current;
-        if (content) return index.hideOthers(content);
+        if (content) return index$3.hideOthers(content);
     }, []);
-    return /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogContentImpl, index_module._extends({}, props, {
+    return /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogContentImpl, _extends._extends({}, props, {
         ref: composedRefs // we make sure focus isn't trapped once `DialogContent` has been closed
         ,
         trapFocus: context.open,
         disableOutsidePointerEvents: true,
-        onCloseAutoFocus: index_module.$e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onCloseAutoFocus, (event)=>{
+        onCloseAutoFocus: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onCloseAutoFocus, (event)=>{
             var _context$triggerRef$c;
             event.preventDefault();
             (_context$triggerRef$c = context.triggerRef.current) === null || _context$triggerRef$c === void 0 || _context$triggerRef$c.focus();
         }),
-        onPointerDownOutside: index_module.$e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onPointerDownOutside, (event)=>{
+        onPointerDownOutside: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onPointerDownOutside, (event)=>{
             const originalEvent = event.detail.originalEvent;
             const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
             const isRightClick = originalEvent.button === 2 || ctrlLeftClick; // If the event is a right-click, we shouldn't close because
@@ -272,14 +528,15 @@ const $5d3850c4d0b4e6c7$export$b6d9565de1e068cf = /*#__PURE__*/ React.forwardRef
             if (isRightClick) event.preventDefault();
         }) // When focus is trapped, a `focusout` event may still happen.
         ,
-        onFocusOutside: index_module.$e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onFocusOutside, (event)=>event.preventDefault()
+        onFocusOutside: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onFocusOutside, (event)=>event.preventDefault()
         )
     }));
 });
 /* -----------------------------------------------------------------------------------------------*/ const $5d3850c4d0b4e6c7$var$DialogContentNonModal = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
     const context = $5d3850c4d0b4e6c7$var$useDialogContext($5d3850c4d0b4e6c7$var$CONTENT_NAME, props.__scopeDialog);
     const hasInteractedOutsideRef = React.useRef(false);
-    return /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogContentImpl, index_module._extends({}, props, {
+    const hasPointerDownOutsideRef = React.useRef(false);
+    return /*#__PURE__*/ React.createElement($5d3850c4d0b4e6c7$var$DialogContentImpl, _extends._extends({}, props, {
         ref: forwardedRef,
         trapFocus: false,
         disableOutsidePointerEvents: false,
@@ -292,19 +549,24 @@ const $5d3850c4d0b4e6c7$export$b6d9565de1e068cf = /*#__PURE__*/ React.forwardRef
                 event.preventDefault();
             }
             hasInteractedOutsideRef.current = false;
+            hasPointerDownOutsideRef.current = false;
         },
         onInteractOutside: (event)=>{
             var _props$onInteractOuts, _context$triggerRef$c3;
             (_props$onInteractOuts = props.onInteractOutside) === null || _props$onInteractOuts === void 0 || _props$onInteractOuts.call(props, event);
-            if (!event.defaultPrevented) hasInteractedOutsideRef.current = true; // Prevent dismissing when clicking the trigger.
+            if (!event.defaultPrevented) {
+                hasInteractedOutsideRef.current = true;
+                if (event.detail.originalEvent.type === 'pointerdown') hasPointerDownOutsideRef.current = true;
+            } // Prevent dismissing when clicking the trigger.
             // As the trigger is already setup to close, without doing so would
             // cause it to close and immediately open.
-            //
-            // We use `onInteractOutside` as some browsers also
-            // focus on pointer down, creating the same issue.
             const target = event.target;
             const targetIsTrigger = (_context$triggerRef$c3 = context.triggerRef.current) === null || _context$triggerRef$c3 === void 0 ? void 0 : _context$triggerRef$c3.contains(target);
-            if (targetIsTrigger) event.preventDefault();
+            if (targetIsTrigger) event.preventDefault(); // On Safari if the trigger is inside a container with tabIndex={0}, when clicked
+            // we will get the pointer down outside event on the trigger, but then a subsequent
+            // focus outside event on the container, we ignore any focus outside event when we've
+            // already had a pointer down outside event.
+            if (event.detail.originalEvent.type === 'focusin' && hasPointerDownOutsideRef.current) event.preventDefault();
         }
     }));
 });
@@ -312,16 +574,16 @@ const $5d3850c4d0b4e6c7$export$b6d9565de1e068cf = /*#__PURE__*/ React.forwardRef
     const { __scopeDialog: __scopeDialog , trapFocus: trapFocus , onOpenAutoFocus: onOpenAutoFocus , onCloseAutoFocus: onCloseAutoFocus , ...contentProps } = props;
     const context = $5d3850c4d0b4e6c7$var$useDialogContext($5d3850c4d0b4e6c7$var$CONTENT_NAME, __scopeDialog);
     const contentRef = React.useRef(null);
-    const composedRefs = index_module.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, contentRef); // Make sure the whole tree has focus guards as our `Dialog` will be
+    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, contentRef); // Make sure the whole tree has focus guards as our `Dialog` will be
     // the last element in the DOM (beacuse of the `Portal`)
-    index.$3db38b7d1fb3fe6a$export$b7ece24a22aeda8c();
-    return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(index.$d3863c46a17e8a28$export$20e40289641fbbb6, {
+    $3db38b7d1fb3fe6a$export$b7ece24a22aeda8c();
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement($d3863c46a17e8a28$export$20e40289641fbbb6, {
         asChild: true,
         loop: true,
         trapped: trapFocus,
         onMountAutoFocus: onOpenAutoFocus,
         onUnmountAutoFocus: onCloseAutoFocus
-    }, /*#__PURE__*/ React.createElement(index.$5cb92bef7577960e$export$177fb62ff3ec1f22, index_module._extends({
+    }, /*#__PURE__*/ React.createElement(index$2.$5cb92bef7577960e$export$177fb62ff3ec1f22, _extends._extends({
         role: "dialog",
         id: context.contentId,
         "aria-describedby": context.descriptionId,
@@ -338,7 +600,7 @@ const $5d3850c4d0b4e6c7$export$b6d9565de1e068cf = /*#__PURE__*/ React.forwardRef
 const $5d3850c4d0b4e6c7$export$16f7638e4a34b909 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
     const { __scopeDialog: __scopeDialog , ...titleProps } = props;
     const context = $5d3850c4d0b4e6c7$var$useDialogContext($5d3850c4d0b4e6c7$var$TITLE_NAME, __scopeDialog);
-    return /*#__PURE__*/ React.createElement(index_module.$8927f6f2acc4f386$export$250ffa63cdc0d034.h2, index_module._extends({
+    return /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.h2, _extends._extends({
         id: context.titleId
     }, titleProps, {
         ref: forwardedRef
@@ -350,7 +612,7 @@ const $5d3850c4d0b4e6c7$export$16f7638e4a34b909 = /*#__PURE__*/ React.forwardRef
 const $5d3850c4d0b4e6c7$export$94e94c2ec2c954d5 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
     const { __scopeDialog: __scopeDialog , ...descriptionProps } = props;
     const context = $5d3850c4d0b4e6c7$var$useDialogContext($5d3850c4d0b4e6c7$var$DESCRIPTION_NAME, __scopeDialog);
-    return /*#__PURE__*/ React.createElement(index_module.$8927f6f2acc4f386$export$250ffa63cdc0d034.p, index_module._extends({
+    return /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.p, _extends._extends({
         id: context.descriptionId
     }, descriptionProps, {
         ref: forwardedRef
@@ -366,23 +628,50 @@ const $5d3850c4d0b4e6c7$export$7c6e2c02157bb7d2 = $5d3850c4d0b4e6c7$export$b6d95
 const $5d3850c4d0b4e6c7$export$f99233281efd08a0 = $5d3850c4d0b4e6c7$export$16f7638e4a34b909;
 const $5d3850c4d0b4e6c7$export$393edc798c47379d = $5d3850c4d0b4e6c7$export$94e94c2ec2c954d5;
 
+/** Use `Modal` to focus a user's attention to an urgent or required prompt for interaction or input. */
 var Modal = function (_a) {
-    var title = _a.title, isOpen = _a.isOpen, onClose = _a.onClose, description = _a.description, children = _a.children, _b = _a.showDescription, showDescription = _b === void 0 ? true : _b;
+    var title = _a.title, description = _a.description, ariaDescribedBy = _a.ariaDescribedBy, isOpen = _a.isOpen, actions = _a.actions, onRequestClose = _a.onRequestClose, children = _a.children, _b = _a.role, role = _b === void 0 ? "dialog" : _b, _c = _a.shouldReturnFocus, shouldReturnFocus = _c === void 0 ? true : _c, _d = _a.isContentScrollable, isContentScrollable = _d === void 0 ? false : _d, _e = _a.size, size = _e === void 0 ? "l" : _e, props = filterDataAttrs.__rest(_a, ["title", "description", "ariaDescribedBy", "isOpen", "actions", "onRequestClose", "children", "role", "shouldReturnFocus", "isContentScrollable", "size"]);
     var arcRootElement = React.useContext(Base.ArcRootElementContext);
-    var modalDescription = React__default["default"].createElement(showDescription ? Text.Text : VisuallyHidden.VisuallyHidden, { children: description });
+    var triggerRef = React.useRef(null);
+    var setTriggerElement = function () {
+        return shouldReturnFocus &&
+            (triggerRef.current = document.activeElement);
+    };
+    var focusTriggerElement = function () {
+        if (triggerRef.current) {
+            triggerRef.current.focus();
+        }
+    };
+    var canShowClose = role !== "alertdialog" && onRequestClose;
+    var hasContent = description || children;
+    var ariaProps = filterDataAttrs.__assign({}, (ariaDescribedBy ? { "aria-describedby": ariaDescribedBy } : {}));
+    var closeModal = function () {
+        if (role !== "alertdialog" && onRequestClose) {
+            onRequestClose();
+        }
+    };
     return (React__default["default"].createElement($5d3850c4d0b4e6c7$export$be92b6f5f03c0fe9, { open: isOpen },
         React__default["default"].createElement($5d3850c4d0b4e6c7$export$602eac185826482c, { container: arcRootElement },
             React__default["default"].createElement($5d3850c4d0b4e6c7$export$c6fdb837b070b4ff, { className: "arc-Modal-overlay" },
-                React__default["default"].createElement($5d3850c4d0b4e6c7$export$7c6e2c02157bb7d2, { onEscapeKeyDown: onClose, onInteractOutside: onClose, className: "arc-Modal-dialog" },
-                    React__default["default"].createElement("div", { className: "arc-Modal-content" },
-                        React__default["default"].createElement("div", { className: "arc-Modal-textWrapper" },
-                            React__default["default"].createElement($5d3850c4d0b4e6c7$export$f99233281efd08a0, { className: "arc-Modal-title" },
-                                React__default["default"].createElement(Heading.Heading, { size: "m" }, title)),
-                            React__default["default"].createElement($5d3850c4d0b4e6c7$export$393edc798c47379d, null, modalDescription)),
-                        children),
-                    React__default["default"].createElement("div", { className: "arc-Modal-iconContainer" },
-                        React__default["default"].createElement("button", { "aria-label": "close", onClick: onClose, className: "arc-Modal-closeButton" },
-                            React__default["default"].createElement(Icon.Icon, { size: 32, icon: BtIconCrossAlt2Px.BtIconCrossAlt2Px_2 }))))))));
+                React__default["default"].createElement($5d3850c4d0b4e6c7$export$7c6e2c02157bb7d2, filterDataAttrs.__assign({}, ariaProps, { role: role, onOpenAutoFocus: setTriggerElement, onCloseAutoFocus: focusTriggerElement, onEscapeKeyDown: closeModal, onInteractOutside: closeModal, className: index$4.classNames("arc-Modal-dialog", "arc-Modal-dialog--".concat(size), {
+                        "arc-Modal-dialog--maxHeightWindow": isContentScrollable
+                    }) }, filterDataAttrs.filterDataAttrs(props)),
+                    React__default["default"].createElement("div", { className: "arc-Modal-section" },
+                        React__default["default"].createElement($5d3850c4d0b4e6c7$export$f99233281efd08a0, { asChild: true },
+                            React__default["default"].createElement(Heading.Heading, { level: "1", size: "m" }, title))),
+                    React__default["default"].createElement(VerticalSpace.VerticalSpace, { size: "12" }),
+                    hasContent && (React__default["default"].createElement("div", { className: "arc-Modal-content" },
+                        React__default["default"].createElement("div", { className: "arc-Modal-section" },
+                            description && (React__default["default"].createElement($5d3850c4d0b4e6c7$export$393edc798c47379d, { asChild: true },
+                                React__default["default"].createElement(Text.Text, null, description))),
+                            description && children && (React__default["default"].createElement(VerticalSpace.VerticalSpace, { "data-testid": "arc-modal-vertical-space", size: "20" })),
+                            children))),
+                    actions && (React__default["default"].createElement("div", { className: "arc-Modal-section" },
+                        React__default["default"].createElement("div", { className: "arc-Modal-actions" }, actions.map(function (props, i) { return (React__default["default"].createElement("div", { key: "arc-modal-button-".concat(i), className: "arc-Modal-actionButton" },
+                            React__default["default"].createElement(Button.Button, filterDataAttrs.__assign({ isFullWidth: true }, props)))); })))),
+                    canShowClose && (React__default["default"].createElement("div", { className: "arc-Modal-iconContainer" },
+                        React__default["default"].createElement("button", { "aria-label": "close", onClick: closeModal, className: "arc-Modal-closeButton" },
+                            React__default["default"].createElement(Icon.Icon, { size: 32, icon: BtIconCrossAlt2Px.BtIconCrossAlt2Px_2 })))))))));
 };
 
 exports.Modal = Modal;