@soomo/react-text-annotator 3.0.0-staging.40 → 3.0.0-staging.41

package/dist/react-text-annotator.es11.js

@@ -1,490 +1,1454 @@
-import defaultBehaviors from "./react-text-annotator.es21.js";
-import * as utilities from "./react-text-annotator.es22.js";
-import { hideContent, defineCustomElement, tagName } from "./react-text-annotator.es22.js";
-import { addBehaviors, addBehavior, removeBehavior } from "./react-text-annotator.es23.js";
-import { learnElementNames, learnCustomElementNames } from "./react-text-annotator.es24.js";
-class CETEI {
-  constructor(options) {
-    this.options = options ? options : {};
-    this.document = this.options.documentObject ? this.options.documentObject : void 0;
-    if (this.document === void 0) {
-      if (typeof window !== "undefined" && window.document) {
-        this.document = window.document;
-      } else if (typeof global !== "undefined" && global.document) {
-        this.document = global.document;
-      }
-    }
-    this.addBehaviors = addBehaviors.bind(this);
-    this.addBehavior = addBehavior.bind(this);
-    this.removeBehavior = removeBehavior.bind(this);
-    this.utilities = {};
-    for (const u of Object.keys(utilities)) {
-      if (["getPrefixDef", "rw", "resolveURI"].includes(u)) {
-        this.utilities[u] = utilities[u].bind(this);
-      } else {
-        this.utilities[u] = utilities[u];
-      }
-    }
-    this.els = [];
-    this.namespaces = /* @__PURE__ */ new Map();
-    this.behaviors = {};
-    this.hasStyle = false;
-    this.prefixDefs = [];
-    this.debug = this.options.debug === true ? true : false;
-    this.discardContent = this.options.discardContent === true ? true : false;
-    if (this.options.base) {
-      this.base = this.options.base;
-    } else {
-      try {
-        if (window) {
-          this.base = window.location.href.replace(/\/[^\/]*$/, "/");
-        }
-      } catch (e) {
-        this.base = "";
-      }
+import * as React from "react";
+import { useLayoutEffect, useEffect, useRef } from "react";
+import { isTypeableCombobox, getDocument, activeElement, contains, isVirtualClick, isVirtualPointerEvent, isSafari, stopEvent, getTarget, isReactEvent, isRootElement, isEventTargetWithin } from "./react-text-annotator.es21.js";
+import { isHTMLElement, isElement, getOverflowAncestors, getNodeName, isLastTraversableNode, getParentNode, getComputedStyle } from "./react-text-annotator.es22.js";
+import { tabbable, isTabbable } from "./react-text-annotator.es23.js";
+import * as ReactDOM from "react-dom";
+import { useFloating as useFloating$1 } from "./react-text-annotator.es13.js";
+import { flip, inline, offset, shift } from "./react-text-annotator.es13.js";
+const SafeReact = {
+  ...React
+};
+const useInsertionEffect = SafeReact.useInsertionEffect;
+const useSafeInsertionEffect = useInsertionEffect || ((fn) => fn());
+function useEffectEvent(callback) {
+  const ref = React.useRef(() => {
+    if (process.env.NODE_ENV !== "production") {
+      throw new Error("Cannot call an event handler while rendering.");
     }
-    if (!this.options.omitDefaultBehaviors) {
-      this.addBehaviors(defaultBehaviors);
+  });
+  useSafeInsertionEffect(() => {
+    ref.current = callback;
+  });
+  return React.useCallback(function() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
-    if (this.options.ignoreFragmentId) {
-      if (window) {
-        window.removeEventListener("ceteiceanload", CETEI.restorePosition);
+    return ref.current == null ? void 0 : ref.current(...args);
+  }, []);
+}
+let rafId = 0;
+function enqueueFocus(el, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    preventScroll = false,
+    cancelPrevious = true,
+    sync = false
+  } = options;
+  cancelPrevious && cancelAnimationFrame(rafId);
+  const exec = () => el == null ? void 0 : el.focus({
+    preventScroll
+  });
+  if (sync) {
+    exec();
+  } else {
+    rafId = requestAnimationFrame(exec);
+  }
+}
+var index = typeof document !== "undefined" ? useLayoutEffect : useEffect;
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
       }
     }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+let serverHandoffComplete = false;
+let count = 0;
+const genId = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + count++
+);
+function useFloatingId() {
+  const [id, setId] = React.useState(() => serverHandoffComplete ? genId() : void 0);
+  index(() => {
+    if (id == null) {
+      setId(genId());
+    }
+  }, []);
+  React.useEffect(() => {
+    serverHandoffComplete = true;
+  }, []);
+  return id;
+}
+const useReactId = SafeReact.useId;
+const useId = useReactId || useFloatingId;
+let devMessageSet;
+if (process.env.NODE_ENV !== "production") {
+  devMessageSet = /* @__PURE__ */ new Set();
+}
+function error() {
+  var _devMessageSet3;
+  for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    messages[_key2] = arguments[_key2];
   }
-  /* 
-    Returns a Promise that fetches an XML source document from the URL
-    provided in the first parameter and then calls the makeHTML5 method
-    on the returned document.
-  */
-  async getHTML5(XML_url, callback, perElementFn) {
-    if (window && window.location.href.startsWith(this.base) && XML_url.indexOf("/") >= 0) {
-      this.base = XML_url.replace(/\/[^\/]*$/, "/");
-    }
-    try {
-      const response = await fetch(XML_url);
-      if (response.ok) {
-        const XML = await response.text();
-        return this.makeHTML5(XML, callback, perElementFn);
-      } else {
-        console.log(`Could not get XML file ${XML_url}.
-Server returned ${response.status}: ${response.statusText}`);
-      }
-    } catch (error) {
-      console.log(error);
+  const message = "Floating UI: " + messages.join(" ");
+  if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {
+    var _devMessageSet4;
+    (_devMessageSet4 = devMessageSet) == null || _devMessageSet4.add(message);
+    console.error(message);
+  }
+}
+function createPubSub() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    emit(event, data) {
+      var _map$get;
+      (_map$get = map.get(event)) == null || _map$get.forEach((handler) => handler(data));
+    },
+    on(event, listener) {
+      map.set(event, [...map.get(event) || [], listener]);
+    },
+    off(event, listener) {
+      var _map$get2;
+      map.set(event, ((_map$get2 = map.get(event)) == null ? void 0 : _map$get2.filter((l) => l !== listener)) || []);
+    }
+  };
+}
+const FloatingNodeContext = /* @__PURE__ */ React.createContext(null);
+const FloatingTreeContext = /* @__PURE__ */ React.createContext(null);
+const useFloatingParentNodeId = () => {
+  var _React$useContext;
+  return ((_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;
+};
+const useFloatingTree = () => React.useContext(FloatingTreeContext);
+function createAttribute(name) {
+  return "data-floating-ui-" + name;
+}
+function useLatestRef(value) {
+  const ref = useRef(value);
+  index(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+function getAncestors(nodes, id) {
+  var _nodes$find;
+  let allAncestors = [];
+  let currentParentId = (_nodes$find = nodes.find((node) => node.id === id)) == null ? void 0 : _nodes$find.parentId;
+  while (currentParentId) {
+    const currentNode = nodes.find((node) => node.id === currentParentId);
+    currentParentId = currentNode == null ? void 0 : currentNode.parentId;
+    if (currentNode) {
+      allAncestors = allAncestors.concat(currentNode);
     }
   }
-  /* 
-    Converts the supplied XML string into HTML5 Custom Elements. If a callback
-    function is supplied, calls it on the result.
-  */
-  makeHTML5(XML, callback, perElementFn) {
-    this.XML_dom = new DOMParser().parseFromString(XML, "text/xml");
-    return this.domToHTML5(this.XML_dom, callback, perElementFn);
+  return allAncestors;
+}
+function getChildren(nodes, id) {
+  let allChildren = nodes.filter((node) => {
+    var _node$context;
+    return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);
+  });
+  let currentChildren = allChildren;
+  while (currentChildren.length) {
+    currentChildren = nodes.filter((node) => {
+      var _currentChildren;
+      return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some((n) => {
+        var _node$context2;
+        return node.parentId === n.id && ((_node$context2 = node.context) == null ? void 0 : _node$context2.open);
+      });
+    });
+    allChildren = allChildren.concat(currentChildren);
+  }
+  return allChildren;
+}
+let counterMap = /* @__PURE__ */ new WeakMap();
+let uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
+let markerMap = {};
+let lockCount = 0;
+const supportsInert = () => typeof HTMLElement !== "undefined" && "inert" in HTMLElement.prototype;
+const unwrapHost = (node) => node && (node.host || unwrapHost(node.parentNode));
+const correctElements = (parent, targets) => targets.map((target) => {
+  if (parent.contains(target)) {
+    return target;
   }
-  preprocess(XML_dom, callback, perElementFn) {
-    this.els = learnElementNames(XML_dom, this.namespaces);
-    let convertEl = (el) => {
-      let newElement;
-      if (this.namespaces.has(el.namespaceURI ? el.namespaceURI : "")) {
-        let prefix = this.namespaces.get(el.namespaceURI ? el.namespaceURI : "");
-        newElement = this.document.createElement(`${prefix}-${el.localName.toLowerCase()}`);
+  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-floating-ui-inert";
+  const controlAttribute = inert ? "inert" : ariaHidden ? "aria-hidden" : null;
+  const avoidElements = correctElements(body, uncorrectedAvoidElements);
+  const elementsToKeep = /* @__PURE__ */ new Set();
+  const elementsToStop = new Set(avoidElements);
+  const hiddenElements = [];
+  if (!markerMap[markerName]) {
+    markerMap[markerName] = /* @__PURE__ */ 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);
+    el.parentNode && keep(el.parentNode);
+  }
+  function deep(parent) {
+    if (!parent || elementsToStop.has(parent)) {
+      return;
+    }
+    [].forEach.call(parent.children, (node) => {
+      if (getNodeName(node) === "script") return;
+      if (elementsToKeep.has(node)) {
+        deep(node);
       } else {
-        newElement = this.document.importNode(el, false);
-      }
-      for (let att of Array.from(el.attributes)) {
-        if (att.name == "xmlns") {
-          newElement.setAttribute("data-xmlns", att.value);
-        } else {
-          newElement.setAttribute(att.name, att.value);
+        const attr2 = controlAttribute ? node.getAttribute(controlAttribute) : null;
+        const alreadyHidden = attr2 !== null && attr2 !== "false";
+        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 (att.name == "xml:id") {
-          newElement.setAttribute("id", att.value);
+        if (markerValue === 1) {
+          node.setAttribute(markerName, "");
         }
-        if (att.name == "xml:lang") {
-          newElement.setAttribute("lang", att.value);
-        }
-        if (att.name == "rendition") {
-          newElement.setAttribute("class", att.value.replace(/#/g, ""));
-        }
-      }
-      newElement.setAttribute("data-origname", el.localName);
-      if (el.hasAttributes()) {
-        newElement.setAttribute("data-origatts", el.getAttributeNames().join(" "));
-      }
-      if (el.childNodes.length == 0) {
-        newElement.setAttribute("data-empty", "");
-      }
-      if (el.localName == "head") {
-        let level = XML_dom.evaluate("count(ancestor::*[tei:head])", el, function(ns) {
-          if (ns == "tei") return "http://www.tei-c.org/ns/1.0";
-        }, 1, null);
-        newElement.setAttribute("data-level", level.numberValue);
-      }
-      if (el.localName == "tagsDecl") {
-        let style = this.document.createElement("style");
-        for (let node of Array.from(el.childNodes)) {
-          if (node.nodeType == 1 && node.localName == "rendition" && node.getAttribute("scheme") == "css") {
-            let rule = "";
-            if (node.hasAttribute("selector")) {
-              rule += node.getAttribute("selector").replace(/([^#, >]+\w*)/g, "tei-$1").replace(/#tei-/g, "#") + "{\n";
-              rule += node.textContent;
-            } else {
-              rule += "." + node.getAttribute("xml:id") + "{\n";
-              rule += node.textContent;
-            }
-            rule += "\n}\n";
-            style.appendChild(this.document.createTextNode(rule));
-          }
-        }
-        if (style.childNodes.length > 0) {
-          newElement.appendChild(style);
-          this.hasStyle = true;
+        if (!alreadyHidden && controlAttribute) {
+          node.setAttribute(controlAttribute, "true");
         }
       }
-      if (el.localName == "prefixDef") {
-        this.prefixDefs.push(el.getAttribute("ident"));
-        this.prefixDefs[el.getAttribute("ident")] = {
-          "matchPattern": el.getAttribute("matchPattern"),
-          "replacementPattern": el.getAttribute("replacementPattern")
-        };
-      }
-      for (let node of Array.from(el.childNodes)) {
-        if (node.nodeType == 1) {
-          newElement.appendChild(convertEl(node));
-        } else {
-          newElement.appendChild(node.cloneNode());
+    });
+  }
+  lockCount++;
+  return () => {
+    hiddenElements.forEach((element) => {
+      const counterValue = (counterMap.get(element) || 0) - 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 (perElementFn) {
-        perElementFn(newElement, el);
-      }
-      return newElement;
-    };
-    this.dom = this.document.createDocumentFragment();
-    for (let node of Array.from(XML_dom.childNodes)) {
-      if (node.nodeType == 1) {
-        this.dom.appendChild(convertEl(node));
-      }
-      if (node.nodeType == 7) {
-        this.dom.appendChild(this.document.importNode(node, true));
-      }
-      if (node.nodeType == 8) {
-        this.dom.appendChild(this.document.importNode(node, true));
+      if (!markerValue) {
+        element.removeAttribute(markerName);
       }
+    });
+    lockCount--;
+    if (!lockCount) {
+      counterMap = /* @__PURE__ */ new WeakMap();
+      counterMap = /* @__PURE__ */ new WeakMap();
+      uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
+      markerMap = {};
     }
-    this.utilities.dom = this.dom.firstElementChild;
-    if (callback) {
-      callback(this.dom, this);
-      if (window) {
-        window.dispatchEvent(ceteiceanLoad);
-      }
+  };
+}
+function markOthers(avoidElements, ariaHidden, inert) {
+  if (ariaHidden === void 0) {
+    ariaHidden = false;
+  }
+  if (inert === void 0) {
+    inert = false;
+  }
+  const body = getDocument(avoidElements[0]).body;
+  return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll("[aria-live]"))), body, ariaHidden, inert);
+}
+const getTabbableOptions = () => ({
+  getShadowRoot: true,
+  displayCheck: (
+    // JSDOM does not support the `tabbable` library. To solve this we can
+    // check if `ResizeObserver` is a real function (not polyfilled), which
+    // determines if the current environment is JSDOM-like.
+    typeof ResizeObserver === "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+  )
+});
+function getTabbableIn(container, direction) {
+  const allTabbable = tabbable(container, getTabbableOptions());
+  if (direction === "prev") {
+    allTabbable.reverse();
+  }
+  const activeIndex = allTabbable.indexOf(activeElement(getDocument(container)));
+  const nextTabbableElements = allTabbable.slice(activeIndex + 1);
+  return nextTabbableElements[0];
+}
+function getNextTabbable() {
+  return getTabbableIn(document.body, "next");
+}
+function getPreviousTabbable() {
+  return getTabbableIn(document.body, "prev");
+}
+function isOutsideEvent(event, container) {
+  const containerElement = container || event.currentTarget;
+  const relatedTarget = event.relatedTarget;
+  return !relatedTarget || !contains(containerElement, relatedTarget);
+}
+function disableFocusInside(container) {
+  const tabbableElements = tabbable(container, getTabbableOptions());
+  tabbableElements.forEach((element) => {
+    element.dataset.tabindex = element.getAttribute("tabindex") || "";
+    element.setAttribute("tabindex", "-1");
+  });
+}
+function enableFocusInside(container) {
+  const elements = container.querySelectorAll("[data-tabindex]");
+  elements.forEach((element) => {
+    const tabindex = element.dataset.tabindex;
+    delete element.dataset.tabindex;
+    if (tabindex) {
+      element.setAttribute("tabindex", tabindex);
     } else {
-      if (typeof window !== "undefined") {
-        window.dispatchEvent(ceteiceanLoad);
+      element.removeAttribute("tabindex");
+    }
+  });
+}
+function getClosestTabbableElement(tabbableElements, element, floating) {
+  const elementIndex = tabbableElements.indexOf(element);
+  function traverseTabbableElements(next2) {
+    const attr2 = createAttribute("focus-guard");
+    let index2 = elementIndex + (next2 ? 1 : 0);
+    let currentElement = tabbableElements[index2];
+    while (currentElement && (!currentElement.isConnected || currentElement.hasAttribute(attr2) || contains(floating, currentElement))) {
+      if (next2) {
+        index2++;
+      } else {
+        index2--;
       }
-      return this.dom;
+      currentElement = tabbableElements[index2];
+    }
+    return currentElement;
+  }
+  const next = traverseTabbableElements(true);
+  if (next) {
+    return next;
+  }
+  return traverseTabbableElements(false);
+}
+const HIDDEN_STYLES = {
+  border: 0,
+  clip: "rect(0 0 0 0)",
+  height: "1px",
+  margin: "-1px",
+  overflow: "hidden",
+  padding: 0,
+  position: "fixed",
+  whiteSpace: "nowrap",
+  width: "1px",
+  top: 0,
+  left: 0
+};
+let timeoutId;
+function setActiveElementOnTab(event) {
+  if (event.key === "Tab") {
+    event.target;
+    clearTimeout(timeoutId);
+  }
+}
+const FocusGuard = /* @__PURE__ */ React.forwardRef(function FocusGuard2(props, ref) {
+  const [role, setRole] = React.useState();
+  index(() => {
+    if (isSafari()) {
+      setRole("button");
     }
+    document.addEventListener("keydown", setActiveElementOnTab);
+    return () => {
+      document.removeEventListener("keydown", setActiveElementOnTab);
+    };
+  }, []);
+  const restProps = {
+    ref,
+    tabIndex: 0,
+    // Role is only for VoiceOver
+    role,
+    "aria-hidden": role ? void 0 : true,
+    [createAttribute("focus-guard")]: "",
+    style: HIDDEN_STYLES
+  };
+  return /* @__PURE__ */ React.createElement("span", _extends({}, props, restProps));
+});
+const PortalContext = /* @__PURE__ */ React.createContext(null);
+const attr = /* @__PURE__ */ createAttribute("portal");
+function useFloatingPortalNode(props) {
+  if (props === void 0) {
+    props = {};
   }
-  /* 
-    Converts the supplied XML DOM into HTML5 Custom Elements. If a callback
-    function is supplied, calls it on the result.
-  */
-  domToHTML5(XML_dom, callback, perElementFn) {
-    this.preprocess(XML_dom, null, perElementFn);
-    this.applyBehaviors();
-    this.done = true;
-    if (callback) {
-      callback(this.dom, this);
-      if (window) {
-        window.dispatchEvent(ceteiceanLoad);
+  const {
+    id,
+    root
+  } = props;
+  const uniqueId = useId();
+  const portalContext = usePortalContext();
+  const [portalNode, setPortalNode] = React.useState(null);
+  const portalNodeRef = React.useRef(null);
+  index(() => {
+    return () => {
+      portalNode == null || portalNode.remove();
+      queueMicrotask(() => {
+        portalNodeRef.current = null;
+      });
+    };
+  }, [portalNode]);
+  index(() => {
+    if (!uniqueId) return;
+    if (portalNodeRef.current) return;
+    const existingIdRoot = id ? document.getElementById(id) : null;
+    if (!existingIdRoot) return;
+    const subRoot = document.createElement("div");
+    subRoot.id = uniqueId;
+    subRoot.setAttribute(attr, "");
+    existingIdRoot.appendChild(subRoot);
+    portalNodeRef.current = subRoot;
+    setPortalNode(subRoot);
+  }, [id, uniqueId]);
+  index(() => {
+    if (!uniqueId) return;
+    if (portalNodeRef.current) return;
+    let container = root || (portalContext == null ? void 0 : portalContext.portalNode);
+    if (container && !isElement(container)) container = container.current;
+    container = container || document.body;
+    let idWrapper = null;
+    if (id) {
+      idWrapper = document.createElement("div");
+      idWrapper.id = id;
+      container.appendChild(idWrapper);
+    }
+    const subRoot = document.createElement("div");
+    subRoot.id = uniqueId;
+    subRoot.setAttribute(attr, "");
+    container = idWrapper || container;
+    container.appendChild(subRoot);
+    portalNodeRef.current = subRoot;
+    setPortalNode(subRoot);
+  }, [id, root, uniqueId, portalContext]);
+  return portalNode;
+}
+function FloatingPortal(props) {
+  const {
+    children,
+    id,
+    root = null,
+    preserveTabOrder = true
+  } = props;
+  const portalNode = useFloatingPortalNode({
+    id,
+    root
+  });
+  const [focusManagerState, setFocusManagerState] = React.useState(null);
+  const beforeOutsideRef = React.useRef(null);
+  const afterOutsideRef = React.useRef(null);
+  const beforeInsideRef = React.useRef(null);
+  const afterInsideRef = React.useRef(null);
+  const shouldRenderGuards = (
+    // The FocusManager and therefore floating element are currently open/
+    // rendered.
+    !!focusManagerState && // Guards are only for non-modal focus management.
+    !focusManagerState.modal && // Don't render if unmount is transitioning.
+    focusManagerState.open && preserveTabOrder && !!(root || portalNode)
+  );
+  React.useEffect(() => {
+    if (!portalNode || !preserveTabOrder || focusManagerState != null && focusManagerState.modal) {
+      return;
+    }
+    function onFocus(event) {
+      if (portalNode && isOutsideEvent(event)) {
+        const focusing = event.type === "focusin";
+        const manageFocus = focusing ? enableFocusInside : disableFocusInside;
+        manageFocus(portalNode);
       }
-    } else {
-      if (typeof window !== "undefined") {
-        window.dispatchEvent(ceteiceanLoad);
+    }
+    portalNode.addEventListener("focusin", onFocus, true);
+    portalNode.addEventListener("focusout", onFocus, true);
+    return () => {
+      portalNode.removeEventListener("focusin", onFocus, true);
+      portalNode.removeEventListener("focusout", onFocus, true);
+    };
+  }, [portalNode, preserveTabOrder, focusManagerState == null ? void 0 : focusManagerState.modal]);
+  return /* @__PURE__ */ React.createElement(PortalContext.Provider, {
+    value: React.useMemo(() => ({
+      preserveTabOrder,
+      beforeOutsideRef,
+      afterOutsideRef,
+      beforeInsideRef,
+      afterInsideRef,
+      portalNode,
+      setFocusManagerState
+    }), [preserveTabOrder, portalNode])
+  }, shouldRenderGuards && portalNode && /* @__PURE__ */ React.createElement(FocusGuard, {
+    "data-type": "outside",
+    ref: beforeOutsideRef,
+    onFocus: (event) => {
+      if (isOutsideEvent(event, portalNode)) {
+        var _beforeInsideRef$curr;
+        (_beforeInsideRef$curr = beforeInsideRef.current) == null || _beforeInsideRef$curr.focus();
+      } else {
+        const prevTabbable = getPreviousTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);
+        prevTabbable == null || prevTabbable.focus();
       }
-      return this.dom;
     }
-  }
-  /*
-    Convenience method for HTML pages containing pre-processed CETEIcean Custom 
-    Elements. Usage:
-      const c = new CETEI();
-      c.processPage();
-  */
-  processPage() {
-    this.els = learnCustomElementNames(this.document);
-    this.applyBehaviors();
-    if (window) {
-      window.dispatchEvent(ceteiceanLoad);
+  }), shouldRenderGuards && portalNode && /* @__PURE__ */ React.createElement("span", {
+    "aria-owns": portalNode.id,
+    style: HIDDEN_STYLES
+  }), portalNode && /* @__PURE__ */ ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /* @__PURE__ */ React.createElement(FocusGuard, {
+    "data-type": "outside",
+    ref: afterOutsideRef,
+    onFocus: (event) => {
+      if (isOutsideEvent(event, portalNode)) {
+        var _afterInsideRef$curre;
+        (_afterInsideRef$curre = afterInsideRef.current) == null || _afterInsideRef$curre.focus();
+      } else {
+        const nextTabbable = getNextTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);
+        nextTabbable == null || nextTabbable.focus();
+        (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) && (focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false, event.nativeEvent));
+      }
+    }
+  }));
+}
+const usePortalContext = () => React.useContext(PortalContext);
+const LIST_LIMIT = 20;
+let previouslyFocusedElements = [];
+function addPreviouslyFocusedElement(element) {
+  previouslyFocusedElements = previouslyFocusedElements.filter((el) => el.isConnected);
+  let tabbableEl = element;
+  if (!tabbableEl || getNodeName(tabbableEl) === "body") return;
+  if (!isTabbable(tabbableEl, getTabbableOptions())) {
+    const tabbableChild = tabbable(tabbableEl, getTabbableOptions())[0];
+    if (tabbableChild) {
+      tabbableEl = tabbableChild;
     }
   }
-  /* 
-    To change a namespace -> prefix mapping, the namespace must first be 
-    unset. Takes a namespace URI. In order to process a TEI P4 document, e.g.,
-    the TEI namespace must be unset before it can be set to the empty string.
-  */
-  unsetNamespace(ns) {
-    this.namespaces.delete(ns);
-  }
-  /* 
-    Sets the base URL for the document. Used to rewrite relative links in the
-    XML source (which may be in a completely different location from the HTML
-    wrapper).
-  */
-  setBaseUrl(base) {
-    this.base = base;
+  previouslyFocusedElements.push(tabbableEl);
+  if (previouslyFocusedElements.length > LIST_LIMIT) {
+    previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
   }
-  /* 
-    Appends any element returned by the function passed in the first
-    parameter to the element in the second parameter. If the function
-    returns nothing, this is a no-op aside from any side effects caused
-    by the provided function.
-  
-    Called by getHandler() and fallback()
-    */
-  append(fn, elt) {
-    let self = this;
-    if (elt && !elt.hasAttribute("data-processed")) {
-      let content = fn.call(self.utilities, elt);
-      if (content) {
-        self.appendBasic(elt, content);
+}
+function getPreviouslyFocusedElement() {
+  return previouslyFocusedElements.slice().reverse().find((el) => el.isConnected);
+}
+const VisuallyHiddenDismiss = /* @__PURE__ */ React.forwardRef(function VisuallyHiddenDismiss2(props, ref) {
+  return /* @__PURE__ */ React.createElement("button", _extends({}, props, {
+    type: "button",
+    ref,
+    tabIndex: -1,
+    style: HIDDEN_STYLES
+  }));
+});
+function FloatingFocusManager(props) {
+  const {
+    context,
+    children,
+    disabled = false,
+    order = ["content"],
+    guards: _guards = true,
+    initialFocus = 0,
+    returnFocus = true,
+    restoreFocus = false,
+    modal = true,
+    visuallyHiddenDismiss = false,
+    closeOnFocusOut = true
+  } = props;
+  const {
+    open,
+    refs,
+    nodeId,
+    onOpenChange,
+    events,
+    dataRef,
+    floatingId,
+    elements: {
+      domReference,
+      floating
+    }
+  } = context;
+  const ignoreInitialFocus = typeof initialFocus === "number" && initialFocus < 0;
+  const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
+  const guards = supportsInert() ? _guards : true;
+  const orderRef = useLatestRef(order);
+  const initialFocusRef = useLatestRef(initialFocus);
+  const returnFocusRef = useLatestRef(returnFocus);
+  const tree = useFloatingTree();
+  const portalContext = usePortalContext();
+  const startDismissButtonRef = React.useRef(null);
+  const endDismissButtonRef = React.useRef(null);
+  const preventReturnFocusRef = React.useRef(false);
+  const isPointerDownRef = React.useRef(false);
+  const tabbableIndexRef = React.useRef(-1);
+  const isInsidePortal = portalContext != null;
+  const firstElementChild = floating == null ? void 0 : floating.firstElementChild;
+  const floatingFocusNode = (firstElementChild == null ? void 0 : firstElementChild.id) === floatingId ? firstElementChild : floating;
+  const getTabbableContent = useEffectEvent(function(container) {
+    if (container === void 0) {
+      container = floatingFocusNode;
+    }
+    return container ? tabbable(container, getTabbableOptions()) : [];
+  });
+  const getTabbableElements = useEffectEvent((container) => {
+    const content = getTabbableContent(container);
+    return orderRef.current.map((type) => {
+      if (domReference && type === "reference") {
+        return domReference;
       }
-    } else {
-      return function() {
-        if (!this.hasAttribute("data-processed")) {
-          let content = fn.call(self.utilities, this);
-          if (content) {
-            self.appendBasic(this, content);
+      if (floatingFocusNode && type === "floating") {
+        return floatingFocusNode;
+      }
+      return content;
+    }).filter(Boolean).flat();
+  });
+  React.useEffect(() => {
+    if (disabled) return;
+    if (!modal) return;
+    function onKeyDown(event) {
+      if (event.key === "Tab") {
+        if (contains(floatingFocusNode, activeElement(getDocument(floatingFocusNode))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {
+          stopEvent(event);
+        }
+        const els = getTabbableElements();
+        const target = getTarget(event);
+        if (orderRef.current[0] === "reference" && target === domReference) {
+          stopEvent(event);
+          if (event.shiftKey) {
+            enqueueFocus(els[els.length - 1]);
+          } else {
+            enqueueFocus(els[1]);
           }
         }
-      };
+        if (orderRef.current[1] === "floating" && target === floatingFocusNode && event.shiftKey) {
+          stopEvent(event);
+          enqueueFocus(els[0]);
+        }
+      }
     }
-  }
-  appendBasic(elt, content) {
-    if (this.discardContent) {
-      elt.innerHTML = "";
-    } else {
-      hideContent(elt, true);
+    const doc = getDocument(floatingFocusNode);
+    doc.addEventListener("keydown", onKeyDown);
+    return () => {
+      doc.removeEventListener("keydown", onKeyDown);
+    };
+  }, [disabled, domReference, floatingFocusNode, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);
+  React.useEffect(() => {
+    if (disabled) return;
+    if (!floating) return;
+    function handleFocusIn(event) {
+      const target = getTarget(event);
+      const tabbableContent = getTabbableContent();
+      const tabbableIndex = tabbableContent.indexOf(target);
+      if (tabbableIndex !== -1) {
+        tabbableIndexRef.current = tabbableIndex;
+      }
     }
-    elt.appendChild(content);
-  }
-  // Given an element, return its qualified name as defined in a behaviors object
-  bName(e) {
-    return e.tagName.substring(0, e.tagName.indexOf("-")).toLowerCase() + ":" + e.getAttribute("data-origname");
-  }
-  /* 
-    Private method called by append(). Takes a child element and a name, and recurses through the
-    child's siblings until an element with that name is found, returning true if it is and false if not.
-  */
-  childExists(elt, name) {
-    if (elt && elt.nodeName == name) {
-      return true;
-    } else {
-      return elt && elt.nextElementSibling && this.childExists(elt.nextElementSibling, name);
+    floating.addEventListener("focusin", handleFocusIn);
+    return () => {
+      floating.removeEventListener("focusin", handleFocusIn);
+    };
+  }, [disabled, floating, getTabbableContent]);
+  React.useEffect(() => {
+    if (disabled) return;
+    if (!closeOnFocusOut) return;
+    function handlePointerDown() {
+      isPointerDownRef.current = true;
+      setTimeout(() => {
+        isPointerDownRef.current = false;
+      });
     }
-  }
-  /* 
-    Takes a template in the form of either an array of 1 or 2 
-    strings or an object with CSS selector keys and either functions
-    or arrays as described above. Returns a closure around a function 
-    that can be called in the element constructor or applied to an 
-    individual element. An empty array is considered a no-op.
-  
-    Called by the getHandler() and getFallback() methods
-  */
-  decorator(template) {
-    if (Array.isArray(template) && template.length == 0) {
-      return function(e) {
+    function handleFocusOutside(event) {
+      const relatedTarget = event.relatedTarget;
+      queueMicrotask(() => {
+        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute(createAttribute("focus-guard")) || tree && (getChildren(tree.nodesRef.current, nodeId).find((node) => {
+          var _node$context, _node$context2;
+          return contains((_node$context = node.context) == null ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? void 0 : _node$context2.elements.domReference, relatedTarget);
+        }) || getAncestors(tree.nodesRef.current, nodeId).find((node) => {
+          var _node$context3, _node$context4;
+          return ((_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating) === relatedTarget || ((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.domReference) === relatedTarget;
+        })));
+        if (restoreFocus && movedToUnrelatedNode && activeElement(getDocument(floatingFocusNode)) === getDocument(floatingFocusNode).body) {
+          if (isHTMLElement(floatingFocusNode)) {
+            floatingFocusNode == null || floatingFocusNode.focus();
+          }
+          const prevTabbableIndex = tabbableIndexRef.current;
+          const tabbableContent = getTabbableContent();
+          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusNode;
+          if (isHTMLElement(nodeToFocus)) {
+            nodeToFocus.focus();
+          }
+        }
+        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current && // Fix React 18 Strict Mode returnFocus due to double rendering.
+        relatedTarget !== getPreviouslyFocusedElement()) {
+          preventReturnFocusRef.current = true;
+          onOpenChange(false, event);
+        }
+      });
+    }
+    if (floating && isHTMLElement(domReference)) {
+      domReference.addEventListener("focusout", handleFocusOutside);
+      domReference.addEventListener("pointerdown", handlePointerDown);
+      floating.addEventListener("focusout", handleFocusOutside);
+      return () => {
+        domReference.removeEventListener("focusout", handleFocusOutside);
+        domReference.removeEventListener("pointerdown", handlePointerDown);
+        floating.removeEventListener("focusout", handleFocusOutside);
       };
     }
-    if (Array.isArray(template) && !Array.isArray(template[0])) {
-      return this.applyDecorator(template);
+  }, [disabled, domReference, floating, floatingFocusNode, modal, nodeId, tree, portalContext, onOpenChange, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox]);
+  React.useEffect(() => {
+    var _portalContext$portal;
+    if (disabled) return;
+    const portalNodes = Array.from((portalContext == null || (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll("[" + createAttribute("portal") + "]")) || []);
+    if (floating) {
+      const insideElements = [floating, ...portalNodes, startDismissButtonRef.current, endDismissButtonRef.current, orderRef.current.includes("reference") || isUntrappedTypeableCombobox ? domReference : null].filter((x) => x != null);
+      const cleanup = modal || isUntrappedTypeableCombobox ? markOthers(insideElements, guards, !guards) : markOthers(insideElements);
+      return () => {
+        cleanup();
+      };
     }
-    let self = this;
-    return function(elt) {
-      for (let rule of template) {
-        if (elt.matches(rule[0]) || rule[0] === "_") {
-          if (Array.isArray(rule[1])) {
-            return self.decorator(rule[1]).call(this, elt);
-          } else {
-            return rule[1].call(this, elt);
-          }
+  }, [disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, guards]);
+  index(() => {
+    if (disabled || !isHTMLElement(floatingFocusNode)) return;
+    const doc = getDocument(floatingFocusNode);
+    const previouslyFocusedElement = activeElement(doc);
+    queueMicrotask(() => {
+      const focusableElements = getTabbableElements(floatingFocusNode);
+      const initialFocusValue = initialFocusRef.current;
+      const elToFocus = (typeof initialFocusValue === "number" ? focusableElements[initialFocusValue] : initialFocusValue.current) || floatingFocusNode;
+      const focusAlreadyInsideFloatingEl = contains(floatingFocusNode, previouslyFocusedElement);
+      if (!ignoreInitialFocus && !focusAlreadyInsideFloatingEl && open) {
+        enqueueFocus(elToFocus, {
+          preventScroll: elToFocus === floatingFocusNode
+        });
+      }
+    });
+  }, [disabled, open, floatingFocusNode, ignoreInitialFocus, getTabbableElements, initialFocusRef]);
+  index(() => {
+    if (disabled || !floatingFocusNode) return;
+    let preventReturnFocusScroll = false;
+    const doc = getDocument(floatingFocusNode);
+    const previouslyFocusedElement = activeElement(doc);
+    const contextData = dataRef.current;
+    let openEvent = contextData.openEvent;
+    const domReference2 = refs.domReference.current;
+    addPreviouslyFocusedElement(previouslyFocusedElement);
+    function onOpenChange2(_ref) {
+      let {
+        open: open2,
+        reason,
+        event,
+        nested
+      } = _ref;
+      if (open2) {
+        openEvent = event;
+      }
+      if (reason === "escape-key" && refs.domReference.current) {
+        addPreviouslyFocusedElement(refs.domReference.current);
+      }
+      if (reason === "hover" && event.type === "mouseleave") {
+        preventReturnFocusRef.current = true;
+      }
+      if (reason !== "outside-press") return;
+      if (nested) {
+        preventReturnFocusRef.current = false;
+        preventReturnFocusScroll = true;
+      } else {
+        preventReturnFocusRef.current = !(isVirtualClick(event) || isVirtualPointerEvent(event));
+      }
+    }
+    events.on("openchange", onOpenChange2);
+    return () => {
+      events.off("openchange", onOpenChange2);
+      const activeEl = activeElement(doc);
+      const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getChildren(tree.nodesRef.current, nodeId).some((node) => {
+        var _node$context5;
+        return contains((_node$context5 = node.context) == null ? void 0 : _node$context5.elements.floating, activeEl);
+      });
+      const shouldFocusReference = isFocusInsideFloatingTree || openEvent && ["click", "mousedown"].includes(openEvent.type);
+      if (shouldFocusReference && refs.domReference.current) {
+        addPreviouslyFocusedElement(refs.domReference.current);
+      }
+      const returnContextElement = domReference2 || previouslyFocusedElement;
+      const tabbableElements = tabbable(getDocument(returnContextElement).body, getTabbableOptions());
+      queueMicrotask(() => {
+        let returnElement = getPreviouslyFocusedElement();
+        if (!returnElement && isHTMLElement(returnContextElement) && floating) {
+          returnElement = getClosestTabbableElement(tabbableElements, returnContextElement, floating);
         }
+        if (
+          // eslint-disable-next-line react-hooks/exhaustive-deps
+          returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(returnElement) && // If the focus moved somewhere else after mount, avoid returning focus
+          // since it likely entered a different element which should be
+          // respected: https://github.com/floating-ui/floating-ui/issues/2607
+          (returnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)
+        ) {
+          returnElement.focus({
+            preventScroll: preventReturnFocusScroll
+          });
+        }
+      });
+    };
+  }, [disabled, floating, floatingFocusNode, returnFocusRef, dataRef, refs, events, tree, nodeId]);
+  index(() => {
+    if (disabled) return;
+    if (!portalContext) return;
+    portalContext.setFocusManagerState({
+      modal,
+      closeOnFocusOut,
+      open,
+      onOpenChange,
+      refs
+    });
+    return () => {
+      portalContext.setFocusManagerState(null);
+    };
+  }, [disabled, portalContext, modal, open, onOpenChange, refs, closeOnFocusOut]);
+  index(() => {
+    if (disabled) return;
+    if (!floatingFocusNode) return;
+    if (typeof MutationObserver !== "function") return;
+    if (ignoreInitialFocus) return;
+    const handleMutation = () => {
+      const tabIndex = floatingFocusNode.getAttribute("tabindex");
+      const tabbableContent = getTabbableContent();
+      const activeEl = activeElement(getDocument(floating));
+      const tabbableIndex = tabbableContent.indexOf(activeEl);
+      if (tabbableIndex !== -1) {
+        tabbableIndexRef.current = tabbableIndex;
+      }
+      if (orderRef.current.includes("floating") || activeEl !== refs.domReference.current && tabbableContent.length === 0) {
+        if (tabIndex !== "0") {
+          floatingFocusNode.setAttribute("tabindex", "0");
+        }
+      } else if (tabIndex !== "-1") {
+        floatingFocusNode.setAttribute("tabindex", "-1");
       }
     };
-  }
-  applyDecorator(strings) {
-    let self = this;
-    return function(elt) {
-      let copy = [];
-      for (let i = 0; i < strings.length; i++) {
-        copy.push(self.template(strings[i], elt));
-      }
-      return self.insert(elt, copy);
+    handleMutation();
+    const observer = new MutationObserver(handleMutation);
+    observer.observe(floatingFocusNode, {
+      childList: true,
+      subtree: true,
+      attributes: true
+    });
+    return () => {
+      observer.disconnect();
     };
+  }, [disabled, floating, floatingFocusNode, refs, orderRef, getTabbableContent, ignoreInitialFocus]);
+  function renderDismissButton(location) {
+    if (disabled || !visuallyHiddenDismiss || !modal) {
+      return null;
+    }
+    return /* @__PURE__ */ React.createElement(VisuallyHiddenDismiss, {
+      ref: location === "start" ? startDismissButtonRef : endDismissButtonRef,
+      onClick: (event) => onOpenChange(false, event.nativeEvent)
+    }, typeof visuallyHiddenDismiss === "string" ? visuallyHiddenDismiss : "Dismiss");
   }
-  /* 
-    Returns the fallback function for the given element name.
-    Called by fallback().
-  */
-  getFallback(behaviors, fn) {
-    if (behaviors[fn]) {
-      if (behaviors[fn] instanceof Function) {
-        return behaviors[fn];
-      } else {
-        return this.decorator(behaviors[fn]);
+  const shouldRenderGuards = !disabled && guards && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, shouldRenderGuards && /* @__PURE__ */ React.createElement(FocusGuard, {
+    "data-type": "inside",
+    ref: portalContext == null ? void 0 : portalContext.beforeInsideRef,
+    onFocus: (event) => {
+      if (modal) {
+        const els = getTabbableElements();
+        enqueueFocus(order[0] === "reference" ? els[0] : els[els.length - 1]);
+      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {
+        preventReturnFocusRef.current = false;
+        if (isOutsideEvent(event, portalContext.portalNode)) {
+          const nextTabbable = getNextTabbable() || domReference;
+          nextTabbable == null || nextTabbable.focus();
+        } else {
+          var _portalContext$before;
+          (_portalContext$before = portalContext.beforeOutsideRef.current) == null || _portalContext$before.focus();
+        }
       }
     }
-  }
-  /* 
-    Returns the handler function for the given element name
-    Called by define().
-  */
-  getHandler(behaviors, fn) {
-    if (behaviors[fn]) {
-      if (behaviors[fn] instanceof Function) {
-        return this.append(behaviors[fn]);
-      } else {
-        return this.append(this.decorator(behaviors[fn]));
+  }), !isUntrappedTypeableCombobox && renderDismissButton("start"), children, renderDismissButton("end"), shouldRenderGuards && /* @__PURE__ */ React.createElement(FocusGuard, {
+    "data-type": "inside",
+    ref: portalContext == null ? void 0 : portalContext.afterInsideRef,
+    onFocus: (event) => {
+      if (modal) {
+        enqueueFocus(getTabbableElements()[0]);
+      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {
+        if (closeOnFocusOut) {
+          preventReturnFocusRef.current = true;
+        }
+        if (isOutsideEvent(event, portalContext.portalNode)) {
+          const prevTabbable = getPreviousTabbable() || domReference;
+          prevTabbable == null || prevTabbable.focus();
+        } else {
+          var _portalContext$afterO;
+          (_portalContext$afterO = portalContext.afterOutsideRef.current) == null || _portalContext$afterO.focus();
+        }
       }
     }
+  }));
+}
+const bubbleHandlerKeys = {
+  pointerdown: "onPointerDown",
+  mousedown: "onMouseDown",
+  click: "onClick"
+};
+const captureHandlerKeys = {
+  pointerdown: "onPointerDownCapture",
+  mousedown: "onMouseDownCapture",
+  click: "onClickCapture"
+};
+const normalizeProp = (normalizable) => {
+  var _normalizable$escapeK, _normalizable$outside;
+  return {
+    escapeKey: typeof normalizable === "boolean" ? normalizable : (_normalizable$escapeK = normalizable == null ? void 0 : normalizable.escapeKey) != null ? _normalizable$escapeK : false,
+    outsidePress: typeof normalizable === "boolean" ? normalizable : (_normalizable$outside = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _normalizable$outside : true
+  };
+};
+function useDismiss(context, props) {
+  if (props === void 0) {
+    props = {};
   }
-  insert(elt, strings) {
-    let content = this.document.createElement("cetei-content");
-    for (let node of Array.from(elt.childNodes)) {
-      if (node.nodeType === 1 && !node.hasAttribute("data-processed")) {
-        this.processElement(node);
+  const {
+    open,
+    onOpenChange,
+    elements,
+    dataRef
+  } = context;
+  const {
+    enabled = true,
+    escapeKey = true,
+    outsidePress: unstable_outsidePress = true,
+    outsidePressEvent = "pointerdown",
+    referencePress = false,
+    referencePressEvent = "pointerdown",
+    ancestorScroll = false,
+    bubbles,
+    capture
+  } = props;
+  const tree = useFloatingTree();
+  const outsidePressFn = useEffectEvent(typeof unstable_outsidePress === "function" ? unstable_outsidePress : () => false);
+  const outsidePress = typeof unstable_outsidePress === "function" ? outsidePressFn : unstable_outsidePress;
+  const insideReactTreeRef = React.useRef(false);
+  const endedOrStartedInsideRef = React.useRef(false);
+  const {
+    escapeKey: escapeKeyBubbles,
+    outsidePress: outsidePressBubbles
+  } = normalizeProp(bubbles);
+  const {
+    escapeKey: escapeKeyCapture,
+    outsidePress: outsidePressCapture
+  } = normalizeProp(capture);
+  const closeOnEscapeKeyDown = useEffectEvent((event) => {
+    var _dataRef$current$floa;
+    if (!open || !enabled || !escapeKey || event.key !== "Escape") {
+      return;
+    }
+    const nodeId = (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;
+    const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];
+    if (!escapeKeyBubbles) {
+      event.stopPropagation();
+      if (children.length > 0) {
+        let shouldDismiss = true;
+        children.forEach((child) => {
+          var _child$context;
+          if ((_child$context = child.context) != null && _child$context.open && !child.context.dataRef.current.__escapeKeyBubbles) {
+            shouldDismiss = false;
+            return;
+          }
+        });
+        if (!shouldDismiss) {
+          return;
+        }
       }
     }
-    if (strings[0].match("<[^>]+>") && strings[1] && strings[1].match("<[^>]+>")) {
-      content.innerHTML = strings[0] + elt.innerHTML + (strings[1] ? strings[1] : "");
-    } else {
-      content.innerHTML = strings[0];
-      content.setAttribute("data-before", strings[0].replace(/<[^>]+>/g, "").length);
-      for (let node of Array.from(elt.childNodes)) {
-        content.appendChild(node.cloneNode(true));
+    onOpenChange(false, isReactEvent(event) ? event.nativeEvent : event, "escape-key");
+  });
+  const closeOnEscapeKeyDownCapture = useEffectEvent((event) => {
+    var _getTarget2;
+    const callback = () => {
+      var _getTarget;
+      closeOnEscapeKeyDown(event);
+      (_getTarget = getTarget(event)) == null || _getTarget.removeEventListener("keydown", callback);
+    };
+    (_getTarget2 = getTarget(event)) == null || _getTarget2.addEventListener("keydown", callback);
+  });
+  const closeOnPressOutside = useEffectEvent((event) => {
+    var _dataRef$current$floa2;
+    const insideReactTree = insideReactTreeRef.current;
+    insideReactTreeRef.current = false;
+    const endedOrStartedInside = endedOrStartedInsideRef.current;
+    endedOrStartedInsideRef.current = false;
+    if (outsidePressEvent === "click" && endedOrStartedInside) {
+      return;
+    }
+    if (insideReactTree) {
+      return;
+    }
+    if (typeof outsidePress === "function" && !outsidePress(event)) {
+      return;
+    }
+    const target = getTarget(event);
+    const inertSelector = "[" + createAttribute("inert") + "]";
+    const markers = getDocument(elements.floating).querySelectorAll(inertSelector);
+    let targetRootAncestor = isElement(target) ? target : null;
+    while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
+      const nextParent = getParentNode(targetRootAncestor);
+      if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {
+        break;
+      }
+      targetRootAncestor = nextParent;
+    }
+    if (markers.length && isElement(target) && !isRootElement(target) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    !contains(target, elements.floating) && // If the target root element contains none of the markers, then the
+    // element was injected after the floating element rendered.
+    Array.from(markers).every((marker) => !contains(targetRootAncestor, marker))) {
+      return;
+    }
+    if (isHTMLElement(target) && floating) {
+      const canScrollX = target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
+      const canScrollY = target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
+      let xCond = canScrollY && event.offsetX > target.clientWidth;
+      if (canScrollY) {
+        const isRTL = getComputedStyle(target).direction === "rtl";
+        if (isRTL) {
+          xCond = event.offsetX <= target.offsetWidth - target.clientWidth;
+        }
       }
-      if (strings.length > 1) {
-        content.innerHTML += strings[1];
-        content.setAttribute("data-after", strings[1].replace(/<[^>]+>/g, "").length);
+      if (xCond || canScrollX && event.offsetY > target.clientHeight) {
+        return;
       }
     }
-    if (content.childNodes.length < 2) {
-      return content.firstChild;
-    } else {
-      return content;
+    const nodeId = (_dataRef$current$floa2 = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa2.nodeId;
+    const targetIsInsideChildren = tree && getChildren(tree.nodesRef.current, nodeId).some((node) => {
+      var _node$context;
+      return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);
+    });
+    if (isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference) || targetIsInsideChildren) {
+      return;
     }
-  }
-  // Runs behaviors recursively on the supplied element and children
-  processElement(elt) {
-    if (elt.hasAttribute("data-origname") && !elt.hasAttribute("data-processed")) {
-      let fn = this.getFallback(this.bName(elt));
-      if (fn) {
-        this.append(fn, elt);
-        elt.setAttribute("data-processed", "");
+    const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];
+    if (children.length > 0) {
+      let shouldDismiss = true;
+      children.forEach((child) => {
+        var _child$context2;
+        if ((_child$context2 = child.context) != null && _child$context2.open && !child.context.dataRef.current.__outsidePressBubbles) {
+          shouldDismiss = false;
+          return;
+        }
+      });
+      if (!shouldDismiss) {
+        return;
       }
     }
-    for (let node of Array.from(elt.childNodes)) {
-      if (node.nodeType === 1) {
-        this.processElement(node);
+    onOpenChange(false, event, "outside-press");
+  });
+  const closeOnPressOutsideCapture = useEffectEvent((event) => {
+    var _getTarget4;
+    const callback = () => {
+      var _getTarget3;
+      closeOnPressOutside(event);
+      (_getTarget3 = getTarget(event)) == null || _getTarget3.removeEventListener(outsidePressEvent, callback);
+    };
+    (_getTarget4 = getTarget(event)) == null || _getTarget4.addEventListener(outsidePressEvent, callback);
+  });
+  React.useEffect(() => {
+    if (!open || !enabled) {
+      return;
+    }
+    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
+    dataRef.current.__outsidePressBubbles = outsidePressBubbles;
+    function onScroll(event) {
+      onOpenChange(false, event, "ancestor-scroll");
+    }
+    const doc = getDocument(elements.floating);
+    escapeKey && doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
+    outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
+    let ancestors = [];
+    if (ancestorScroll) {
+      if (isElement(elements.domReference)) {
+        ancestors = getOverflowAncestors(elements.domReference);
+      }
+      if (isElement(elements.floating)) {
+        ancestors = ancestors.concat(getOverflowAncestors(elements.floating));
+      }
+      if (!isElement(elements.reference) && elements.reference && elements.reference.contextElement) {
+        ancestors = ancestors.concat(getOverflowAncestors(elements.reference.contextElement));
       }
     }
-  }
-  template(str, elt) {
-    let result = str;
-    if (str.search(/\$(\w*)(@([a-zA-Z:]+))/)) {
-      let re = /\$(\w*)@([a-zA-Z:]+)/g;
-      let replacements;
-      while (replacements = re.exec(str)) {
-        if (elt.hasAttribute(replacements[2])) {
-          if (replacements[1] && this.utilities[replacements[1]]) {
-            result = result.replace(replacements[0], this.utilities[replacements[1]](elt.getAttribute(replacements[2])));
-          } else {
-            result = result.replace(replacements[0], elt.getAttribute(replacements[2]));
-          }
-        } else {
-          result = result.replace(replacements[0], "");
-        }
+    ancestors = ancestors.filter((ancestor) => {
+      var _doc$defaultView;
+      return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);
+    });
+    ancestors.forEach((ancestor) => {
+      ancestor.addEventListener("scroll", onScroll, {
+        passive: true
+      });
+    });
+    return () => {
+      escapeKey && doc.removeEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
+      outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
+      ancestors.forEach((ancestor) => {
+        ancestor.removeEventListener("scroll", onScroll);
+      });
+    };
+  }, [dataRef, elements, escapeKey, outsidePress, outsidePressEvent, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);
+  React.useEffect(() => {
+    insideReactTreeRef.current = false;
+  }, [outsidePress, outsidePressEvent]);
+  const reference = React.useMemo(() => ({
+    onKeyDown: closeOnEscapeKeyDown,
+    [bubbleHandlerKeys[referencePressEvent]]: (event) => {
+      if (referencePress) {
+        onOpenChange(false, event.nativeEvent, "reference-press");
       }
     }
-    return result;
-  }
-  // Define or apply behaviors for the document
-  applyBehaviors() {
-    if (typeof window !== "undefined" && window.customElements) {
-      this.define.call(this, this.els);
-    } else {
-      this.fallback.call(this, this.els);
+  }), [closeOnEscapeKeyDown, onOpenChange, referencePress, referencePressEvent]);
+  const floating = React.useMemo(() => ({
+    onKeyDown: closeOnEscapeKeyDown,
+    onMouseDown() {
+      endedOrStartedInsideRef.current = true;
+    },
+    onMouseUp() {
+      endedOrStartedInsideRef.current = true;
+    },
+    [captureHandlerKeys[outsidePressEvent]]: () => {
+      insideReactTreeRef.current = true;
     }
-  }
-  /* 
-    Registers the list of elements provided with the browser.
-    Called by makeHTML5(), but can be called independently if, for example,
-    you've created Custom Elements via an XSLT transformation instead.
-  */
-  define(names) {
-    for (let name of names) {
-      const fn = this.getHandler(this.behaviors, name);
-      defineCustomElement(name, fn, this.debug);
+  }), [closeOnEscapeKeyDown, outsidePressEvent]);
+  return React.useMemo(() => enabled ? {
+    reference,
+    floating
+  } : {}, [enabled, reference, floating]);
+}
+function useFloatingRootContext(options) {
+  const {
+    open = false,
+    onOpenChange: onOpenChangeProp,
+    elements: elementsProp
+  } = options;
+  const floatingId = useId();
+  const dataRef = React.useRef({});
+  const [events] = React.useState(() => createPubSub());
+  const nested = useFloatingParentNodeId() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const optionDomReference = elementsProp.reference;
+    if (optionDomReference && !isElement(optionDomReference)) {
+      error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
     }
   }
-  /* 
-    Provides fallback functionality for environments where Custom Elements
-    are not supported.
-  
-    Like define(), this is called by makeHTML5(), but can be called
-    independently.
-  */
-  fallback(names) {
-    for (let name of names) {
-      let fn = this.getFallback(this.behaviors, name);
-      if (fn) {
-        for (let elt of Array.from((this.dom && !this.done ? this.dom : this.document).querySelectorAll(tagName(name)))) {
-          if (!elt.hasAttribute("data-processed")) {
-            this.append(fn, elt);
-            elt.setAttribute("data-processed", "");
-          }
-        }
+  const [positionReference, setPositionReference] = React.useState(elementsProp.reference);
+  const onOpenChange = useEffectEvent((open2, event, reason) => {
+    dataRef.current.openEvent = open2 ? event : void 0;
+    events.emit("openchange", {
+      open: open2,
+      event,
+      reason,
+      nested
+    });
+    onOpenChangeProp == null || onOpenChangeProp(open2, event, reason);
+  });
+  const refs = React.useMemo(() => ({
+    setPositionReference
+  }), []);
+  const elements = React.useMemo(() => ({
+    reference: positionReference || elementsProp.reference || null,
+    floating: elementsProp.floating || null,
+    domReference: elementsProp.reference
+  }), [positionReference, elementsProp.reference, elementsProp.floating]);
+  return React.useMemo(() => ({
+    dataRef,
+    open,
+    onOpenChange,
+    elements,
+    events,
+    floatingId,
+    refs
+  }), [open, onOpenChange, elements, events, floatingId, refs]);
+}
+function useFloating(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    nodeId
+  } = options;
+  const internalRootContext = useFloatingRootContext({
+    ...options,
+    elements: {
+      reference: null,
+      floating: null,
+      ...options.elements
+    }
+  });
+  const rootContext = options.rootContext || internalRootContext;
+  const computedElements = rootContext.elements;
+  const [_domReference, setDomReference] = React.useState(null);
+  const [positionReference, _setPositionReference] = React.useState(null);
+  const optionDomReference = computedElements == null ? void 0 : computedElements.reference;
+  const domReference = optionDomReference || _domReference;
+  const domReferenceRef = React.useRef(null);
+  const tree = useFloatingTree();
+  index(() => {
+    if (domReference) {
+      domReferenceRef.current = domReference;
+    }
+  }, [domReference]);
+  const position = useFloating$1({
+    ...options,
+    elements: {
+      ...computedElements,
+      ...positionReference && {
+        reference: positionReference
       }
     }
+  });
+  const setPositionReference = React.useCallback((node) => {
+    const computedPositionReference = isElement(node) ? {
+      getBoundingClientRect: () => node.getBoundingClientRect(),
+      contextElement: node
+    } : node;
+    _setPositionReference(computedPositionReference);
+    position.refs.setReference(computedPositionReference);
+  }, [position.refs]);
+  const setReference = React.useCallback((node) => {
+    if (isElement(node) || node === null) {
+      domReferenceRef.current = node;
+      setDomReference(node);
+    }
+    if (isElement(position.refs.reference.current) || position.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    node !== null && !isElement(node)) {
+      position.refs.setReference(node);
+    }
+  }, [position.refs]);
+  const refs = React.useMemo(() => ({
+    ...position.refs,
+    setReference,
+    setPositionReference,
+    domReference: domReferenceRef
+  }), [position.refs, setReference, setPositionReference]);
+  const elements = React.useMemo(() => ({
+    ...position.elements,
+    domReference
+  }), [position.elements, domReference]);
+  const context = React.useMemo(() => ({
+    ...position,
+    ...rootContext,
+    refs,
+    elements,
+    nodeId
+  }), [position, refs, elements, nodeId, rootContext]);
+  index(() => {
+    rootContext.dataRef.current.floatingContext = context;
+    const node = tree == null ? void 0 : tree.nodesRef.current.find((node2) => node2.id === nodeId);
+    if (node) {
+      node.context = context;
+    }
+  });
+  return React.useMemo(() => ({
+    ...position,
+    context,
+    refs,
+    elements
+  }), [position, refs, elements, context]);
+}
+const ACTIVE_KEY = "active";
+const SELECTED_KEY = "selected";
+function mergeProps(userProps, propsList, elementKey) {
+  const map = /* @__PURE__ */ new Map();
+  const isItem = elementKey === "item";
+  let domUserProps = userProps;
+  if (isItem && userProps) {
+    const {
+      [ACTIVE_KEY]: _,
+      [SELECTED_KEY]: __,
+      ...validProps
+    } = userProps;
+    domUserProps = validProps;
   }
-  /**********************
-   * Utility functions  *
-   **********************/
-  static savePosition() {
-    window.sessionStorage.setItem(window.location + "-scroll", window.scrollY);
-  }
-  static restorePosition() {
-    if (!window.location.hash) {
-      let scroll;
-      if (scroll = window.sessionStorage.getItem(window.location + "-scroll")) {
-        window.sessionStorage.removeItem(window.location + "-scroll");
-        setTimeout(function() {
-          window.scrollTo(0, scroll);
-        }, 100);
+  return {
+    ...elementKey === "floating" && {
+      tabIndex: -1
+    },
+    ...domUserProps,
+    ...propsList.map((value) => {
+      const propsOrGetProps = value ? value[elementKey] : null;
+      if (typeof propsOrGetProps === "function") {
+        return userProps ? propsOrGetProps(userProps) : null;
       }
-    } else {
-      setTimeout(function() {
-        let h = this.document.querySelector(window.decodeURI(window.location.hash));
-        if (h) {
-          h.scrollIntoView();
+      return propsOrGetProps;
+    }).concat(userProps).reduce((acc, props) => {
+      if (!props) {
+        return acc;
+      }
+      Object.entries(props).forEach((_ref) => {
+        let [key, value] = _ref;
+        if (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) {
+          return;
         }
-      }, 100);
-    }
+        if (key.indexOf("on") === 0) {
+          if (!map.has(key)) {
+            map.set(key, []);
+          }
+          if (typeof value === "function") {
+            var _map$get;
+            (_map$get = map.get(key)) == null || _map$get.push(value);
+            acc[key] = function() {
+              var _map$get2;
+              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+              }
+              return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map((fn) => fn(...args)).find((val) => val !== void 0);
+            };
+          }
+        } else {
+          acc[key] = value;
+        }
+      });
+      return acc;
+    }, {})
+  };
+}
+function useInteractions(propsList) {
+  if (propsList === void 0) {
+    propsList = [];
   }
+  const referenceDeps = propsList.map((key) => key == null ? void 0 : key.reference);
+  const floatingDeps = propsList.map((key) => key == null ? void 0 : key.floating);
+  const itemDeps = propsList.map((key) => key == null ? void 0 : key.item);
+  const getReferenceProps = React.useCallback(
+    (userProps) => mergeProps(userProps, propsList, "reference"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    referenceDeps
+  );
+  const getFloatingProps = React.useCallback(
+    (userProps) => mergeProps(userProps, propsList, "floating"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    floatingDeps
+  );
+  const getItemProps = React.useCallback(
+    (userProps) => mergeProps(userProps, propsList, "item"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    itemDeps
+  );
+  return React.useMemo(() => ({
+    getReferenceProps,
+    getFloatingProps,
+    getItemProps
+  }), [getReferenceProps, getFloatingProps, getItemProps]);
 }
-try {
-  if (typeof window !== "undefined") {
-    window.CETEI = CETEI;
-    window.addEventListener("beforeunload", CETEI.savePosition);
-    var ceteiceanLoad = new Event("ceteiceanload");
-    window.addEventListener("ceteiceanload", CETEI.restorePosition);
+const componentRoleToAriaRoleMap = /* @__PURE__ */ new Map([["select", "listbox"], ["combobox", "listbox"], ["label", false]]);
+function useRole(context, props) {
+  var _componentRoleToAriaR;
+  if (props === void 0) {
+    props = {};
   }
-} catch (e) {
-  console.log(e);
+  const {
+    open,
+    floatingId
+  } = context;
+  const {
+    enabled = true,
+    role = "dialog"
+  } = props;
+  const ariaRole = (_componentRoleToAriaR = componentRoleToAriaRoleMap.get(role)) != null ? _componentRoleToAriaR : role;
+  const referenceId = useId();
+  const parentId = useFloatingParentNodeId();
+  const isNested = parentId != null;
+  const reference = React.useMemo(() => {
+    if (ariaRole === "tooltip" || role === "label") {
+      return {
+        ["aria-" + (role === "label" ? "labelledby" : "describedby")]: open ? floatingId : void 0
+      };
+    }
+    return {
+      "aria-expanded": open ? "true" : "false",
+      "aria-haspopup": ariaRole === "alertdialog" ? "dialog" : ariaRole,
+      "aria-controls": open ? floatingId : void 0,
+      ...ariaRole === "listbox" && {
+        role: "combobox"
+      },
+      ...ariaRole === "menu" && {
+        id: referenceId
+      },
+      ...ariaRole === "menu" && isNested && {
+        role: "menuitem"
+      },
+      ...role === "select" && {
+        "aria-autocomplete": "none"
+      },
+      ...role === "combobox" && {
+        "aria-autocomplete": "list"
+      }
+    };
+  }, [ariaRole, floatingId, isNested, open, referenceId, role]);
+  const floating = React.useMemo(() => {
+    const floatingProps = {
+      id: floatingId,
+      ...ariaRole && {
+        role: ariaRole
+      }
+    };
+    if (ariaRole === "tooltip" || role === "label") {
+      return floatingProps;
+    }
+    return {
+      ...floatingProps,
+      ...ariaRole === "menu" && {
+        "aria-labelledby": referenceId
+      }
+    };
+  }, [ariaRole, floatingId, referenceId, role]);
+  const item = React.useCallback((_ref) => {
+    let {
+      active,
+      selected
+    } = _ref;
+    const commonProps = {
+      role: "option",
+      ...active && {
+        id: floatingId + "-option"
+      }
+    };
+    switch (role) {
+      case "select":
+        return {
+          ...commonProps,
+          "aria-selected": active && selected
+        };
+      case "combobox": {
+        return {
+          ...commonProps,
+          ...active && {
+            "aria-selected": true
+          }
+        };
+      }
+    }
+    return {};
+  }, [floatingId, role]);
+  return React.useMemo(() => enabled ? {
+    reference,
+    floating,
+    item
+  } : {}, [enabled, reference, floating, item]);
 }
 export {
-  CETEI as default
+  FloatingFocusManager,
+  FloatingPortal,
+  flip,
+  getOverflowAncestors,
+  inline,
+  offset,
+  shift,
+  useDismiss,
+  useFloating,
+  useFloatingParentNodeId,
+  useFloatingPortalNode,
+  useFloatingRootContext,
+  useFloatingTree,
+  useId,
+  useInteractions,
+  useRole
 };
 //# sourceMappingURL=react-text-annotator.es11.js.map