@surdeddd/bottom-sheet 0.23.4 → 0.24.1

package/dist/overlay.js

@@ -2,6 +2,15 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// src/core/primitives/shared.ts
+var STORE_KEY = /* @__PURE__ */ Symbol.for("@surdeddd/bottom-sheet/shared/1");
+function shared(name, init) {
+  const host = globalThis;
+  const store = host[STORE_KEY] ?? (host[STORE_KEY] = {});
+  if (!(name in store)) store[name] = init();
+  return store[name];
+}
+
 // src/core/lifecycle/sheet-stack.ts
 var BASE_Z = 100;
 var STEP = 10;
@@ -69,10 +78,25 @@ var SheetStack = class {
     });
   }
 };
-var sheetStack = new SheetStack();
+var sheetStack = shared("stack", () => new SheetStack());
+
+// src/core/primitives/dev-warn.ts
+function devWarn(...args) {
+  if (typeof process !== "undefined" && process.env && process.env.NODE_ENV !== "production" && typeof console !== "undefined") {
+    console.warn(...args);
+  }
+}
 
 // src/core/primitives/css-length.ts
 var probe = null;
+var rejected = /* @__PURE__ */ new Set();
+var warnRejected = (value) => {
+  if (rejected.has(value)) return;
+  rejected.add(value);
+  devWarn(
+    `[BottomSheet] snap size "${value}" is not a CSS length the browser accepts \u2014 it resolves to 0.`
+  );
+};
 var PROBE_ATTR = "data-bs-probe";
 var ensureProbe = (axis) => {
   if (typeof document === "undefined") return null;
@@ -114,19 +138,13 @@ var resolveSnap = (point, mode, measureFit) => {
   if (!el) return 0;
   {
     el.style.height = point;
+    if (el.style.height === "") warnRejected(point);
     return Math.max(0, el.getBoundingClientRect().height);
   }
 };
 
-// src/core/primitives/dev-warn.ts
-function devWarn(...args) {
-  if (typeof process !== "undefined" && process.env && process.env.NODE_ENV !== "production" && typeof console !== "undefined") {
-    console.warn(...args);
-  }
-}
-
 // src/core/primitives/instance-id.ts
-var counters = {};
+var counters = shared("instanceIds", () => ({}));
 function nextInstanceId(prefix) {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
     return `${prefix}-${crypto.randomUUID()}`;
@@ -154,7 +172,13 @@ function createEventBus() {
       const set = listeners.get(event);
       if (!set) return;
       for (const fn of [...set]) {
-        fn(payload);
+        try {
+          fn(payload);
+        } catch (err) {
+          queueMicrotask(() => {
+            throw err;
+          });
+        }
       }
     },
     listenerCount(event) {
@@ -201,27 +225,51 @@ var collectFocusables = (root) => {
 var focusables = (root) => collectFocusables(root).filter(
   (el) => !el.hasAttribute("inert") && isVisible(el) && !el.matches("[aria-hidden='true']")
 );
+var findDeep = (root, selector) => {
+  const direct = root.querySelector(selector);
+  if (direct || typeof HTMLSlotElement === "undefined") return direct;
+  for (const slot of Array.from(root.querySelectorAll("slot"))) {
+    for (const assigned of slot.assignedElements()) {
+      if (assigned.matches(selector)) return assigned;
+      const inner = findDeep(assigned, selector);
+      if (inner) return inner;
+    }
+  }
+  return null;
+};
+var FOCUS_ALLOW_ATTR = "data-bs-focus-allow";
+var composedParent = (node) => {
+  const slot = node.assignedSlot;
+  if (slot) return slot;
+  const parent = node.parentNode;
+  return parent instanceof ShadowRoot ? parent.host : parent;
+};
 var containsComposed = (container, node) => {
-  let n = node;
-  while (n) {
+  for (let n = node; n; n = composedParent(n)) {
     if (n === container) return true;
-    const slot = n.assignedSlot;
-    if (slot) {
-      n = slot;
-      continue;
-    }
-    const parent = n.parentNode;
-    n = parent instanceof ShadowRoot ? parent.host : parent;
   }
   return false;
 };
-var trapStack = [];
+var isAllowedOutside = (node) => {
+  for (let n = node; n; n = composedParent(n)) {
+    if (n instanceof Element && n.hasAttribute(FOCUS_ALLOW_ATTR)) return true;
+  }
+  return false;
+};
+var deepActiveElement = () => {
+  let active = document.activeElement;
+  while (active?.shadowRoot?.activeElement) {
+    active = active.shadowRoot.activeElement;
+  }
+  return active;
+};
+var trapStack = shared("focusTraps", () => []);
 var installFocusTrap = (container, options = {}) => {
   if (typeof document === "undefined") return () => {
   };
   const token = {};
-  trapStack.push(token);
-  const isActive = () => trapStack[trapStack.length - 1] === token;
+  if (!options.isActive) trapStack.push(token);
+  const isActive = options.isActive ?? (() => trapStack[trapStack.length - 1] === token);
   const previouslyFocused = document.activeElement;
   const focusInitial = () => {
     const spec = options.initialFocus;
@@ -230,10 +278,11 @@ var installFocusTrap = (container, options = {}) => {
       container.focus({ preventScroll: true });
       return;
     }
-    const initial = typeof spec === "string" ? container.querySelector(spec) : spec ?? focusables(container)[0] ?? container;
+    const initial = typeof spec === "string" ? findDeep(container, spec) : spec ?? focusables(container)[0] ?? container;
     initial?.focus({ preventScroll: true });
   };
-  focusInitial();
+  if (!containsComposed(container, deepActiveElement())) focusInitial();
+  let backwards = false;
   const handleKey = (e) => {
     if (!isActive()) return;
     if (e.key === "Escape" && options.onEscape) {
@@ -241,6 +290,10 @@ var installFocusTrap = (container, options = {}) => {
       return;
     }
     if (e.key !== "Tab") return;
+    backwards = e.shiftKey;
+    setTimeout(() => {
+      backwards = false;
+    }, 0);
     const list = focusables(container);
     if (list.length === 0) {
       e.preventDefault();
@@ -248,7 +301,7 @@ var installFocusTrap = (container, options = {}) => {
     }
     const first = list[0];
     const last = list[list.length - 1];
-    const active = document.activeElement;
+    const active = deepActiveElement();
     if (e.shiftKey && active === first) {
       e.preventDefault();
       last.focus();
@@ -259,11 +312,11 @@ var installFocusTrap = (container, options = {}) => {
   };
   const handleFocusIn = (e) => {
     if (!isActive()) return;
-    const target = e.target;
-    if (target && !containsComposed(container, target)) {
-      const list = focusables(container);
-      list[0]?.focus({ preventScroll: true });
-    }
+    const target = e.composedPath()[0] ?? e.target;
+    if (!target || containsComposed(container, target)) return;
+    if (isAllowedOutside(target)) return;
+    const list = focusables(container);
+    list[backwards ? list.length - 1 : 0]?.focus({ preventScroll: true });
   };
   document.addEventListener("keydown", handleKey, true);
   document.addEventListener("focusin", handleFocusIn, true);
@@ -285,21 +338,25 @@ var installFocusTrap = (container, options = {}) => {
 };
 
 // src/core/lifecycle/scroll-lock.ts
-var lockCount = 0;
-var savedStyles = null;
+var state = shared("scrollLock", () => ({
+  count: 0,
+  saved: null
+}));
 var lockBodyScroll = () => {
   if (typeof document === "undefined") return () => {
   };
-  if (lockCount === 0) {
+  if (state.count === 0) {
     const body = document.body;
-    savedStyles = {
+    const saved = {
       overflow: body.style.overflow,
       position: body.style.position,
       top: body.style.top,
       width: body.style.width,
       paddingRight: body.style.paddingRight,
+      scrollX: window.scrollX,
       scrollY: window.scrollY
     };
+    state.saved = saved;
     const scrollbarGap = window.innerWidth - document.documentElement.clientWidth;
     if (scrollbarGap > 0) {
       const current = parseFloat(getComputedStyle(body).paddingRight) || 0;
@@ -307,53 +364,72 @@ var lockBodyScroll = () => {
     }
     body.style.overflow = "hidden";
     body.style.position = "fixed";
-    body.style.top = `-${savedStyles.scrollY}px`;
+    body.style.top = `-${saved.scrollY}px`;
     body.style.width = "100%";
   }
-  lockCount++;
+  state.count++;
   let released = false;
   return () => {
     if (released) return;
     released = true;
-    lockCount = Math.max(0, lockCount - 1);
-    if (lockCount === 0 && savedStyles) {
+    state.count = Math.max(0, state.count - 1);
+    if (state.count === 0 && state.saved) {
       const body = document.body;
-      body.style.overflow = savedStyles.overflow;
-      body.style.position = savedStyles.position;
-      body.style.top = savedStyles.top;
-      body.style.width = savedStyles.width;
-      body.style.paddingRight = savedStyles.paddingRight;
-      window.scrollTo(0, savedStyles.scrollY);
-      savedStyles = null;
+      const saved = state.saved;
+      body.style.overflow = saved.overflow;
+      body.style.position = saved.position;
+      body.style.top = saved.top;
+      body.style.width = saved.width;
+      body.style.paddingRight = saved.paddingRight;
+      window.scrollTo({
+        top: saved.scrollY,
+        left: saved.scrollX,
+        behavior: "instant"
+      });
+      state.saved = null;
     }
   };
 };
 
 // src/core/features/inert-siblings.ts
+var OWN_ROOTS = ".bs-root, .ovl-root";
+var LAYER_CLASSES = [
+  "bs-backdrop",
+  "bs-screen",
+  "bs-root",
+  "ovl-backdrop",
+  "ovl-root"
+];
+var isLayer = (el) => LAYER_CLASSES.some((name) => el.classList.contains(name));
 function createInertSiblings(rootProvider) {
   const tracked = [];
+  const remove = () => {
+    for (const el of tracked) el.removeAttribute("inert");
+    tracked.length = 0;
+  };
   return {
     apply() {
       if (typeof document === "undefined") return;
-      let top = rootProvider();
-      while (top.parentElement && top.parentElement !== document.body) {
-        top = top.parentElement;
-      }
-      const parent = top.parentElement ?? document.body;
-      for (const child of Array.from(parent.children)) {
-        if (child === top) continue;
-        if (child.hasAttribute("inert")) continue;
-        if (child.classList.contains("bs-backdrop") || child.classList.contains("bs-screen") || child.classList.contains("bs-root")) {
+      remove();
+      const surface = rootProvider();
+      let node = surface.closest(OWN_ROOTS) ?? surface;
+      while (node && node !== document.body) {
+        const parent = node.parentElement;
+        if (!parent) {
+          const root = node.getRootNode();
+          node = typeof ShadowRoot !== "undefined" && root instanceof ShadowRoot ? root.host : null;
           continue;
         }
-        child.setAttribute("inert", "");
-        tracked.push(child);
+        for (const sibling of Array.from(parent.children)) {
+          if (sibling === node) continue;
+          if (sibling.hasAttribute("inert") || isLayer(sibling)) continue;
+          sibling.setAttribute("inert", "");
+          tracked.push(sibling);
+        }
+        node = parent;
       }
     },
-    remove() {
-      for (const el of tracked) el.removeAttribute("inert");
-      tracked.length = 0;
-    }
+    remove
   };
 }
 
@@ -361,6 +437,7 @@ function createInertSiblings(rootProvider) {
 var LifecycleController = class {
   constructor(deps, opts) {
     __publicField(this, "element");
+    __publicField(this, "isTop");
     __publicField(this, "focusTrapEnabled");
     __publicField(this, "initialFocus");
     __publicField(this, "closeOnEscape");
@@ -374,6 +451,7 @@ var LifecycleController = class {
     __publicField(this, "installed", false);
     __publicField(this, "destroyed", false);
     this.element = deps.element;
+    this.isTop = deps.isTop;
     this.focusTrapEnabled = opts.focusTrap ?? false;
     this.initialFocus = opts.initialFocus;
     this.closeOnEscape = opts.closeOnEscape ?? true;
@@ -394,12 +472,17 @@ var LifecycleController = class {
     }
     if (this.focusTrapEnabled && !this.releaseFocusTrap) {
       this.releaseFocusTrap = installFocusTrap(this.element, {
-        initialFocus: this.initialFocus
+        initialFocus: this.initialFocus,
+        isActive: this.isTop
       });
     }
-    if (this.inertSiblingsEnabled && this.shouldApplyInertSiblings()) {
-      this.inertSiblings.apply();
-    }
+    this.syncTop();
+  }
+  syncTop() {
+    if (!this.installed || !this.inertSiblingsEnabled) return;
+    if (!this.shouldApplyInertSiblings()) return;
+    if (this.isTop?.() ?? true) this.inertSiblings.apply();
+    else this.inertSiblings.remove();
   }
   setReturnFocus(target) {
     if (this.destroyed) return;
@@ -528,148 +611,266 @@ function installOverlaySwipe(deps) {
 }
 
 // src/core/features/history-coordinator.ts
-var entries = [];
-var subscribers = /* @__PURE__ */ new Set();
-var suppress = 0;
-var pendingRebrands = [];
-var listenerInstalled = false;
-var hasWindow = () => typeof window !== "undefined";
-var hasHistory = () => typeof history !== "undefined";
-var brandMarker = (surface) => ({
+var MARKER = "__bs";
+var STACK = "__bsStack";
+var DEPTH = "__bsDepth";
+var ROUTED = "__bsRouted";
+var SETTLE_TIMEOUT_MS = 1e3;
+var state2 = shared(
+  "history",
+  () => ({
+    live: [],
+    stackId: void 0,
+    baseUrl: void 0,
+    position: null,
+    knownLength: 0,
+    href: "",
+    subscribers: /* @__PURE__ */ new Set(),
+    internal: 0,
+    pending: [],
+    deferred: [],
+    waiters: [],
+    timer: null,
+    listening: false,
+    leftovers: false,
+    orphanChecked: false,
+    push: null,
+    replace: null
+  })
+);
+var hasHistory = () => typeof window !== "undefined" && typeof history !== "undefined";
+var plain = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+var depthOf = (value) => {
+  const depth = value?.[DEPTH];
+  return typeof depth === "number" ? depth : null;
+};
+var isMarker = (value) => value?.[MARKER] === true;
+var inStack = (value) => value !== null && state2.stackId !== void 0 && value[STACK] === state2.stackId && depthOf(value) !== null;
+var foreignKeys = (value) => {
+  const out = {};
+  const source = plain(value);
+  if (!source) return out;
+  for (const key of Object.keys(source)) {
+    if (!key.startsWith(MARKER)) out[key] = source[key];
+  }
+  return out;
+};
+var markerFor = (surface, depth) => ({
+  ...foreignKeys(history.state),
   ...surface.markerState(),
-  __bs: true
+  [MARKER]: true,
+  [STACK]: state2.stackId,
+  [DEPTH]: depth
 });
+var urlForDepth = (depth) => {
+  for (let i = depth - 1; i >= 0; i -= 1) {
+    const url = state2.live[i]?.surface.url;
+    if (url !== void 0) return url;
+  }
+  return state2.baseUrl;
+};
 var runInternal = (fn) => {
+  state2.internal += 1;
   try {
     fn();
+    return true;
+  } catch {
+    return false;
   } finally {
+    state2.internal -= 1;
   }
 };
 var notifyRouteChange = () => {
-  const snapshot = Array.from(subscribers);
-  for (const fn of snapshot) fn();
+  for (const fn of Array.from(state2.subscribers)) {
+    try {
+      fn();
+    } catch (err) {
+      queueMicrotask(() => {
+        throw err;
+      });
+    }
+  }
 };
 var ensureListener = () => {
-  if (listenerInstalled || !hasWindow()) return;
+  if (state2.listening || !hasHistory()) return;
   window.addEventListener("popstate", onPopState);
-  listenerInstalled = true;
+  state2.listening = true;
 };
 var maybeTeardownListener = () => {
-  if (!listenerInstalled) return;
-  if (entries.length > 0 || subscribers.size > 0 || suppress > 0) return;
-  if (hasWindow()) window.removeEventListener("popstate", onPopState);
-  listenerInstalled = false;
-};
-function onPopState() {
-  if (suppress > 0) {
-    suppress -= 1;
-    const rebrand = pendingRebrands.shift();
-    if (rebrand) rebrand();
-    maybeTeardownListener();
-    return;
-  }
-  if (entries.length === 0) {
-    notifyRouteChange();
-    maybeTeardownListener();
+  if (!state2.listening) return;
+  if (state2.live.length > 0 || state2.subscribers.size > 0 || state2.pending.length > 0 || state2.leftovers) {
     return;
   }
-  let target = null;
-  let targetIdx = -1;
-  for (let i = entries.length - 1; i >= 0; i -= 1) {
-    const entry = entries[i];
-    if (!entry.surface.isOpen()) continue;
-    if (!target) {
-      target = entry;
-      targetIdx = i;
-    }
-    if (entry.surface.isTop()) {
-      target = entry;
-      targetIdx = i;
-      break;
-    }
-  }
-  if (!target) {
-    const removed = entries.pop();
-    if (removed) removed.live = false;
+  if (hasHistory()) window.removeEventListener("popstate", onPopState);
+  state2.listening = false;
+};
+var settleIfIdle = () => {
+  if (state2.pending.length > 0) return;
+  if (state2.timer !== null) {
+    clearTimeout(state2.timer);
+    state2.timer = null;
+  }
+  for (const entry of state2.deferred.splice(0)) pushEntry(entry);
+  for (const resolve of state2.waiters.splice(0)) resolve();
+};
+var traverse = (delta, kind) => {
+  state2.pending.push(kind);
+  if (state2.timer !== null) clearTimeout(state2.timer);
+  state2.timer = setTimeout(() => {
+    state2.timer = null;
+    state2.pending.length = 0;
+    settleIfIdle();
     maybeTeardownListener();
-    return;
-  }
-  target.live = false;
-  entries.splice(targetIdx, 1);
-  const settled = target;
-  void Promise.resolve(settled.surface.close()).then(() => {
-    if (settled.surface.isOpen()) restore(settled);
+  }, SETTLE_TIMEOUT_MS);
+  ensureListener();
+  const moved = runInternal(() => {
+    if (delta < 0) history.back();
+    else history.forward();
   });
-  maybeTeardownListener();
-}
-function restore(entry) {
-  if (!hasWindow() || !hasHistory()) return;
-  entry.live = true;
+  if (!moved) {
+    state2.pending.pop();
+    settleIfIdle();
+  }
+};
+var newStackId = () => `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+var startStack = () => {
+  state2.stackId = newStackId();
+  const current = history.state;
+  const leftover = plain(current);
+  state2.baseUrl = isMarker(leftover) && leftover?.[ROUTED] !== void 0 ? void 0 : location.href;
+  if (isMarker(leftover)) return;
+  if (current !== null && current !== void 0 && !leftover) return;
   runInternal(() => {
-    try {
-      history.pushState(brandMarker(entry.surface), "", entry.surface.url);
-    } catch {
-      entry.live = false;
-    }
+    history.replaceState(
+      { ...foreignKeys(current), [STACK]: state2.stackId, [DEPTH]: 0 },
+      "",
+      location.href
+    );
   });
-  if (entry.live) {
-    entries.push(entry);
-    ensureListener();
-  }
+};
+function pushEntry(entry) {
+  const depth = state2.live.length + 1;
+  if (state2.live.length === 0) startStack();
+  const written = runInternal(() => {
+    history.pushState(markerFor(entry.surface, depth), "", entry.surface.url);
+  });
+  if (!written) return false;
+  state2.live.push(entry);
+  state2.position = depth;
+  state2.knownLength = history.length;
+  state2.href = location.href;
+  ensureListener();
+  return true;
 }
-function pushBackMarker(surface) {
-  const entry = { surface, priorUrl: void 0, live: false };
-  if (!hasWindow() || !hasHistory()) {
-    return entry;
+var enlist = (entry) => {
+  if (state2.pending.length > 0) state2.deferred.push(entry);
+  else pushEntry(entry);
+};
+var sameBrand = (a, b) => {
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])) {
+    if (key.startsWith(MARKER) && a[key] !== b[key]) return false;
   }
-  entry.priorUrl = surface.url !== void 0 ? location.href : void 0;
+  return true;
+};
+var rebrand = (depth) => {
+  const entry = state2.live[depth - 1];
+  if (!entry) return;
+  const url = urlForDepth(depth);
+  const marker = markerFor(entry.surface, depth);
+  const atUrl = url === void 0 || new URL(url, location.href).href === location.href;
+  if (atUrl && sameBrand(plain(history.state) ?? {}, marker)) return;
   runInternal(() => {
+    history.replaceState(marker, "", url);
+  });
+  state2.href = location.href;
+};
+var closeAbove = (depth) => {
+  const dropped = state2.live.splice(depth);
+  for (let i = dropped.length - 1; i >= 0; i -= 1) {
+    const entry = dropped[i];
+    let closing = void 0;
     try {
-      history.pushState(brandMarker(surface), "", surface.url);
-      entry.live = true;
-    } catch {
-      entry.live = false;
+      closing = entry.surface.close();
+    } catch (err) {
+      queueMicrotask(() => {
+        throw err;
+      });
     }
-  });
-  if (entry.live) {
-    entries.push(entry);
-    ensureListener();
+    void Promise.resolve(closing).then(() => {
+      if (!entry.surface.isOpen()) return;
+      const known = (e) => e.surface === entry.surface;
+      if (state2.live.some(known) || state2.deferred.some(known)) return;
+      enlist(entry);
+    });
+  }
+};
+function onPopState(event) {
+  const kind = state2.pending.shift();
+  const byUser = kind !== "pop";
+  const landed = plain(event.state);
+  const depth = depthOf(landed);
+  const from = state2.position;
+  const liveBefore = state2.live.length;
+  const grew = history.length > state2.knownLength;
+  state2.knownLength = history.length;
+  const within = inStack(landed);
+  if (within && depth !== null) {
+    state2.position = depth;
+    if (depth > state2.live.length) {
+      const forward = from !== null && from < depth;
+      traverse(forward ? 1 : -1, byUser ? "skip" : "pop");
+    } else if (depth < state2.live.length) {
+      if (byUser) closeAbove(depth);
+    } else {
+      rebrand(depth);
+    }
+  } else if (isMarker(landed)) {
+    state2.position = null;
+    traverse(-1, byUser ? "skip" : "pop");
+  } else {
+    state2.position = null;
+    if (byUser && !grew && state2.live.length > 0) {
+      closeAbove(state2.live.length - 1);
+    }
+  }
+  const moved = location.href !== state2.href;
+  state2.href = location.href;
+  if (kind === void 0 && moved && (liveBefore === 0 || !within)) {
+    notifyRouteChange();
   }
+  settleIfIdle();
+  maybeTeardownListener();
+}
+function pushBackMarker(surface) {
+  const entry = { surface };
+  if (hasHistory()) enlist(entry);
   return entry;
 }
 function popBackMarker(handle) {
-  if (!hasWindow() || !hasHistory()) return;
+  if (!hasHistory()) return Promise.resolve();
   const entry = handle;
-  const idx = entries.indexOf(entry);
-  if (idx === -1 || !entry.live) return;
-  const last = entries.length - 1;
-  entry.live = false;
-  entries.splice(idx, 1);
-  let rebrand = null;
-  if (idx !== last) {
-    const rebrandSurface = entries[entries.length - 1].surface;
-    const rebrandUrl = entry.priorUrl;
-    rebrand = () => {
-      runInternal(() => {
-        history.replaceState(
-          brandMarker(rebrandSurface),
-          "",
-          rebrandUrl !== void 0 ? rebrandUrl : location.href
-        );
-      });
-    };
+  const waiting = state2.deferred.indexOf(entry);
+  if (waiting !== -1) state2.deferred.splice(waiting, 1);
+  const idx = state2.live.indexOf(entry);
+  if (idx === -1) return historySettled();
+  const top = state2.live.length;
+  state2.live.splice(idx, 1);
+  const current = plain(history.state);
+  const onTop = isMarker(current) && inStack(current) && depthOf(current) === top;
+  if (onTop && state2.pending.length === 0) {
+    traverse(-1, "pop");
+  } else {
+    state2.leftovers = true;
+    ensureListener();
   }
-  pendingRebrands.push(rebrand);
-  suppress += 1;
-  runInternal(() => {
-    try {
-      history.back();
-    } catch {
-      suppress = Math.max(0, suppress - 1);
-      pendingRebrands.pop();
-    }
-  });
   maybeTeardownListener();
+  return historySettled();
+}
+function historySettled() {
+  if (state2.pending.length === 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    state2.waiters.push(resolve);
+  });
 }
 
 // src/core/overlay-options.ts
@@ -791,7 +992,8 @@ var OverlayEngine = class {
     this.lifecycle = new LifecycleController(
       {
         element: this.element,
-        close: () => this.close("escape")
+        close: () => this.close("escape"),
+        isTop: () => this.isTop
       },
       {
         focusTrap: this.focusTrapEnabled,
@@ -799,12 +1001,7 @@ var OverlayEngine = class {
         closeOnEscape: this.closeOnEscape,
         lockBodyScroll: this.bodyScrollLockEnabled,
         inertSiblings: this.inertSiblingsEnabled,
-        shouldApplyInertSiblings: () => {
-          const bodyChildren = Array.from(document.body.children);
-          return bodyChildren.some(
-            (c) => c === this.element || c.contains(this.element)
-          );
-        },
+        shouldApplyInertSiblings: () => this.element.isConnected,
         returnFocus: opts.returnFocus
       }
     );
@@ -821,9 +1018,9 @@ var OverlayEngine = class {
   open() {
     if (this.destroyed || this.isOpen_) return Promise.resolve();
     this.maybeMount();
-    this.emit("before-open", void 0);
     this.isOpen_ = true;
     this.isAnimating_ = true;
+    this.emit("before-open", void 0);
     sheetStack.promote(this.id);
     this.element.removeAttribute("hidden");
     this.element.setAttribute("data-state", "entering");
@@ -900,13 +1097,11 @@ var OverlayEngine = class {
   }
   close(reason = "programmatic") {
     if (this.destroyed || !this.isOpen_) return Promise.resolve();
-    this.emit("before-close", void 0);
     this.isOpen_ = false;
     this.isAnimating_ = true;
+    this.emit("before-close", void 0);
     sheetStack.update();
-    if (reason !== "back" && this.backMarker) {
-      popBackMarker(this.backMarker);
-    }
+    const historyDone = reason !== "back" && this.backMarker ? popBackMarker(this.backMarker) : Promise.resolve();
     this.backMarker = null;
     this.element.setAttribute("data-state", "exiting");
     const dur = this.effectiveDuration();
@@ -917,7 +1112,7 @@ var OverlayEngine = class {
     }
     this.setWillChange(true);
     const cycle = ++this.cycleNonce;
-    return new Promise((resolve) => {
+    const exited = new Promise((resolve) => {
       requestAnimationFrame(() => {
         if (this.destroyed || cycle !== this.cycleNonce) return resolve();
         this.element.style.transform = closedTransformFor(
@@ -954,6 +1149,7 @@ var OverlayEngine = class {
         });
       });
     });
+    return Promise.all([exited, historyDone]).then(() => void 0);
   }
   toggle() {
     if (this.destroyed) return Promise.resolve();
@@ -966,7 +1162,7 @@ var OverlayEngine = class {
     this.setWillChange(false);
     this.releaseInteractiveListeners();
     if (this.backMarker) {
-      popBackMarker(this.backMarker);
+      void popBackMarker(this.backMarker);
       this.backMarker = null;
     }
     this.releaseStackEntry?.();
@@ -1260,7 +1456,6 @@ var OverlayEngine = class {
     if (this.closeOnBackEnabled && this.backMarker === null && typeof window !== "undefined") {
       this.backMarker = pushBackMarker({
         isOpen: () => this.isOpen_,
-        isTop: () => this.isTop,
         close: () => this.close("back"),
         markerState: () => ({ __bsOverlay: this.id })
       });
@@ -1296,7 +1491,9 @@ var OverlayEngine = class {
         if (this.backdrop) this.backdrop.style.zIndex = String(z - 1);
       },
       setIsTop: (isTop) => {
+        const changed = this.isTop !== isTop;
         this.isTop = isTop;
+        if (changed) this.lifecycle?.syncTop();
         if (this.backdrop) {
           this.backdrop.style.display = isTop ? "" : "none";
         }