@soomo/text-annotator 3.1.0-staging.24 → 3.1.0-staging.25

package/dist/text-annotator.es.js

@@ -1,1430 +1,2470 @@
-import debounce from "debounce";
-import { colord } from "colord";
-import { dequal } from "dequal/lite";
-import { v4 } from "uuid";
-import { serializeW3CBodies, parseW3CBodies, parseW3CUser, createStore, createSelectionState, createHoverState, createViewportState, Origin, createAnonymousGuest, createUndoStack, createLifecycleObserver, createBaseAnnotator } from "@annotorious/core";
-import { Origin as Origin2, UserSelectAction, createBody } from "@annotorious/core";
-import RBush from "rbush";
-import { createNanoEvents } from "nanoevents";
-import hotkeys from "hotkeys-js";
-import { poll } from "poll";
-const NOT_ANNOTATABLE_CLASS = "not-annotatable";
-const NOT_ANNOTATABLE_SELECTOR = `.${NOT_ANNOTATABLE_CLASS}`;
-const isNotAnnotatable = (node) => {
-  var _a;
-  const closestNotAnnotatable = node instanceof HTMLElement ? node.closest(NOT_ANNOTATABLE_SELECTOR) : (_a = node.parentElement) == null ? void 0 : _a.closest(NOT_ANNOTATABLE_SELECTOR);
-  return Boolean(closestNotAnnotatable);
-};
-const isRangeAnnotatable = (range) => {
-  const ancestor = range.commonAncestorContainer;
-  return !isNotAnnotatable(ancestor);
-};
-const cancelSingleClickEvents = (container) => container.addEventListener("click", (event) => {
-  const targetElement = event.target;
-  const shouldPrevent = (
-    // Allow clicks within not-annotatable elements
-    !targetElement.closest(NOT_ANNOTATABLE_SELECTOR) && !event.target.closest("a")
-  );
-  if (shouldPrevent)
-    event.preventDefault();
-});
-const isMac = /mac/i.test(navigator.userAgentData ? navigator.userAgentData.platform : navigator.platform);
-const programmaticallyFocusable = (container) => {
-  if (!container.hasAttribute("tabindex") && container.tabIndex < 0) {
-    container.setAttribute("tabindex", "-1");
-  }
-  container.classList.add("no-focus-outline");
-};
-const iterateNotAnnotatableElements = function* (range) {
-  const notAnnotatableIterator = document.createNodeIterator(
-    range.commonAncestorContainer,
+const ue = "not-annotatable", et = `.${ue}`, st = (t) => {
+  var n;
+  return !!(t instanceof HTMLElement ? t.closest(et) : (n = t.parentElement) == null ? void 0 : n.closest(et));
+}, Re = (t) => {
+  const e = t.commonAncestorContainer;
+  return !st(e);
+}, Me = (t) => t.addEventListener("click", (e) => {
+  // Allow clicks within not-annotatable elements
+  !e.target.closest(et) && !e.target.closest("a") && e.preventDefault();
+}), ke = /mac/i.test(navigator.userAgentData ? navigator.userAgentData.platform : navigator.platform), Ie = (t) => {
+  !t.hasAttribute("tabindex") && t.tabIndex < 0 && t.setAttribute("tabindex", "-1"), t.classList.add("no-focus-outline");
+}, Ne = function* (t) {
+  const e = document.createNodeIterator(
+    t.commonAncestorContainer,
     NodeFilter.SHOW_ELEMENT,
-    (node) => node instanceof HTMLElement && node.classList.contains(NOT_ANNOTATABLE_CLASS) && !node.parentElement.closest(NOT_ANNOTATABLE_SELECTOR) && range.intersectsNode(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP
+    (o) => o instanceof HTMLElement && o.classList.contains(ue) && !o.parentElement.closest(et) && t.intersectsNode(o) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP
   );
-  let notAnnotatableNode;
-  while (notAnnotatableNode = notAnnotatableIterator.nextNode()) {
-    if (notAnnotatableNode instanceof HTMLElement) {
-      yield notAnnotatableNode;
-    }
+  let n;
+  for (; n = e.nextNode(); )
+    n instanceof HTMLElement && (yield n);
+}, _e = (t) => {
+  if (!Re(t)) return [];
+  const e = [];
+  let n = null;
+  for (const o of Ne(t)) {
+    let i;
+    n ? (i = document.createRange(), i.setStartAfter(n), i.setEndBefore(o)) : (i = t.cloneRange(), i.setEndBefore(o)), i.collapsed || e.push(i), n = o;
   }
-};
-const splitAnnotatableRanges = (range) => {
-  if (!isRangeAnnotatable(range)) return [];
-  const annotatableRanges = [];
-  let prevNotAnnotatable = null;
-  for (const notAnnotatable of iterateNotAnnotatableElements(range)) {
-    let subRange;
-    if (!prevNotAnnotatable) {
-      subRange = range.cloneRange();
-      subRange.setEndBefore(notAnnotatable);
-    } else {
-      subRange = document.createRange();
-      subRange.setStartAfter(prevNotAnnotatable);
-      subRange.setEndBefore(notAnnotatable);
-    }
-    if (!subRange.collapsed)
-      annotatableRanges.push(subRange);
-    prevNotAnnotatable = notAnnotatable;
+  if (n) {
+    const o = t.cloneRange();
+    o.setStartAfter(n), o.collapsed || e.push(o);
   }
-  if (prevNotAnnotatable) {
-    const lastRange = range.cloneRange();
-    lastRange.setStartAfter(prevNotAnnotatable);
-    if (!lastRange.collapsed) {
-      annotatableRanges.push(lastRange);
-    }
-  }
-  return annotatableRanges.length > 0 ? annotatableRanges : [range];
-};
-const getRangeAnnotatableContents = (range) => {
-  const contents = range.cloneContents();
-  contents.querySelectorAll(NOT_ANNOTATABLE_SELECTOR).forEach((el) => el.remove());
-  return contents;
-};
-const getQuoteContext = (range, container, length = 10, offsetReferenceSelector) => {
-  const offsetReference = offsetReferenceSelector ? range.startContainer.parentElement.closest(offsetReferenceSelector) : container;
-  const rangeBefore = document.createRange();
-  rangeBefore.setStart(offsetReference, 0);
-  rangeBefore.setEnd(range.startContainer, range.startOffset);
-  const before = getRangeAnnotatableContents(rangeBefore).textContent;
-  const rangeAfter = document.createRange();
-  rangeAfter.setStart(range.endContainer, range.endOffset);
-  if (offsetReference === document.body)
-    rangeAfter.setEnd(offsetReference, offsetReference.childNodes.length);
-  else
-    rangeAfter.setEndAfter(offsetReference);
-  const after = getRangeAnnotatableContents(rangeAfter).textContent;
+  return e.length > 0 ? e : [t];
+}, Kt = (t) => {
+  const e = t.cloneContents();
+  return e.querySelectorAll(et).forEach((n) => n.remove()), e;
+}, Ue = (t, e, n = 10, o) => {
+  const i = o ? t.startContainer.parentElement.closest(o) : e, s = document.createRange();
+  s.setStart(i, 0), s.setEnd(t.startContainer, t.startOffset);
+  const a = Kt(s).textContent, r = document.createRange();
+  r.setStart(t.endContainer, t.endOffset), i === document.body ? r.setEnd(i, i.childNodes.length) : r.setEndAfter(i);
+  const l = Kt(r).textContent;
   return {
-    prefix: before.substring(before.length - length),
-    suffix: after.substring(0, length)
-  };
-};
-const isRevived = (selector) => selector.every((s) => s.range instanceof Range && !s.range.collapsed);
-const whitespaceOrEmptyRegex = /^\s*$/;
-const isWhitespaceOrEmpty = (range) => whitespaceOrEmptyRegex.test(range.toString());
-const getRelation = (rectA, rectB) => {
-  const round = (num) => Math.round(num * 10) / 10;
-  const a = {
-    top: round(rectA.top),
-    bottom: round(rectA.bottom),
-    left: round(rectA.left),
-    right: round(rectA.right)
-  };
-  const b = {
-    top: round(rectB.top),
-    bottom: round(rectB.bottom),
-    left: round(rectB.left),
-    right: round(rectB.right)
-  };
-  if (Math.abs(a.top - b.top) < 0.5 && Math.abs(a.bottom - b.bottom) < 0.5) {
-    if (Math.abs(a.left - b.right) < 0.5 || Math.abs(a.right - b.left) < 0.5)
+    prefix: a.substring(a.length - n),
+    suffix: l.substring(0, n)
+  };
+}, F = (t) => t.every((e) => e.range instanceof Range && !e.range.collapsed), De = /^\s*$/, Ve = (t) => De.test(t.toString()), Ye = (t, e) => {
+  const n = (s) => Math.round(s * 10) / 10, o = {
+    top: n(t.top),
+    bottom: n(t.bottom),
+    left: n(t.left),
+    right: n(t.right)
+  }, i = {
+    top: n(e.top),
+    bottom: n(e.bottom),
+    left: n(e.left),
+    right: n(e.right)
+  };
+  if (Math.abs(o.top - i.top) < 0.5 && Math.abs(o.bottom - i.bottom) < 0.5) {
+    if (Math.abs(o.left - i.right) < 0.5 || Math.abs(o.right - i.left) < 0.5)
       return "inline-adjacent";
-    if (a.left >= b.left && a.right <= b.right)
+    if (o.left >= i.left && o.right <= i.right)
       return "inline-is-contained";
-    if (a.left <= b.left && a.right >= b.right)
+    if (o.left <= i.left && o.right >= i.right)
       return "inline-contains";
-  } else {
-    if (a.top <= b.top && a.bottom >= b.bottom) {
-      if (a.left <= b.left && a.right >= b.right) {
-        return "block-contains";
-      }
-    } else if (a.top >= b.top && a.bottom <= b.bottom) {
-      if (a.left >= b.left && a.right <= b.right) {
-        return "block-is-contained";
-      }
-    }
-  }
-};
-const union = (a, b) => {
-  const left = Math.min(a.left, b.left);
-  const right = Math.max(a.right, b.right);
-  const top = Math.min(a.top, b.top);
-  const bottom = Math.max(a.bottom, b.bottom);
-  return new DOMRect(left, top, right - left, bottom - top);
-};
-const mergeClientRects = (rects) => rects.reduce((merged, rectA) => {
-  if (rectA.width === 0 || rectA.height === 0)
-    return merged;
-  let next = [...merged];
-  let wasMerged = false;
-  for (const rectB of merged) {
-    const relation = getRelation(rectA, rectB);
-    if (relation === "inline-adjacent") {
-      next = next.map((r) => r === rectB ? union(rectA, rectB) : r);
-      wasMerged = true;
+  } else if (o.top <= i.top && o.bottom >= i.bottom) {
+    if (o.left <= i.left && o.right >= i.right)
+      return "block-contains";
+  } else if (o.top >= i.top && o.bottom <= i.bottom && o.left >= i.left && o.right <= i.right)
+    return "block-is-contained";
+}, Ke = (t, e) => {
+  const n = Math.min(t.left, e.left), o = Math.max(t.right, e.right), i = Math.min(t.top, e.top), s = Math.max(t.bottom, e.bottom);
+  return new DOMRect(n, i, o - n, s - i);
+}, Pe = (t) => t.reduce((e, n) => {
+  if (n.width === 0 || n.height === 0)
+    return e;
+  let o = [...e], i = !1;
+  for (const s of e) {
+    const a = Ye(n, s);
+    if (a === "inline-adjacent") {
+      o = o.map((r) => r === s ? Ke(n, s) : r), i = !0;
       break;
-    } else if (relation === "inline-contains") {
-      next = next.map((r) => r === rectB ? rectA : r);
-      wasMerged = true;
+    } else if (a === "inline-contains") {
+      o = o.map((r) => r === s ? n : r), i = !0;
       break;
-    } else if (relation === "inline-is-contained") {
-      wasMerged = true;
+    } else if (a === "inline-is-contained") {
+      i = !0;
       break;
-    } else if (relation === "block-contains" || relation === "block-is-contained") {
-      if (rectA.width < rectB.width) {
-        next = next.map((r) => r === rectB ? rectA : r);
-      }
-      wasMerged = true;
+    } else if (a === "block-contains" || a === "block-is-contained") {
+      n.width < s.width && (o = o.map((r) => r === s ? n : r)), i = !0;
       break;
     }
   }
-  return wasMerged ? next : [...next, rectA];
-}, []);
-const toDomRectList = (rects) => ({
-  length: rects.length,
-  item: (index) => rects[index],
+  return i ? o : [...o, n];
+}, []), Mo = (t) => ({
+  length: t.length,
+  item: (e) => t[e],
   [Symbol.iterator]: function* () {
-    for (let i = 0; i < this.length; i++)
-      yield this.item(i);
+    for (let e = 0; e < this.length; e++)
+      yield this.item(e);
   }
-});
-const rangeToSelector = (range, container, offsetReferenceSelector) => {
-  const rangeBefore = document.createRange();
-  const offsetReference = offsetReferenceSelector ? range.startContainer.parentElement.closest(offsetReferenceSelector) : container;
-  rangeBefore.setStart(offsetReference, 0);
-  rangeBefore.setEnd(range.startContainer, range.startOffset);
-  const before = getRangeAnnotatableContents(rangeBefore).textContent;
-  const quote = range.toString();
-  const start = before.length || 0;
-  const end = start + quote.length;
-  return offsetReferenceSelector ? { quote, start, end, range, offsetReference } : { quote, start, end, range };
-};
-const reviveSelector = (selector, container) => {
-  var _a, _b;
-  const { start, end } = selector;
-  const offsetReference = selector.offsetReference || container;
-  const iterator = document.createNodeIterator(
-    container,
+}), Xe = (t, e, n) => {
+  const o = document.createRange(), i = n ? t.startContainer.parentElement.closest(n) : e;
+  o.setStart(i, 0), o.setEnd(t.startContainer, t.startOffset);
+  const s = Kt(o).textContent, a = t.toString(), r = s.length || 0, l = r + a.length;
+  return n ? { quote: a, start: r, end: l, range: t, offsetReference: i } : { quote: a, start: r, end: l, range: t };
+}, fe = (t, e) => {
+  var g, u;
+  const { start: n, end: o } = t, i = t.offsetReference || e, s = document.createNodeIterator(
+    e,
     NodeFilter.SHOW_TEXT,
-    (node) => {
-      var _a2;
-      return ((_a2 = node.parentElement) == null ? void 0 : _a2.closest(NOT_ANNOTATABLE_SELECTOR)) ? NodeFilter.FILTER_SKIP : NodeFilter.FILTER_ACCEPT;
+    (f) => {
+      var A;
+      return (A = f.parentElement) != null && A.closest(et) ? NodeFilter.FILTER_SKIP : NodeFilter.FILTER_ACCEPT;
     }
   );
-  let runningOffset = 0;
-  const range = document.createRange();
-  let n = iterator.nextNode();
-  if (n === null) console.error("Could not revive annotation target. Content missing.");
-  let startCounting = !offsetReference;
-  while (n !== null) {
-    startCounting || (startCounting = offsetReference == null ? void 0 : offsetReference.contains(n));
-    if (startCounting) {
-      const len = ((_a = n.textContent) == null ? void 0 : _a.length) || 0;
-      if (runningOffset + len > start) {
-        range.setStart(n, start - runningOffset);
+  let a = 0;
+  const r = document.createRange();
+  let l = s.nextNode();
+  l === null && console.error("Could not revive annotation target. Content missing.");
+  let d = !i;
+  for (; l !== null; ) {
+    if (d || (d = i == null ? void 0 : i.contains(l)), d) {
+      const f = ((g = l.textContent) == null ? void 0 : g.length) || 0;
+      if (a + f > n) {
+        r.setStart(l, n - a);
         break;
       }
-      runningOffset += len;
+      a += f;
     }
-    n = iterator.nextNode();
+    l = s.nextNode();
   }
-  while (n !== null) {
-    const len = ((_b = n.textContent) == null ? void 0 : _b.length) || 0;
-    if (runningOffset + len >= end) {
-      range.setEnd(n, end - runningOffset);
+  for (; l !== null; ) {
+    const f = ((u = l.textContent) == null ? void 0 : u.length) || 0;
+    if (a + f >= o) {
+      r.setEnd(l, o - a);
       break;
     }
-    runningOffset += len;
-    n = iterator.nextNode();
+    a += f, l = s.nextNode();
   }
   return {
-    ...selector,
-    range
-  };
-};
-const reviveTarget = (target, container) => isRevived(target.selector) ? target : {
-  ...target,
-  selector: target.selector.map((s) => s.range instanceof Range && !s.range.collapsed ? s : reviveSelector(s, container))
-};
-const reviveAnnotation = (annotation, container) => isRevived(annotation.target.selector) ? annotation : { ...annotation, target: reviveTarget(annotation.target, container) };
-const clonedNodeContains = (clonedNode, targetNode) => {
-  if (clonedNode.isEqualNode(targetNode)) {
-    return true;
-  }
-  for (let child of clonedNode.childNodes) {
-    if (clonedNodeContains(child, targetNode)) {
-      return true;
+    ...t,
+    range: r
+  };
+}, vt = (t, e) => F(t.selector) ? t : {
+  ...t,
+  selector: t.selector.map((n) => n.range instanceof Range && !n.range.collapsed ? n : fe(n, e))
+}, Ct = (t, e) => F(t.target.selector) ? t : { ...t, target: vt(t.target, e) }, he = (t, e) => {
+  if (t.isEqualNode(e))
+    return !0;
+  for (let n of t.childNodes)
+    if (he(n, e))
+      return !0;
+  return !1;
+}, $e = (t, e) => {
+  const n = t.cloneContents();
+  return he(n, e);
+}, He = (t, e) => {
+  const n = t.cloneRange(), o = e.contains(n.startContainer), i = e.contains(n.endContainer);
+  return !o && !i && !$e(n, e) ? (n.collapse(), n) : (o || n.setStart(e, 0), i || n.setEnd(e, e.childNodes.length), n);
+}, Lt = (t) => ({
+  ...t,
+  type: t.type,
+  x: t.x,
+  y: t.y,
+  clientX: t.clientX,
+  clientY: t.clientY,
+  offsetX: t.offsetX,
+  offsetY: t.offsetY,
+  screenX: t.screenX,
+  screenY: t.screenY,
+  isPrimary: t.isPrimary,
+  altKey: t.altKey,
+  ctrlKey: t.ctrlKey,
+  metaKey: t.metaKey,
+  shiftKey: t.shiftKey,
+  button: t.button,
+  buttons: t.buttons,
+  currentTarget: t.currentTarget,
+  target: t.target,
+  defaultPrevented: t.defaultPrevented,
+  detail: t.detail,
+  eventPhase: t.eventPhase,
+  pointerId: t.pointerId,
+  pointerType: t.pointerType,
+  timeStamp: t.timeStamp
+}), pt = (t) => ({
+  ...t,
+  type: t.type,
+  key: t.key,
+  code: t.code,
+  location: t.location,
+  repeat: t.repeat,
+  altKey: t.altKey,
+  ctrlKey: t.ctrlKey,
+  metaKey: t.metaKey,
+  shiftKey: t.shiftKey,
+  currentTarget: t.currentTarget,
+  target: t.target,
+  defaultPrevented: t.defaultPrevented,
+  detail: t.detail,
+  timeStamp: t.timeStamp
+}), je = (t, e) => {
+  const { left: n, top: o, right: i, bottom: s } = t;
+  return new DOMRect(n - e.left, o - e.top, i - n, s - o);
+}, ko = (t, e) => {
+  const { left: n, top: o, right: i, bottom: s } = t;
+  return new DOMRect(n + e.left, o + e.top, i - n, s - o);
+}, pe = (t) => {
+  if (t === null)
+    return document.scrollingElement;
+  const { overflowY: e } = window.getComputedStyle(t);
+  return e !== "visible" && e !== "hidden" && t.scrollHeight > t.clientHeight ? t : pe(t.parentElement);
+}, ze = (t, e) => (n) => {
+  const o = typeof n == "string" ? n : n.id, i = (a) => {
+    const r = s.getBoundingClientRect(), l = s.clientHeight, d = s.clientWidth, g = a.selector[0].range.getBoundingClientRect(), { width: u, height: f } = e.getAnnotationBounds(o), A = g.top - r.top, p = g.left - r.left, b = s.parentElement ? s.scrollTop : 0, x = s.parentElement ? s.scrollLeft : 0, m = A + b - (l - f) / 2, c = p + x - (d - u) / 2;
+    s.scroll({ top: m, left: c, behavior: "smooth" });
+  }, s = pe(t);
+  if (s) {
+    const a = e.getAnnotation(o), { range: r } = a.target.selector[0];
+    if (r && !r.collapsed)
+      return i(a.target), !0;
+    {
+      const l = vt(a.target, t), { range: d } = l.selector[0];
+      if (d && !d.collapsed)
+        return i(l), !0;
     }
   }
-  return false;
-};
-const rangeContains = (range, node) => {
-  const rangeContents = range.cloneContents();
-  return clonedNodeContains(rangeContents, node);
+  return !1;
+}, q = {
+  fill: "rgb(0, 128, 255)",
+  fillOpacity: 0.18
+}, Et = {
+  fill: "rgb(0, 128, 255)",
+  fillOpacity: 0.45
+}, Fe = (t, e, n, o, i) => {
+  var a, r;
+  const s = n ? typeof n == "function" ? n(t.annotation, t.state, i) || ((a = t.state) != null && a.selected ? Et : q) : n : (r = t.state) != null && r.selected ? Et : q;
+  return o && o.paint(t, e) || s;
 };
-const trimRangeToContainer = (range, container) => {
-  const trimmedRange = range.cloneRange();
-  const containsRangeStart = container.contains(trimmedRange.startContainer);
-  const containsRangeEnd = container.contains(trimmedRange.endContainer);
-  if (!containsRangeStart && !containsRangeEnd) {
-    const containedWithinRange = rangeContains(trimmedRange, container);
-    if (!containedWithinRange) {
-      trimmedRange.collapse();
-      return trimmedRange;
+function We(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var gt = { exports: {} }, zt;
+function qe() {
+  if (zt) return gt.exports;
+  zt = 1;
+  function t(e, n = 100, o = {}) {
+    if (typeof e != "function")
+      throw new TypeError(`Expected the first parameter to be a function, got \`${typeof e}\`.`);
+    if (n < 0)
+      throw new RangeError("`wait` must not be negative.");
+    const { immediate: i } = typeof o == "boolean" ? { immediate: o } : o;
+    let s, a, r, l, d;
+    function g() {
+      const A = s, p = a;
+      return s = void 0, a = void 0, d = e.apply(A, p), d;
     }
+    function u() {
+      const A = Date.now() - l;
+      A < n && A >= 0 ? r = setTimeout(u, n - A) : (r = void 0, i || (d = g()));
+    }
+    const f = function(...A) {
+      if (s && this !== s && Object.getPrototypeOf(this) === Object.getPrototypeOf(s))
+        throw new Error("Debounced method called with different contexts of the same prototype.");
+      s = this, a = A, l = Date.now();
+      const p = i && !r;
+      return r || (r = setTimeout(u, n)), p && (d = g()), d;
+    };
+    return Object.defineProperty(f, "isPending", {
+      get() {
+        return r !== void 0;
+      }
+    }), f.clear = () => {
+      r && (clearTimeout(r), r = void 0);
+    }, f.flush = () => {
+      r && f.trigger();
+    }, f.trigger = () => {
+      d = g(), f.clear();
+    }, f;
   }
-  if (!containsRangeStart) {
-    trimmedRange.setStart(container, 0);
+  return gt.exports.debounce = t, gt.exports = t, gt.exports;
+}
+var Ge = /* @__PURE__ */ qe();
+const Xt = /* @__PURE__ */ We(Ge), Qe = (t) => {
+  const { top: e, left: n } = t.getBoundingClientRect(), { innerWidth: o, innerHeight: i } = window, s = -n, a = -e, r = o - n, l = i - e;
+  return { top: e, left: n, minX: s, minY: a, maxX: r, maxY: l };
+}, Je = (t) => {
+  let e = /* @__PURE__ */ new Set();
+  return (o) => {
+    const i = o.map((s) => s.id);
+    (e.size !== i.length || i.some((s) => !e.has(s))) && t.set(i), e = new Set(i);
+  };
+}, $t = (t, e, n, o) => {
+  const { store: i, selection: s, hover: a } = e;
+  let r, l, d;
+  const g = Je(n), u = (T) => {
+    const { x: R, y: w } = t.getBoundingClientRect(), v = i.getAt(T.clientX - R, T.clientY - w, !1, l);
+    v ? a.current !== v.id && (t.classList.add("hovered"), a.set(v.id)) : a.current && (t.classList.remove("hovered"), a.set(null));
+  };
+  t.addEventListener("pointermove", u);
+  const f = (T = !1) => {
+    d && d.clear();
+    const R = Qe(t), { minX: w, minY: v, maxX: h, maxY: E } = R, M = l ? i.getIntersecting(w, v, h, E).filter(({ annotation: _ }) => l(_)) : i.getIntersecting(w, v, h, E), O = s.selected.map(({ id: _ }) => _), U = M.map(({ annotation: _, rects: ht }) => {
+      const W = O.includes(_.id), G = _.id === a.current;
+      return { annotation: _, rects: ht, state: { selected: W, hover: G } };
+    });
+    o.redraw(U, R, r, d, T), setTimeout(() => g(M.map(({ annotation: _ }) => _)), 1);
+  }, A = (T) => {
+    d = T, f();
+  }, p = (T) => {
+    r = T, f();
+  }, b = (T) => {
+    l = T, f(!1);
+  }, x = () => f();
+  i.observe(x);
+  const m = s.subscribe(() => f()), c = () => f(!0);
+  document.addEventListener("scroll", c, { capture: !0, passive: !0 });
+  const y = Xt(() => {
+    i.recalculatePositions(), d == null || d.reset(), f();
+  }, 10);
+  window.addEventListener("resize", y);
+  const C = new ResizeObserver(y);
+  C.observe(t);
+  const S = { attributes: !0, childList: !0, subtree: !0 }, L = new MutationObserver((T) => {
+    T.every((w) => w.target === t || t.contains(w.target)) || f(!0);
+  });
+  return L.observe(document.body, S), {
+    destroy: () => {
+      t.removeEventListener("pointermove", u), o.destroy(), i.unobserve(x), m(), document.removeEventListener("scroll", c), y.clear(), window.removeEventListener("resize", y), C.disconnect(), L.disconnect();
+    },
+    redraw: f,
+    setStyle: p,
+    setFilter: b,
+    setPainter: A,
+    setVisible: o.setVisible
+  };
+}, Ze = () => {
+  const t = document.createElement("canvas");
+  return t.width = window.innerWidth, t.height = window.innerHeight, t.className = "r6o-canvas-highlight-layer bg", t;
+}, tn = (t, e) => {
+  t.width = window.innerWidth, t.height = window.innerHeight;
+}, en = (t) => {
+  t.classList.add("r6o-annotatable");
+  const e = Ze(), n = e.getContext("2d");
+  document.body.appendChild(e);
+  const o = (r, l, d, g) => requestAnimationFrame(() => {
+    const { width: u, height: f } = e;
+    n.clearRect(-0.5, -0.5, u + 1, f + 1), g && g.clear();
+    const { top: A, left: p } = l;
+    [...r].sort((x, m) => {
+      const { annotation: { target: { created: c } } } = x, { annotation: { target: { created: y } } } = m;
+      return c.getTime() - y.getTime();
+    }).forEach((x) => {
+      var C;
+      const m = d ? typeof d == "function" ? d(x.annotation, x.state) : d : (C = x.state) != null && C.selected ? Et : q, c = g && g.paint(x, l) || m, y = x.rects.map(({ x: S, y: L, width: B, height: T }) => ({
+        x: S + p,
+        y: L + A,
+        width: B,
+        height: T
+      }));
+      if (n.fillStyle = c.fill, n.globalAlpha = c.fillOpacity || 1, y.forEach(
+        ({ x: S, y: L, width: B, height: T }) => n.fillRect(S, L, B, T)
+      ), c.underlineColor) {
+        n.globalAlpha = 1, n.strokeStyle = c.underlineColor, n.lineWidth = c.underlineThickness ?? 1;
+        const S = c.underlineOffset ?? 0;
+        y.forEach(({ x: L, y: B, width: T, height: R }) => {
+          n.beginPath(), n.moveTo(L, B + R + S), n.lineTo(L + T, B + R + S), n.stroke();
+        });
+      }
+    });
+  }), i = Xt(() => tn(e), 10);
+  return window.addEventListener("resize", i), {
+    destroy: () => {
+      e.remove(), i.clear(), window.removeEventListener("resize", i);
+    },
+    setVisible: (r) => {
+      console.log("setVisible not implemented on Canvas renderer");
+    },
+    redraw: o
+  };
+}, nn = (t, e, n) => $t(t, e, n, en(t));
+var on = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) }, j = function(t) {
+  return typeof t == "string" ? t.length > 0 : typeof t == "number";
+}, D = function(t, e, n) {
+  return e === void 0 && (e = 0), n === void 0 && (n = Math.pow(10, e)), Math.round(n * t) / n + 0;
+}, P = function(t, e, n) {
+  return e === void 0 && (e = 0), n === void 0 && (n = 1), t > n ? n : t > e ? t : e;
+}, ge = function(t) {
+  return (t = isFinite(t) ? t % 360 : 0) > 0 ? t : t + 360;
+}, Ft = function(t) {
+  return { r: P(t.r, 0, 255), g: P(t.g, 0, 255), b: P(t.b, 0, 255), a: P(t.a) };
+}, Tt = function(t) {
+  return { r: D(t.r), g: D(t.g), b: D(t.b), a: D(t.a, 3) };
+}, sn = /^#([0-9a-f]{3,8})$/i, mt = function(t) {
+  var e = t.toString(16);
+  return e.length < 2 ? "0" + e : e;
+}, me = function(t) {
+  var e = t.r, n = t.g, o = t.b, i = t.a, s = Math.max(e, n, o), a = s - Math.min(e, n, o), r = a ? s === e ? (n - o) / a : s === n ? 2 + (o - e) / a : 4 + (e - n) / a : 0;
+  return { h: 60 * (r < 0 ? r + 6 : r), s: s ? a / s * 100 : 0, v: s / 255 * 100, a: i };
+}, ye = function(t) {
+  var e = t.h, n = t.s, o = t.v, i = t.a;
+  e = e / 360 * 6, n /= 100, o /= 100;
+  var s = Math.floor(e), a = o * (1 - n), r = o * (1 - (e - s) * n), l = o * (1 - (1 - e + s) * n), d = s % 6;
+  return { r: 255 * [o, r, a, a, l, o][d], g: 255 * [l, o, o, r, a, a][d], b: 255 * [a, a, l, o, o, r][d], a: i };
+}, Wt = function(t) {
+  return { h: ge(t.h), s: P(t.s, 0, 100), l: P(t.l, 0, 100), a: P(t.a) };
+}, qt = function(t) {
+  return { h: D(t.h), s: D(t.s), l: D(t.l), a: D(t.a, 3) };
+}, Gt = function(t) {
+  return ye((n = (e = t).s, { h: e.h, s: (n *= ((o = e.l) < 50 ? o : 100 - o) / 100) > 0 ? 2 * n / (o + n) * 100 : 0, v: o + n, a: e.a }));
+  var e, n, o;
+}, ct = function(t) {
+  return { h: (e = me(t)).h, s: (i = (200 - (n = e.s)) * (o = e.v) / 100) > 0 && i < 200 ? n * o / 100 / (i <= 100 ? i : 200 - i) * 100 : 0, l: i / 2, a: e.a };
+  var e, n, o, i;
+}, rn = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i, an = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i, cn = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i, ln = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i, Qt = { string: [[function(t) {
+  var e = sn.exec(t);
+  return e ? (t = e[1]).length <= 4 ? { r: parseInt(t[0] + t[0], 16), g: parseInt(t[1] + t[1], 16), b: parseInt(t[2] + t[2], 16), a: t.length === 4 ? D(parseInt(t[3] + t[3], 16) / 255, 2) : 1 } : t.length === 6 || t.length === 8 ? { r: parseInt(t.substr(0, 2), 16), g: parseInt(t.substr(2, 2), 16), b: parseInt(t.substr(4, 2), 16), a: t.length === 8 ? D(parseInt(t.substr(6, 2), 16) / 255, 2) : 1 } : null : null;
+}, "hex"], [function(t) {
+  var e = cn.exec(t) || ln.exec(t);
+  return e ? e[2] !== e[4] || e[4] !== e[6] ? null : Ft({ r: Number(e[1]) / (e[2] ? 100 / 255 : 1), g: Number(e[3]) / (e[4] ? 100 / 255 : 1), b: Number(e[5]) / (e[6] ? 100 / 255 : 1), a: e[7] === void 0 ? 1 : Number(e[7]) / (e[8] ? 100 : 1) }) : null;
+}, "rgb"], [function(t) {
+  var e = rn.exec(t) || an.exec(t);
+  if (!e) return null;
+  var n, o, i = Wt({ h: (n = e[1], o = e[2], o === void 0 && (o = "deg"), Number(n) * (on[o] || 1)), s: Number(e[3]), l: Number(e[4]), a: e[5] === void 0 ? 1 : Number(e[5]) / (e[6] ? 100 : 1) });
+  return Gt(i);
+}, "hsl"]], object: [[function(t) {
+  var e = t.r, n = t.g, o = t.b, i = t.a, s = i === void 0 ? 1 : i;
+  return j(e) && j(n) && j(o) ? Ft({ r: Number(e), g: Number(n), b: Number(o), a: Number(s) }) : null;
+}, "rgb"], [function(t) {
+  var e = t.h, n = t.s, o = t.l, i = t.a, s = i === void 0 ? 1 : i;
+  if (!j(e) || !j(n) || !j(o)) return null;
+  var a = Wt({ h: Number(e), s: Number(n), l: Number(o), a: Number(s) });
+  return Gt(a);
+}, "hsl"], [function(t) {
+  var e = t.h, n = t.s, o = t.v, i = t.a, s = i === void 0 ? 1 : i;
+  if (!j(e) || !j(n) || !j(o)) return null;
+  var a = function(r) {
+    return { h: ge(r.h), s: P(r.s, 0, 100), v: P(r.v, 0, 100), a: P(r.a) };
+  }({ h: Number(e), s: Number(n), v: Number(o), a: Number(s) });
+  return ye(a);
+}, "hsv"]] }, Jt = function(t, e) {
+  for (var n = 0; n < e.length; n++) {
+    var o = e[n][0](t);
+    if (o) return [o, e[n][1]];
   }
-  if (!containsRangeEnd) {
-    trimmedRange.setEnd(container, container.childNodes.length);
+  return [null, void 0];
+}, dn = function(t) {
+  return typeof t == "string" ? Jt(t.trim(), Qt.string) : typeof t == "object" && t !== null ? Jt(t, Qt.object) : [null, void 0];
+}, Ot = function(t, e) {
+  var n = ct(t);
+  return { h: n.h, s: P(n.s + 100 * e, 0, 100), l: n.l, a: n.a };
+}, Bt = function(t) {
+  return (299 * t.r + 587 * t.g + 114 * t.b) / 1e3 / 255;
+}, Zt = function(t, e) {
+  var n = ct(t);
+  return { h: n.h, s: n.s, l: P(n.l + 100 * e, 0, 100), a: n.a };
+}, te = function() {
+  function t(e) {
+    this.parsed = dn(e)[0], this.rgba = this.parsed || { r: 0, g: 0, b: 0, a: 1 };
   }
-  return trimmedRange;
-};
-const clonePointerEvent = (event) => ({
-  ...event,
-  type: event.type,
-  x: event.x,
-  y: event.y,
-  clientX: event.clientX,
-  clientY: event.clientY,
-  offsetX: event.offsetX,
-  offsetY: event.offsetY,
-  screenX: event.screenX,
-  screenY: event.screenY,
-  isPrimary: event.isPrimary,
-  altKey: event.altKey,
-  ctrlKey: event.ctrlKey,
-  metaKey: event.metaKey,
-  shiftKey: event.shiftKey,
-  button: event.button,
-  buttons: event.buttons,
-  currentTarget: event.currentTarget,
-  target: event.target,
-  defaultPrevented: event.defaultPrevented,
-  detail: event.detail,
-  eventPhase: event.eventPhase,
-  pointerId: event.pointerId,
-  pointerType: event.pointerType,
-  timeStamp: event.timeStamp
-});
-const cloneKeyboardEvent = (event) => ({
-  ...event,
-  type: event.type,
-  key: event.key,
-  code: event.code,
-  location: event.location,
-  repeat: event.repeat,
-  altKey: event.altKey,
-  ctrlKey: event.ctrlKey,
-  metaKey: event.metaKey,
-  shiftKey: event.shiftKey,
-  currentTarget: event.currentTarget,
-  target: event.target,
-  defaultPrevented: event.defaultPrevented,
-  detail: event.detail,
-  timeStamp: event.timeStamp
-});
-const toParentBounds = (rect, offset) => {
-  const { left, top, right, bottom } = rect;
-  return new DOMRect(left - offset.left, top - offset.top, right - left, bottom - top);
+  return t.prototype.isValid = function() {
+    return this.parsed !== null;
+  }, t.prototype.brightness = function() {
+    return D(Bt(this.rgba), 2);
+  }, t.prototype.isDark = function() {
+    return Bt(this.rgba) < 0.5;
+  }, t.prototype.isLight = function() {
+    return Bt(this.rgba) >= 0.5;
+  }, t.prototype.toHex = function() {
+    return e = Tt(this.rgba), n = e.r, o = e.g, i = e.b, a = (s = e.a) < 1 ? mt(D(255 * s)) : "", "#" + mt(n) + mt(o) + mt(i) + a;
+    var e, n, o, i, s, a;
+  }, t.prototype.toRgb = function() {
+    return Tt(this.rgba);
+  }, t.prototype.toRgbString = function() {
+    return e = Tt(this.rgba), n = e.r, o = e.g, i = e.b, (s = e.a) < 1 ? "rgba(" + n + ", " + o + ", " + i + ", " + s + ")" : "rgb(" + n + ", " + o + ", " + i + ")";
+    var e, n, o, i, s;
+  }, t.prototype.toHsl = function() {
+    return qt(ct(this.rgba));
+  }, t.prototype.toHslString = function() {
+    return e = qt(ct(this.rgba)), n = e.h, o = e.s, i = e.l, (s = e.a) < 1 ? "hsla(" + n + ", " + o + "%, " + i + "%, " + s + ")" : "hsl(" + n + ", " + o + "%, " + i + "%)";
+    var e, n, o, i, s;
+  }, t.prototype.toHsv = function() {
+    return e = me(this.rgba), { h: D(e.h), s: D(e.s), v: D(e.v), a: D(e.a, 3) };
+    var e;
+  }, t.prototype.invert = function() {
+    return $({ r: 255 - (e = this.rgba).r, g: 255 - e.g, b: 255 - e.b, a: e.a });
+    var e;
+  }, t.prototype.saturate = function(e) {
+    return e === void 0 && (e = 0.1), $(Ot(this.rgba, e));
+  }, t.prototype.desaturate = function(e) {
+    return e === void 0 && (e = 0.1), $(Ot(this.rgba, -e));
+  }, t.prototype.grayscale = function() {
+    return $(Ot(this.rgba, -1));
+  }, t.prototype.lighten = function(e) {
+    return e === void 0 && (e = 0.1), $(Zt(this.rgba, e));
+  }, t.prototype.darken = function(e) {
+    return e === void 0 && (e = 0.1), $(Zt(this.rgba, -e));
+  }, t.prototype.rotate = function(e) {
+    return e === void 0 && (e = 15), this.hue(this.hue() + e);
+  }, t.prototype.alpha = function(e) {
+    return typeof e == "number" ? $({ r: (n = this.rgba).r, g: n.g, b: n.b, a: e }) : D(this.rgba.a, 3);
+    var n;
+  }, t.prototype.hue = function(e) {
+    var n = ct(this.rgba);
+    return typeof e == "number" ? $({ h: e, s: n.s, l: n.l, a: n.a }) : D(n.h);
+  }, t.prototype.isEqual = function(e) {
+    return this.toHex() === $(e).toHex();
+  }, t;
+}(), $ = function(t) {
+  return t instanceof te ? t : new te(t);
 };
-const toViewportBounds = (rect, offset) => {
-  const { left, top, right, bottom } = rect;
-  return new DOMRect(left + offset.left, top + offset.top, right - left, bottom - top);
-};
-const getScrollParent = (el) => {
-  if (el === null)
-    return document.scrollingElement;
-  const { overflowY } = window.getComputedStyle(el);
-  const isScrollable = overflowY !== "visible" && overflowY !== "hidden";
-  if (isScrollable && el.scrollHeight > el.clientHeight)
-    return el;
-  else
-    return getScrollParent(el.parentElement);
-};
-const scrollIntoView = (container, store) => (annotationOrId) => {
-  const id = typeof annotationOrId === "string" ? annotationOrId : annotationOrId.id;
-  const scroll = (target) => {
-    const parentBounds = scrollParent.getBoundingClientRect();
-    const parentHeight = scrollParent.clientHeight;
-    const parentWidth = scrollParent.clientWidth;
-    const annotationBounds = target.selector[0].range.getBoundingClientRect();
-    const { width, height } = store.getAnnotationBounds(id);
-    const offsetTop = annotationBounds.top - parentBounds.top;
-    const offsetLeft = annotationBounds.left - parentBounds.left;
-    const scrollTop = scrollParent.parentElement ? scrollParent.scrollTop : 0;
-    const scrollLeft = scrollParent.parentElement ? scrollParent.scrollLeft : 0;
-    const top = offsetTop + scrollTop - (parentHeight - height) / 2;
-    const left = offsetLeft + scrollLeft - (parentWidth - width) / 2;
-    scrollParent.scroll({ top, left, behavior: "smooth" });
+const un = (t) => [
+  `background-color:${$((t == null ? void 0 : t.fill) || q.fill).alpha((t == null ? void 0 : t.fillOpacity) === void 0 ? q.fillOpacity : t.fillOpacity).toHex()}`,
+  t != null && t.underlineThickness ? "text-decoration:underline" : void 0,
+  t != null && t.underlineColor ? `text-decoration-color:${t.underlineColor}` : void 0,
+  t != null && t.underlineOffset ? `text-underline-offset:${t.underlineOffset}px` : void 0,
+  t != null && t.underlineThickness ? `text-decoration-thickness:${t.underlineThickness}px` : void 0
+].filter(Boolean).join(";"), fn = () => {
+  const t = document.createElement("style");
+  document.getElementsByTagName("head")[0].appendChild(t);
+  let e = /* @__PURE__ */ new Set();
+  return {
+    destroy: () => {
+      CSS.highlights.clear(), t.remove();
+    },
+    setVisible: (s) => {
+      console.log("setVisible not implemented on CSS Custom Highlights renderer");
+    },
+    redraw: (s, a, r, l) => {
+      l && l.clear();
+      const d = new Set(s.map((u) => u.annotation.id));
+      Array.from(e).filter((u) => !d.has(u));
+      const g = s.map((u) => {
+        var p;
+        const f = r ? typeof r == "function" ? r(u.annotation, u.state) : r : (p = u.state) != null && p.selected ? Et : q, A = l && l.paint(u, a) || f;
+        return `::highlight(_${u.annotation.id}) { ${un(A)} }`;
+      });
+      t.innerHTML = g.join(`
+`), CSS.highlights.clear(), s.forEach(({ annotation: u }) => {
+        const f = u.target.selector.map((p) => p.range), A = new Highlight(...f);
+        CSS.highlights.set(`_${u.id}`, A);
+      }), e = d;
+    }
   };
-  const scrollParent = getScrollParent(container);
-  if (scrollParent) {
-    const current = store.getAnnotation(id);
-    const { range } = current.target.selector[0];
-    if (range && !range.collapsed) {
-      scroll(current.target);
-      return true;
-    } else {
-      const revived = reviveTarget(current.target, container);
-      const { range: range2 } = revived.selector[0];
-      if (range2 && !range2.collapsed) {
-        scroll(revived);
-        return true;
+}, hn = (t, e, n) => $t(t, e, n, fn());
+var ee = Object.prototype.hasOwnProperty;
+function Pt(t, e) {
+  var n, o;
+  if (t === e) return !0;
+  if (t && e && (n = t.constructor) === e.constructor) {
+    if (n === Date) return t.getTime() === e.getTime();
+    if (n === RegExp) return t.toString() === e.toString();
+    if (n === Array) {
+      if ((o = t.length) === e.length)
+        for (; o-- && Pt(t[o], e[o]); ) ;
+      return o === -1;
+    }
+    if (!n || typeof t == "object") {
+      o = 0;
+      for (n in t)
+        if (ee.call(t, n) && ++o && !ee.call(e, n) || !(n in e) || !Pt(t[n], e[n])) return !1;
+      return Object.keys(e).length === o;
+    }
+  }
+  return t !== t && e !== e;
+}
+const pn = (t, e) => {
+  const n = (s, a) => s.x <= a.x + a.width && s.x + s.width >= a.x && s.y <= a.y + a.height && s.y + s.height >= a.y, o = (s) => s.rects.reduce((a, r) => a + r.width, 0), i = e.filter(({ rects: s }) => s.some((a) => n(t, a)));
+  return i.sort((s, a) => o(a) - o(s)), i.findIndex((s) => s.rects.includes(t));
+}, gn = (t) => {
+  t.classList.add("r6o-annotatable");
+  const e = document.createElement("div");
+  e.className = "r6o-span-highlight-layer", t.insertBefore(e, t.firstChild);
+  let n = [];
+  return {
+    destroy: () => {
+      e.remove();
+    },
+    redraw: (a, r, l, d, g) => {
+      const f = !(Pt(n, a) && g);
+      if (!d && !f) return;
+      f && (e.innerHTML = ""), [...a].sort((p, b) => {
+        const { annotation: { target: { created: x } } } = p, { annotation: { target: { created: m } } } = b;
+        return x && m ? x.getTime() - m.getTime() : 0;
+      }).forEach((p) => {
+        p.rects.map((b) => {
+          const x = pn(b, a), m = Fe(p, r, l, d, x);
+          if (f) {
+            const c = document.createElement("span");
+            c.className = "r6o-annotation", c.dataset.annotation = p.annotation.id, c.style.left = `${b.x}px`, c.style.top = `${b.y}px`, c.style.width = `${b.width}px`, c.style.height = `${b.height}px`, c.style.backgroundColor = $((m == null ? void 0 : m.fill) || q.fill).alpha((m == null ? void 0 : m.fillOpacity) === void 0 ? q.fillOpacity : m.fillOpacity).toHex(), m.underlineStyle && (c.style.borderStyle = m.underlineStyle), m.underlineColor && (c.style.borderColor = m.underlineColor), m.underlineThickness && (c.style.borderBottomWidth = `${m.underlineThickness}px`), m.underlineOffset && (c.style.paddingBottom = `${m.underlineOffset}px`), e.appendChild(c);
+          }
+        });
+      }), n = a;
+    },
+    setVisible: (a) => {
+      a ? e.classList.remove("hidden") : e.classList.add("hidden");
+    }
+  };
+}, mn = (t, e, n) => $t(t, e, n, gn(t)), V = [];
+for (let t = 0; t < 256; ++t)
+  V.push((t + 256).toString(16).slice(1));
+function yn(t, e = 0) {
+  return (V[t[e + 0]] + V[t[e + 1]] + V[t[e + 2]] + V[t[e + 3]] + "-" + V[t[e + 4]] + V[t[e + 5]] + "-" + V[t[e + 6]] + V[t[e + 7]] + "-" + V[t[e + 8]] + V[t[e + 9]] + "-" + V[t[e + 10]] + V[t[e + 11]] + V[t[e + 12]] + V[t[e + 13]] + V[t[e + 14]] + V[t[e + 15]]).toLowerCase();
+}
+let Rt;
+const bn = new Uint8Array(16);
+function wn() {
+  if (!Rt) {
+    if (typeof crypto > "u" || !crypto.getRandomValues)
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    Rt = crypto.getRandomValues.bind(crypto);
+  }
+  return Rt(bn);
+}
+const An = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), ne = { randomUUID: An };
+function be(t, e, n) {
+  if (ne.randomUUID && !e && !t)
+    return ne.randomUUID();
+  t = t || {};
+  const o = t.random || (t.rng || wn)();
+  return o[6] = o[6] & 15 | 64, o[8] = o[8] & 63 | 128, yn(o);
+}
+var oe = Object.prototype.hasOwnProperty;
+function Q(t, e) {
+  var n, o;
+  if (t === e) return !0;
+  if (t && e && (n = t.constructor) === e.constructor) {
+    if (n === Date) return t.getTime() === e.getTime();
+    if (n === RegExp) return t.toString() === e.toString();
+    if (n === Array) {
+      if ((o = t.length) === e.length)
+        for (; o-- && Q(t[o], e[o]); ) ;
+      return o === -1;
+    }
+    if (!n || typeof t == "object") {
+      o = 0;
+      for (n in t)
+        if (oe.call(t, n) && ++o && !oe.call(e, n) || !(n in e) || !Q(t[n], e[n])) return !1;
+      return Object.keys(e).length === o;
+    }
+  }
+  return t !== t && e !== e;
+}
+function Mt() {
+}
+function xn(t, e) {
+  return t != t ? e == e : t !== e || t && typeof t == "object" || typeof t == "function";
+}
+const J = [];
+function Ht(t, e = Mt) {
+  let n;
+  const o = /* @__PURE__ */ new Set();
+  function i(r) {
+    if (xn(t, r) && (t = r, n)) {
+      const l = !J.length;
+      for (const d of o)
+        d[1](), J.push(d, t);
+      if (l) {
+        for (let d = 0; d < J.length; d += 2)
+          J[d][0](J[d + 1]);
+        J.length = 0;
       }
     }
   }
-  return false;
-};
-const DEFAULT_STYLE = {
-  fill: "rgb(0, 128, 255)",
-  fillOpacity: 0.18
-};
-const DEFAULT_SELECTED_STYLE = {
-  fill: "rgb(0, 128, 255)",
-  fillOpacity: 0.45
-};
-const paint = (highlight, viewportBounds, style, painter, zIndex) => {
-  var _a, _b;
-  const base = style ? typeof style === "function" ? style(highlight.annotation, highlight.state, zIndex) || (((_a = highlight.state) == null ? void 0 : _a.selected) ? DEFAULT_SELECTED_STYLE : DEFAULT_STYLE) : style : ((_b = highlight.state) == null ? void 0 : _b.selected) ? DEFAULT_SELECTED_STYLE : DEFAULT_STYLE;
-  return painter ? painter.paint(highlight, viewportBounds) || base : base;
-};
-const getViewportBounds = (container) => {
-  const { top, left } = container.getBoundingClientRect();
-  const { innerWidth, innerHeight } = window;
-  const minX = -left;
-  const minY = -top;
-  const maxX = innerWidth - left;
-  const maxY = innerHeight - top;
-  return { top, left, minX, minY, maxX, maxY };
-};
-const trackViewport = (viewport) => {
-  let visible = /* @__PURE__ */ new Set();
-  const onDraw = (annotations) => {
-    const ids = annotations.map((a) => a.id);
-    if (visible.size !== ids.length || ids.some((id) => !visible.has(id))) {
-      viewport.set(ids);
+  function s(r) {
+    i(r(t));
+  }
+  function a(r, l = Mt) {
+    const d = [r, l];
+    return o.add(d), o.size === 1 && (n = e(i, s) || Mt), r(t), () => {
+      o.delete(d), o.size === 0 && n && (n(), n = null);
+    };
+  }
+  return { set: i, update: s, subscribe: a };
+}
+const vn = (t) => {
+  const { subscribe: e, set: n } = Ht();
+  let o;
+  return e((i) => o = i), t.observe(({ changes: i }) => {
+    if (o) {
+      (i.deleted || []).some((a) => a.id === o) && n(void 0);
+      const s = (i.updated || []).find(({ oldValue: a }) => a.id === o);
+      s && n(s.newValue.id);
     }
-    visible = new Set(ids);
+  }), {
+    get current() {
+      return o;
+    },
+    subscribe: e,
+    set: n
   };
-  return onDraw;
 };
-const createBaseRenderer = (container, state, viewport, renderer) => {
-  const { store, selection, hover } = state;
-  let currentStyle;
-  let currentFilter;
-  let currentPainter;
-  const onDraw = trackViewport(viewport);
-  const onPointerMove = (event) => {
-    const { x, y } = container.getBoundingClientRect();
-    const hit = store.getAt(event.clientX - x, event.clientY - y, false, currentFilter);
-    if (hit) {
-      if (hover.current !== hit.id) {
-        container.classList.add("hovered");
-        hover.set(hit.id);
+var En = /* @__PURE__ */ ((t) => (t.EDIT = "EDIT", t.SELECT = "SELECT", t.NONE = "NONE", t))(En || {});
+const yt = { selected: [] }, Sn = (t, e, n) => {
+  const { subscribe: o, set: i } = Ht(yt);
+  let s = e, a = yt;
+  o((p) => a = p);
+  const r = () => {
+    Q(a, yt) || i(yt);
+  }, l = () => {
+    var p;
+    return ((p = a.selected) == null ? void 0 : p.length) === 0;
+  }, d = (p) => {
+    if (l())
+      return !1;
+    const b = typeof p == "string" ? p : p.id;
+    return a.selected.some((x) => x.id === b);
+  }, g = (p, b) => {
+    let x;
+    if (Array.isArray(p)) {
+      if (x = p.map((c) => t.getAnnotation(c)).filter(Boolean), x.length < p.length) {
+        console.warn("Invalid selection: " + p.filter((c) => !x.some((y) => y.id === c)));
+        return;
       }
     } else {
-      if (hover.current) {
-        container.classList.remove("hovered");
-        hover.set(null);
+      const c = t.getAnnotation(p);
+      if (!c) {
+        console.warn("Invalid selection: " + p);
+        return;
       }
+      x = [c];
     }
+    const m = x.reduce((c, y) => {
+      const C = ie(y, s, n);
+      return C === "EDIT" ? [...c, { id: y.id, editable: !0 }] : C === "SELECT" ? [...c, { id: y.id }] : c;
+    }, []);
+    i({ selected: m, event: b });
+  }, u = (p, b) => {
+    const x = Array.isArray(p) ? p : [p], m = x.map((c) => t.getAnnotation(c)).filter((c) => !!c);
+    i({
+      selected: m.map((c) => {
+        const y = b === void 0 ? ie(c, s, n) === "EDIT" : b;
+        return { id: c.id, editable: y };
+      })
+    }), m.length !== x.length && console.warn("Invalid selection", p);
+  }, f = (p) => {
+    if (l())
+      return !1;
+    const { selected: b } = a;
+    b.some(({ id: x }) => p.includes(x)) && i({ selected: b.filter(({ id: x }) => !p.includes(x)) });
+  }, A = (p) => s = p;
+  return t.observe(
+    ({ changes: p }) => f((p.deleted || []).map((b) => b.id))
+  ), {
+    get event() {
+      return a ? a.event : null;
+    },
+    get selected() {
+      return a ? [...a.selected] : null;
+    },
+    get userSelectAction() {
+      return s;
+    },
+    clear: r,
+    isEmpty: l,
+    isSelected: d,
+    setSelected: u,
+    setUserSelectAction: A,
+    subscribe: o,
+    userSelect: g
+  };
+}, ie = (t, e, n) => {
+  const o = n ? n.serialize(t) : t;
+  return typeof e == "function" ? e(o) : e || "EDIT";
+}, Y = [];
+for (let t = 0; t < 256; ++t)
+  Y.push((t + 256).toString(16).slice(1));
+function Cn(t, e = 0) {
+  return (Y[t[e + 0]] + Y[t[e + 1]] + Y[t[e + 2]] + Y[t[e + 3]] + "-" + Y[t[e + 4]] + Y[t[e + 5]] + "-" + Y[t[e + 6]] + Y[t[e + 7]] + "-" + Y[t[e + 8]] + Y[t[e + 9]] + "-" + Y[t[e + 10]] + Y[t[e + 11]] + Y[t[e + 12]] + Y[t[e + 13]] + Y[t[e + 14]] + Y[t[e + 15]]).toLowerCase();
+}
+let kt;
+const Ln = new Uint8Array(16);
+function Tn() {
+  if (!kt) {
+    if (typeof crypto > "u" || !crypto.getRandomValues)
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    kt = crypto.getRandomValues.bind(crypto);
+  }
+  return kt(Ln);
+}
+const On = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), se = { randomUUID: On };
+function we(t, e, n) {
+  if (se.randomUUID && !e && !t)
+    return se.randomUUID();
+  t = t || {};
+  const o = t.random || (t.rng || Tn)();
+  return o[6] = o[6] & 15 | 64, o[8] = o[8] & 63 | 128, Cn(o);
+}
+const It = (t) => {
+  const e = (n) => {
+    const o = { ...n };
+    return n.created && typeof n.created == "string" && (o.created = new Date(n.created)), n.updated && typeof n.updated == "string" && (o.updated = new Date(n.updated)), o;
   };
-  container.addEventListener("pointermove", onPointerMove);
-  const redraw = (lazy = false) => {
-    if (currentPainter)
-      currentPainter.clear();
-    const bounds = getViewportBounds(container);
-    const { minX, minY, maxX, maxY } = bounds;
-    const annotationsInView = currentFilter ? store.getIntersecting(minX, minY, maxX, maxY).filter(({ annotation }) => currentFilter(annotation)) : store.getIntersecting(minX, minY, maxX, maxY);
-    const selectedIds = selection.selected.map(({ id }) => id);
-    const highlights = annotationsInView.map(({ annotation, rects }) => {
-      const selected = selectedIds.includes(annotation.id);
-      const hovered = annotation.id === hover.current;
-      return { annotation, rects, state: { selected, hover: hovered } };
-    });
-    renderer.redraw(highlights, bounds, currentStyle, currentPainter, lazy);
-    setTimeout(() => onDraw(annotationsInView.map(({ annotation }) => annotation)), 1);
-  };
-  const setPainter = (painter) => {
-    currentPainter = painter;
-    redraw();
-  };
-  const setStyle = (style) => {
-    currentStyle = style;
-    redraw();
-  };
-  const setFilter = (filter) => {
-    currentFilter = filter;
-    redraw(false);
-  };
-  const onStoreChange = () => redraw();
-  store.observe(onStoreChange);
-  const unsubscribeSelection = selection.subscribe(() => redraw());
-  const onScroll = () => redraw(true);
-  document.addEventListener("scroll", onScroll, { capture: true, passive: true });
-  const onResize = debounce(() => {
-    store.recalculatePositions();
-    currentPainter == null ? void 0 : currentPainter.reset();
-    redraw();
-  }, 10);
-  window.addEventListener("resize", onResize);
-  const resizeObserver = new ResizeObserver(onResize);
-  resizeObserver.observe(container);
-  const config = { attributes: true, childList: true, subtree: true };
-  const mutationObserver = new MutationObserver((records) => {
-    const isInternal = records.every((record) => record.target === container || container.contains(record.target));
-    if (!isInternal) redraw(true);
-  });
-  mutationObserver.observe(document.body, config);
-  const destroy = () => {
-    container.removeEventListener("pointermove", onPointerMove);
-    renderer.destroy();
-    store.unobserve(onStoreChange);
-    unsubscribeSelection();
-    document.removeEventListener("scroll", onScroll);
-    onResize.clear();
-    window.removeEventListener("resize", onResize);
-    resizeObserver.disconnect();
-    mutationObserver.disconnect();
-  };
   return {
-    destroy,
-    redraw,
-    setStyle,
-    setFilter,
-    setPainter,
-    setVisible: renderer.setVisible
+    ...t,
+    bodies: (t.bodies || []).map(e),
+    target: e(t.target)
+  };
+}, Io = (t, e, n, o) => ({
+  id: we(),
+  annotation: typeof t == "string" ? t : t.id,
+  created: n || /* @__PURE__ */ new Date(),
+  creator: o,
+  ...e
+}), Bn = (t, e) => {
+  const n = new Set(t.bodies.map((o) => o.id));
+  return e.bodies.filter((o) => !n.has(o.id));
+}, Rn = (t, e) => {
+  const n = new Set(e.bodies.map((o) => o.id));
+  return t.bodies.filter((o) => !n.has(o.id));
+}, Mn = (t, e) => e.bodies.map((n) => {
+  const o = t.bodies.find((i) => i.id === n.id);
+  return { newBody: n, oldBody: o && !Q(o, n) ? o : void 0 };
+}).filter(({ oldBody: n }) => n).map(({ oldBody: n, newBody: o }) => ({ oldBody: n, newBody: o })), kn = (t, e) => !Q(t.target, e.target), Ae = (t, e) => {
+  const n = Bn(t, e), o = Rn(t, e), i = Mn(t, e);
+  return {
+    oldValue: t,
+    newValue: e,
+    bodiesCreated: n.length > 0 ? n : void 0,
+    bodiesDeleted: o.length > 0 ? o : void 0,
+    bodiesUpdated: i.length > 0 ? i : void 0,
+    targetUpdated: kn(t, e) ? { oldTarget: t.target, newTarget: e.target } : void 0
   };
 };
-const createCanvas$1 = () => {
-  const canvas = document.createElement("canvas");
-  canvas.width = window.innerWidth;
-  canvas.height = window.innerHeight;
-  canvas.className = "r6o-canvas-highlight-layer bg";
-  return canvas;
-};
-const resetCanvas = (canvas, highres) => {
-  canvas.width = window.innerWidth;
-  canvas.height = window.innerHeight;
-};
-const createRenderer$2 = (container) => {
-  container.classList.add("r6o-annotatable");
-  const canvas = createCanvas$1();
-  const ctx = canvas.getContext("2d");
-  document.body.appendChild(canvas);
-  const redraw = (highlights, viewportBounds, currentStyle, currentPainter) => requestAnimationFrame(() => {
-    const { width, height } = canvas;
-    ctx.clearRect(-0.5, -0.5, width + 1, height + 1);
-    if (currentPainter)
-      currentPainter.clear();
-    const { top, left } = viewportBounds;
-    const highlightsByCreation = [...highlights].sort((highlightA, highlightB) => {
-      const { annotation: { target: { created: createdA } } } = highlightA;
-      const { annotation: { target: { created: createdB } } } = highlightB;
-      return createdA.getTime() - createdB.getTime();
-    });
-    highlightsByCreation.forEach((h) => {
-      var _a;
-      const base = currentStyle ? typeof currentStyle === "function" ? currentStyle(h.annotation, h.state) : currentStyle : ((_a = h.state) == null ? void 0 : _a.selected) ? DEFAULT_SELECTED_STYLE : DEFAULT_STYLE;
-      const style = currentPainter ? currentPainter.paint(h, viewportBounds) || base : base;
-      const offsetRects = h.rects.map(({ x, y, width: width2, height: height2 }) => ({
-        x: x + left,
-        y: y + top,
-        width: width2,
-        height: height2
-      }));
-      ctx.fillStyle = style.fill;
-      ctx.globalAlpha = style.fillOpacity || 1;
-      offsetRects.forEach(
-        ({ x, y, width: width2, height: height2 }) => ctx.fillRect(x, y, width2, height2)
-      );
-      if (style.underlineColor) {
-        ctx.globalAlpha = 1;
-        ctx.strokeStyle = style.underlineColor;
-        ctx.lineWidth = style.underlineThickness ?? 1;
-        const underlineOffset = style.underlineOffset ?? 0;
-        offsetRects.forEach(({ x, y, width: width2, height: height2 }) => {
-          ctx.beginPath();
-          ctx.moveTo(x, y + height2 + underlineOffset);
-          ctx.lineTo(x + width2, y + height2 + underlineOffset);
-          ctx.stroke();
-        });
-      }
-    });
-  });
-  const onResize = debounce(() => resetCanvas(canvas), 10);
-  window.addEventListener("resize", onResize);
-  const setVisible = (visible) => {
-    console.log("setVisible not implemented on Canvas renderer");
-  };
-  const destroy = () => {
-    canvas.remove();
-    onResize.clear();
-    window.removeEventListener("resize", onResize);
-  };
+var k = /* @__PURE__ */ ((t) => (t.LOCAL = "LOCAL", t.REMOTE = "REMOTE", t.SILENT = "SILENT", t))(k || {});
+const In = (t, e) => {
+  var n, o;
+  const { changes: i, origin: s } = e;
+  if (!(t.options.origin ? t.options.origin === s : s !== "SILENT"))
+    return !1;
+  if (t.options.ignore) {
+    const { ignore: a } = t.options, r = (l) => l && l.length > 0;
+    if (!(r(i.created) || r(i.deleted))) {
+      const l = (n = i.updated) == null ? void 0 : n.some((g) => r(g.bodiesCreated) || r(g.bodiesDeleted) || r(g.bodiesUpdated)), d = (o = i.updated) == null ? void 0 : o.some((g) => g.targetUpdated);
+      if (a === "BODY_ONLY" && l && !d || a === "TARGET_ONLY" && d && !l)
+        return !1;
+    }
+  }
+  if (t.options.annotations) {
+    const a = /* @__PURE__ */ new Set([
+      ...(i.created || []).map((r) => r.id),
+      ...(i.deleted || []).map((r) => r.id),
+      ...(i.updated || []).map(({ oldValue: r }) => r.id)
+    ]);
+    return !!(Array.isArray(t.options.annotations) ? t.options.annotations : [t.options.annotations]).find((r) => a.has(r));
+  } else
+    return !0;
+}, Nn = (t, e) => {
+  const n = new Set((t.created || []).map((u) => u.id)), o = new Set((t.updated || []).map(({ newValue: u }) => u.id)), i = new Set((e.created || []).map((u) => u.id)), s = new Set((e.deleted || []).map((u) => u.id)), a = new Set((e.updated || []).map(({ oldValue: u }) => u.id)), r = new Set((e.updated || []).filter(({ oldValue: u }) => n.has(u.id) || o.has(u.id)).map(({ oldValue: u }) => u.id)), l = [
+    ...(t.created || []).filter((u) => !s.has(u.id)).map((u) => a.has(u.id) ? e.updated.find(({ oldValue: f }) => f.id === u.id).newValue : u),
+    ...e.created || []
+  ], d = [
+    ...(t.deleted || []).filter((u) => !i.has(u.id)),
+    ...(e.deleted || []).filter((u) => !n.has(u.id))
+  ], g = [
+    ...(t.updated || []).filter(({ newValue: u }) => !s.has(u.id)).map((u) => {
+      const { oldValue: f, newValue: A } = u;
+      if (a.has(A.id)) {
+        const p = e.updated.find((b) => b.oldValue.id === A.id).newValue;
+        return Ae(f, p);
+      } else
+        return u;
+    }),
+    ...(e.updated || []).filter(({ oldValue: u }) => !r.has(u.id))
+  ];
+  return { created: l, deleted: d, updated: g };
+}, Nt = (t) => {
+  const e = t.id === void 0 ? we() : t.id;
   return {
-    destroy,
-    setVisible,
-    redraw
+    ...t,
+    id: e,
+    bodies: t.bodies === void 0 ? [] : t.bodies.map((n) => ({
+      ...n,
+      annotation: e
+    })),
+    target: {
+      ...t.target,
+      annotation: e
+    }
   };
-};
-const createCanvasRenderer = (container, state, viewport) => createBaseRenderer(container, state, viewport, createRenderer$2(container));
-const toCSS = (s) => {
-  const backgroundColor = colord((s == null ? void 0 : s.fill) || DEFAULT_STYLE.fill).alpha((s == null ? void 0 : s.fillOpacity) === void 0 ? DEFAULT_STYLE.fillOpacity : s.fillOpacity).toHex();
-  const rules = [
-    `background-color:${backgroundColor}`,
-    (s == null ? void 0 : s.underlineThickness) ? `text-decoration:underline` : void 0,
-    (s == null ? void 0 : s.underlineColor) ? `text-decoration-color:${s.underlineColor}` : void 0,
-    (s == null ? void 0 : s.underlineOffset) ? `text-underline-offset:${s.underlineOffset}px` : void 0,
-    (s == null ? void 0 : s.underlineThickness) ? `text-decoration-thickness:${s.underlineThickness}px` : void 0
-  ].filter(Boolean);
-  return rules.join(";");
-};
-const createRenderer$1 = () => {
-  const elem = document.createElement("style");
-  document.getElementsByTagName("head")[0].appendChild(elem);
-  let currentRendered = /* @__PURE__ */ new Set();
-  const redraw = (highlights, viewportBounds, currentStyle, painter) => {
-    if (painter)
-      painter.clear();
-    const nextRendered = new Set(highlights.map((h) => h.annotation.id));
-    Array.from(currentRendered).filter((id) => !nextRendered.has(id));
-    const updatedCSS = highlights.map((h) => {
-      var _a;
-      const base = currentStyle ? typeof currentStyle === "function" ? currentStyle(h.annotation, h.state) : currentStyle : ((_a = h.state) == null ? void 0 : _a.selected) ? DEFAULT_SELECTED_STYLE : DEFAULT_STYLE;
-      const style = painter ? painter.paint(h, viewportBounds) || base : base;
-      return `::highlight(_${h.annotation.id}) { ${toCSS(style)} }`;
-    });
-    elem.innerHTML = updatedCSS.join("\n");
-    CSS.highlights.clear();
-    highlights.forEach(({ annotation }) => {
-      const ranges = annotation.target.selector.map((s) => s.range);
-      const highlights2 = new Highlight(...ranges);
-      CSS.highlights.set(`_${annotation.id}`, highlights2);
+}, _n = (t) => t.id !== void 0, Un = () => {
+  const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map(), n = [], o = (w, v = {}) => {
+    n.push({ onChange: w, options: v });
+  }, i = (w) => {
+    const v = n.findIndex((h) => h.onChange == w);
+    v > -1 && n.splice(v, 1);
+  }, s = (w, v) => {
+    const h = {
+      origin: w,
+      changes: {
+        created: v.created || [],
+        updated: v.updated || [],
+        deleted: v.deleted || []
+      },
+      state: [...t.values()]
+    };
+    n.forEach((E) => {
+      In(E, h) && E.onChange(h);
     });
-    currentRendered = nextRendered;
+  }, a = (w, v = k.LOCAL) => {
+    if (w.id && t.get(w.id))
+      throw Error(`Cannot add annotation ${w.id} - exists already`);
+    {
+      const h = Nt(w);
+      t.set(h.id, h), h.bodies.forEach((E) => e.set(E.id, h.id)), s(v, { created: [h] });
+    }
+  }, r = (w, v) => {
+    const h = Nt(typeof w == "string" ? v : w), E = typeof w == "string" ? w : w.id, M = E && t.get(E);
+    if (M) {
+      const O = Ae(M, h);
+      return E === h.id ? t.set(E, h) : (t.delete(E), t.set(h.id, h)), M.bodies.forEach((U) => e.delete(U.id)), h.bodies.forEach((U) => e.set(U.id, h.id)), O;
+    } else
+      console.warn(`Cannot update annotation ${E} - does not exist`);
+  }, l = (w, v = k.LOCAL, h = k.LOCAL) => {
+    const E = _n(v) ? h : v, M = r(w, v);
+    M && s(E, { updated: [M] });
+  }, d = (w, v = k.LOCAL) => {
+    const h = w.reduce((E, M) => {
+      const O = r(M);
+      return O ? [...E, O] : E;
+    }, []);
+    h.length > 0 && s(v, { updated: h });
+  }, g = (w, v = k.LOCAL) => {
+    const h = t.get(w.annotation);
+    if (h) {
+      const E = {
+        ...h,
+        bodies: [...h.bodies, w]
+      };
+      t.set(h.id, E), e.set(w.id, E.id), s(v, { updated: [{
+        oldValue: h,
+        newValue: E,
+        bodiesCreated: [w]
+      }] });
+    } else
+      console.warn(`Attempt to add body to missing annotation: ${w.annotation}`);
+  }, u = () => [...t.values()], f = (w = k.LOCAL) => {
+    const v = [...t.values()];
+    t.clear(), e.clear(), s(w, { deleted: v });
+  }, A = (w, v = !0, h = k.LOCAL) => {
+    const E = w.map(Nt);
+    if (v) {
+      const M = [...t.values()];
+      t.clear(), e.clear(), E.forEach((O) => {
+        t.set(O.id, O), O.bodies.forEach((U) => e.set(U.id, O.id));
+      }), s(h, { created: E, deleted: M });
+    } else {
+      const M = w.reduce((O, U) => {
+        const _ = U.id && t.get(U.id);
+        return _ ? [...O, _] : O;
+      }, []);
+      if (M.length > 0)
+        throw Error(`Bulk insert would overwrite the following annotations: ${M.map((O) => O.id).join(", ")}`);
+      E.forEach((O) => {
+        t.set(O.id, O), O.bodies.forEach((U) => e.set(U.id, O.id));
+      }), s(h, { created: E });
+    }
+  }, p = (w) => {
+    const v = typeof w == "string" ? w : w.id, h = t.get(v);
+    if (h)
+      return t.delete(v), h.bodies.forEach((E) => e.delete(E.id)), h;
+    console.warn(`Attempt to delete missing annotation: ${v}`);
+  }, b = (w, v = k.LOCAL) => {
+    const h = p(w);
+    h && s(v, { deleted: [h] });
+  }, x = (w, v = k.LOCAL) => {
+    const h = w.reduce((E, M) => {
+      const O = p(M);
+      return O ? [...E, O] : E;
+    }, []);
+    h.length > 0 && s(v, { deleted: h });
+  }, m = (w) => {
+    const v = t.get(w.annotation);
+    if (v) {
+      const h = v.bodies.find((E) => E.id === w.id);
+      if (h) {
+        e.delete(h.id);
+        const E = {
+          ...v,
+          bodies: v.bodies.filter((M) => M.id !== w.id)
+        };
+        return t.set(v.id, E), {
+          oldValue: v,
+          newValue: E,
+          bodiesDeleted: [h]
+        };
+      } else
+        console.warn(`Attempt to delete missing body ${w.id} from annotation ${w.annotation}`);
+    } else
+      console.warn(`Attempt to delete body from missing annotation ${w.annotation}`);
+  }, c = (w, v = k.LOCAL) => {
+    const h = m(w);
+    h && s(v, { updated: [h] });
+  }, y = (w, v = k.LOCAL) => {
+    const h = w.map((E) => m(E)).filter(Boolean);
+    h.length > 0 && s(v, { updated: h });
+  }, C = (w) => {
+    const v = t.get(w);
+    return v ? { ...v } : void 0;
+  }, S = (w) => {
+    const v = e.get(w);
+    if (v) {
+      const h = C(v).bodies.find((E) => E.id === w);
+      if (h)
+        return h;
+      console.error(`Store integrity error: body ${w} in index, but not in annotation`);
+    } else
+      console.warn(`Attempt to retrieve missing body: ${w}`);
+  }, L = (w, v) => {
+    if (w.annotation !== v.annotation)
+      throw "Annotation integrity violation: annotation ID must be the same when updating bodies";
+    const h = t.get(w.annotation);
+    if (h) {
+      const E = h.bodies.find((O) => O.id === w.id), M = {
+        ...h,
+        bodies: h.bodies.map((O) => O.id === E.id ? v : O)
+      };
+      return t.set(h.id, M), E.id !== v.id && (e.delete(E.id), e.set(v.id, M.id)), {
+        oldValue: h,
+        newValue: M,
+        bodiesUpdated: [{ oldBody: E, newBody: v }]
+      };
+    } else
+      console.warn(`Attempt to add body to missing annotation ${w.annotation}`);
+  }, B = (w, v, h = k.LOCAL) => {
+    const E = L(w, v);
+    E && s(h, { updated: [E] });
+  }, T = (w, v = k.LOCAL) => {
+    const h = w.map((E) => L({ id: E.id, annotation: E.annotation }, E)).filter(Boolean);
+    s(v, { updated: h });
+  }, R = (w) => {
+    const v = t.get(w.annotation);
+    if (v) {
+      const h = {
+        ...v,
+        target: {
+          ...v.target,
+          ...w
+        }
+      };
+      return t.set(v.id, h), {
+        oldValue: v,
+        newValue: h,
+        targetUpdated: {
+          oldTarget: v.target,
+          newTarget: w
+        }
+      };
+    } else
+      console.warn(`Attempt to update target on missing annotation: ${w.annotation}`);
   };
-  const setVisible = (visible) => {
-    console.log("setVisible not implemented on CSS Custom Highlights renderer");
+  return {
+    addAnnotation: a,
+    addBody: g,
+    all: u,
+    bulkAddAnnotation: A,
+    bulkDeleteAnnotation: x,
+    bulkDeleteBodies: y,
+    bulkUpdateAnnotation: d,
+    bulkUpdateBodies: T,
+    bulkUpdateTargets: (w, v = k.LOCAL) => {
+      const h = w.map((E) => R(E)).filter(Boolean);
+      h.length > 0 && s(v, { updated: h });
+    },
+    clear: f,
+    deleteAnnotation: b,
+    deleteBody: c,
+    getAnnotation: C,
+    getBody: S,
+    observe: o,
+    unobserve: i,
+    updateAnnotation: l,
+    updateBody: B,
+    updateTarget: (w, v = k.LOCAL) => {
+      const h = R(w);
+      h && s(v, { updated: [h] });
+    }
   };
-  const destroy = () => {
-    CSS.highlights.clear();
-    elem.remove();
+};
+let Dn = () => ({
+  emit(t, ...e) {
+    for (let n = this.events[t] || [], o = 0, i = n.length; o < i; o++)
+      n[o](...e);
+  },
+  events: {},
+  on(t, e) {
+    var n;
+    return ((n = this.events)[t] || (n[t] = [])).push(e), () => {
+      var o;
+      this.events[t] = (o = this.events[t]) == null ? void 0 : o.filter((i) => e !== i);
+    };
+  }
+});
+const Vn = 250, Yn = (t, e) => {
+  const n = Dn(), o = [];
+  let i = -1, s = !1, a = 0;
+  const r = (p) => {
+    if (!s) {
+      const { changes: b } = p, x = performance.now();
+      if (x - a > Vn)
+        o.splice(i + 1), o.push(b), i = o.length - 1;
+      else {
+        const m = o.length - 1;
+        o[m] = Nn(o[m], b);
+      }
+      a = x;
+    }
+    s = !1;
   };
+  t.observe(r, { origin: k.LOCAL });
+  const l = (p) => p && p.length > 0 && t.bulkDeleteAnnotation(p), d = (p) => p && p.length > 0 && t.bulkAddAnnotation(p, !1), g = (p) => p && p.length > 0 && t.bulkUpdateAnnotation(p.map(({ oldValue: b }) => b)), u = (p) => p && p.length > 0 && t.bulkUpdateAnnotation(p.map(({ newValue: b }) => b)), f = (p) => p && p.length > 0 && t.bulkAddAnnotation(p, !1), A = (p) => p && p.length > 0 && t.bulkDeleteAnnotation(p);
   return {
-    destroy,
-    setVisible,
-    redraw
+    canRedo: () => o.length - 1 > i,
+    canUndo: () => i > -1,
+    destroy: () => t.unobserve(r),
+    getHistory: () => ({ changes: [...o], pointer: i }),
+    on: (p, b) => n.on(p, b),
+    redo: () => {
+      if (o.length - 1 > i) {
+        s = !0;
+        const { created: p, updated: b, deleted: x } = o[i + 1];
+        d(p), u(b), A(x), n.emit("redo", o[i + 1]), i += 1;
+      }
+    },
+    undo: () => {
+      if (i > -1) {
+        s = !0;
+        const { created: p, updated: b, deleted: x } = o[i];
+        l(p), g(b), f(x), n.emit("undo", o[i]), i -= 1;
+      }
+    }
   };
-};
-const createHighlightsRenderer = (container, state, viewport) => createBaseRenderer(container, state, viewport, createRenderer$1());
-const computeZIndex = (rect, all) => {
-  const intersects = (a, b) => a.x <= b.x + b.width && a.x + a.width >= b.x && a.y <= b.y + b.height && a.y + a.height >= b.y;
-  const getLength = (h) => h.rects.reduce((total, rect2) => total + rect2.width, 0);
-  const intersecting = all.filter(({ rects }) => rects.some((r) => intersects(rect, r)));
-  intersecting.sort((a, b) => getLength(b) - getLength(a));
-  return intersecting.findIndex((h) => h.rects.includes(rect));
-};
-const createRenderer = (container) => {
-  container.classList.add("r6o-annotatable");
-  const highlightLayer = document.createElement("div");
-  highlightLayer.className = "r6o-span-highlight-layer";
-  container.insertBefore(highlightLayer, container.firstChild);
-  let currentRendered = [];
-  const redraw = (highlights, viewportBounds, currentStyle, painter, lazy) => {
-    const noChanges = dequal(currentRendered, highlights);
-    const shouldRedraw = !(noChanges && lazy);
-    if (!painter && !shouldRedraw) return;
-    if (shouldRedraw)
-      highlightLayer.innerHTML = "";
-    const sorted = [...highlights].sort((highlightA, highlightB) => {
-      const { annotation: { target: { created: createdA } } } = highlightA;
-      const { annotation: { target: { created: createdB } } } = highlightB;
-      return createdA && createdB ? createdA.getTime() - createdB.getTime() : 0;
-    });
-    sorted.forEach((highlight) => {
-      highlight.rects.map((rect) => {
-        const zIndex = computeZIndex(rect, highlights);
-        const style = paint(highlight, viewportBounds, currentStyle, painter, zIndex);
-        if (shouldRedraw) {
-          const span = document.createElement("span");
-          span.className = "r6o-annotation";
-          span.dataset.annotation = highlight.annotation.id;
-          span.style.left = `${rect.x}px`;
-          span.style.top = `${rect.y}px`;
-          span.style.width = `${rect.width}px`;
-          span.style.height = `${rect.height}px`;
-          span.style.backgroundColor = colord((style == null ? void 0 : style.fill) || DEFAULT_STYLE.fill).alpha((style == null ? void 0 : style.fillOpacity) === void 0 ? DEFAULT_STYLE.fillOpacity : style.fillOpacity).toHex();
-          if (style.underlineStyle)
-            span.style.borderStyle = style.underlineStyle;
-          if (style.underlineColor)
-            span.style.borderColor = style.underlineColor;
-          if (style.underlineThickness)
-            span.style.borderBottomWidth = `${style.underlineThickness}px`;
-          if (style.underlineOffset)
-            span.style.paddingBottom = `${style.underlineOffset}px`;
-          highlightLayer.appendChild(span);
-        }
+}, Kn = () => {
+  const { subscribe: t, set: e } = Ht([]);
+  return {
+    subscribe: t,
+    set: e
+  };
+}, Pn = (t, e, n, o) => {
+  const { hover: i, selection: s, store: a, viewport: r } = t, l = /* @__PURE__ */ new Map();
+  let d = [], g;
+  const u = (b, x) => {
+    l.has(b) ? l.get(b).push(x) : l.set(b, [x]);
+  }, f = (b, x) => {
+    const m = l.get(b);
+    if (m) {
+      const c = m.indexOf(x);
+      c !== -1 && m.splice(c, 1);
+    }
+  }, A = (b, x, m) => {
+    l.has(b) && setTimeout(() => {
+      l.get(b).forEach((c) => {
+        if (n) {
+          const y = Array.isArray(x) ? x.map((S) => n.serialize(S)) : n.serialize(x), C = m ? m instanceof PointerEvent ? m : n.serialize(m) : void 0;
+          c(y, C);
+        } else
+          c(x, m);
       });
+    }, 1);
+  };
+  s.subscribe(({ selected: b }) => {
+    if (!(d.length === 0 && b.length === 0)) {
+      if (d.length === 0 && b.length > 0)
+        d = b.map(({ id: x }) => a.getAnnotation(x));
+      else if (d.length > 0 && b.length === 0)
+        d.forEach((x) => {
+          const m = a.getAnnotation(x.id);
+          m && !Q(m, x) && A("updateAnnotation", m, x);
+        }), d = [];
+      else {
+        const x = new Set(d.map((c) => c.id)), m = new Set(b.map(({ id: c }) => c));
+        d.filter((c) => !m.has(c.id)).forEach((c) => {
+          const y = a.getAnnotation(c.id);
+          y && !Q(y, c) && A("updateAnnotation", y, c);
+        }), d = [
+          // Remove annotations that were deselected
+          ...d.filter((c) => m.has(c.id)),
+          // Add editable annotations that were selected
+          ...b.filter(({ id: c }) => !x.has(c)).map(({ id: c }) => a.getAnnotation(c))
+        ];
+      }
+      A("selectionChanged", d);
+    }
+  }), i.subscribe((b) => {
+    !g && b ? A("mouseEnterAnnotation", a.getAnnotation(b)) : g && !b ? A("mouseLeaveAnnotation", a.getAnnotation(g)) : g && b && (A("mouseLeaveAnnotation", a.getAnnotation(g)), A("mouseEnterAnnotation", a.getAnnotation(b))), g = b;
+  }), r == null || r.subscribe((b) => A("viewportIntersect", b.map((x) => a.getAnnotation(x)))), a.observe((b) => {
+    const { created: x, deleted: m } = b.changes;
+    (x || []).forEach((c) => A("createAnnotation", c)), (m || []).forEach((c) => A("deleteAnnotation", c)), (b.changes.updated || []).filter((c) => [
+      ...c.bodiesCreated || [],
+      ...c.bodiesDeleted || [],
+      ...c.bodiesUpdated || []
+    ].length > 0).forEach(({ oldValue: c, newValue: y }) => {
+      const C = d.find((S) => S.id === c.id) || c;
+      d = d.map((S) => S.id === c.id ? y : S), A("updateAnnotation", y, C);
     });
-    currentRendered = highlights;
-  };
-  const setVisible = (visible) => {
-    if (visible)
-      highlightLayer.classList.remove("hidden");
-    else
-      highlightLayer.classList.add("hidden");
-  };
-  const destroy = () => {
-    highlightLayer.remove();
+  }, { origin: k.LOCAL }), a.observe((b) => {
+    if (d) {
+      const x = new Set(d.map((c) => c.id)), m = (b.changes.updated || []).filter(({ newValue: c }) => x.has(c.id)).map(({ newValue: c }) => c);
+      m.length > 0 && (d = d.map((c) => m.find((C) => C.id === c.id) || c));
+    }
+  }, { origin: k.REMOTE });
+  const p = (b) => (x) => {
+    const { updated: m } = x;
+    b ? (m || []).forEach((c) => A("updateAnnotation", c.oldValue, c.newValue)) : (m || []).forEach((c) => A("updateAnnotation", c.newValue, c.oldValue));
+  };
+  return e.on("undo", p(!0)), e.on("redo", p(!1)), { on: u, off: f, emit: A };
+}, Xn = (t) => (e) => e.reduce((n, o) => {
+  const { parsed: i, error: s } = t.parse(o);
+  return s ? {
+    parsed: n.parsed,
+    failed: [...n.failed, o]
+  } : i ? {
+    parsed: [...n.parsed, i],
+    failed: n.failed
+  } : {
+    ...n
+  };
+}, { parsed: [], failed: [] }), $n = (t, e, n) => {
+  const { store: o, selection: i } = t, s = (m) => {
+    if (n) {
+      const { parsed: c, error: y } = n.parse(m);
+      c ? o.addAnnotation(c, k.REMOTE) : console.error(y);
+    } else
+      o.addAnnotation(It(m), k.REMOTE);
+  }, a = () => i.clear(), r = () => o.clear(), l = (m) => {
+    const c = o.getAnnotation(m);
+    return n && c ? n.serialize(c) : c;
+  }, d = () => n ? o.all().map(n.serialize) : o.all(), g = () => {
+    var m;
+    const c = (((m = i.selected) == null ? void 0 : m.map((y) => y.id)) || []).map((y) => o.getAnnotation(y)).filter(Boolean);
+    return n ? c.map(n.serialize) : c;
+  }, u = (m, c = !0) => fetch(m).then((y) => y.json()).then((y) => (A(y, c), y)), f = (m) => {
+    if (typeof m == "string") {
+      const c = o.getAnnotation(m);
+      if (o.deleteAnnotation(m), c)
+        return n ? n.serialize(c) : c;
+    } else {
+      const c = n ? n.parse(m).parsed : m;
+      if (c)
+        return o.deleteAnnotation(c), m;
+    }
+  }, A = (m, c = !0) => {
+    if (n) {
+      const y = n.parseAll || Xn(n), { parsed: C, failed: S } = y(m);
+      S.length > 0 && console.warn(`Discarded ${S.length} invalid annotations`, S), o.bulkAddAnnotation(C, c, k.REMOTE);
+    } else
+      o.bulkAddAnnotation(m.map(It), c, k.REMOTE);
+  }, p = (m, c) => {
+    m ? i.setSelected(m, c) : i.clear();
+  }, b = (m) => {
+    i.clear(), i.setUserSelectAction(m);
+  }, x = (m) => {
+    if (n) {
+      const c = n.parse(m).parsed, y = n.serialize(o.getAnnotation(c.id));
+      return o.updateAnnotation(c), y;
+    } else {
+      const c = o.getAnnotation(m.id);
+      return o.updateAnnotation(It(m)), c;
+    }
   };
   return {
-    destroy,
-    redraw,
-    setVisible
+    addAnnotation: s,
+    cancelSelected: a,
+    canRedo: e.canRedo,
+    canUndo: e.canUndo,
+    clearAnnotations: r,
+    getAnnotationById: l,
+    getAnnotations: d,
+    getHistory: e.getHistory,
+    getSelected: g,
+    loadAnnotations: u,
+    redo: e.redo,
+    removeAnnotation: f,
+    setAnnotations: A,
+    setSelected: p,
+    setUserSelectAction: b,
+    undo: e.undo,
+    updateAnnotation: x
+  };
+}, Hn = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+let jn = (t) => crypto.getRandomValues(new Uint8Array(t)), zn = (t, e, n) => {
+  let o = (2 << Math.log2(t.length - 1)) - 1, i = -~(1.6 * o * e / t.length);
+  return (s = e) => {
+    let a = "";
+    for (; ; ) {
+      let r = n(i), l = i | 0;
+      for (; l--; )
+        if (a += t[r[l] & o] || "", a.length >= s) return a;
+    }
   };
+}, Fn = (t, e = 21) => zn(t, e | 0, jn), Wn = (t = 21) => {
+  let e = "", n = crypto.getRandomValues(new Uint8Array(t |= 0));
+  for (; t--; )
+    e += Hn[n[t] & 63];
+  return e;
 };
-const createSpansRenderer = (container, state, viewport) => createBaseRenderer(container, state, viewport, createRenderer(container));
-const W3CTextFormat = (source, container) => ({
-  parse: (serialized) => parseW3CTextAnnotation(serialized),
-  serialize: (annotation) => serializeW3CTextAnnotation(annotation, source, container)
+const qn = () => ({ isGuest: !0, id: Fn("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_", 20)() }), Gn = (t) => {
+  const e = JSON.stringify(t);
+  let n = 0;
+  for (let o = 0, i = e.length; o < i; o++) {
+    let s = e.charCodeAt(o);
+    n = (n << 5) - n + s, n |= 0;
+  }
+  return `${n}`;
+}, xe = (t) => t ? typeof t == "object" ? { ...t } : t : void 0, Qn = (t, e) => (Array.isArray(t) ? t : [t]).map((n) => {
+  const { id: o, type: i, purpose: s, value: a, created: r, modified: l, creator: d, ...g } = n;
+  return {
+    id: o || `temp-${Gn(n)}`,
+    annotation: e,
+    type: i,
+    purpose: s,
+    value: a,
+    creator: xe(d),
+    created: r ? new Date(r) : void 0,
+    updated: l ? new Date(l) : void 0,
+    ...g
+  };
+}), Jn = (t) => t.map((e) => {
+  var n;
+  const { annotation: o, created: i, updated: s, ...a } = e, r = {
+    ...a,
+    created: i == null ? void 0 : i.toISOString(),
+    modified: s == null ? void 0 : s.toISOString()
+  };
+  return (n = r.id) != null && n.startsWith("temp-") && delete r.id, r;
 });
-const isTextSelector = (selector) => selector.quote !== void 0 && selector.start !== void 0 && selector.end !== void 0;
-const parseW3CTextTargets = (annotation) => {
+Wn();
+const No = (t, e) => ({
+  parse: (n) => eo(n),
+  serialize: (n) => no(n, t, e)
+}), Zn = (t) => t.quote !== void 0 && t.start !== void 0 && t.end !== void 0, to = (t) => {
   const {
-    id: annotationId,
-    creator,
-    created,
-    modified,
-    target
-  } = annotation;
-  const w3cTargets = Array.isArray(target) ? target : [target];
-  if (w3cTargets.length === 0) {
-    return { error: Error(`No targets found for annotation: ${annotation.id}`) };
-  }
-  const parsed = {
-    creator: parseW3CUser(creator),
-    created: created ? new Date(created) : void 0,
-    updated: modified ? new Date(modified) : void 0,
-    annotation: annotationId,
+    id: e,
+    creator: n,
+    created: o,
+    modified: i,
+    target: s
+  } = t, a = Array.isArray(s) ? s : [s];
+  if (a.length === 0)
+    return { error: Error(`No targets found for annotation: ${t.id}`) };
+  const r = {
+    creator: xe(n),
+    created: o ? new Date(o) : void 0,
+    updated: i ? new Date(i) : void 0,
+    annotation: e,
     selector: [],
     // @ts-expect-error: `styleClass` is not part of the core `TextAnnotationTarget` type
-    styleClass: "styleClass" in w3cTargets[0] ? w3cTargets[0].styleClass : void 0
+    styleClass: "styleClass" in a[0] ? a[0].styleClass : void 0
   };
-  for (const w3cTarget of w3cTargets) {
-    const w3cSelectors = Array.isArray(w3cTarget.selector) ? w3cTarget.selector : [w3cTarget.selector];
-    const selector = w3cSelectors.reduce((s, w3cSelector) => {
-      switch (w3cSelector.type) {
+  for (const l of a) {
+    const g = (Array.isArray(l.selector) ? l.selector : [l.selector]).reduce((u, f) => {
+      switch (f.type) {
         case "TextQuoteSelector":
-          s.quote = w3cSelector.exact;
+          u.quote = f.exact;
           break;
         case "TextPositionSelector":
-          s.start = w3cSelector.start;
-          s.end = w3cSelector.end;
+          u.start = f.start, u.end = f.end;
           break;
       }
-      return s;
+      return u;
     }, {});
-    if (isTextSelector(selector)) {
-      parsed.selector.push(
+    if (Zn(g))
+      "outdated" in l && l.outdated, r.selector.push(
         {
-          ...selector,
-          id: w3cTarget.id,
+          ...g,
+          id: l.id,
           // @ts-expect-error: `scope` is not part of the core `TextSelector` type
-          scope: w3cTarget.scope
+          scope: l.scope
         }
       );
-    } else {
-      const missingTypes = [
-        !selector.start ? "TextPositionSelector" : void 0,
-        !selector.quote ? "TextQuoteSelector" : void 0
+    else {
+      const u = [
+        g.start ? void 0 : "TextPositionSelector",
+        g.quote ? void 0 : "TextQuoteSelector"
       ].filter(Boolean);
-      return { error: Error(`Missing selector types: ${missingTypes.join(" and ")} for annotation: ${annotation.id}`) };
+      return { error: Error(`Missing selector types: ${u.join(" and ")} for annotation: ${t.id}`) };
     }
   }
-  return { parsed };
-};
-const parseW3CTextAnnotation = (annotation) => {
-  const annotationId = annotation.id || v4();
-  const {
-    creator,
-    created,
-    modified,
-    body,
-    ...rest
-  } = annotation;
-  const bodies = parseW3CBodies(body, annotationId);
-  const target = parseW3CTextTargets(annotation);
-  const parseResult = "error" in target ? { error: target.error } : {
+  return { parsed: r };
+}, eo = (t) => {
+  const e = t.id || be(), {
+    creator: n,
+    created: o,
+    modified: i,
+    body: s,
+    ...a
+  } = t, r = Qn(s, e), l = to(t);
+  return "error" in l ? { error: l.error } : {
     parsed: {
-      ...rest,
-      id: annotationId,
-      bodies,
-      target: target.parsed
+      ...a,
+      id: e,
+      bodies: r,
+      target: l.parsed
     }
   };
-  return parseResult;
-};
-const serializeW3CTextAnnotation = (annotation, source, container) => {
-  const { bodies, target, ...rest } = annotation;
-  const {
-    selector,
-    creator,
-    created,
-    updated,
-    ...targetRest
-  } = target;
-  const w3cTargets = selector.map((s) => {
-    const { id, quote, start, end, range } = s;
-    const { prefix, suffix } = getQuoteContext(range, container);
-    const w3cSelectors = [{
+}, no = (t, e, n) => {
+  const { bodies: o, target: i, ...s } = t, {
+    selector: a,
+    creator: r,
+    created: l,
+    updated: d,
+    ...g
+  } = i, u = a.map((f) => {
+    const { id: A, quote: p, start: b, end: x, range: m } = f, { prefix: c, suffix: y } = Ue(m, n), C = [{
       type: "TextQuoteSelector",
-      exact: quote,
-      prefix,
-      suffix
+      exact: p,
+      prefix: c,
+      suffix: y
     }, {
       type: "TextPositionSelector",
-      start,
-      end
+      start: b,
+      end: x
     }];
     return {
-      ...targetRest,
-      id,
+      ...g,
+      id: A,
+      // @ts-expect-error: `outdated` is not part of the core `TextSelector` type
+      outdated: "outdated" in f ? f.outdated : void 0,
       // @ts-expect-error: `scope` is not part of the core `TextSelector` type
-      scope: "scope" in s ? s.scope : void 0,
-      source,
-      selector: w3cSelectors
+      scope: "scope" in f ? f.scope : void 0,
+      source: e,
+      selector: C
     };
   });
   return {
-    ...rest,
+    ...s,
     "@context": "http://www.w3.org/ns/anno.jsonld",
-    id: annotation.id,
+    id: t.id,
     type: "Annotation",
-    body: serializeW3CBodies(annotation.bodies),
-    creator,
-    created: created == null ? void 0 : created.toISOString(),
-    modified: updated == null ? void 0 : updated.toISOString(),
-    target: w3cTargets
+    body: Jn(t.bodies),
+    creator: r,
+    created: l == null ? void 0 : l.toISOString(),
+    modified: d == null ? void 0 : d.toISOString(),
+    target: u
   };
 };
-const createSpatialTree = (store, container) => {
-  const tree = new RBush();
-  const index = /* @__PURE__ */ new Map();
-  const emitter = createNanoEvents();
-  const toItems = (target, offset) => {
-    const rects = target.selector.flatMap((s) => {
-      const revivedRange = isRevived([s]) ? s.range : reviveSelector(s, container).range;
-      return Array.from(revivedRange.getClientRects());
-    });
-    const merged = mergeClientRects(rects).map((rect) => toParentBounds(rect, offset));
-    return merged.map((rect) => {
-      const { x, y, width, height } = rect;
+function ve(t, e, n = 0, o = t.length - 1, i = oo) {
+  for (; o > n; ) {
+    if (o - n > 600) {
+      const l = o - n + 1, d = e - n + 1, g = Math.log(l), u = 0.5 * Math.exp(2 * g / 3), f = 0.5 * Math.sqrt(g * u * (l - u) / l) * (d - l / 2 < 0 ? -1 : 1), A = Math.max(n, Math.floor(e - d * u / l + f)), p = Math.min(o, Math.floor(e + (l - d) * u / l + f));
+      ve(t, e, A, p, i);
+    }
+    const s = t[e];
+    let a = n, r = o;
+    for (ot(t, n, e), i(t[o], s) > 0 && ot(t, n, o); a < r; ) {
+      for (ot(t, a, r), a++, r--; i(t[a], s) < 0; ) a++;
+      for (; i(t[r], s) > 0; ) r--;
+    }
+    i(t[n], s) === 0 ? ot(t, n, r) : (r++, ot(t, r, o)), r <= e && (n = r + 1), e <= r && (o = r - 1);
+  }
+}
+function ot(t, e, n) {
+  const o = t[e];
+  t[e] = t[n], t[n] = o;
+}
+function oo(t, e) {
+  return t < e ? -1 : t > e ? 1 : 0;
+}
+class io {
+  constructor(e = 9) {
+    this._maxEntries = Math.max(4, e), this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4)), this.clear();
+  }
+  all() {
+    return this._all(this.data, []);
+  }
+  search(e) {
+    let n = this.data;
+    const o = [];
+    if (!wt(e, n)) return o;
+    const i = this.toBBox, s = [];
+    for (; n; ) {
+      for (let a = 0; a < n.children.length; a++) {
+        const r = n.children[a], l = n.leaf ? i(r) : r;
+        wt(e, l) && (n.leaf ? o.push(r) : Ut(e, l) ? this._all(r, o) : s.push(r));
+      }
+      n = s.pop();
+    }
+    return o;
+  }
+  collides(e) {
+    let n = this.data;
+    if (!wt(e, n)) return !1;
+    const o = [];
+    for (; n; ) {
+      for (let i = 0; i < n.children.length; i++) {
+        const s = n.children[i], a = n.leaf ? this.toBBox(s) : s;
+        if (wt(e, a)) {
+          if (n.leaf || Ut(e, a)) return !0;
+          o.push(s);
+        }
+      }
+      n = o.pop();
+    }
+    return !1;
+  }
+  load(e) {
+    if (!(e && e.length)) return this;
+    if (e.length < this._minEntries) {
+      for (let o = 0; o < e.length; o++)
+        this.insert(e[o]);
+      return this;
+    }
+    let n = this._build(e.slice(), 0, e.length - 1, 0);
+    if (!this.data.children.length)
+      this.data = n;
+    else if (this.data.height === n.height)
+      this._splitRoot(this.data, n);
+    else {
+      if (this.data.height < n.height) {
+        const o = this.data;
+        this.data = n, n = o;
+      }
+      this._insert(n, this.data.height - n.height - 1, !0);
+    }
+    return this;
+  }
+  insert(e) {
+    return e && this._insert(e, this.data.height - 1), this;
+  }
+  clear() {
+    return this.data = tt([]), this;
+  }
+  remove(e, n) {
+    if (!e) return this;
+    let o = this.data;
+    const i = this.toBBox(e), s = [], a = [];
+    let r, l, d;
+    for (; o || s.length; ) {
+      if (o || (o = s.pop(), l = s[s.length - 1], r = a.pop(), d = !0), o.leaf) {
+        const g = so(e, o.children, n);
+        if (g !== -1)
+          return o.children.splice(g, 1), s.push(o), this._condense(s), this;
+      }
+      !d && !o.leaf && Ut(o, i) ? (s.push(o), a.push(r), r = 0, l = o, o = o.children[0]) : l ? (r++, o = l.children[r], d = !1) : o = null;
+    }
+    return this;
+  }
+  toBBox(e) {
+    return e;
+  }
+  compareMinX(e, n) {
+    return e.minX - n.minX;
+  }
+  compareMinY(e, n) {
+    return e.minY - n.minY;
+  }
+  toJSON() {
+    return this.data;
+  }
+  fromJSON(e) {
+    return this.data = e, this;
+  }
+  _all(e, n) {
+    const o = [];
+    for (; e; )
+      e.leaf ? n.push(...e.children) : o.push(...e.children), e = o.pop();
+    return n;
+  }
+  _build(e, n, o, i) {
+    const s = o - n + 1;
+    let a = this._maxEntries, r;
+    if (s <= a)
+      return r = tt(e.slice(n, o + 1)), Z(r, this.toBBox), r;
+    i || (i = Math.ceil(Math.log(s) / Math.log(a)), a = Math.ceil(s / Math.pow(a, i - 1))), r = tt([]), r.leaf = !1, r.height = i;
+    const l = Math.ceil(s / a), d = l * Math.ceil(Math.sqrt(a));
+    re(e, n, o, d, this.compareMinX);
+    for (let g = n; g <= o; g += d) {
+      const u = Math.min(g + d - 1, o);
+      re(e, g, u, l, this.compareMinY);
+      for (let f = g; f <= u; f += l) {
+        const A = Math.min(f + l - 1, u);
+        r.children.push(this._build(e, f, A, i - 1));
+      }
+    }
+    return Z(r, this.toBBox), r;
+  }
+  _chooseSubtree(e, n, o, i) {
+    for (; i.push(n), !(n.leaf || i.length - 1 === o); ) {
+      let s = 1 / 0, a = 1 / 0, r;
+      for (let l = 0; l < n.children.length; l++) {
+        const d = n.children[l], g = _t(d), u = co(e, d) - g;
+        u < a ? (a = u, s = g < s ? g : s, r = d) : u === a && g < s && (s = g, r = d);
+      }
+      n = r || n.children[0];
+    }
+    return n;
+  }
+  _insert(e, n, o) {
+    const i = o ? e : this.toBBox(e), s = [], a = this._chooseSubtree(i, this.data, n, s);
+    for (a.children.push(e), at(a, i); n >= 0 && s[n].children.length > this._maxEntries; )
+      this._split(s, n), n--;
+    this._adjustParentBBoxes(i, s, n);
+  }
+  // split overflowed node into two
+  _split(e, n) {
+    const o = e[n], i = o.children.length, s = this._minEntries;
+    this._chooseSplitAxis(o, s, i);
+    const a = this._chooseSplitIndex(o, s, i), r = tt(o.children.splice(a, o.children.length - a));
+    r.height = o.height, r.leaf = o.leaf, Z(o, this.toBBox), Z(r, this.toBBox), n ? e[n - 1].children.push(r) : this._splitRoot(o, r);
+  }
+  _splitRoot(e, n) {
+    this.data = tt([e, n]), this.data.height = e.height + 1, this.data.leaf = !1, Z(this.data, this.toBBox);
+  }
+  _chooseSplitIndex(e, n, o) {
+    let i, s = 1 / 0, a = 1 / 0;
+    for (let r = n; r <= o - n; r++) {
+      const l = rt(e, 0, r, this.toBBox), d = rt(e, r, o, this.toBBox), g = lo(l, d), u = _t(l) + _t(d);
+      g < s ? (s = g, i = r, a = u < a ? u : a) : g === s && u < a && (a = u, i = r);
+    }
+    return i || o - n;
+  }
+  // sorts node children by the best axis for split
+  _chooseSplitAxis(e, n, o) {
+    const i = e.leaf ? this.compareMinX : ro, s = e.leaf ? this.compareMinY : ao, a = this._allDistMargin(e, n, o, i), r = this._allDistMargin(e, n, o, s);
+    a < r && e.children.sort(i);
+  }
+  // total margin of all possible split distributions where each node is at least m full
+  _allDistMargin(e, n, o, i) {
+    e.children.sort(i);
+    const s = this.toBBox, a = rt(e, 0, n, s), r = rt(e, o - n, o, s);
+    let l = bt(a) + bt(r);
+    for (let d = n; d < o - n; d++) {
+      const g = e.children[d];
+      at(a, e.leaf ? s(g) : g), l += bt(a);
+    }
+    for (let d = o - n - 1; d >= n; d--) {
+      const g = e.children[d];
+      at(r, e.leaf ? s(g) : g), l += bt(r);
+    }
+    return l;
+  }
+  _adjustParentBBoxes(e, n, o) {
+    for (let i = o; i >= 0; i--)
+      at(n[i], e);
+  }
+  _condense(e) {
+    for (let n = e.length - 1, o; n >= 0; n--)
+      e[n].children.length === 0 ? n > 0 ? (o = e[n - 1].children, o.splice(o.indexOf(e[n]), 1)) : this.clear() : Z(e[n], this.toBBox);
+  }
+}
+function so(t, e, n) {
+  if (!n) return e.indexOf(t);
+  for (let o = 0; o < e.length; o++)
+    if (n(t, e[o])) return o;
+  return -1;
+}
+function Z(t, e) {
+  rt(t, 0, t.children.length, e, t);
+}
+function rt(t, e, n, o, i) {
+  i || (i = tt(null)), i.minX = 1 / 0, i.minY = 1 / 0, i.maxX = -1 / 0, i.maxY = -1 / 0;
+  for (let s = e; s < n; s++) {
+    const a = t.children[s];
+    at(i, t.leaf ? o(a) : a);
+  }
+  return i;
+}
+function at(t, e) {
+  return t.minX = Math.min(t.minX, e.minX), t.minY = Math.min(t.minY, e.minY), t.maxX = Math.max(t.maxX, e.maxX), t.maxY = Math.max(t.maxY, e.maxY), t;
+}
+function ro(t, e) {
+  return t.minX - e.minX;
+}
+function ao(t, e) {
+  return t.minY - e.minY;
+}
+function _t(t) {
+  return (t.maxX - t.minX) * (t.maxY - t.minY);
+}
+function bt(t) {
+  return t.maxX - t.minX + (t.maxY - t.minY);
+}
+function co(t, e) {
+  return (Math.max(e.maxX, t.maxX) - Math.min(e.minX, t.minX)) * (Math.max(e.maxY, t.maxY) - Math.min(e.minY, t.minY));
+}
+function lo(t, e) {
+  const n = Math.max(t.minX, e.minX), o = Math.max(t.minY, e.minY), i = Math.min(t.maxX, e.maxX), s = Math.min(t.maxY, e.maxY);
+  return Math.max(0, i - n) * Math.max(0, s - o);
+}
+function Ut(t, e) {
+  return t.minX <= e.minX && t.minY <= e.minY && e.maxX <= t.maxX && e.maxY <= t.maxY;
+}
+function wt(t, e) {
+  return e.minX <= t.maxX && e.minY <= t.maxY && e.maxX >= t.minX && e.maxY >= t.minY;
+}
+function tt(t) {
+  return {
+    children: t,
+    height: 1,
+    leaf: !0,
+    minX: 1 / 0,
+    minY: 1 / 0,
+    maxX: -1 / 0,
+    maxY: -1 / 0
+  };
+}
+function re(t, e, n, o, i) {
+  const s = [e, n];
+  for (; s.length; ) {
+    if (n = s.pop(), e = s.pop(), n - e <= o) continue;
+    const a = e + Math.ceil((n - e) / o / 2) * o;
+    ve(t, a, e, n, i), s.push(e, a, a, n);
+  }
+}
+let uo = () => ({
+  emit(t, ...e) {
+    for (let n = this.events[t] || [], o = 0, i = n.length; o < i; o++)
+      n[o](...e);
+  },
+  events: {},
+  on(t, e) {
+    var n;
+    return ((n = this.events)[t] || (n[t] = [])).push(e), () => {
+      var o;
+      this.events[t] = (o = this.events[t]) == null ? void 0 : o.filter((i) => e !== i);
+    };
+  }
+});
+const fo = (t, e) => {
+  const n = new io(), o = /* @__PURE__ */ new Map(), i = uo(), s = (y, C) => {
+    const S = y.selector.flatMap((B) => {
+      const T = F([B]) ? B.range : fe(B, e).range;
+      return Array.from(T.getClientRects());
+    }), L = Pe(S).map((B) => je(B, C));
+    return L.map((B) => {
+      const { x: T, y: R, width: w, height: v } = B;
       return {
-        minX: x,
-        minY: y,
-        maxX: x + width,
-        maxY: y + height,
+        minX: T,
+        minY: R,
+        maxX: T + w,
+        maxY: R + v,
         annotation: {
-          id: target.annotation,
-          rects: merged
+          id: y.annotation,
+          rects: L
         }
       };
     });
-  };
-  const all = () => [...index.values()];
-  const clear = () => {
-    tree.clear();
-    index.clear();
-  };
-  const insert = (target) => {
-    const rects = toItems(target, container.getBoundingClientRect());
-    if (rects.length === 0) return;
-    rects.forEach((rect) => tree.insert(rect));
-    index.set(target.annotation, rects);
-  };
-  const remove = (target) => {
-    const rects = index.get(target.annotation);
-    if (rects) {
-      rects.forEach((rect) => tree.remove(rect));
-      index.delete(target.annotation);
-    }
-  };
-  const update = (target) => {
-    remove(target);
-    insert(target);
-  };
-  const set = (targets, replace = true) => {
-    if (replace)
-      clear();
-    const offset = container.getBoundingClientRect();
-    const rectsByTarget = targets.map((target) => ({ target, rects: toItems(target, offset) }));
-    rectsByTarget.forEach(({ target, rects }) => {
-      if (rects.length > 0)
-        index.set(target.annotation, rects);
-    });
-    const allRects = rectsByTarget.flatMap(({ rects }) => rects);
-    tree.load(allRects);
-  };
-  const getAt = (x, y, all2 = false) => {
-    const hits = tree.search({
-      minX: x,
-      minY: y,
-      maxX: x,
-      maxY: y
+  }, a = () => [...o.values()], r = () => {
+    n.clear(), o.clear();
+  }, l = (y) => {
+    const C = s(y, e.getBoundingClientRect());
+    C.length !== 0 && (C.forEach((S) => n.insert(S)), o.set(y.annotation, C));
+  }, d = (y) => {
+    const C = o.get(y.annotation);
+    C && (C.forEach((S) => n.remove(S)), o.delete(y.annotation));
+  }, g = (y) => {
+    d(y), l(y);
+  }, u = (y, C = !0) => {
+    C && r();
+    const S = e.getBoundingClientRect(), L = y.map((T) => ({ target: T, rects: s(T, S) }));
+    L.forEach(({ target: T, rects: R }) => {
+      R.length > 0 && o.set(T.annotation, R);
     });
-    const area = (rect) => rect.annotation.rects.reduce((area2, r) => area2 + r.width * r.height, 0);
-    if (hits.length > 0) {
-      hits.sort((a, b) => area(a) - area(b));
-      return all2 ? hits.map((h) => h.annotation.id) : [hits[0].annotation.id];
-    } else {
-      return [];
-    }
-  };
-  const getAnnotationBounds = (id) => {
-    const rects = getAnnotationRects(id);
-    if (rects.length === 0)
-      return void 0;
-    let left = rects[0].left;
-    let top = rects[0].top;
-    let right = rects[0].right;
-    let bottom = rects[0].bottom;
-    for (let i = 1; i < rects.length; i++) {
-      const rect = rects[i];
-      left = Math.min(left, rect.left);
-      top = Math.min(top, rect.top);
-      right = Math.max(right, rect.right);
-      bottom = Math.max(bottom, rect.bottom);
-    }
-    return new DOMRect(left, top, right - left, bottom - top);
-  };
-  const getAnnotationRects = (id) => {
-    const indexed = index.get(id);
-    if (indexed) {
-      return indexed[0].annotation.rects;
-    } else {
-      return [];
+    const B = L.flatMap(({ rects: T }) => T);
+    n.load(B);
+  }, f = (y, C, S = !1) => {
+    const L = n.search({
+      minX: y,
+      minY: C,
+      maxX: y,
+      maxY: C
+    }), B = (T) => T.annotation.rects.reduce((R, w) => R + w.width * w.height, 0);
+    return L.length > 0 ? (L.sort((T, R) => B(T) - B(R)), S ? L.map((T) => T.annotation.id) : [L[0].annotation.id]) : [];
+  }, A = (y) => {
+    const C = p(y);
+    if (C.length === 0)
+      return;
+    let S = C[0].left, L = C[0].top, B = C[0].right, T = C[0].bottom;
+    for (let R = 1; R < C.length; R++) {
+      const w = C[R];
+      S = Math.min(S, w.left), L = Math.min(L, w.top), B = Math.max(B, w.right), T = Math.max(T, w.bottom);
     }
+    return new DOMRect(S, L, B - S, T - L);
+  }, p = (y) => {
+    const C = o.get(y);
+    return C ? C[0].annotation.rects : [];
   };
-  const getIntersecting = (minX, minY, maxX, maxY) => {
-    const rects = tree.search({ minX, minY, maxX, maxY });
-    const annotationIds = new Set(rects.map((rect) => rect.annotation.id));
-    return Array.from(annotationIds).map((annotationId) => ({
-      annotation: store.getAnnotation(annotationId),
-      rects: getAnnotationRects(annotationId)
-    })).filter((t) => Boolean(t.annotation));
-  };
-  const size = () => tree.all().length;
-  const recalculate = () => {
-    set(store.all().map((a) => a.target), true);
-    emitter.emit("recalculate");
-  };
-  const on = (event, callback) => emitter.on(event, callback);
   return {
-    all,
-    clear,
-    getAt,
-    getAnnotationBounds,
-    getAnnotationRects,
-    getIntersecting,
-    insert,
-    recalculate,
-    remove,
-    set,
-    size,
-    update,
-    on
-  };
-};
-const createTextAnnotatorState = (container, opts) => {
-  const store = createStore();
-  const tree = createSpatialTree(store, container);
-  const selection = createSelectionState(store, opts.userSelectAction, opts.adapter);
-  const hover = createHoverState(store);
-  const viewport = createViewportState();
-  const addAnnotation = (annotation, origin = Origin.LOCAL) => {
-    const revived = reviveAnnotation(annotation, container);
-    const isValid = isRevived(revived.target.selector);
-    if (isValid)
-      store.addAnnotation(revived, origin);
-    return isValid;
-  };
-  const bulkAddAnnotation = (annotations, replace = true, origin = Origin.LOCAL) => {
-    const revived = annotations.map((a) => reviveAnnotation(a, container));
-    const couldNotRevive = revived.filter((a) => !isRevived(a.target.selector));
-    store.bulkAddAnnotation(revived, replace, origin);
-    return couldNotRevive;
-  };
-  const bulkUpsertAnnotations = (annotations, origin = Origin.LOCAL) => {
-    const revived = annotations.map((a) => reviveAnnotation(a, container));
-    const couldNotRevive = revived.filter((a) => !isRevived(a.target.selector));
-    revived.forEach((a) => {
-      if (store.getAnnotation(a.id))
-        store.updateAnnotation(a, origin);
-      else
-        store.addAnnotation(a, origin);
-    });
-    return couldNotRevive;
-  };
-  const updateTarget = (target, origin = Origin.LOCAL) => {
-    const revived = reviveTarget(target, container);
-    store.updateTarget(revived, origin);
-  };
-  const bulkUpdateTargets = (targets, origin = Origin.LOCAL) => {
-    const revived = targets.map((t) => reviveTarget(t, container));
-    store.bulkUpdateTargets(revived, origin);
-  };
-  function getAt(x, y, all, filter) {
-    const getAll = all || Boolean(filter);
-    const annotations = tree.getAt(x, y, getAll).map((id) => store.getAnnotation(id));
-    const filtered = filter ? annotations.filter(filter) : annotations;
-    if (filtered.length === 0)
-      return void 0;
-    return all ? filtered : filtered[0];
+    all: a,
+    clear: r,
+    getAt: f,
+    getAnnotationBounds: A,
+    getAnnotationRects: p,
+    getIntersecting: (y, C, S, L) => {
+      const B = n.search({ minX: y, minY: C, maxX: S, maxY: L }), T = new Set(B.map((R) => R.annotation.id));
+      return Array.from(T).map((R) => ({
+        annotation: t.getAnnotation(R),
+        rects: p(R)
+      })).filter((R) => !!R.annotation);
+    },
+    insert: l,
+    recalculate: () => {
+      u(t.all().map((y) => y.target), !0), i.emit("recalculate");
+    },
+    remove: d,
+    set: u,
+    size: () => n.all().length,
+    update: g,
+    on: (y, C) => i.on(y, C)
+  };
+}, ho = (t, e) => {
+  const n = Un(), o = fo(n, t), i = Sn(n, e.userSelectAction, e.adapter), s = vn(n), a = Kn(), r = (c, y = k.LOCAL) => {
+    const C = Ct(c, t), S = F(C.target.selector);
+    return S && n.addAnnotation(C, y), S;
+  }, l = (c, y = !0, C = k.LOCAL) => {
+    const S = c.map((B) => Ct(B, t)), L = S.filter((B) => !F(B.target.selector));
+    return n.bulkAddAnnotation(S, y, C), L;
+  }, d = (c, y = k.LOCAL) => {
+    const C = c.map((L) => Ct(L, t)), S = C.filter((L) => !F(L.target.selector));
+    return C.forEach((L) => {
+      n.getAnnotation(L.id) ? n.updateAnnotation(L, y) : n.addAnnotation(L, y);
+    }), S;
+  }, g = (c, y = k.LOCAL) => {
+    const C = vt(c, t);
+    n.updateTarget(C, y);
+  }, u = (c, y = k.LOCAL) => {
+    const C = c.map((S) => vt(S, t));
+    n.bulkUpdateTargets(C, y);
+  };
+  function f(c, y, C, S) {
+    const L = C || !!S, B = o.getAt(c, y, L).map((R) => n.getAnnotation(R)), T = S ? B.filter(S) : B;
+    if (T.length !== 0)
+      return C ? T : T[0];
   }
-  const getAnnotationBounds = (id) => {
-    const rects = tree.getAnnotationRects(id);
-    return rects.length > 0 ? tree.getAnnotationBounds(id) : void 0;
-  };
-  const getIntersecting = (minX, minY, maxX, maxY) => tree.getIntersecting(minX, minY, maxX, maxY);
-  const getAnnotationRects = (id) => tree.getAnnotationRects(id);
-  const recalculatePositions = () => tree.recalculate();
-  const onRecalculatePositions = (callback) => tree.on("recalculate", callback);
-  store.observe(({ changes }) => {
-    const deleted = (changes.deleted || []).filter((a) => isRevived(a.target.selector));
-    const created = (changes.created || []).filter((a) => isRevived(a.target.selector));
-    const updated = (changes.updated || []).filter((u) => isRevived(u.newValue.target.selector));
-    if ((deleted == null ? void 0 : deleted.length) > 0)
-      deleted.forEach((a) => tree.remove(a.target));
-    if (created.length > 0)
-      tree.set(created.map((a) => a.target), false);
-    if ((updated == null ? void 0 : updated.length) > 0)
-      updated.forEach(({ newValue }) => tree.update(newValue.target));
-  });
-  return {
+  const A = (c) => o.getAnnotationRects(c).length > 0 ? o.getAnnotationBounds(c) : void 0, p = (c, y, C, S) => o.getIntersecting(c, y, C, S), b = (c) => o.getAnnotationRects(c), x = () => o.recalculate(), m = (c) => o.on("recalculate", c);
+  return n.observe(({ changes: c }) => {
+    const y = (c.deleted || []).filter((L) => F(L.target.selector)), C = (c.created || []).filter((L) => F(L.target.selector)), S = (c.updated || []).filter((L) => F(L.newValue.target.selector));
+    (y == null ? void 0 : y.length) > 0 && y.forEach((L) => o.remove(L.target)), C.length > 0 && o.set(C.map((L) => L.target), !1), (S == null ? void 0 : S.length) > 0 && S.forEach(({ newValue: L }) => o.update(L.target));
+  }), {
     store: {
-      ...store,
-      addAnnotation,
-      bulkAddAnnotation,
-      bulkUpdateTargets,
-      bulkUpsertAnnotations,
-      getAnnotationBounds,
-      getAnnotationRects,
-      getIntersecting,
-      getAt,
-      recalculatePositions,
-      onRecalculatePositions,
-      updateTarget
+      ...n,
+      addAnnotation: r,
+      bulkAddAnnotation: l,
+      bulkUpdateTargets: u,
+      bulkUpsertAnnotations: d,
+      getAnnotationBounds: A,
+      getAnnotationRects: b,
+      getIntersecting: p,
+      getAt: f,
+      recalculatePositions: x,
+      onRecalculatePositions: m,
+      updateTarget: g
+    },
+    selection: i,
+    hover: s,
+    viewport: a
+  };
+}, po = () => {
+  const t = document.createElement("canvas");
+  t.width = 2 * window.innerWidth, t.height = 2 * window.innerHeight, t.className = "r6o-presence-layer";
+  const e = t.getContext("2d");
+  return e.scale(2, 2), e.translate(0.5, 0.5), t;
+}, go = (t, e = {}) => {
+  const n = po(), o = n.getContext("2d");
+  document.body.appendChild(n);
+  const i = /* @__PURE__ */ new Map(), s = (g) => Array.from(i.entries()).filter(([u, f]) => f.presenceKey === g.presenceKey).map(([u, f]) => u);
+  return t.on("selectionChange", (g, u) => {
+    s(g).forEach((A) => i.delete(A)), u && u.forEach((A) => i.set(A, g));
+  }), {
+    clear: () => {
+      const { width: g, height: u } = n;
+      o.clearRect(-0.5, -0.5, g + 1, u + 1);
+    },
+    destroy: () => {
+      n.remove();
+    },
+    paint: (g, u, f) => {
+      e.font && (o.font = e.font);
+      const A = i.get(g.annotation.id);
+      if (A) {
+        const { height: p } = g.rects[0], b = g.rects[0].x + u.left, x = g.rects[0].y + u.top;
+        o.fillStyle = A.appearance.color, o.fillRect(b - 2, x - 2.5, 2, p + 5);
+        const m = o.measureText(A.appearance.label), c = m.width + 6, y = m.actualBoundingBoxAscent + m.actualBoundingBoxDescent + 8, C = m.fontBoundingBoxAscent ? 8 : 6.5;
+        return o.fillRect(b - 2, x - 2.5 - y, c, y), o.fillStyle = "#fff", o.fillText(A.appearance.label, b + 1, x - C), {
+          fill: A.appearance.color,
+          fillOpacity: f ? 0.45 : 0.18
+        };
+      }
     },
-    selection,
-    hover,
-    viewport
+    reset: () => {
+      n.width = 2 * window.innerWidth, n.height = 2 * window.innerHeight;
+      const g = n.getContext("2d");
+      g.scale(2, 2), g.translate(0.5, 0.5);
+    }
   };
-};
-const createCanvas = () => {
-  const canvas = document.createElement("canvas");
-  canvas.width = 2 * window.innerWidth;
-  canvas.height = 2 * window.innerHeight;
-  canvas.className = "r6o-presence-layer";
-  const context = canvas.getContext("2d");
-  context.scale(2, 2);
-  context.translate(0.5, 0.5);
-  return canvas;
-};
-const createPresencePainter = (provider, opts = {}) => {
-  const canvas = createCanvas();
-  const ctx = canvas.getContext("2d");
-  document.body.appendChild(canvas);
-  const trackedAnnotations = /* @__PURE__ */ new Map();
-  const getAnnotationsForUser = (p) => Array.from(trackedAnnotations.entries()).filter(([id, user]) => user.presenceKey === p.presenceKey).map(([id, _]) => id);
-  provider.on("selectionChange", (p, selection) => {
-    const currentIds = getAnnotationsForUser(p);
-    currentIds.forEach((id) => trackedAnnotations.delete(id));
-    if (selection)
-      selection.forEach((id) => trackedAnnotations.set(id, p));
+}, Dt = typeof navigator < "u" ? navigator.userAgent.toLowerCase().indexOf("firefox") > 0 : !1;
+function Vt(t, e, n, o) {
+  t.addEventListener ? t.addEventListener(e, n, o) : t.attachEvent && t.attachEvent("on".concat(e), n);
+}
+function it(t, e, n, o) {
+  t.removeEventListener ? t.removeEventListener(e, n, o) : t.detachEvent && t.detachEvent("on".concat(e), n);
+}
+function Ee(t, e) {
+  const n = e.slice(0, e.length - 1);
+  for (let o = 0; o < n.length; o++) n[o] = t[n[o].toLowerCase()];
+  return n;
+}
+function Se(t) {
+  typeof t != "string" && (t = ""), t = t.replace(/\s/g, "");
+  const e = t.split(",");
+  let n = e.lastIndexOf("");
+  for (; n >= 0; )
+    e[n - 1] += ",", e.splice(n, 1), n = e.lastIndexOf("");
+  return e;
+}
+function mo(t, e) {
+  const n = t.length >= e.length ? t : e, o = t.length >= e.length ? e : t;
+  let i = !0;
+  for (let s = 0; s < n.length; s++)
+    o.indexOf(n[s]) === -1 && (i = !1);
+  return i;
+}
+const dt = {
+  backspace: 8,
+  "⌫": 8,
+  tab: 9,
+  clear: 12,
+  enter: 13,
+  "↩": 13,
+  return: 13,
+  esc: 27,
+  escape: 27,
+  space: 32,
+  left: 37,
+  up: 38,
+  right: 39,
+  down: 40,
+  del: 46,
+  delete: 46,
+  ins: 45,
+  insert: 45,
+  home: 36,
+  end: 35,
+  pageup: 33,
+  pagedown: 34,
+  capslock: 20,
+  num_0: 96,
+  num_1: 97,
+  num_2: 98,
+  num_3: 99,
+  num_4: 100,
+  num_5: 101,
+  num_6: 102,
+  num_7: 103,
+  num_8: 104,
+  num_9: 105,
+  num_multiply: 106,
+  num_add: 107,
+  num_enter: 108,
+  num_subtract: 109,
+  num_decimal: 110,
+  num_divide: 111,
+  "⇪": 20,
+  ",": 188,
+  ".": 190,
+  "/": 191,
+  "`": 192,
+  "-": Dt ? 173 : 189,
+  "=": Dt ? 61 : 187,
+  ";": Dt ? 59 : 186,
+  "'": 222,
+  "[": 219,
+  "]": 221,
+  "\\": 220
+}, H = {
+  // shiftKey
+  "⇧": 16,
+  shift: 16,
+  // altKey
+  "⌥": 18,
+  alt: 18,
+  option: 18,
+  // ctrlKey
+  "⌃": 17,
+  ctrl: 17,
+  control: 17,
+  // metaKey
+  "⌘": 91,
+  cmd: 91,
+  command: 91
+}, xt = {
+  16: "shiftKey",
+  18: "altKey",
+  17: "ctrlKey",
+  91: "metaKey",
+  shiftKey: 16,
+  ctrlKey: 17,
+  altKey: 18,
+  metaKey: 91
+}, K = {
+  16: !1,
+  18: !1,
+  17: !1,
+  91: !1
+}, N = {};
+for (let t = 1; t < 20; t++)
+  dt["f".concat(t)] = 111 + t;
+let I = [], lt = null, Ce = "all";
+const z = /* @__PURE__ */ new Map(), ft = (t) => dt[t.toLowerCase()] || H[t.toLowerCase()] || t.toUpperCase().charCodeAt(0), yo = (t) => Object.keys(dt).find((e) => dt[e] === t), bo = (t) => Object.keys(H).find((e) => H[e] === t);
+function Le(t) {
+  Ce = t || "all";
+}
+function ut() {
+  return Ce || "all";
+}
+function wo() {
+  return I.slice(0);
+}
+function Ao() {
+  return I.map((t) => yo(t) || bo(t) || String.fromCharCode(t));
+}
+function xo() {
+  const t = [];
+  return Object.keys(N).forEach((e) => {
+    N[e].forEach((n) => {
+      let {
+        key: o,
+        scope: i,
+        mods: s,
+        shortcut: a
+      } = n;
+      t.push({
+        scope: i,
+        shortcut: a,
+        mods: s,
+        keys: o.split("+").map((r) => ft(r))
+      });
+    });
+  }), t;
+}
+function vo(t) {
+  const e = t.target || t.srcElement, {
+    tagName: n
+  } = e;
+  let o = !0;
+  const i = n === "INPUT" && !["checkbox", "radio", "range", "button", "file", "reset", "submit", "color"].includes(e.type);
+  return (e.isContentEditable || (i || n === "TEXTAREA" || n === "SELECT") && !e.readOnly) && (o = !1), o;
+}
+function Eo(t) {
+  return typeof t == "string" && (t = ft(t)), I.indexOf(t) !== -1;
+}
+function So(t, e) {
+  let n, o;
+  t || (t = ut());
+  for (const i in N)
+    if (Object.prototype.hasOwnProperty.call(N, i))
+      for (n = N[i], o = 0; o < n.length; )
+        n[o].scope === t ? n.splice(o, 1).forEach((a) => {
+          let {
+            element: r
+          } = a;
+          return jt(r);
+        }) : o++;
+  ut() === t && Le(e || "all");
+}
+function Co(t) {
+  let e = t.keyCode || t.which || t.charCode;
+  const n = I.indexOf(e);
+  if (n >= 0 && I.splice(n, 1), t.key && t.key.toLowerCase() === "meta" && I.splice(0, I.length), (e === 93 || e === 224) && (e = 91), e in K) {
+    K[e] = !1;
+    for (const o in H) H[o] === e && (X[o] = !1);
+  }
+}
+function Te(t) {
+  if (typeof t > "u")
+    Object.keys(N).forEach((i) => {
+      Array.isArray(N[i]) && N[i].forEach((s) => At(s)), delete N[i];
+    }), jt(null);
+  else if (Array.isArray(t))
+    t.forEach((i) => {
+      i.key && At(i);
+    });
+  else if (typeof t == "object")
+    t.key && At(t);
+  else if (typeof t == "string") {
+    for (var e = arguments.length, n = new Array(e > 1 ? e - 1 : 0), o = 1; o < e; o++)
+      n[o - 1] = arguments[o];
+    let [i, s] = n;
+    typeof i == "function" && (s = i, i = ""), At({
+      key: t,
+      scope: i,
+      method: s,
+      splitKey: "+"
+    });
+  }
+}
+const At = (t) => {
+  let {
+    key: e,
+    scope: n,
+    method: o,
+    splitKey: i = "+"
+  } = t;
+  Se(e).forEach((a) => {
+    const r = a.split(i), l = r.length, d = r[l - 1], g = d === "*" ? "*" : ft(d);
+    if (!N[g]) return;
+    n || (n = ut());
+    const u = l > 1 ? Ee(H, r) : [], f = [];
+    N[g] = N[g].filter((A) => {
+      const b = (o ? A.method === o : !0) && A.scope === n && mo(A.mods, u);
+      return b && f.push(A.element), !b;
+    }), f.forEach((A) => jt(A));
   });
-  const clear = () => {
-    const { width, height } = canvas;
-    ctx.clearRect(-0.5, -0.5, width + 1, height + 1);
-  };
-  const paint2 = (highlight, viewportBounds, isSelected) => {
-    if (opts.font)
-      ctx.font = opts.font;
-    const user = trackedAnnotations.get(highlight.annotation.id);
-    if (user) {
-      const { height } = highlight.rects[0];
-      const x = highlight.rects[0].x + viewportBounds.left;
-      const y = highlight.rects[0].y + viewportBounds.top;
-      ctx.fillStyle = user.appearance.color;
-      ctx.fillRect(x - 2, y - 2.5, 2, height + 5);
-      const metrics = ctx.measureText(user.appearance.label);
-      const labelWidth = metrics.width + 6;
-      const labelHeight = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent + 8;
-      const paddingBottom = metrics.fontBoundingBoxAscent ? 8 : 6.5;
-      ctx.fillRect(x - 2, y - 2.5 - labelHeight, labelWidth, labelHeight);
-      ctx.fillStyle = "#fff";
-      ctx.fillText(user.appearance.label, x + 1, y - paddingBottom);
-      return {
-        fill: user.appearance.color,
-        fillOpacity: isSelected ? 0.45 : 0.18
+};
+function ae(t, e, n, o) {
+  if (e.element !== o)
+    return;
+  let i;
+  if (e.scope === n || e.scope === "all") {
+    i = e.mods.length > 0;
+    for (const s in K)
+      Object.prototype.hasOwnProperty.call(K, s) && (!K[s] && e.mods.indexOf(+s) > -1 || K[s] && e.mods.indexOf(+s) === -1) && (i = !1);
+    (e.mods.length === 0 && !K[16] && !K[18] && !K[17] && !K[91] || i || e.shortcut === "*") && (e.keys = [], e.keys = e.keys.concat(I), e.method(t, e) === !1 && (t.preventDefault ? t.preventDefault() : t.returnValue = !1, t.stopPropagation && t.stopPropagation(), t.cancelBubble && (t.cancelBubble = !0)));
+  }
+}
+function ce(t, e) {
+  const n = N["*"];
+  let o = t.keyCode || t.which || t.charCode;
+  if (!X.filter.call(this, t)) return;
+  if ((o === 93 || o === 224) && (o = 91), I.indexOf(o) === -1 && o !== 229 && I.push(o), ["metaKey", "ctrlKey", "altKey", "shiftKey"].forEach((r) => {
+    const l = xt[r];
+    t[r] && I.indexOf(l) === -1 ? I.push(l) : !t[r] && I.indexOf(l) > -1 ? I.splice(I.indexOf(l), 1) : r === "metaKey" && t[r] && (I = I.filter((d) => d in xt || d === o));
+  }), o in K) {
+    K[o] = !0;
+    for (const r in H)
+      H[r] === o && (X[r] = !0);
+    if (!n) return;
+  }
+  for (const r in K)
+    Object.prototype.hasOwnProperty.call(K, r) && (K[r] = t[xt[r]]);
+  t.getModifierState && !(t.altKey && !t.ctrlKey) && t.getModifierState("AltGraph") && (I.indexOf(17) === -1 && I.push(17), I.indexOf(18) === -1 && I.push(18), K[17] = !0, K[18] = !0);
+  const i = ut();
+  if (n)
+    for (let r = 0; r < n.length; r++)
+      n[r].scope === i && (t.type === "keydown" && n[r].keydown || t.type === "keyup" && n[r].keyup) && ae(t, n[r], i, e);
+  if (!(o in N)) return;
+  const s = N[o], a = s.length;
+  for (let r = 0; r < a; r++)
+    if ((t.type === "keydown" && s[r].keydown || t.type === "keyup" && s[r].keyup) && s[r].key) {
+      const l = s[r], {
+        splitKey: d
+      } = l, g = l.key.split(d), u = [];
+      for (let f = 0; f < g.length; f++)
+        u.push(ft(g[f]));
+      u.sort().join("") === I.sort().join("") && ae(t, l, i, e);
+    }
+}
+function X(t, e, n) {
+  I = [];
+  const o = Se(t);
+  let i = [], s = "all", a = document, r = 0, l = !1, d = !0, g = "+", u = !1, f = !1;
+  for (n === void 0 && typeof e == "function" && (n = e), Object.prototype.toString.call(e) === "[object Object]" && (e.scope && (s = e.scope), e.element && (a = e.element), e.keyup && (l = e.keyup), e.keydown !== void 0 && (d = e.keydown), e.capture !== void 0 && (u = e.capture), typeof e.splitKey == "string" && (g = e.splitKey), e.single === !0 && (f = !0)), typeof e == "string" && (s = e), f && Te(t, s); r < o.length; r++)
+    t = o[r].split(g), i = [], t.length > 1 && (i = Ee(H, t)), t = t[t.length - 1], t = t === "*" ? "*" : ft(t), t in N || (N[t] = []), N[t].push({
+      keyup: l,
+      keydown: d,
+      scope: s,
+      mods: i,
+      shortcut: o[r],
+      method: n,
+      key: o[r],
+      splitKey: g,
+      element: a
+    });
+  if (typeof a < "u" && window) {
+    if (!z.has(a)) {
+      const A = function() {
+        let b = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : window.event;
+        return ce(b, a);
+      }, p = function() {
+        let b = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : window.event;
+        ce(b, a), Co(b);
       };
+      z.set(a, {
+        keydownListener: A,
+        keyupListenr: p,
+        capture: u
+      }), Vt(a, "keydown", A, u), Vt(a, "keyup", p, u);
     }
-  };
-  const reset = () => {
-    canvas.width = 2 * window.innerWidth;
-    canvas.height = 2 * window.innerHeight;
-    const context = canvas.getContext("2d");
-    context.scale(2, 2);
-    context.translate(0.5, 0.5);
-  };
-  const destroy = () => {
-    canvas.remove();
-  };
-  return {
-    clear,
-    destroy,
-    paint: paint2,
-    reset
-  };
-};
-const CLICK_TIMEOUT = 300;
-const ARROW_KEYS = ["up", "down", "left", "right"];
-const SELECT_ALL = isMac ? "⌘+a" : "ctrl+a";
-const SELECTION_KEYS = [
-  ...ARROW_KEYS.map((key) => `shift+${key}`),
-  SELECT_ALL
-];
-const createSelectionHandler = (container, state, options) => {
-  const { store, selection } = state;
-  let currentUser;
-  const { annotatingEnabled, offsetReferenceSelector, selectionMode } = options;
-  const setUser = (user) => currentUser = user;
-  let currentFilter;
-  const setFilter = (filter) => currentFilter = filter;
-  let currentTarget;
-  let isLeftClick;
-  let lastDownEvent;
-  let currentAnnotatingEnabled = annotatingEnabled;
-  const setAnnotatingEnabled = (enabled) => {
-    currentAnnotatingEnabled = enabled;
-    onSelectionChange.clear();
-    if (!enabled) {
-      currentTarget = void 0;
-      isLeftClick = void 0;
-      lastDownEvent = void 0;
+    if (!lt) {
+      const A = () => {
+        I = [];
+      };
+      lt = {
+        listener: A,
+        capture: u
+      }, Vt(window, "focus", A, u);
     }
-  };
-  const onSelectStart = (evt) => {
-    if (!currentAnnotatingEnabled) return;
-    if (isLeftClick === false) return;
-    currentTarget = isNotAnnotatable(evt.target) ? void 0 : {
-      annotation: v4(),
+  }
+}
+function Lo(t) {
+  let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "all";
+  Object.keys(N).forEach((n) => {
+    N[n].filter((i) => i.scope === e && i.shortcut === t).forEach((i) => {
+      i && i.method && i.method();
+    });
+  });
+}
+function jt(t) {
+  const e = Object.values(N).flat();
+  if (e.findIndex((o) => {
+    let {
+      element: i
+    } = o;
+    return i === t;
+  }) < 0) {
+    const {
+      keydownListener: o,
+      keyupListenr: i,
+      capture: s
+    } = z.get(t) || {};
+    o && i && (it(t, "keyup", i, s), it(t, "keydown", o, s), z.delete(t));
+  }
+  if ((e.length <= 0 || z.size <= 0) && (Object.keys(z).forEach((i) => {
+    const {
+      keydownListener: s,
+      keyupListenr: a,
+      capture: r
+    } = z.get(i) || {};
+    s && a && (it(i, "keyup", a, r), it(i, "keydown", s, r), z.delete(i));
+  }), z.clear(), Object.keys(N).forEach((i) => delete N[i]), lt)) {
+    const {
+      listener: i,
+      capture: s
+    } = lt;
+    it(window, "focus", i, s), lt = null;
+  }
+}
+const Yt = {
+  getPressedKeyString: Ao,
+  setScope: Le,
+  getScope: ut,
+  deleteScope: So,
+  getPressedKeyCodes: wo,
+  getAllKeyCodes: xo,
+  isPressed: Eo,
+  filter: vo,
+  trigger: Lo,
+  unbind: Te,
+  keyMap: dt,
+  modifier: H,
+  modifierMap: xt
+};
+for (const t in Yt)
+  Object.prototype.hasOwnProperty.call(Yt, t) && (X[t] = Yt[t]);
+if (typeof window < "u") {
+  const t = window.hotkeys;
+  X.noConflict = (e) => (e && window.hotkeys === X && (window.hotkeys = t), X), window.hotkeys = X;
+}
+async function To(t, e, n = () => !1) {
+  do {
+    if (await t(), await n()) break;
+    const o = e;
+    await new Promise((i) => setTimeout(i, Math.max(0, o)));
+  } while (!await n());
+}
+const le = 300, Oe = ["up", "down", "left", "right"], Be = ke ? "⌘+a" : "ctrl+a", Oo = [
+  ...Oe.map((t) => `shift+${t}`),
+  Be
+], Bo = (t, e, n) => {
+  const { store: o, selection: i } = e;
+  let s;
+  const { annotatingEnabled: a, offsetReferenceSelector: r, selectionMode: l } = n, d = (h) => s = h;
+  let g;
+  const u = (h) => g = h;
+  let f, A, p, b = a;
+  const x = (h) => {
+    b = h, c.clear(), h || (f = void 0, A = void 0, p = void 0);
+  }, m = (h) => {
+    b && A !== !1 && (f = st(h.target) ? void 0 : {
+      annotation: be(),
       selector: [],
-      creator: currentUser,
+      creator: s,
       created: /* @__PURE__ */ new Date()
-    };
-  };
-  const onSelectionChange = debounce((evt) => {
-    if (!currentAnnotatingEnabled) return;
-    const sel = document.getSelection();
-    if (!(sel == null ? void 0 : sel.anchorNode)) {
+    });
+  }, c = Xt((h) => {
+    if (!b) return;
+    const E = document.getSelection();
+    if (!(E != null && E.anchorNode))
       return;
-    }
-    if (isNotAnnotatable(sel.anchorNode)) {
-      currentTarget = void 0;
+    if (st(E.anchorNode)) {
+      f = void 0;
       return;
     }
-    const timeDifference = evt.timeStamp - ((lastDownEvent == null ? void 0 : lastDownEvent.timeStamp) || evt.timeStamp);
-    if ((lastDownEvent == null ? void 0 : lastDownEvent.type) === "pointerdown") {
-      if (timeDifference < 1e3 && !currentTarget) {
-        onSelectStart(lastDownEvent || evt);
-      } else if (sel.isCollapsed && timeDifference < CLICK_TIMEOUT) {
-        onSelectStart(lastDownEvent || evt);
-      }
-    }
-    if (!currentTarget) return;
-    if (sel.isCollapsed) {
-      if (store.getAnnotation(currentTarget.annotation)) {
-        selection.clear();
-        store.deleteAnnotation(currentTarget.annotation);
-      }
+    const M = h.timeStamp - ((p == null ? void 0 : p.timeStamp) || h.timeStamp);
+    if ((p == null ? void 0 : p.type) === "pointerdown" && (M < 1e3 && !f || E.isCollapsed && M < le) && m(p || h), !f) return;
+    if (E.isCollapsed) {
+      o.getAnnotation(f.annotation) && (i.clear(), o.deleteAnnotation(f.annotation));
       return;
     }
-    const selectionRange = sel.getRangeAt(0);
-    const containedRange = trimRangeToContainer(selectionRange, container);
-    if (isWhitespaceOrEmpty(containedRange)) return;
-    const annotatableRanges = splitAnnotatableRanges(containedRange.cloneRange());
-    const hasChanged = annotatableRanges.length !== currentTarget.selector.length || annotatableRanges.some((r, i) => {
-      var _a;
-      return r.toString() !== ((_a = currentTarget.selector[i]) == null ? void 0 : _a.quote);
-    });
-    if (!hasChanged) return;
-    currentTarget = {
-      ...currentTarget,
-      selector: annotatableRanges.map((r) => rangeToSelector(r, container, offsetReferenceSelector)),
+    const O = E.getRangeAt(0), U = He(O, t);
+    if (Ve(U)) return;
+    const _ = _e(U.cloneRange());
+    (_.length !== f.selector.length || _.some((W, G) => {
+      var St;
+      return W.toString() !== ((St = f.selector[G]) == null ? void 0 : St.quote);
+    })) && (f = {
+      ...f,
+      selector: _.map((W) => Xe(W, t, r)),
       updated: /* @__PURE__ */ new Date()
+    }, o.getAnnotation(f.annotation) ? o.updateTarget(f, k.LOCAL) : i.clear());
+  }, 10), y = (h) => {
+    st(h.target) || (p = Lt(h), A = p.button === 0);
+  }, C = async (h) => {
+    if (st(h.target) || !A) return;
+    const E = () => {
+      const { x: O, y: U } = t.getBoundingClientRect(), _ = h.target instanceof Node && t.contains(h.target) && o.getAt(h.clientX - O, h.clientY - U, l === "all", g);
+      if (_) {
+        const { selected: ht } = i, W = new Set(ht.map((nt) => nt.id)), G = Array.isArray(_) ? _.map((nt) => nt.id) : [_.id];
+        (W.size !== G.length || !G.every((nt) => W.has(nt))) && i.userSelect(G, h);
+      } else
+        i.clear();
     };
-    if (store.getAnnotation(currentTarget.annotation)) {
-      store.updateTarget(currentTarget, Origin.LOCAL);
-    } else {
-      selection.clear();
-    }
-  }, 10);
-  const onPointerDown = (evt) => {
-    if (isNotAnnotatable(evt.target)) return;
-    lastDownEvent = clonePointerEvent(evt);
-    isLeftClick = lastDownEvent.button === 0;
-  };
-  const onPointerUp = async (evt) => {
-    if (isNotAnnotatable(evt.target) || !isLeftClick) return;
-    const clickSelect = () => {
-      const { x, y } = container.getBoundingClientRect();
-      const hovered = evt.target instanceof Node && container.contains(evt.target) && store.getAt(evt.clientX - x, evt.clientY - y, selectionMode === "all", currentFilter);
-      if (hovered) {
-        const { selected } = selection;
-        const currentIds = new Set(selected.map((s) => s.id));
-        const nextIds = Array.isArray(hovered) ? hovered.map((a) => a.id) : [hovered.id];
-        const hasChanged = currentIds.size !== nextIds.length || !nextIds.every((id) => currentIds.has(id));
-        if (hasChanged)
-          selection.userSelect(nextIds, evt);
-      } else {
-        selection.clear();
-      }
-    };
-    const timeDifference = evt.timeStamp - lastDownEvent.timeStamp;
-    if (timeDifference < CLICK_TIMEOUT) {
-      await pollSelectionCollapsed();
-      const sel = document.getSelection();
-      if (sel == null ? void 0 : sel.isCollapsed) {
-        currentTarget = void 0;
-        clickSelect();
+    if (h.timeStamp - p.timeStamp < le) {
+      await S();
+      const O = document.getSelection();
+      if (O != null && O.isCollapsed) {
+        f = void 0, E();
         return;
       }
     }
-    if (currentTarget && currentTarget.selector.length > 0) {
-      upsertCurrentTarget();
-      selection.userSelect(currentTarget.annotation, clonePointerEvent(evt));
-    }
-  };
-  const pollSelectionCollapsed = async () => {
-    const sel = document.getSelection();
-    let stopPolling = false;
-    let isCollapsed = sel == null ? void 0 : sel.isCollapsed;
-    const shouldStopPolling = () => isCollapsed || stopPolling;
-    const pollingDelayMs = 1;
-    const stopPollingInMs = 50;
-    setTimeout(() => stopPolling = true, stopPollingInMs);
-    return poll(() => isCollapsed = sel == null ? void 0 : sel.isCollapsed, pollingDelayMs, shouldStopPolling);
-  };
-  const onContextMenu = (evt) => {
-    const sel = document.getSelection();
-    if (sel == null ? void 0 : sel.isCollapsed) return;
-    if (!currentTarget || currentTarget.selector.length === 0) {
-      onSelectionChange(evt);
-    }
-    upsertCurrentTarget();
-    selection.userSelect(currentTarget.annotation, clonePointerEvent(evt));
-  };
-  const onKeyup = (evt) => {
-    if (!currentAnnotatingEnabled) return;
-    if (evt.key === "Shift" && currentTarget) {
-      const sel = document.getSelection();
-      if (!sel.isCollapsed) {
-        upsertCurrentTarget();
-        selection.userSelect(currentTarget.annotation, cloneKeyboardEvent(evt));
-      }
-    }
-  };
-  const onSelectAll = (evt) => {
-    const onSelected = () => setTimeout(() => {
-      if ((currentTarget == null ? void 0 : currentTarget.selector.length) > 0) {
-        selection.clear();
-        store.addAnnotation({
-          id: currentTarget.annotation,
-          bodies: [],
-          target: currentTarget
-        });
-        selection.userSelect(currentTarget.annotation, cloneKeyboardEvent(evt));
-      }
-      document.removeEventListener("selectionchange", onSelected);
+    f && f.selector.length > 0 && (w(), i.userSelect(f.annotation, Lt(h)));
+  }, S = async () => {
+    const h = document.getSelection();
+    let E = !1, M = h == null ? void 0 : h.isCollapsed;
+    const O = () => M || E, U = 1;
+    return setTimeout(() => E = !0, 50), To(() => M = h == null ? void 0 : h.isCollapsed, U, O);
+  }, L = (h) => {
+    const E = document.getSelection();
+    E != null && E.isCollapsed || ((!f || f.selector.length === 0) && c(h), w(), i.userSelect(f.annotation, Lt(h)));
+  }, B = (h) => {
+    b && h.key === "Shift" && f && (document.getSelection().isCollapsed || (w(), i.userSelect(f.annotation, pt(h))));
+  }, T = (h) => {
+    const E = () => setTimeout(() => {
+      (f == null ? void 0 : f.selector.length) > 0 && (i.clear(), o.addAnnotation({
+        id: f.annotation,
+        bodies: [],
+        target: f
+      }), i.userSelect(f.annotation, pt(h))), document.removeEventListener("selectionchange", E);
     }, 100);
-    document.addEventListener("selectionchange", onSelected);
-    onSelectStart(evt);
+    document.addEventListener("selectionchange", E), m(h);
   };
-  hotkeys(SELECTION_KEYS.join(","), { element: container, keydown: true, keyup: false }, (evt) => {
-    if (!evt.repeat)
-      lastDownEvent = cloneKeyboardEvent(evt);
-  });
-  hotkeys(SELECT_ALL, { keydown: true, keyup: false }, (evt) => {
-    lastDownEvent = cloneKeyboardEvent(evt);
-    onSelectAll(evt);
+  X(Oo.join(","), { element: t, keydown: !0, keyup: !1 }, (h) => {
+    h.repeat || (p = pt(h));
+  }), X(Be, { keydown: !0, keyup: !1 }, (h) => {
+    p = pt(h), T(h);
   });
-  const handleArrowKeyPress = (evt) => {
-    if (evt.repeat || evt.target !== container && evt.target !== document.body) {
-      return;
-    }
-    currentTarget = void 0;
-    selection.clear();
-  };
-  hotkeys(ARROW_KEYS.join(","), { keydown: true, keyup: false }, handleArrowKeyPress);
-  const upsertCurrentTarget = () => {
-    const existingAnnotation = store.getAnnotation(currentTarget.annotation);
-    if (!existingAnnotation) {
-      store.addAnnotation({
-        id: currentTarget.annotation,
+  const R = (h) => {
+    h.repeat || h.target !== t && h.target !== document.body || (f = void 0, i.clear());
+  };
+  X(Oe.join(","), { keydown: !0, keyup: !1 }, R);
+  const w = () => {
+    const h = o.getAnnotation(f.annotation);
+    if (!h) {
+      o.addAnnotation({
+        id: f.annotation,
         bodies: [],
-        target: currentTarget
+        target: f
       });
       return;
     }
-    const { target: { updated: existingTargetUpdated } } = existingAnnotation;
-    const { updated: currentTargetUpdated } = currentTarget;
-    if (!existingTargetUpdated || !currentTargetUpdated || existingTargetUpdated < currentTargetUpdated) {
-      store.updateTarget(currentTarget);
-    }
-  };
-  document.addEventListener("pointerdown", onPointerDown);
-  document.addEventListener("pointerup", onPointerUp);
-  document.addEventListener("contextmenu", onContextMenu);
-  container.addEventListener("keyup", onKeyup);
-  container.addEventListener("selectstart", onSelectStart);
-  document.addEventListener("selectionchange", onSelectionChange);
-  const destroy = () => {
-    currentTarget = void 0;
-    isLeftClick = void 0;
-    lastDownEvent = void 0;
-    onSelectionChange.clear();
-    document.removeEventListener("pointerdown", onPointerDown);
-    document.removeEventListener("pointerup", onPointerUp);
-    document.removeEventListener("contextmenu", onContextMenu);
-    container.removeEventListener("keyup", onKeyup);
-    container.removeEventListener("selectstart", onSelectStart);
-    document.removeEventListener("selectionchange", onSelectionChange);
-    hotkeys.unbind();
+    const { target: { updated: E } } = h, { updated: M } = f;
+    (!E || !M || E < M) && o.updateTarget(f);
   };
-  return {
-    destroy,
-    setFilter,
-    setUser,
-    setAnnotatingEnabled
-  };
-};
-const fillDefaults = (opts, defaults) => ({
-  ...opts,
-  annotatingEnabled: opts.annotatingEnabled ?? defaults.annotatingEnabled,
-  user: opts.user || defaults.user
-});
-const USE_DEFAULT_RENDERER = "SPANS";
-const createTextAnnotator = (container, options = {}) => {
-  cancelSingleClickEvents(container);
-  programmaticallyFocusable(container);
-  const opts = fillDefaults(options, {
-    annotatingEnabled: true,
-    user: createAnonymousGuest()
-  });
-  const state = createTextAnnotatorState(container, opts);
-  const { selection, viewport } = state;
-  const store = state.store;
-  const undoStack = createUndoStack(store);
-  const lifecycle = createLifecycleObserver(state, undoStack, opts.adapter);
-  let currentUser = opts.user;
-  const useRenderer = opts.renderer === "CSS_HIGHLIGHTS" ? Boolean(CSS.highlights) ? "CSS_HIGHLIGHTS" : USE_DEFAULT_RENDERER : opts.renderer || USE_DEFAULT_RENDERER;
-  const highlightRenderer = useRenderer === "SPANS" ? createSpansRenderer(container, state, viewport) : useRenderer === "CSS_HIGHLIGHTS" ? createHighlightsRenderer(container, state, viewport) : useRenderer === "CANVAS" ? createCanvasRenderer(container, state, viewport) : void 0;
-  if (!highlightRenderer)
-    throw `Unknown renderer implementation: ${useRenderer}`;
-  console.debug(`Using ${useRenderer} renderer`);
-  if (opts.style)
-    highlightRenderer.setStyle(opts.style);
-  const selectionHandler = createSelectionHandler(container, state, opts);
-  selectionHandler.setUser(currentUser);
-  selectionHandler.setAnnotatingEnabled(opts.annotatingEnabled);
-  const base = createBaseAnnotator(state, undoStack, opts.adapter);
-  const getUser = () => currentUser;
-  const setAnnotatingEnabled = (enabled) => {
-    selectionHandler.setAnnotatingEnabled(
-      enabled === void 0 ? true : enabled
+  return document.addEventListener("pointerdown", y), document.addEventListener("pointerup", C), document.addEventListener("contextmenu", L), t.addEventListener("keyup", B), t.addEventListener("selectstart", m), document.addEventListener("selectionchange", c), {
+    destroy: () => {
+      f = void 0, A = void 0, p = void 0, c.clear(), document.removeEventListener("pointerdown", y), document.removeEventListener("pointerup", C), document.removeEventListener("contextmenu", L), t.removeEventListener("keyup", B), t.removeEventListener("selectstart", m), document.removeEventListener("selectionchange", c), X.unbind();
+    },
+    setFilter: u,
+    setUser: d,
+    setAnnotatingEnabled: x
+  };
+}, Ro = (t, e) => ({
+  ...t,
+  annotatingEnabled: t.annotatingEnabled ?? e.annotatingEnabled,
+  user: t.user || e.user
+}), de = "SPANS", _o = (t, e = {}) => {
+  Me(t), Ie(t);
+  const n = Ro(e, {
+    annotatingEnabled: !0,
+    user: qn()
+  }), o = ho(t, n), { selection: i, viewport: s } = o, a = o.store, r = Yn(a), l = Pn(o, r, n.adapter);
+  let d = n.user;
+  const g = n.renderer === "CSS_HIGHLIGHTS" ? CSS.highlights ? "CSS_HIGHLIGHTS" : de : n.renderer || de, u = g === "SPANS" ? mn(t, o, s) : g === "CSS_HIGHLIGHTS" ? hn(t, o, s) : g === "CANVAS" ? nn(t, o, s) : void 0;
+  if (!u)
+    throw `Unknown renderer implementation: ${g}`;
+  console.debug(`Using ${g} renderer`), n.style && u.setStyle(n.style);
+  const f = Bo(t, o, n);
+  f.setUser(d), f.setAnnotatingEnabled(n.annotatingEnabled);
+  const A = $n(o, r, n.adapter), p = () => d, b = (S) => {
+    f.setAnnotatingEnabled(
+      S === void 0 ? !0 : S
     );
-  };
-  const setFilter = (filter) => {
-    highlightRenderer.setFilter(filter);
-    selectionHandler.setFilter(filter);
-  };
-  const setUser = (user) => {
-    currentUser = user;
-    selectionHandler.setUser(user);
-  };
-  const setPresenceProvider = (provider) => {
-    if (provider) {
-      highlightRenderer.setPainter(createPresencePainter(provider, opts.presence));
-      provider.on("selectionChange", () => highlightRenderer.redraw());
-    }
-  };
-  const setSelected = (arg) => {
-    if (arg) {
-      selection.setSelected(arg);
-    } else {
-      selection.clear();
-    }
-  };
-  const destroy = () => {
-    highlightRenderer.destroy();
-    selectionHandler.destroy();
-    undoStack.destroy();
+  }, x = (S) => {
+    u.setFilter(S), f.setFilter(S);
+  }, m = (S) => {
+    d = S, f.setUser(S);
+  }, c = (S) => {
+    S && (u.setPainter(go(S, n.presence)), S.on("selectionChange", () => u.redraw()));
+  }, y = (S) => {
+    S ? i.setSelected(S) : i.clear();
   };
   return {
-    ...base,
-    destroy,
-    element: container,
-    getUser,
-    setAnnotatingEnabled,
-    setFilter,
-    setStyle: highlightRenderer.setStyle.bind(highlightRenderer),
-    redraw: highlightRenderer.redraw.bind(highlightRenderer),
-    setUser,
-    setSelected,
-    setPresenceProvider,
-    setVisible: highlightRenderer.setVisible.bind(highlightRenderer),
-    on: lifecycle.on,
-    off: lifecycle.off,
-    scrollIntoView: scrollIntoView(container, store),
-    state
+    ...A,
+    destroy: () => {
+      u.destroy(), f.destroy(), r.destroy();
+    },
+    element: t,
+    getUser: p,
+    setAnnotatingEnabled: b,
+    setFilter: x,
+    setStyle: u.setStyle.bind(u),
+    redraw: u.redraw.bind(u),
+    setUser: m,
+    setSelected: y,
+    setPresenceProvider: c,
+    setVisible: u.setVisible.bind(u),
+    on: l.on,
+    off: l.off,
+    scrollIntoView: ze(t, a),
+    state: o
   };
 };
 export {
-  DEFAULT_SELECTED_STYLE,
-  DEFAULT_STYLE,
-  NOT_ANNOTATABLE_CLASS,
-  NOT_ANNOTATABLE_SELECTOR,
-  Origin2 as Origin,
-  UserSelectAction,
-  W3CTextFormat,
-  cancelSingleClickEvents,
-  cloneKeyboardEvent,
-  clonePointerEvent,
-  createBody,
-  createCanvasRenderer,
-  createHighlightsRenderer,
-  createPresencePainter,
-  createRenderer$1 as createRenderer,
-  createSelectionHandler,
-  createSpansRenderer,
-  createTextAnnotator,
-  createTextAnnotatorState,
-  fillDefaults,
-  getQuoteContext,
-  getRangeAnnotatableContents,
-  isMac,
-  isNotAnnotatable,
-  isRangeAnnotatable,
-  isRevived,
-  isWhitespaceOrEmpty,
-  mergeClientRects,
-  paint,
-  parseW3CTextAnnotation,
-  programmaticallyFocusable,
-  rangeContains,
-  rangeToSelector,
-  reviveAnnotation,
-  reviveSelector,
-  reviveTarget,
-  scrollIntoView,
-  serializeW3CTextAnnotation,
-  splitAnnotatableRanges,
-  toDomRectList,
-  toParentBounds,
-  toViewportBounds,
-  trimRangeToContainer,
-  whitespaceOrEmptyRegex
+  Et as DEFAULT_SELECTED_STYLE,
+  q as DEFAULT_STYLE,
+  ue as NOT_ANNOTATABLE_CLASS,
+  et as NOT_ANNOTATABLE_SELECTOR,
+  k as Origin,
+  En as UserSelectAction,
+  No as W3CTextFormat,
+  Me as cancelSingleClickEvents,
+  pt as cloneKeyboardEvent,
+  Lt as clonePointerEvent,
+  Io as createBody,
+  nn as createCanvasRenderer,
+  hn as createHighlightsRenderer,
+  go as createPresencePainter,
+  fn as createRenderer,
+  Bo as createSelectionHandler,
+  mn as createSpansRenderer,
+  _o as createTextAnnotator,
+  ho as createTextAnnotatorState,
+  Ro as fillDefaults,
+  Ue as getQuoteContext,
+  Kt as getRangeAnnotatableContents,
+  ke as isMac,
+  st as isNotAnnotatable,
+  Re as isRangeAnnotatable,
+  F as isRevived,
+  Ve as isWhitespaceOrEmpty,
+  Pe as mergeClientRects,
+  Fe as paint,
+  eo as parseW3CTextAnnotation,
+  Ie as programmaticallyFocusable,
+  $e as rangeContains,
+  Xe as rangeToSelector,
+  Ct as reviveAnnotation,
+  fe as reviveSelector,
+  vt as reviveTarget,
+  ze as scrollIntoView,
+  no as serializeW3CTextAnnotation,
+  _e as splitAnnotatableRanges,
+  Mo as toDomRectList,
+  je as toParentBounds,
+  ko as toViewportBounds,
+  He as trimRangeToContainer,
+  De as whitespaceOrEmptyRegex
 };
 //# sourceMappingURL=text-annotator.es.js.map