@msviderok/base-ui-solid 1.0.0-beta.1

package/cjs/floating-ui-solid/utils/composite.js

@@ -0,0 +1,266 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGridCellMap = createGridCellMap;
+exports.findNonDisabledListIndex = findNonDisabledListIndex;
+exports.getGridCellIndexOfCorner = getGridCellIndexOfCorner;
+exports.getGridCellIndices = getGridCellIndices;
+exports.getGridNavigatedIndex = getGridNavigatedIndex;
+exports.getMaxListIndex = getMaxListIndex;
+exports.getMinListIndex = getMinListIndex;
+exports.isDifferentGridRow = isDifferentGridRow;
+exports.isIndexOutOfListBounds = isIndexOutOfListBounds;
+exports.isListIndexDisabled = isListIndexDisabled;
+var _utils = require("@floating-ui/utils");
+var _constants = require("./constants");
+var _event = require("./event");
+function isDifferentGridRow(index, cols, prevRow) {
+  return Math.floor(index / cols) !== prevRow;
+}
+function isIndexOutOfListBounds(listRef, index) {
+  return index < 0 || index >= listRef.length;
+}
+function getMinListIndex(listRef, disabledIndices) {
+  return findNonDisabledListIndex(listRef, {
+    disabledIndices
+  });
+}
+function getMaxListIndex(listRef, disabledIndices) {
+  return findNonDisabledListIndex(listRef, {
+    decrement: true,
+    startingIndex: listRef.length,
+    disabledIndices
+  });
+}
+function findNonDisabledListIndex(listRef, {
+  startingIndex = -1,
+  decrement = false,
+  disabledIndices,
+  amount = 1
+} = {}) {
+  let index = startingIndex;
+  do {
+    index += decrement ? -amount : amount;
+  } while (index >= 0 && index <= listRef.length - 1 && isListIndexDisabled(listRef, index, disabledIndices));
+  return index;
+}
+function getGridNavigatedIndex(listRef, {
+  event,
+  orientation,
+  loop,
+  rtl,
+  cols,
+  disabledIndices,
+  minIndex,
+  maxIndex,
+  prevIndex,
+  stopEvent: stop = false
+}) {
+  let nextIndex = prevIndex;
+  if (event.key === _constants.ARROW_UP) {
+    if (stop) {
+      (0, _event.stopEvent)(event);
+    }
+    if (prevIndex === -1) {
+      nextIndex = maxIndex;
+    } else {
+      nextIndex = findNonDisabledListIndex(listRef, {
+        startingIndex: nextIndex,
+        amount: cols,
+        decrement: true,
+        disabledIndices
+      });
+      if (loop && (prevIndex - cols < minIndex || nextIndex < 0)) {
+        const col = prevIndex % cols;
+        const maxCol = maxIndex % cols;
+        const offset = maxIndex - (maxCol - col);
+        if (maxCol === col) {
+          nextIndex = maxIndex;
+        } else {
+          nextIndex = maxCol > col ? offset : offset - cols;
+        }
+      }
+    }
+    if (isIndexOutOfListBounds(listRef, nextIndex)) {
+      nextIndex = prevIndex;
+    }
+  }
+  if (event.key === _constants.ARROW_DOWN) {
+    if (stop) {
+      (0, _event.stopEvent)(event);
+    }
+    if (prevIndex === -1) {
+      nextIndex = minIndex;
+    } else {
+      nextIndex = findNonDisabledListIndex(listRef, {
+        startingIndex: prevIndex,
+        amount: cols,
+        disabledIndices
+      });
+      if (loop && prevIndex + cols > maxIndex) {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex % cols - cols,
+          amount: cols,
+          disabledIndices
+        });
+      }
+    }
+    if (isIndexOutOfListBounds(listRef, nextIndex)) {
+      nextIndex = prevIndex;
+    }
+  }
+
+  // Remains on the same row/column.
+  if (orientation === 'both') {
+    const prevRow = (0, _utils.floor)(prevIndex / cols);
+    if (event.key === (rtl ? _constants.ARROW_LEFT : _constants.ARROW_RIGHT)) {
+      if (stop) {
+        (0, _event.stopEvent)(event);
+      }
+      if (prevIndex % cols !== cols - 1) {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex,
+          disabledIndices
+        });
+        if (loop && isDifferentGridRow(nextIndex, cols, prevRow)) {
+          nextIndex = findNonDisabledListIndex(listRef, {
+            startingIndex: prevIndex - prevIndex % cols - 1,
+            disabledIndices
+          });
+        }
+      } else if (loop) {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex - prevIndex % cols - 1,
+          disabledIndices
+        });
+      }
+      if (isDifferentGridRow(nextIndex, cols, prevRow)) {
+        nextIndex = prevIndex;
+      }
+    }
+    if (event.key === (rtl ? _constants.ARROW_RIGHT : _constants.ARROW_LEFT)) {
+      if (stop) {
+        (0, _event.stopEvent)(event);
+      }
+      if (prevIndex % cols !== 0) {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex,
+          decrement: true,
+          disabledIndices
+        });
+        if (loop && isDifferentGridRow(nextIndex, cols, prevRow)) {
+          nextIndex = findNonDisabledListIndex(listRef, {
+            startingIndex: prevIndex + (cols - prevIndex % cols),
+            decrement: true,
+            disabledIndices
+          });
+        }
+      } else if (loop) {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex + (cols - prevIndex % cols),
+          decrement: true,
+          disabledIndices
+        });
+      }
+      if (isDifferentGridRow(nextIndex, cols, prevRow)) {
+        nextIndex = prevIndex;
+      }
+    }
+    const lastRow = (0, _utils.floor)(maxIndex / cols) === prevRow;
+    if (isIndexOutOfListBounds(listRef, nextIndex)) {
+      if (loop && lastRow) {
+        nextIndex = event.key === (rtl ? _constants.ARROW_RIGHT : _constants.ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex - prevIndex % cols - 1,
+          disabledIndices
+        });
+      } else {
+        nextIndex = prevIndex;
+      }
+    }
+  }
+  return nextIndex;
+}
+
+/** For each cell index, gets the item index that occupies that cell */
+function createGridCellMap(sizes, cols, dense) {
+  const cellMap = [];
+  let startIndex = 0;
+  sizes.forEach(({
+    width,
+    height
+  }, index) => {
+    if (width > cols) {
+      if (process.env.NODE_ENV !== 'production') {
+        throw new Error(`[Floating UI]: Invalid grid - item width at index ${index} is greater than grid columns`);
+      }
+    }
+    let itemPlaced = false;
+    if (dense) {
+      startIndex = 0;
+    }
+    while (!itemPlaced) {
+      const targetCells = [];
+      for (let i = 0; i < width; i += 1) {
+        for (let j = 0; j < height; j += 1) {
+          targetCells.push(startIndex + i + j * cols);
+        }
+      }
+      if (startIndex % cols + width <= cols && targetCells.every(cell => cellMap[cell] == null)) {
+        targetCells.forEach(cell => {
+          cellMap[cell] = index;
+        });
+        itemPlaced = true;
+      } else {
+        startIndex += 1;
+      }
+    }
+  });
+
+  // convert into a non-sparse array
+  return [...cellMap];
+}
+
+/** Gets cell index of an item's corner or -1 when index is -1. */
+function getGridCellIndexOfCorner(index, sizes, cellMap, cols, corner) {
+  if (index === -1) {
+    return -1;
+  }
+  const firstCellIndex = cellMap.indexOf(index);
+  const sizeItem = sizes[index];
+  switch (corner) {
+    case 'tl':
+      return firstCellIndex;
+    case 'tr':
+      if (!sizeItem) {
+        return firstCellIndex;
+      }
+      return firstCellIndex + sizeItem.width - 1;
+    case 'bl':
+      if (!sizeItem) {
+        return firstCellIndex;
+      }
+      return firstCellIndex + (sizeItem.height - 1) * cols;
+    case 'br':
+      return cellMap.lastIndexOf(index);
+    default:
+      return -1;
+  }
+}
+
+/** Gets all cell indices that correspond to the specified indices */
+function getGridCellIndices(indices, cellMap) {
+  return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);
+}
+function isListIndexDisabled(listRef, index, disabledIndices) {
+  if (typeof disabledIndices === 'function') {
+    const disabled = disabledIndices.length > 0 ? disabledIndices(index) : disabledIndices();
+    return Array.isArray(disabled) ? disabled.includes(index) : disabled === true;
+  }
+  if (disabledIndices) {
+    return disabledIndices.includes(index);
+  }
+  const element = listRef[index];
+  return element == null || element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true';
+}

package/cjs/floating-ui-solid/utils/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
+export declare const ACTIVE_KEY = "active";
+export declare const SELECTED_KEY = "selected";
+export declare const TYPEABLE_SELECTOR: string;
+export declare const ARROW_LEFT = "ArrowLeft";
+export declare const ARROW_RIGHT = "ArrowRight";
+export declare const ARROW_UP = "ArrowUp";
+export declare const ARROW_DOWN = "ArrowDown";

package/cjs/floating-ui-solid/utils/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TYPEABLE_SELECTOR = exports.SELECTED_KEY = exports.FOCUSABLE_ATTRIBUTE = exports.ARROW_UP = exports.ARROW_RIGHT = exports.ARROW_LEFT = exports.ARROW_DOWN = exports.ACTIVE_KEY = void 0;
+const FOCUSABLE_ATTRIBUTE = exports.FOCUSABLE_ATTRIBUTE = 'data-base-ui-focusable';
+const ACTIVE_KEY = exports.ACTIVE_KEY = 'active';
+const SELECTED_KEY = exports.SELECTED_KEY = 'selected';
+const TYPEABLE_SELECTOR = exports.TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled])," + "[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+const ARROW_LEFT = exports.ARROW_LEFT = 'ArrowLeft';
+const ARROW_RIGHT = exports.ARROW_RIGHT = 'ArrowRight';
+const ARROW_UP = exports.ARROW_UP = 'ArrowUp';
+const ARROW_DOWN = exports.ARROW_DOWN = 'ArrowDown';

package/cjs/floating-ui-solid/utils/createAttribute.d.ts

@@ -0,0 +1 @@
+export declare function createAttribute(name: string): string;

package/cjs/floating-ui-solid/utils/createAttribute.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAttribute = createAttribute;
+function createAttribute(name) {
+  return `data-base-ui-${name}`;
+}

package/cjs/floating-ui-solid/utils/createEventEmitter.d.ts

@@ -0,0 +1,5 @@
+export declare function createEventEmitter(): {
+  emit(event: string, data: any): void;
+  on(event: string, listener: (data: any) => void): void;
+  off(event: string, listener: (data: any) => void): void;
+};

package/cjs/floating-ui-solid/utils/createEventEmitter.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEventEmitter = createEventEmitter;
+function createEventEmitter() {
+  const map = new Map();
+  return {
+    emit(event, data) {
+      map.get(event)?.forEach(listener => listener(data));
+    },
+    on(event, listener) {
+      if (!map.has(event)) {
+        map.set(event, new Set());
+      }
+      map.get(event).add(listener);
+    },
+    off(event, listener) {
+      map.get(event)?.delete(listener);
+    }
+  };
+}

package/cjs/floating-ui-solid/utils/element.d.ts

@@ -0,0 +1,11 @@
+export declare function activeElement(doc: Document): Element | null;
+export declare function contains(parent?: Element | null | undefined, child?: Element | null | undefined): boolean;
+export declare function getTarget(event: Event): EventTarget | null;
+export declare function isEventTargetWithin(event: Event, node: Node | null | undefined): boolean;
+export declare function isRootElement(element: Element): boolean;
+export declare function getDocument(node: Element | null | undefined): Document;
+export declare function isTypeableElement(element: unknown): boolean;
+export declare function isTypeableCombobox(element: Element | null | undefined): boolean;
+export declare function matchesFocusVisible(element: Element | null): boolean;
+export declare function getFloatingFocusElement(floatingElement: HTMLElement | null | undefined): HTMLElement | null;
+export declare function isEventTargetInsidePortal<E extends Event>(event: E): boolean;

package/cjs/floating-ui-solid/utils/element.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.activeElement = activeElement;
+exports.contains = contains;
+exports.getDocument = getDocument;
+exports.getFloatingFocusElement = getFloatingFocusElement;
+exports.getTarget = getTarget;
+exports.isEventTargetInsidePortal = isEventTargetInsidePortal;
+exports.isEventTargetWithin = isEventTargetWithin;
+exports.isRootElement = isRootElement;
+exports.isTypeableCombobox = isTypeableCombobox;
+exports.isTypeableElement = isTypeableElement;
+exports.matchesFocusVisible = matchesFocusVisible;
+var _dom = require("@floating-ui/utils/dom");
+var _detectBrowser = require("../../utils/detectBrowser");
+var _constants = require("./constants");
+var _createAttribute = require("./createAttribute");
+function activeElement(doc) {
+  let element = doc.activeElement;
+  while (element?.shadowRoot?.activeElement != null) {
+    element = element.shadowRoot.activeElement;
+  }
+  return element;
+}
+function contains(parent, child) {
+  if (!parent || !child) {
+    return false;
+  }
+  const rootNode = child.getRootNode?.();
+
+  // First, attempt with faster native method
+  if (parent.contains(child)) {
+    return true;
+  }
+
+  // then fallback to custom implementation with Shadow DOM support
+  if (rootNode && (0, _dom.isShadowRoot)(rootNode)) {
+    let next = child;
+    while (next) {
+      if (parent === next) {
+        return true;
+      }
+      // @ts-ignore
+      next = next.parentNode || next.host;
+    }
+  }
+
+  // Give up, the result is false
+  return false;
+}
+function getTarget(event) {
+  if ('composedPath' in event) {
+    return event.composedPath()[0];
+  }
+
+  // TS thinks `event` is of type never as it assumes all browsers support
+  // `composedPath()`, but browsers without shadow DOM don't.
+  return event.target;
+}
+function isEventTargetWithin(event, node) {
+  if (node == null) {
+    return false;
+  }
+  if ('composedPath' in event) {
+    return event.composedPath().includes(node);
+  }
+
+  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't
+  const eventAgain = event;
+  return eventAgain.target != null && node.contains(eventAgain.target);
+}
+function isRootElement(element) {
+  return element.matches('html,body');
+}
+function getDocument(node) {
+  return node?.ownerDocument || document;
+}
+function isTypeableElement(element) {
+  return (0, _dom.isHTMLElement)(element) && element.matches(_constants.TYPEABLE_SELECTOR);
+}
+function isTypeableCombobox(element) {
+  if (!element) {
+    return false;
+  }
+  return element.getAttribute('role') === 'combobox' && isTypeableElement(element);
+}
+function matchesFocusVisible(element) {
+  // We don't want to block focus from working with `visibleOnly`
+  // (JSDOM doesn't match `:focus-visible` when the element has `:focus`)
+  if (!element || _detectBrowser.isJSDOM) {
+    return true;
+  }
+  try {
+    return element.matches(':focus-visible');
+  } catch (_e) {
+    return true;
+  }
+}
+function getFloatingFocusElement(floatingElement) {
+  if (!floatingElement) {
+    return null;
+  }
+  // Try to find the element that has `{...getFloatingProps()}` spread on it.
+  // This indicates the floating element is acting as a positioning wrapper, and
+  // so focus should be managed on the child element with the event handlers and
+  // aria props.
+  return floatingElement.hasAttribute(_constants.FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(`[${_constants.FOCUSABLE_ATTRIBUTE}]`) || floatingElement;
+}
+function isEventTargetInsidePortal(event) {
+  return !!event.target?.closest(`[${(0, _createAttribute.createAttribute)('portal')}]`);
+}

package/cjs/floating-ui-solid/utils/enqueueFocus.d.ts

@@ -0,0 +1,8 @@
+import type { FocusableElement } from 'tabbable';
+interface Options {
+  preventScroll?: boolean;
+  cancelPrevious?: boolean;
+  sync?: boolean;
+}
+export declare function enqueueFocus(el: FocusableElement | null, options?: Options): void;
+export {};

package/cjs/floating-ui-solid/utils/enqueueFocus.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.enqueueFocus = enqueueFocus;
+let rafId = 0;
+function enqueueFocus(el, options = {}) {
+  const {
+    preventScroll = false,
+    cancelPrevious = true,
+    sync = false
+  } = options;
+  if (cancelPrevious) {
+    cancelAnimationFrame(rafId);
+  }
+  const exec = () => {
+    return el?.focus({
+      preventScroll
+    });
+  };
+  if (sync) {
+    exec();
+  } else {
+    rafId = requestAnimationFrame(exec);
+  }
+}

package/cjs/floating-ui-solid/utils/event.d.ts

@@ -0,0 +1,4 @@
+export declare function stopEvent(event: Event): void;
+export declare function isVirtualClick(event: MouseEvent | PointerEvent): boolean;
+export declare function isVirtualPointerEvent(event: PointerEvent): boolean;
+export declare function isMouseLikePointerType(pointerType: string | undefined, strict?: boolean): boolean;

package/cjs/floating-ui-solid/utils/event.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMouseLikePointerType = isMouseLikePointerType;
+exports.isVirtualClick = isVirtualClick;
+exports.isVirtualPointerEvent = isVirtualPointerEvent;
+exports.stopEvent = stopEvent;
+var _detectBrowser = require("../../utils/detectBrowser");
+function stopEvent(event) {
+  event.preventDefault();
+  event.stopPropagation();
+}
+
+// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts
+function isVirtualClick(event) {
+  // FIXME: Firefox is now emitting a deprecation warning for `mozInputSource`.
+  // Try to find a workaround for this. `react-aria` source still has the check.
+  if (event.mozInputSource === 0 && event.isTrusted) {
+    return true;
+  }
+  if (_detectBrowser.isAndroid && event.pointerType) {
+    return event.type === 'click' && event.buttons === 1;
+  }
+  return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+  if (_detectBrowser.isJSDOM) {
+    return false;
+  }
+  return !_detectBrowser.isAndroid && event.width === 0 && event.height === 0 || _detectBrowser.isAndroid && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'mouse' ||
+  // iOS VoiceOver returns 0.333• for width/height.
+  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'touch';
+}
+function isMouseLikePointerType(pointerType, strict) {
+  // On some Linux machines with Chromium, mouse inputs return a `pointerType`
+  // of "pen": https://github.com/floating-ui/floating-ui/issues/2015
+  const values = ['mouse', 'pen'];
+  if (!strict) {
+    values.push('', undefined);
+  }
+  return values.includes(pointerType);
+}

package/cjs/floating-ui-solid/utils/markOthers.d.ts

@@ -0,0 +1,4 @@
+type Undo = () => void;
+export declare const supportsInert: () => boolean;
+export declare function markOthers(avoidElements: Element[], ariaHidden?: boolean, inert?: boolean): Undo;
+export {};

package/cjs/floating-ui-solid/utils/markOthers.js

@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.markOthers = markOthers;
+exports.supportsInert = void 0;
+var _dom = require("@floating-ui/utils/dom");
+var _element = require("./element");
+// Modified to add conditional `aria-hidden` support:
+// https://github.com/theKashey/aria-hidden/blob/9220c8f4a4fd35f63bee5510a9f41a37264382d4/src/index.ts
+
+const counters = {
+  inert: new WeakMap(),
+  'aria-hidden': new WeakMap(),
+  none: new WeakMap()
+};
+function getCounterMap(control) {
+  if (control === 'inert') {
+    return counters.inert;
+  }
+  if (control === 'aria-hidden') {
+    return counters['aria-hidden'];
+  }
+  return counters.none;
+}
+let uncontrolledElementsSet = new WeakSet();
+let markerMap = {};
+let lockCount = 0;
+const supportsInert = () => typeof HTMLElement !== 'undefined' && 'inert' in HTMLElement.prototype;
+exports.supportsInert = supportsInert;
+const unwrapHost = node => node && (node.host || unwrapHost(node.parentNode));
+const correctElements = (parent, targets) => targets.map(target => {
+  if (parent.contains(target)) {
+    return target;
+  }
+  const correctedTarget = unwrapHost(target);
+  if (parent.contains(correctedTarget)) {
+    return correctedTarget;
+  }
+  return null;
+}).filter(x => x != null);
+function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert) {
+  const markerName = 'data-base-ui-inert';
+  // eslint-disable-next-line no-nested-ternary
+  const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;
+  const avoidElements = correctElements(body, uncorrectedAvoidElements);
+  const elementsToKeep = new Set();
+  const elementsToStop = new Set(avoidElements);
+  const hiddenElements = [];
+  if (!markerMap[markerName]) {
+    markerMap[markerName] = new WeakMap();
+  }
+  const markerCounter = markerMap[markerName];
+  avoidElements.forEach(keep);
+  deep(body);
+  elementsToKeep.clear();
+  function keep(el) {
+    if (!el || elementsToKeep.has(el)) {
+      return;
+    }
+    elementsToKeep.add(el);
+    if (el.parentNode) {
+      keep(el.parentNode);
+    }
+  }
+  function deep(parent) {
+    if (!parent || elementsToStop.has(parent)) {
+      return;
+    }
+    [].forEach.call(parent.children, node => {
+      if ((0, _dom.getNodeName)(node) === 'script') {
+        return;
+      }
+      if (elementsToKeep.has(node)) {
+        deep(node);
+      } else {
+        const attr = controlAttribute ? node.getAttribute(controlAttribute) : null;
+        const alreadyHidden = attr !== null && attr !== 'false';
+        const counterMap = getCounterMap(controlAttribute);
+        const counterValue = (counterMap.get(node) || 0) + 1;
+        const markerValue = (markerCounter.get(node) || 0) + 1;
+        counterMap.set(node, counterValue);
+        markerCounter.set(node, markerValue);
+        hiddenElements.push(node);
+        if (counterValue === 1 && alreadyHidden) {
+          uncontrolledElementsSet.add(node);
+        }
+        if (markerValue === 1) {
+          node.setAttribute(markerName, '');
+        }
+        if (!alreadyHidden && controlAttribute) {
+          node.setAttribute(controlAttribute, controlAttribute === 'inert' ? '' : 'true');
+        }
+      }
+    });
+  }
+  lockCount += 1;
+  return () => {
+    hiddenElements.forEach(element => {
+      const counterMap = getCounterMap(controlAttribute);
+      const currentCounterValue = counterMap.get(element) || 0;
+      const counterValue = currentCounterValue - 1;
+      const markerValue = (markerCounter.get(element) || 0) - 1;
+      counterMap.set(element, counterValue);
+      markerCounter.set(element, markerValue);
+      if (!counterValue) {
+        if (!uncontrolledElementsSet.has(element) && controlAttribute) {
+          element.removeAttribute(controlAttribute);
+        }
+        uncontrolledElementsSet.delete(element);
+      }
+      if (!markerValue) {
+        element.removeAttribute(markerName);
+      }
+    });
+    lockCount -= 1;
+    if (!lockCount) {
+      counters.inert = new WeakMap();
+      counters['aria-hidden'] = new WeakMap();
+      counters.none = new WeakMap();
+      uncontrolledElementsSet = new WeakSet();
+      markerMap = {};
+    }
+  };
+}
+function markOthers(avoidElements, ariaHidden = false, inert = false) {
+  const body = (0, _element.getDocument)(avoidElements[0]).body;
+  return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll('[aria-live]'))), body, ariaHidden, inert);
+}