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

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

@@ -1,1454 +1,490 @@
-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.");
-    }
-  });
-  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];
-    }
-    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];
-  }
-  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);
-    }
-  }
-  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;
-  }
-  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);
+import defaultBehaviors from "./react-text-annotator.es23.js";
+import * as utilities from "./react-text-annotator.es24.js";
+import { hideContent, defineCustomElement, tagName } from "./react-text-annotator.es24.js";
+import { addBehaviors, addBehavior, removeBehavior } from "./react-text-annotator.es25.js";
+import { learnElementNames, learnCustomElementNames } from "./react-text-annotator.es26.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 {
-        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 (markerValue === 1) {
-          node.setAttribute(markerName, "");
-        }
-        if (!alreadyHidden && controlAttribute) {
-          node.setAttribute(controlAttribute, "true");
-        }
-      }
-    });
-  }
-  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);
+        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(/\/[^\/]*$/, "/");
         }
-        uncontrolledElementsSet.delete(element);
+      } catch (e) {
+        this.base = "";
       }
-      if (!markerValue) {
-        element.removeAttribute(markerName);
-      }
-    });
-    lockCount--;
-    if (!lockCount) {
-      counterMap = /* @__PURE__ */ new WeakMap();
-      counterMap = /* @__PURE__ */ new WeakMap();
-      uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
-      markerMap = {};
     }
-  };
-}
-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 {
-      element.removeAttribute("tabindex");
+    if (!this.options.omitDefaultBehaviors) {
+      this.addBehaviors(defaultBehaviors);
     }
-  });
-}
-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--;
+    if (this.options.ignoreFragmentId) {
+      if (window) {
+        window.removeEventListener("ceteiceanload", CETEI.restorePosition);
       }
-      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 = {};
-  }
-  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);
-      }
-    }
-    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();
-      }
-    }
-  }), 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();
+  /* 
+    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 {
-        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));
+        console.log(`Could not get XML file ${XML_url}.
+Server returned ${response.status}: ${response.statusText}`);
       }
-    }
-  }));
-}
-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;
+    } catch (error) {
+      console.log(error);
     }
   }
-  previouslyFocusedElements.push(tabbableEl);
-  if (previouslyFocusedElements.length > LIST_LIMIT) {
-    previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
+  /* 
+    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);
   }
-}
-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;
-      }
-      if (floatingFocusNode && type === "floating") {
-        return floatingFocusNode;
+  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()}`);
+      } else {
+        newElement = this.document.importNode(el, false);
       }
-      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);
+      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 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 (att.name == "xml:id") {
+          newElement.setAttribute("id", att.value);
         }
-        if (orderRef.current[1] === "floating" && target === floatingFocusNode && event.shiftKey) {
-          stopEvent(event);
-          enqueueFocus(els[0]);
+        if (att.name == "xml:lang") {
+          newElement.setAttribute("lang", att.value);
+        }
+        if (att.name == "rendition") {
+          newElement.setAttribute("class", att.value.replace(/#/g, ""));
         }
       }
-    }
-    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;
-      }
-    }
-    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;
-      });
-    }
-    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();
+      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 ((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 (style.childNodes.length > 0) {
+          newElement.appendChild(style);
+          this.hasStyle = true;
         }
-      });
-    }
-    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);
-      };
-    }
-  }, [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();
-      };
-    }
-  }, [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 (el.localName == "prefixDef") {
+        this.prefixDefs.push(el.getAttribute("ident"));
+        this.prefixDefs[el.getAttribute("ident")] = {
+          "matchPattern": el.getAttribute("matchPattern"),
+          "replacementPattern": el.getAttribute("replacementPattern")
+        };
       }
-      if (reason === "escape-key" && refs.domReference.current) {
-        addPreviouslyFocusedElement(refs.domReference.current);
+      for (let node of Array.from(el.childNodes)) {
+        if (node.nodeType == 1) {
+          newElement.appendChild(convertEl(node));
+        } else {
+          newElement.appendChild(node.cloneNode());
+        }
       }
-      if (reason === "hover" && event.type === "mouseleave") {
-        preventReturnFocusRef.current = true;
+      if (perElementFn) {
+        perElementFn(newElement, el);
       }
-      if (reason !== "outside-press") return;
-      if (nested) {
-        preventReturnFocusRef.current = false;
-        preventReturnFocusScroll = true;
-      } else {
-        preventReturnFocusRef.current = !(isVirtualClick(event) || isVirtualPointerEvent(event));
+      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));
       }
-    }
-    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);
+      if (node.nodeType == 7) {
+        this.dom.appendChild(this.document.importNode(node, true));
       }
-      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 (node.nodeType == 8) {
+        this.dom.appendChild(this.document.importNode(node, true));
       }
-      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");
+    }
+    this.utilities.dom = this.dom.firstElementChild;
+    if (callback) {
+      callback(this.dom, this);
+      if (window) {
+        window.dispatchEvent(ceteiceanLoad);
       }
-    };
-    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;
+    } else {
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(ceteiceanLoad);
+      }
+      return this.dom;
     }
-    return /* @__PURE__ */ React.createElement(VisuallyHiddenDismiss, {
-      ref: location === "start" ? startDismissButtonRef : endDismissButtonRef,
-      onClick: (event) => onOpenChange(false, event.nativeEvent)
-    }, typeof visuallyHiddenDismiss === "string" ? visuallyHiddenDismiss : "Dismiss");
   }
-  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();
-        }
+  /* 
+    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);
       }
-    }
-  }), !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();
-        }
+    } else {
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(ceteiceanLoad);
       }
+      return this.dom;
     }
-  }));
-}
-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 = {};
   }
-  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;
+  /*
+    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);
     }
-    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;
+  }
+  /* 
+    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;
+  }
+  /* 
+    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);
+      }
+    } else {
+      return function() {
+        if (!this.hasAttribute("data-processed")) {
+          let content = fn.call(self.utilities, this);
+          if (content) {
+            self.appendBasic(this, content);
           }
-        });
-        if (!shouldDismiss) {
-          return;
         }
-      }
-    }
-    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;
+  }
+  appendBasic(elt, content) {
+    if (this.discardContent) {
+      elt.innerHTML = "";
+    } else {
+      hideContent(elt, true);
     }
-    if (typeof outsidePress === "function" && !outsidePress(event)) {
-      return;
+    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);
     }
-    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;
+  }
+  /* 
+    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) {
+      };
     }
-    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 (Array.isArray(template) && !Array.isArray(template[0])) {
+      return this.applyDecorator(template);
     }
-    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;
+    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);
+          }
         }
       }
-      if (xCond || canScrollX && event.offsetY > target.clientHeight) {
-        return;
+    };
+  }
+  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);
+    };
+  }
+  /* 
+    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 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;
-    }
-    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;
+  }
+  /* 
+    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]));
       }
     }
-    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));
+  }
+  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);
       }
     }
-    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");
+    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));
+      }
+      if (strings.length > 1) {
+        content.innerHTML += strings[1];
+        content.setAttribute("data-after", strings[1].replace(/<[^>]+>/g, "").length);
       }
     }
-  }), [closeOnEscapeKeyDown, onOpenChange, referencePress, referencePressEvent]);
-  const floating = React.useMemo(() => ({
-    onKeyDown: closeOnEscapeKeyDown,
-    onMouseDown() {
-      endedOrStartedInsideRef.current = true;
-    },
-    onMouseUp() {
-      endedOrStartedInsideRef.current = true;
-    },
-    [captureHandlerKeys[outsidePressEvent]]: () => {
-      insideReactTreeRef.current = true;
-    }
-  }), [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.");
+    if (content.childNodes.length < 2) {
+      return content.firstChild;
+    } else {
+      return content;
     }
   }
-  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
+  // 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 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;
+    for (let node of Array.from(elt.childNodes)) {
+      if (node.nodeType === 1) {
+        this.processElement(node);
+      }
     }
-  });
-  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;
   }
-  return {
-    ...elementKey === "floating" && {
-      tabIndex: -1
-    },
-    ...domUserProps,
-    ...propsList.map((value) => {
-      const propsOrGetProps = value ? value[elementKey] : null;
-      if (typeof propsOrGetProps === "function") {
-        return userProps ? propsOrGetProps(userProps) : null;
-      }
-      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;
-        }
-        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);
-            };
+  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 {
-          acc[key] = value;
+          result = result.replace(replacements[0], "");
         }
-      });
-      return acc;
-    }, {})
-  };
-}
-function useInteractions(propsList) {
-  if (propsList === void 0) {
-    propsList = [];
+      }
+    }
+    return result;
   }
-  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]);
-}
-const componentRoleToAriaRoleMap = /* @__PURE__ */ new Map([["select", "listbox"], ["combobox", "listbox"], ["label", false]]);
-function useRole(context, props) {
-  var _componentRoleToAriaR;
-  if (props === void 0) {
-    props = {};
+  // 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);
+    }
   }
-  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
-      };
+  /* 
+    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);
     }
-    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
+  }
+  /* 
+    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", "");
+          }
+        }
       }
-    };
-    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
-          }
-        };
+  }
+  /**********************
+   * 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);
       }
+    } else {
+      setTimeout(function() {
+        let h = this.document.querySelector(window.decodeURI(window.location.hash));
+        if (h) {
+          h.scrollIntoView();
+        }
+      }, 100);
     }
-    return {};
-  }, [floatingId, role]);
-  return React.useMemo(() => enabled ? {
-    reference,
-    floating,
-    item
-  } : {}, [enabled, reference, floating, item]);
+  }
+}
+try {
+  if (typeof window !== "undefined") {
+    window.CETEI = CETEI;
+    window.addEventListener("beforeunload", CETEI.savePosition);
+    var ceteiceanLoad = new Event("ceteiceanload");
+    window.addEventListener("ceteiceanload", CETEI.restorePosition);
+  }
+} catch (e) {
+  console.log(e);
 }
 export {
-  FloatingFocusManager,
-  FloatingPortal,
-  flip,
-  getOverflowAncestors,
-  inline,
-  offset,
-  shift,
-  useDismiss,
-  useFloating,
-  useFloatingParentNodeId,
-  useFloatingPortalNode,
-  useFloatingRootContext,
-  useFloatingTree,
-  useId,
-  useInteractions,
-  useRole
+  CETEI as default
 };
 //# sourceMappingURL=react-text-annotator.es11.js.map