@pine-ds/core 5.0.0-mercury.0 → 5.0.0

package/dist/cjs/pds-modal.cjs.entry.js

@@ -0,0 +1,592 @@
+'use strict';
+
+var index = require('./index-D9iJuJCP.js');
+var closest = require('./closest-D0qyYtJ3.js');
+var tabbable = require('./tabbable-BrrrGvdG.js');
+var reconnectedContent = require('./reconnected-content-CpnEQcTp.js');
+require('./keep-hydrated-AKoh0DG4.js');
+
+const pdsModalCss = () => `.pds-modal__backdrop{-ms-flex-align:start;align-items:flex-start;background-color:rgba(0, 0, 0, 0.4);border:0;display:-ms-flexbox;display:flex;height:100%;inset:0;-ms-flex-pack:center;justify-content:center;margin:0;max-height:100%;max-width:100%;opacity:0;padding:0;position:fixed;-webkit-transition:opacity var(--pine-motion-duration-base) var(--pine-motion-easing-in), visibility var(--pine-motion-duration-base) var(--pine-motion-easing-in);transition:opacity var(--pine-motion-duration-base) var(--pine-motion-easing-in), visibility var(--pine-motion-duration-base) var(--pine-motion-easing-in);visibility:hidden;width:100%;z-index:var(--pine-z-index-modal)}@supports ((-webkit-backdrop-filter: blur(3px)) or (backdrop-filter: blur(3px))){.pds-modal__backdrop{-webkit-backdrop-filter:blur(3px);backdrop-filter:blur(3px)}}pds-modal pds-modal .pds-modal__backdrop{z-index:var(--pine-z-index-priority)}.pds-modal__backdrop::-webkit-backdrop{background:transparent}.pds-modal__backdrop::-ms-backdrop{background:transparent}.pds-modal__backdrop::backdrop{background:transparent}.pds-modal__backdrop[aria-modal=false]{overflow:auto;-ms-scroll-chaining:none;overscroll-behavior:contain}@supports ((-webkit-backdrop-filter: blur(3px)) or (backdrop-filter: blur(3px))){.pds-modal__backdrop[aria-modal=false]{-webkit-backdrop-filter:none;backdrop-filter:none}.pds-modal__backdrop[aria-modal=false]::before{-webkit-backdrop-filter:blur(3px);backdrop-filter:blur(3px);content:"";inset:0;position:fixed;z-index:-1}}.pds-modal__backdrop.open{opacity:1;-webkit-transition-timing-function:var(--pine-motion-easing-out);transition-timing-function:var(--pine-motion-easing-out);visibility:visible}.pds-modal{background:var(--pine-color-background-overlay);border-radius:var(--pine-dimension-sm);-webkit-box-shadow:var(--pine-box-shadow-400);box-shadow:var(--pine-box-shadow-400);display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;margin:var(--pine-dimension-md);max-height:none;width:100%}.pds-modal.pds-modal--scrollable{max-height:calc(100vh - (5vh + 96px))}@supports (height: 100dvh){.pds-modal.pds-modal--scrollable{max-height:calc(100dvh - (5dvh + 96px))}}@media (min-width: 992px){.pds-modal{-webkit-margin-before:6vh;margin-block-start:6vh}@supports (height: 100dvh){.pds-modal{-webkit-margin-before:6dvh;margin-block-start:6dvh}}}@media (min-width: 1200px){.pds-modal{-webkit-margin-before:8vh;margin-block-start:8vh}@supports (height: 100dvh){.pds-modal{-webkit-margin-before:8dvh;margin-block-start:8dvh}}}.pds-modal--sm{max-width:520px}.pds-modal--md{max-width:700px}.pds-modal--lg{max-width:900px}.pds-modal--custom{max-width:var(--pds-modal-max-width, 700px)}.pds-modal--fullscreen{border-radius:0;height:100%;margin:0;max-height:100vh;max-width:100%}@supports (height: 100dvh){.pds-modal--fullscreen{max-height:100dvh}}.pds-modal--fullscreen.pds-modal--scrollable{max-height:100vh}@supports (height: 100dvh){.pds-modal--fullscreen.pds-modal--scrollable{max-height:100dvh}}.pds-modal--fullscreen .pds-modal-content{-ms-flex:1;flex:1}.pds-modal--scrollable pds-modal-content{-webkit-border-after:1px solid transparent;border-block-end:1px solid transparent;-webkit-border-before:1px solid transparent;border-block-start:1px solid transparent;overflow-y:auto}.pds-modal:not(.pds-modal--scrollable) pds-modal-content{overflow-y:visible}`;
+
+const PRESET_SIZES = ['sm', 'md', 'lg', 'fullscreen'];
+const isCustomLength = (value) => /^[a-z0-9.%+\-*/(), ]+$/i.test(value) &&
+    /\d/.test(value) &&
+    (typeof CSS === 'undefined' || CSS.supports('max-width', value));
+/** Whether `node` is `ancestor` or inside it, crossing shadow roots, which `Node.contains` doesn't. */
+function containsComposed(ancestor, node) {
+    for (let current = node; current; current = current instanceof ShadowRoot ? current.host : current.parentNode) {
+        if (current === ancestor)
+            return true;
+    }
+    return false;
+}
+/**
+ * Every open modal, with the order it opened in, which ranks top-layer modals and the modals
+ * inside them. Kept here rather than queried from the document, which can't see a modal inside
+ * another component's shadow root.
+ */
+const openModals = new Map();
+let openSequence = 0;
+/** Whether the panel of an open popover that takes Escape sits in `root`, including inside shadow roots under it. */
+function hasOpenPopover(root) {
+    if (root.querySelector('[data-pds-popover-open]'))
+        return true;
+    return Array.from(root.querySelectorAll('*')).some(el => !!el.shadowRoot && hasOpenPopover(el.shadowRoot));
+}
+/**
+ * Whether `a` comes before `b` in the page. `compareDocumentPosition` is arbitrary across a shadow
+ * boundary, so each side climbs to its host until both are in the same tree.
+ */
+function precedesComposed(a, b) {
+    // A document has no host, which ends each climb.
+    for (let x = a; x; x = x.getRootNode().host) {
+        for (let y = b; y; y = y.getRootNode().host) {
+            if (x.getRootNode() === y.getRootNode()) {
+                return !!(x.compareDocumentPosition(y) & Node.DOCUMENT_POSITION_FOLLOWING);
+            }
+        }
+    }
+    return false;
+}
+/** The focused element, followed down through shadow roots to the control that has focus. */
+function deepActiveElement() {
+    var _a;
+    let active = document.activeElement;
+    while ((_a = active === null || active === void 0 ? void 0 : active.shadowRoot) === null || _a === void 0 ? void 0 : _a.activeElement)
+        active = active.shadowRoot.activeElement;
+    return active;
+}
+const PdsModal = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.pdsModalOpen = index.createEvent(this, "pdsModalOpen");
+        this.pdsModalClose = index.createEvent(this, "pdsModalClose");
+        this.focusableElements = [];
+        /**
+         * Whether the modal can be dismissed by clicking the backdrop, pressing Escape, or the browser's
+         * own close request (such as a back gesture)
+         * @default true
+         */
+        this.backdropDismiss = true;
+        /**
+         * Whether the modal is open
+         * @default false
+         */
+        this.open = false;
+        /**
+         * The size of the modal. Can be a predefined value ('sm', 'md', 'lg', 'fullscreen') or a custom
+         * max-width as a CSS length (e.g., '1250px', '80vw'). A custom width stays fluid below that size.
+         * A value that is neither falls back to 'md'.
+         * @default 'md'
+         */
+        this.size = 'md';
+        /**
+         * Whether the modal content should be scrollable
+         * @default true
+         */
+        this.scrollable = true;
+        /**
+         * Whether the modal opens outside the browser top layer as a non-modal dialog.
+         * When `true` it opens with `dialog.show()` instead of `dialog.showModal()`, so
+         * overlays rendered elsewhere in the DOM (file pickers, editor menus) can display
+         * above it via `z-index`. The page is not made inert and focus is not trapped in
+         * this mode. Read when the modal opens; changing it while the modal is open is
+         * not supported.
+         * @default false
+         */
+        this.disableTopLayer = false;
+        /**
+         * Whether to skip moving focus into the modal when it opens. Set it for a
+         * modal that can open from a background event while the user is mid-task
+         * elsewhere on the page, where moving focus would interrupt them. Pair it
+         * with `disableTopLayer`: in the top layer the rest of the page is inert, so
+         * focus can't stay there. On close, focus moves back only if nothing outside
+         * the modal has taken it.
+         * @default false
+         */
+        this.disableInitialFocus = false;
+        /**
+         * Stores the list of focusable elements in the modal
+         */
+        this.focusableElementsArray = [];
+        // The browser's own close request (an Escape nothing prevented, a back gesture) would close the
+        // dialog without updating `open`, so close it through hideModal() instead, or not at all.
+        this.handleCancel = (e) => {
+            e.preventDefault();
+            if (!this.open)
+                return;
+            // The request reaches the top-layer dialog even when a disableTopLayer modal inside it is on
+            // top; that one closes first, as it would on Escape.
+            const top = this.innermostOpenModal();
+            const target = (top && containsComposed(this.el, top) ? top : this.el);
+            if (target.backdropDismiss)
+                target.hideModal();
+        };
+        this.handleBackdropClick = (e) => {
+            if (!this.backdropDismiss || !this.open)
+                return;
+            // This modal's own backdrop; a nested modal's backdrop handles its own clicks.
+            if (e.target === this.modalRef) {
+                e.stopPropagation();
+                // Only close if this is the innermost modal
+                if (this.innermostOpenModal() === this.el) {
+                    this.hideModal();
+                }
+            }
+        };
+        this.handleKeyDown = (e) => {
+            var _a, _b, _c, _d;
+            // If the modal is not open, don't handle any keyboard events
+            if (!this.open)
+                return;
+            // Handle Escape key to close the modal
+            if (e.key === 'Escape') {
+                // Every open pds-modal shares this document-level listener for the
+                // same keydown event. Whichever one runs first can synchronously move
+                // focus (hideModal() restores it), which would make a later instance's
+                // own read of document.activeElement reflect that side effect instead
+                // of where focus actually was when the key was pressed — stacking two
+                // sibling modals closing on one Escape instead of just the top one.
+                // That alone isn't enough, though: isStackedAboveOverlay's `:modal`
+                // check reads LIVE top-layer state, and hideModal()'s close() clears it
+                // synchronously — so whichever sibling's listener runs first (DOM
+                // order, not z-index) can close itself and erase the very evidence a
+                // later listener needs to recognize it was stacked above. Snapshot that
+                // determination too, in the same first-listener-wins block, before any
+                // instance has had a chance to act on this keypress.
+                const eventSnapshot = e;
+                if (!('__pdsActiveElementAtEscape' in eventSnapshot)) {
+                    const activeAtDispatch = document.activeElement;
+                    eventSnapshot.__pdsActiveElementAtEscape = activeAtDispatch;
+                    // Followed into shadow roots: for a modal inside one, document.activeElement is only the host.
+                    eventSnapshot.__pdsDeepActiveElementAtEscape = deepActiveElement();
+                    const topLayerDialog = (_a = activeAtDispatch === null || activeAtDispatch === void 0 ? void 0 : activeAtDispatch.closest('dialog')) !== null && _a !== void 0 ? _a : null;
+                    eventSnapshot.__pdsTopLayerDialogAtEscape = topLayerDialog;
+                    eventSnapshot.__pdsTopLayerDialogWasModalAtEscape = !!(topLayerDialog && topLayerDialog.matches(':modal'));
+                    // A control that closed on this Escape (a combobox on its own element, a dropdown menu or
+                    // multiselect in document's capture phase) has prevented it before this bubble listener.
+                    // Read before any modal prevents it below.
+                    eventSnapshot.__pdsEscapeHandledInside = e.defaultPrevented;
+                    // Which modal is innermost is read once too: the inner one closing first would make its
+                    // outer modal the innermost by the time that modal's listener runs.
+                    eventSnapshot.__pdsInnermostModalAtEscape = this.innermostOpenModal();
+                }
+                if (eventSnapshot.__pdsEscapeHandledInside)
+                    return;
+                // Leave Escape to a genuinely stacked-above overlay (disableTopLayer's
+                // reason for existing) — not just to anything outside this modal.
+                const active = eventSnapshot.__pdsActiveElementAtEscape;
+                if (this.disableTopLayer &&
+                    active &&
+                    active !== document.body &&
+                    !containsComposed(this.el, (_b = eventSnapshot.__pdsDeepActiveElementAtEscape) !== null && _b !== void 0 ? _b : active) &&
+                    this.isStackedAboveOverlay(active, (_c = eventSnapshot.__pdsTopLayerDialogAtEscape) !== null && _c !== void 0 ? _c : null, (_d = eventSnapshot.__pdsTopLayerDialogWasModalAtEscape) !== null && _d !== void 0 ? _d : false)) {
+                    return;
+                }
+                // An open popover inside takes Escape from its own document listener, which runs after this
+                // one, so leave the key for it. Its preventDefault() keeps the native dialog open.
+                if (this.modalRef && hasOpenPopover(this.modalRef))
+                    return;
+                // Always prevent native dialog close behavior
+                e.preventDefault();
+                // Only close if backdropDismiss is enabled and this is the innermost modal
+                if (this.backdropDismiss && eventSnapshot.__pdsInnermostModalAtEscape === this.el) {
+                    this.hideModal();
+                }
+                return;
+            }
+            // Handle Tab key for focus trapping
+            if (e.key === 'Tab') {
+                // In non-top-layer mode the modal is deliberately not focus-isolated: focus
+                // must be able to leave it into overlays stacked above (the whole point of
+                // disableTopLayer), so do not trap Tab here.
+                if (this.disableTopLayer)
+                    return;
+                // A control inside that handles Tab itself (a popup with its own trap) has already moved
+                // focus. This holds only when it listens on its own element, which runs before this
+                // document listener; one listening on document too would race it.
+                if (e.defaultPrevented)
+                    return;
+                // Every open modal hears this keydown. When focus is in a modal dialog opened above this one,
+                // that dialog traps Tab: this modal's list also holds its controls, so it would wrap first. A
+                // non-modal dialog inside (a disableTopLayer modal) doesn't trap, so this one still does.
+                const activeElement = deepActiveElement();
+                if (!activeElement || this.modalDialogAbove(activeElement))
+                    return;
+                // Content can change while the modal is open (rows fetched in, sections shown), so the
+                // first and last elements are read now rather than from the list taken on opening.
+                this.updateFocusableElements();
+                // If there are no focusable elements, do nothing
+                if (this.focusableElements.length === 0)
+                    return;
+                // Get the first and last focusable elements
+                const firstFocusableElement = this.focusableElements[0];
+                const lastFocusableElement = this.focusableElements[this.focusableElements.length - 1];
+                // activeElement is the control inside any shadow root, as the list holds, not the host
+                // document.activeElement reports. It's matched to its own stop first, so a stop inside a
+                // listed host isn't taken for that host; a focused node that isn't a stop counts as the
+                // innermost stop it sits in.
+                const stop = this.stopIndex(activeElement);
+                const isFirstElement = stop === 0;
+                const isLastElement = stop === this.focusableElements.length - 1;
+                // If shift + tab is pressed and focus is on the first element, move to the last element
+                if (e.shiftKey && isFirstElement) {
+                    e.preventDefault();
+                    this.focusElement(lastFocusableElement);
+                }
+                // If tab is pressed and focus is on the last element, move to the first element
+                else if (!e.shiftKey && isLastElement) {
+                    e.preventDefault();
+                    this.focusElement(firstFocusableElement);
+                }
+            }
+        };
+    }
+    componentWillLoad() {
+        this.warnOnInvalidSize();
+    }
+    sizeChanged() {
+        this.warnOnInvalidSize();
+    }
+    componentDidLoad() {
+        this.modalRef = this.el.querySelector('.pds-modal__backdrop');
+        // @Watch('open') only fires on a later change, not the prop's initial
+        // value — a modal mounted with `open` already true (static markup, or a
+        // framework passing it on first render) would otherwise never call
+        // show()/showModal(): the panel still appears, since that's driven by the
+        // `open` CSS class, but the native <dialog> itself was never opened, so
+        // there's no top-layer promotion, no dialog focusing steps, and no
+        // focusable-elements list or previousActiveElement captured.
+        if (this.open) {
+            this.showModal();
+        }
+    }
+    // Unwraps a nested dialog.pds-modal__backdrop left by a page-cache (Turbo, bfcache) reconnect.
+    componentDidRender() {
+        reconnectedContent.unwrapReconnectedContent(this.el.querySelector('.pds-modal'), 'dialog.pds-modal__backdrop', '.pds-modal');
+    }
+    // Here rather than in componentDidLoad, which runs once: a modal taken out of the page and put
+    // back (a morph or a framework moving it) gets its keyboard handling, and its place among the
+    // open modals, back too. Adding the same listener twice is a no-op.
+    connectedCallback() {
+        document.addEventListener('keydown', this.handleKeyDown);
+        if (this.open && !openModals.has(this.el))
+            openModals.set(this.el, ++openSequence);
+    }
+    disconnectedCallback() {
+        // Clean up event listener
+        document.removeEventListener('keydown', this.handleKeyDown);
+        openModals.delete(this.el);
+    }
+    handleOpenChange(newValue) {
+        if (newValue) {
+            this.showModal();
+        }
+        else {
+            this.hideModal();
+        }
+    }
+    /**
+     * Updates the list of focusable elements in the modal
+     */
+    updateFocusableElements() {
+        if (!this.modalRef)
+            return;
+        this.focusableElements = tabbable.tabbableIn(this.modalRef);
+    }
+    /**
+     * Sets focus to the first focusable element in the modal
+     */
+    setInitialFocus() {
+        if (this.focusableElements.length === 0)
+            return;
+        // Focus the first focusable element
+        const firstElement = this.focusableElements[0];
+        // For web components, we need to ensure they're properly focused
+        this.focusElement(firstElement);
+    }
+    /**
+     * Focuses an element from the list. It holds the controls themselves, inside any shadow root,
+     * so they take focus directly.
+     */
+    focusElement(element) {
+        element === null || element === void 0 ? void 0 : element.focus();
+    }
+    /**
+     * Opens the modal
+     */
+    async showModal() {
+        var _a;
+        if (this.modalRef) {
+            try {
+                // Store the currently focused element to restore focus when modal closes. Showing an open
+                // modal again (the open watcher does) would record a control inside it instead.
+                if (!this.modalRef.open)
+                    this.previousActiveElement = document.activeElement;
+                // showModal() promotes the dialog to the browser top layer (and makes the
+                // rest of the page inert), which prevents any overlay outside the dialog
+                // from ever painting above it. show() opens a non-modal dialog that stays
+                // in the normal stacking context so those overlays can stack above it.
+                if (this.disableTopLayer) {
+                    this.modalRef.show();
+                }
+                else {
+                    this.modalRef.showModal();
+                }
+                this.open = true;
+                // Showing an open modal again doesn't move it above one opened after it.
+                if (!openModals.has(this.el))
+                    openModals.set(this.el, ++openSequence);
+                // Update focusable elements and set initial focus
+                // Using a longer timeout to ensure all components are fully rendered
+                const openedAs = (_a = openModals.get(this.el)) !== null && _a !== void 0 ? _a : 0;
+                setTimeout(() => {
+                    var _a, _b;
+                    this.updateFocusableElements();
+                    // A modal opened above this one in the meantime has focus; don't take it back. Not this
+                    // modal itself (moving it gives it a new place), and not a disableTopLayer modal outside
+                    // it while this one is in the top layer, which sits below it.
+                    const openedAbove = Array.from(openModals).some(([modal, sequence]) => sequence > openedAs &&
+                        modal !== this.el &&
+                        (containsComposed(this.el, modal) || !modal.disableTopLayer || this.disableTopLayer));
+                    if (openedAbove) {
+                        this.pdsModalOpen.emit();
+                        return;
+                    }
+                    if (this.disableInitialFocus) {
+                        // show()/showModal() also move focus into the dialog natively (the
+                        // HTML spec's "dialog focusing steps") — that native step isn't
+                        // necessarily done by the time this task runs either, so counter it
+                        // here, in the same deferred slot setInitialFocus() below uses for
+                        // the same reason, rather than racing it synchronously above.
+                        //
+                        // disableInitialFocus exists for a drawer that can open in the
+                        // background while the user is mid-task elsewhere — by the time
+                        // this runs, they may have already clicked into something of
+                        // their own outside the dialog. Only act if focus is still where
+                        // the native steps (or nothing) left it, so that isn't stolen.
+                        const activeElement = document.activeElement;
+                        const focusAlreadyClaimedElsewhere = activeElement !== null && activeElement !== document.body && !((_a = this.modalRef) === null || _a === void 0 ? void 0 : _a.contains(activeElement));
+                        if (!focusAlreadyClaimedElsewhere) {
+                            if (this.previousActiveElement !== document.body && typeof ((_b = this.previousActiveElement) === null || _b === void 0 ? void 0 : _b.focus) === 'function') {
+                                this.previousActiveElement.focus();
+                            }
+                            else if (activeElement instanceof HTMLElement) {
+                                // Nothing was focused before opening (previousActiveElement is
+                                // body), so there's nothing to restore focus to — body.focus()
+                                // would be a no-op and leave focus wherever the native focusing
+                                // steps put it, inside the dialog. Blur that instead so focus
+                                // ends up nowhere, matching the state before opening.
+                                activeElement.blur();
+                            }
+                        }
+                    }
+                    else {
+                        this.setInitialFocus();
+                    }
+                    this.pdsModalOpen.emit();
+                }, 100);
+            }
+            catch (error) {
+                console.error('Failed to show modal:', error);
+            }
+        }
+    }
+    /**
+     * Closes the modal
+     */
+    async hideModal() {
+        var _a;
+        if (this.modalRef) {
+            try {
+                // Capture before close(): with the async task queue, a prop change
+                // that triggers hideModal() (e.g. light dismiss setting `open` false
+                // on a pointerdown elsewhere) doesn't run until the next frame — by
+                // then the browser has already moved focus to whatever the user's
+                // click actually landed on. Restoring previousActiveElement in that
+                // case would steal focus back from a real new destination; only
+                // restore it when focus is still inside the modal (or nowhere, i.e.
+                // document.body), meaning nothing else has claimed it since.
+                const activeElement = document.activeElement;
+                const focusAlreadyMovedElsewhere = activeElement !== null && activeElement !== document.body && !this.modalRef.contains(activeElement);
+                this.modalRef.close();
+                this.open = false;
+                openModals.delete(this.el);
+                // Restore focus to the element that was focused before the modal was opened. If that's
+                // gone or can't take focus (disabled, hidden, or nothing), fall back to the open modal now
+                // on top, so focus doesn't land on an inert page behind it.
+                if (!focusAlreadyMovedElsewhere) {
+                    const previous = this.previousActiveElement;
+                    if (previous && previous !== document.body && previous.isConnected)
+                        (_a = previous.focus) === null || _a === void 0 ? void 0 : _a.call(previous);
+                    const active = deepActiveElement();
+                    // document.body isn't a real restore target — it's just where focus lands when nothing
+                    // was focused before opening, so landing back there never counts as a successful restore.
+                    if (!previous || previous === document.body || !containsComposed(previous, active) || containsComposed(this.el, active))
+                        this.focusTopModal();
+                }
+                this.pdsModalClose.emit();
+            }
+            catch (error) {
+                console.error('Failed to hide modal:', error);
+            }
+        }
+    }
+    /**
+     * Focuses the first control of the open modal now on top, when the page behind it is inert: that
+     * modal is in the top layer (or paints there inside a top-layer one), or it wraps this one. A
+     * non-modal one over an interactive page, like a drawer, is left alone.
+     */
+    focusTopModal() {
+        var _a;
+        const top = this.innermostOpenModal();
+        const dialog = top === null || top === void 0 ? void 0 : top.querySelector('.pds-modal__backdrop');
+        if (!dialog)
+            return;
+        if (!closest.closest('dialog:modal', dialog) && !containsComposed(top, this.el))
+            return;
+        (_a = tabbable.tabbableIn(dialog).find(el => !containsComposed(this.el, el))) === null || _a === void 0 ? void 0 : _a.focus();
+    }
+    /**
+     * Gets the z-index of a modal's backdrop element
+     */
+    getBackdropZIndex(modal) {
+        const backdrop = modal.querySelector('.pds-modal__backdrop');
+        // `auto` (no z-index token loaded) parses to NaN, which no comparison can rank.
+        const zIndex = backdrop ? parseInt(getComputedStyle(backdrop).zIndex, 10) : -1;
+        return Number.isNaN(zIndex) ? 0 : zIndex;
+    }
+    /**
+     * Whether `active` sits inside a surface actually stacked above this modal.
+     *
+     * Used to decide whether an Escape keypress belongs to that surface instead
+     * of this modal. Focus being merely *outside* this modal is not enough on
+     * its own: in `disableTopLayer` mode the page stays interactive (that's the
+     * point of a non-modal usage like a drawer), so focus will routinely be on
+     * ordinary page content while the modal is open, and that must not be
+     * mistaken for "an overlay owns Escape."
+     *
+     * Two ways a surface can be above: it is itself promoted to the browser's
+     * top layer (a regular `showModal()` dialog, which paints above everything
+     * outside the top layer regardless of z-index — a sibling pds-modal opened
+     * over a `disableTopLayer` drawer typically shares the exact same z-index
+     * token, so a numeric comparison alone would miss it), or it has a higher
+     * z-index than this modal's own backdrop (a `disableTopLayer` overlay, or
+     * anything else deliberately raised above it).
+     *
+     * `topLayerDialog` / `topLayerDialogWasModal` come pre-snapshotted from the
+     * keydown event (see handleKeyDown) rather than being re-derived here: by
+     * the time a later sibling modal's listener runs, an earlier one may have
+     * already closed itself, which clears `:modal` — reading it live here would
+     * lose that evidence depending on listener order.
+     */
+    isStackedAboveOverlay(active, topLayerDialog, topLayerDialogWasModal) {
+        // A top-layer dialog this modal sits inside is underneath it, not an overlay above.
+        if (topLayerDialog && topLayerDialog !== this.modalRef && topLayerDialogWasModal && !containsComposed(topLayerDialog, this.el)) {
+            return true;
+        }
+        const ownZIndex = this.getBackdropZIndex(this.el);
+        let node = active;
+        while (node && node !== document.body) {
+            const style = getComputedStyle(node);
+            const zIndex = parseInt(style.zIndex, 10);
+            if (style.position !== 'static' && !isNaN(zIndex) && zIndex > ownZIndex) {
+                return true;
+            }
+            node = node.parentElement;
+        }
+        return false;
+    }
+    /**
+     * The open modal that takes Escape or a backdrop click, among those with no other open modal
+     * inside them (a nested modal's backdrop can share its outer modal's z-index). A top-layer dialog
+     * (or a modal inside one) paints above anything outside it, and within the top layer the last
+     * opened is on top. Modals in the same layer (the page, or one top-layer dialog) then rank by
+     * the highest backdrop, then the one later in the page.
+     */
+    innermostOpenModal() {
+        const open = Array.from(openModals.keys()).filter(modal => modal.isConnected);
+        const innermost = open.filter(modal => !open.some(other => other !== modal && containsComposed(modal, other)));
+        const byDocumentOrder = [...innermost].sort((a, b) => (precedesComposed(a, b) ? -1 : 1));
+        // A modal inside a top-layer dialog paints in that dialog's place in the top layer, even when it
+        // isn't in the top layer itself (disableTopLayer), so that dialog's open order ranks it first.
+        const rank = (modal) => {
+            var _a;
+            const backdrop = modal.querySelector('.pds-modal__backdrop');
+            const topLayerDialog = backdrop ? closest.closest('dialog:modal', backdrop) : null;
+            const topLayerModal = topLayerDialog === null || topLayerDialog === void 0 ? void 0 : topLayerDialog.closest('pds-modal');
+            const layer = topLayerDialog ? ((_a = (topLayerModal && openModals.get(topLayerModal))) !== null && _a !== void 0 ? _a : 0) : 0;
+            return [topLayerDialog ? 1 : 0, layer, this.getBackdropZIndex(modal), byDocumentOrder.indexOf(modal)];
+        };
+        let top = null;
+        let topRank = [-1, -1, -1, -1];
+        for (const modal of innermost) {
+            const modalRank = rank(modal);
+            const above = modalRank.findIndex((value, i) => value !== topRank[i]);
+            if (above >= 0 && modalRank[above] > topRank[above]) {
+                top = modal;
+                topRank = modalRank;
+            }
+        }
+        return top;
+    }
+    /** Whether a modal dialog other than this one sits between the focused element and this modal. */
+    modalDialogAbove(active) {
+        var _a;
+        for (let dialog = closest.closest('dialog[open]', active); dialog instanceof HTMLElement;) {
+            if (dialog === this.modalRef)
+                return false;
+            if (dialog.matches(':modal'))
+                return true;
+            // Up from this dialog, across a shadow root; past the document root, closest() gives nothing.
+            dialog = closest.closest('dialog[open]', (_a = dialog.parentElement) !== null && _a !== void 0 ? _a : dialog.getRootNode().host);
+        }
+        return false;
+    }
+    /** The focused element's place in the list: its own stop, or the innermost stop it sits in. */
+    stopIndex(active) {
+        const own = this.focusableElements.indexOf(active);
+        if (own >= 0)
+            return own;
+        for (let i = this.focusableElements.length - 1; i >= 0; i--) {
+            if (containsComposed(this.focusableElements[i], active))
+                return i;
+        }
+        return -1;
+    }
+    resolveSize() {
+        var _a;
+        const size = ((_a = this.size) !== null && _a !== void 0 ? _a : '').trim() || 'md';
+        if (PRESET_SIZES.includes(size))
+            return [size];
+        return isCustomLength(size) ? ['custom', size] : [undefined];
+    }
+    warnOnInvalidSize() {
+        if (this.resolveSize()[0] !== undefined)
+            return;
+        console.warn(`pds-modal: invalid size "${String(this.size).slice(0, 50)}", using md`);
+    }
+    render() {
+        const [sizeClass = 'md', customSize] = this.resolveSize();
+        return (index.h("dialog", { key: '39f42306fff4fae51a9dffe86500a2c7e55cf8f5', class: {
+                'pds-modal__backdrop': true,
+                'open': this.open
+            }, "aria-modal": this.disableTopLayer ? 'false' : 'true', "aria-labelledby": `${this.componentId}-heading`, onClick: this.handleBackdropClick, onCancel: this.handleCancel }, index.h("div", { key: 'baff708cc933457027074dda27ce440e7a65a0da', class: {
+                'pds-modal': true,
+                [`pds-modal--${sizeClass}`]: true,
+                'pds-modal--scrollable': this.scrollable
+            }, style: customSize !== undefined ? { '--pds-modal-max-width': customSize } : undefined, part: "modal" }, index.h("slot", { key: 'd752edad801a28fcd5b93aa50f52528255a319b8' }))));
+    }
+    get el() { return index.getElement(this); }
+    static get watchers() { return {
+        "size": [{
+                "sizeChanged": 0
+            }],
+        "open": [{
+                "handleOpenChange": 0
+            }]
+    }; }
+};
+PdsModal.style = pdsModalCss();
+
+exports.pds_modal = PdsModal;