@linloir/limr 0.0.0-stage → 1.0.0

package/dist/chunk-N77VD2YR.js

@@ -0,0 +1,1238 @@
+import {
+  AnnotationCard,
+  Collapse,
+  DocumentProvider,
+  Markdown,
+  OverlayScrollArea,
+  copyText,
+  deleteAnnotations,
+  highlightPalette,
+  highlightSelection,
+  scrollWithMotion,
+  sourceRangeStartRect,
+  useAppearance,
+  useDocument,
+  useDocumentSelector,
+  useIsomorphicLayoutEffect,
+  useLocale,
+  useRuntime,
+  useSelection,
+  useStoreSelector,
+  useTheme
+} from "./chunk-3ILUZKDB.js";
+import {
+  annotationReferenceRange,
+  defaultHighlight,
+  intersects,
+  mapText,
+  rangeOf,
+  resolveAnnotationAnchors,
+  sameRange,
+  selectionFromRange
+} from "./chunk-TTISGBST.js";
+
+// src/components/Reader.tsx
+import { useEffect as useEffect7, useId as useId2, useRef as useRef5, useState as useState5 } from "react";
+
+// src/components/TableOfContents.tsx
+import { useEffect as useEffect2, useRef } from "react";
+
+// src/react/overflow-fade.ts
+import { useEffect } from "react";
+function useOverflowFade(ref, runtime, contentSelector, beforeMeasure) {
+  useEffect(() => {
+    const host = ref.current;
+    if (!host) return;
+    let frame = 0, transitions = 0;
+    const measure = () => {
+      frame = 0;
+      beforeMeasure?.();
+      const box = host.getBoundingClientRect();
+      const viewport = window.visualViewport;
+      let top = Math.max(box.top, viewport?.offsetTop ?? 0);
+      let bottom = Math.min(box.bottom, (viewport?.offsetTop ?? 0) + (viewport?.height ?? innerHeight));
+      const root = runtime.configuration.get().scrollRoot;
+      if (root) {
+        const bounds = root.getBoundingClientRect();
+        top = Math.max(top, bounds.top + root.clientTop);
+        bottom = Math.min(bottom, bounds.top + root.clientTop + root.clientHeight);
+      }
+      const contents = [...host.querySelectorAll(contentSelector)].map((element) => element.getBoundingClientRect());
+      const clipsTop = bottom > top && contents.some((rect) => rect.top < top - 0.5);
+      const clipsBottom = bottom > top && contents.some((rect) => rect.bottom > bottom + 0.5);
+      host.toggleAttribute("data-overflow-top", clipsTop);
+      host.toggleAttribute("data-overflow-bottom", clipsBottom);
+      const set = (name, value) => {
+        const css = `${Math.max(0, value).toFixed(2)}px`;
+        if (host.style.getPropertyValue(name) !== css) host.style.setProperty(name, css);
+      };
+      set("--limr-fade-start", top - box.top);
+      set("--limr-fade-end", bottom - box.top);
+      if (transitions && host.getAnimations({ subtree: true }).some((animation) => animation.playState === "running")) schedule();
+      else transitions = 0;
+    };
+    const schedule = () => {
+      if (!frame) frame = requestAnimationFrame(measure);
+    };
+    const refresh = () => {
+      cancelAnimationFrame(frame);
+      measure();
+    };
+    const start = () => {
+      transitions++;
+      schedule();
+    };
+    const end = () => {
+      transitions = Math.max(0, transitions - 1);
+      schedule();
+    };
+    host.addEventListener("transitionrun", start);
+    host.addEventListener("transitionend", end);
+    host.addEventListener("transitioncancel", end);
+    const resize = new ResizeObserver(refresh);
+    resize.observe(host);
+    const mutation = new MutationObserver((records) => {
+      if (records.some((record) => {
+        const element = record.target instanceof Element ? record.target : record.target.parentElement;
+        return element && element !== host && !element.closest(".limr-highlight-layer,.limr-paint-layer");
+      })) refresh();
+    });
+    mutation.observe(host, { subtree: true, childList: true, characterData: true, attributes: true, attributeFilter: ["style", "class"] });
+    const unsubscribe = [runtime.layout.subscribe(schedule), runtime.viewport.subscribe(refresh), runtime.documentOffset.subscribe(schedule), runtime.configuration.subscribe(schedule)];
+    const scroll = (event) => {
+      const target = event.target;
+      if (target === window.document || target === window || target instanceof Element && target.contains(host)) refresh();
+    };
+    window.addEventListener("scroll", scroll, { capture: true, passive: true });
+    window.addEventListener("resize", schedule);
+    window.visualViewport?.addEventListener("resize", schedule);
+    window.visualViewport?.addEventListener("scroll", refresh);
+    schedule();
+    return () => {
+      cancelAnimationFrame(frame);
+      resize.disconnect();
+      mutation.disconnect();
+      unsubscribe.forEach((fn) => fn());
+      host.removeEventListener("transitionrun", start);
+      host.removeEventListener("transitionend", end);
+      host.removeEventListener("transitioncancel", end);
+      window.removeEventListener("scroll", scroll, true);
+      window.removeEventListener("resize", schedule);
+      window.visualViewport?.removeEventListener("resize", schedule);
+      window.visualViewport?.removeEventListener("scroll", refresh);
+      host.removeAttribute("data-overflow-top");
+      host.removeAttribute("data-overflow-bottom");
+      host.style.removeProperty("--limr-fade-start");
+      host.style.removeProperty("--limr-fade-end");
+    };
+  }, [ref, runtime, contentSelector, beforeMeasure]);
+}
+
+// src/components/TableOfContents.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function TableOfContents({ title, maxDepth = 6, followActive = true, topInset = 24, updateHash = false, className, style }) {
+  const runtime = useRuntime();
+  const appearance = useAppearance();
+  const theme = useTheme(), locale = useLocale();
+  const headings = useDocumentSelector((doc) => doc.headings);
+  useStoreSelector(runtime.layout, (value) => value);
+  const active = useStoreSelector(runtime.interaction, (state) => state.activeHeading);
+  const list = useRef(null);
+  useOverflowFade(list, runtime, ":scope > ol");
+  const manualUntil = useRef(0);
+  const timer = useRef(void 0);
+  const visible = headings.filter((heading) => heading.level <= maxDepth && !runtime.headings.get(heading.id)?.closest("[inert]"));
+  visible.sort((a, b) => {
+    const left = runtime.headings.get(a.id), right = runtime.headings.get(b.id);
+    return left && right && left !== right ? left.compareDocumentPosition(right) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1 : 0;
+  });
+  const minimum = Math.min(...visible.map((heading) => heading.level), 6);
+  useEffect2(() => {
+    if (!followActive || !active) return;
+    const follow = () => {
+      const container = list.current;
+      if (!container || container.clientHeight === 0) return;
+      const element = Array.from(container.querySelectorAll("[data-heading]")).find((item) => item.dataset.heading === active);
+      if (!element) return;
+      const top = element.getBoundingClientRect().top - container.getBoundingClientRect().top + container.scrollTop - topInset;
+      const target = Math.max(0, Math.min(top, container.scrollHeight - container.clientHeight));
+      if (Math.abs(target - container.scrollTop) > 1) scrollWithMotion(container, target);
+    };
+    const delay = Math.max(0, manualUntil.current - Date.now());
+    timer.current = setTimeout(follow, delay);
+    return () => clearTimeout(timer.current);
+  }, [active, headings, followActive, topInset]);
+  const manual = () => {
+    manualUntil.current = Date.now() + 1200;
+    clearTimeout(timer.current);
+  };
+  return /* @__PURE__ */ jsxs("nav", { className: `limr-toc ${className ?? ""}`, style, "data-limr-theme": theme, "data-limr-appearance": appearance, "aria-label": title ?? locale.contents, children: [
+    /* @__PURE__ */ jsx("div", { className: "limr-toc-title", children: title ?? locale.contents }),
+    /* @__PURE__ */ jsx("div", { className: "limr-toc-scroll", ref: list, onWheel: manual, onTouchStart: manual, onKeyDown: manual, tabIndex: 0, children: /* @__PURE__ */ jsx("ol", { children: visible.map((heading) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(
+      "a",
+      {
+        "data-heading": heading.id,
+        href: `#${heading.id}`,
+        "aria-current": heading.id === active ? "location" : void 0,
+        style: { paddingInlineStart: 12 + Math.min(heading.level - minimum, 4) * 14 },
+        onClick: (event) => {
+          event.preventDefault();
+          runtime.scrollToHeading(heading.id);
+          if (updateHash) history.replaceState(history.state, "", `#${heading.id}`);
+        },
+        children: /* @__PURE__ */ jsx("span", { className: "limr-underline", children: heading.text })
+      }
+    ) }, heading.id)) }) })
+  ] });
+}
+
+// src/components/AnnotationSidebar.tsx
+import { useCallback, useEffect as useEffect4, useMemo, useRef as useRef2, useState as useState2, useSyncExternalStore } from "react";
+import { flushSync } from "react-dom";
+
+// src/components/AnnotationContent.tsx
+import { useEffect as useEffect3, useState } from "react";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function AnnotationContent({ annotationId, presentation, expanded = true, enabled = true }) {
+  const runtime = useRuntime();
+  const annotation = useStoreSelector(runtime.decorations, (state) => state.annotations.get(annotationId));
+  const editing = useStoreSelector(runtime.interaction, (state) => state.editing === annotationId);
+  const definition = useStoreSelector(runtime.configuration, () => runtime.annotationTypes.get(annotation?.type ?? "citation"));
+  const version = useStoreSelector(runtime.resourceVersions, (versions) => versions.get(annotationId) ?? 0);
+  const [loaded, setLoaded] = useState({ id: annotationId, loading: !!definition?.load, error: null });
+  useEffect3(() => {
+    if (!definition?.load || !annotation || !enabled) return;
+    let disposed = false;
+    setLoaded({ id: annotationId, loading: true, error: null });
+    const request = runtime.resources.acquire(runtime.getResourceKey(annotation), (signal) => definition.load(annotation, { signal }));
+    request.promise.then((data) => {
+      if (!disposed) setLoaded({ id: annotationId, data, loading: false, error: null });
+    }).catch((error) => {
+      if (!disposed) setLoaded({ id: annotationId, loading: false, error: error instanceof Error ? error : new Error(String(error)) });
+    });
+    return () => {
+      disposed = true;
+      request.release();
+    };
+  }, [runtime, annotation, annotationId, definition, version, enabled]);
+  const retry = () => runtime.invalidateAnnotation(annotationId);
+  const Content = definition?.Content;
+  const current = loaded.id === annotationId ? loaded : { loading: !!definition?.load, error: null, data: void 0 };
+  if (!annotation) return /* @__PURE__ */ jsxs2("span", { className: "limr-muted", children: [
+    runtime.locale.unavailable,
+    " \xB7 ",
+    annotationId
+  ] });
+  if (!Content) return /* @__PURE__ */ jsxs2("span", { className: "limr-muted", children: [
+    runtime.locale.unavailable,
+    " \xB7 ",
+    annotation.type
+  ] });
+  return /* @__PURE__ */ jsx2(Content, { editing, annotation, data: definition?.load ? current.data ?? annotation.data : annotation.data, loading: definition?.load ? current.loading : false, error: current.error, retry, presentation, expanded });
+}
+function AnnotationGroup({ occurrence, presentation, expanded = true, enabled = true }) {
+  return /* @__PURE__ */ jsx2(Fragment, { children: occurrence.annotationIds.map((id) => /* @__PURE__ */ jsx2("div", { className: "limr-annotation-entry", children: /* @__PURE__ */ jsx2(AnnotationContent, { annotationId: id, presentation, expanded, enabled }) }, id)) });
+}
+
+// src/components/annotation-reference.ts
+function annotationReferenceText(document2, occurrence) {
+  const referenceRange = annotationReferenceRange(document2, occurrence);
+  const blocks = document2.blocks.filter((block) => intersects(block.range, referenceRange));
+  let reference = "";
+  const visit = (node) => {
+    const range = rangeOf(node);
+    if (!intersects(range, referenceRange) || ["annotationReference", "footnoteReference", "annotationDefinition", "definition"].includes(node.type)) return;
+    if (node.value !== void 0) {
+      const mapping = mapText(document2.source, node.value, range);
+      reference += node.value.split("").filter((_, index) => mapping.ends[index] > referenceRange.start && mapping.starts[index] < referenceRange.end).join("");
+    } else if (node.type === "image") reference += String(node.alt ?? "");
+    else node.children?.forEach(visit);
+  };
+  blocks.forEach((block, index) => {
+    if (index) reference += " ";
+    visit(block.node);
+  });
+  if (!occurrence.embedded) reference ||= occurrence.quote ?? document2.source.slice(referenceRange.start, referenceRange.end);
+  return reference.replace(/\s+/g, " ").trim();
+}
+
+// src/components/AnnotationSidebar.tsx
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var alignSidebar = (items, { activeId, gap, height, prioritizeActive }) => {
+  const positions = items.map((item) => item.anchorTop);
+  const activeIndex = items.findIndex((item) => item.id === activeId);
+  const pivot = activeIndex < 0 ? 0 : activeIndex;
+  if (!items.length) return /* @__PURE__ */ new Map();
+  positions[pivot] = height === void 0 ? items[pivot].anchorTop : Math.max(0, Math.min(items[pivot].anchorTop, height - items[pivot].height));
+  for (let i = pivot - 1; i >= 0; i--) positions[i] = Math.min(items[i].anchorTop, positions[i + 1] - items[i].height - gap);
+  for (let i = pivot + 1; i < items.length; i++) positions[i] = Math.max(items[i].anchorTop, positions[i - 1] + items[i - 1].height + gap);
+  if (height !== void 0 && items.reduce((sum, item) => sum + item.height, gap * (items.length - 1)) <= height) {
+    const start = prioritizeActive && activeIndex >= 0 ? pivot + 1 : 0;
+    for (let i = items.length - 1; i >= start; i--) positions[i] = Math.min(positions[i], (i === items.length - 1 ? height : positions[i + 1] - gap) - items[i].height);
+    if (start || activeIndex < 0 || positions[0] >= 0) for (let i = start; i < items.length; i++) positions[i] = Math.max(positions[i], i === 0 ? 0 : positions[i - 1] + items[i - 1].height + gap);
+  }
+  return new Map(items.map((item, index) => [item.id, positions[index]]));
+};
+function AnnotationSidebar({ sync = "document", gap = 14, positioner = alignSidebar, renderCard, className, style }) {
+  const runtime = useRuntime();
+  const document2 = useDocument();
+  const appearance = useAppearance();
+  const theme = useTheme(), locale = useLocale();
+  const decorations = useStoreSelector(runtime.decorations, (value) => value);
+  const active = useStoreSelector(runtime.interaction, (state) => state.active);
+  const hovered = useStoreSelector(runtime.interaction, (state) => state.hovered);
+  const hoverSource = useStoreSelector(runtime.interaction, (state) => state.hoverSource);
+  const activeSource = useStoreSelector(runtime.interaction, (state) => state.activeSource);
+  useSyncExternalStore(runtime.configuration.subscribe, runtime.configuration.get, runtime.configuration.get);
+  const layout = useSyncExternalStore(runtime.layout.subscribe, runtime.layout.get, runtime.layout.get);
+  const viewport = useSyncExternalStore(runtime.viewport.subscribe, runtime.viewport.get, runtime.viewport.get);
+  const rail = useRef2(null);
+  const cards = useRef2(/* @__PURE__ */ new Map());
+  const [sizes, setSizes] = useState2(/* @__PURE__ */ new Map());
+  const [minimumSizes, setMinimumSizes] = useState2(/* @__PURE__ */ new Map());
+  const [anchorTops, setAnchorTops] = useState2(/* @__PURE__ */ new Map());
+  const [railHeight, setRailHeight] = useState2(0);
+  const measured = useRef2({ sizes: /* @__PURE__ */ new Map(), minimum: /* @__PURE__ */ new Map(), height: 0 });
+  const resizeFrame = useRef2(0);
+  const [viewportTop, setViewportTop] = useState2(0);
+  const [viewportHeight, setViewportHeight] = useState2(0);
+  const [cardLock, setCardLock] = useState2(null);
+  const lastFocus = useRef2(null);
+  const [release, setRelease] = useState2(null);
+  const occurrences = useMemo(() => {
+    const values = [...decorations.occurrences].sort((a, b) => a.range.start - b.range.start || a.range.end - b.range.end || a.id.localeCompare(b.id));
+    if (sync === "none") {
+      for (const annotation of decorations.annotations.values()) if (annotation.type !== "highlight" && !values.some((item) => item.annotationIds.includes(annotation.id))) values.push({ id: `unanchored-${annotation.id}`, range: { start: 0, end: 0 }, annotationIds: [annotation.id] });
+    }
+    return values;
+  }, [decorations, sync]);
+  const references = useMemo(() => new Map(occurrences.map((occurrence) => [occurrence.id, annotationReferenceText(document2, occurrence)])), [document2, occurrences]);
+  const annotationGroups = useMemo(() => new Map(occurrences.map((occurrence) => [occurrence.id, occurrence.annotationIds.flatMap((id) => {
+    const annotation = decorations.annotations.get(id);
+    return annotation ? [annotation] : [];
+  })])), [decorations, occurrences]);
+  const measure = useCallback((beforePaint = false) => {
+    const next = /* @__PURE__ */ new Map();
+    const minimum = /* @__PURE__ */ new Map();
+    cards.current.forEach((element2, id) => {
+      const height2 = element2.getBoundingClientRect().height;
+      next.set(id, height2);
+      const panels = [...element2.querySelectorAll(":scope > .limr-sidebar-card-body > .limr-collapse")];
+      minimum.set(id, height2 - panels.reduce((sum, panel) => sum + panel.getBoundingClientRect().height, 0));
+    });
+    const height = rail.current?.getBoundingClientRect().height ?? 0;
+    const old = measured.current;
+    if (old.height === height && old.sizes.size === next.size && [...next].every(([id, size2]) => size2 === old.sizes.get(id) && Math.abs(minimum.get(id) - (old.minimum.get(id) ?? 0)) < 0.5)) return;
+    measured.current = { sizes: next, minimum, height };
+    const update = () => {
+      setSizes(next);
+      setMinimumSizes(minimum);
+      setRailHeight(height);
+    };
+    if (!beforePaint) {
+      update();
+      return;
+    }
+    const element = rail.current;
+    element?.setAttribute("data-resizing", "");
+    flushSync(update);
+    cancelAnimationFrame(resizeFrame.current);
+    resizeFrame.current = requestAnimationFrame(() => {
+      resizeFrame.current = requestAnimationFrame(() => element?.removeAttribute("data-resizing"));
+    });
+  }, []);
+  const prepareFade = useCallback(() => measure(true), [measure]);
+  useOverflowFade(rail, runtime, ":scope > .limr-sidebar-card", prepareFade);
+  useEffect4(() => {
+    const observer = new ResizeObserver(() => measure(true));
+    if (rail.current) observer.observe(rail.current);
+    cards.current.forEach((element) => observer.observe(element));
+    measure();
+    return () => observer.disconnect();
+  }, [occurrences, measure, anchorTops]);
+  useEffect4(() => () => cancelAnimationFrame(resizeFrame.current), []);
+  useIsomorphicLayoutEffect(() => {
+    if (sync === "none" || !rail.current) return;
+    const top = rail.current.getBoundingClientRect().top;
+    const values = /* @__PURE__ */ new Map();
+    const displacement2 = runtime.getContentOffset();
+    for (const occurrence of occurrences) {
+      const marker = runtime.anchors.get(occurrence.id);
+      if (!marker || marker.closest("[inert]")) continue;
+      const rect = sourceRangeStartRect(runtime, decorations.referenceRanges.get(occurrence.id) ?? occurrence.range);
+      values.set(occurrence.id, (rect || marker.getBoundingClientRect()).top - top - displacement2);
+    }
+    setAnchorTops((old) => old.size === values.size && [...values].every(([id, value]) => Math.abs(value - (old.get(id) ?? -Infinity)) < 0.5) ? old : values);
+  }, [runtime, decorations.referenceRanges, occurrences, layout, sync]);
+  useIsomorphicLayoutEffect(() => {
+    if (sync !== "document" || !rail.current) return;
+    const root = runtime.configuration.get().scrollRoot;
+    const bounds = rail.current.getBoundingClientRect();
+    const top = Math.max(bounds.top, runtime.getViewportTop() + (root?.clientTop ?? 0), window.visualViewport?.offsetTop ?? 0);
+    const bottom = Math.min(bounds.bottom, root ? runtime.getViewportTop() + root.clientTop + root.clientHeight : Infinity, (window.visualViewport?.offsetTop ?? 0) + (window.visualViewport?.height ?? innerHeight));
+    setViewportTop(Math.max(0, top - bounds.top + (runtime.configuration.get().scrollOffset ?? 24)));
+    setViewportHeight(Math.max(0, bottom - top));
+  }, [runtime, layout, viewport, sync]);
+  useEffect4(() => {
+    const dismiss = (event) => {
+      if (event.button !== 0) return;
+      const target = event.target;
+      if (!(target instanceof Element)) return;
+      const card = target.closest(".limr-sidebar-card");
+      const marker = target.closest("[data-limr-anchor]");
+      if (card && rail.current?.contains(card) || marker && runtime.anchors.get(marker.dataset.limrAnchor) === marker) return;
+      if (target.closest(".limr-overlay-positioner,.limr-selection-toolbar")) return;
+      const { active: active2, hovered: hovered2 } = runtime.interaction.get();
+      if (active2 || hovered2) runtime.activate(null);
+    };
+    const escape = (event) => {
+      if (event.key !== "Escape" || event.defaultPrevented || !runtime.interaction.get().active) return;
+      const anchor = runtime.anchors.get(runtime.interaction.get().active);
+      anchor?.focus({ preventScroll: true });
+      runtime.activate(null);
+    };
+    window.document.addEventListener("pointerdown", dismiss);
+    window.document.addEventListener("keydown", escape);
+    return () => {
+      window.document.removeEventListener("pointerdown", dismiss);
+      window.document.removeEventListener("keydown", escape);
+      if (sync === "document") runtime.documentOffset.set(0);
+    };
+  }, [runtime, sync]);
+  const items = occurrences.filter((item) => sync === "none" || anchorTops.has(item.id));
+  if (sync !== "none") items.sort((a, b) => (anchorTops.get(a.id) ?? 0) - (anchorTops.get(b.id) ?? 0));
+  const readingId = items.find((item) => (anchorTops.get(item.id) ?? 0) >= viewportTop)?.id ?? items.at(-1)?.id ?? null;
+  const alignmentId = hovered ?? active ?? readingId;
+  const focusedId = hovered ?? active;
+  const source = hovered ? hoverSource : active ? activeSource : null;
+  const locked = source === "sidebar" && cardLock?.id === alignmentId ? cardLock : null;
+  const lockedTop = locked?.top;
+  useIsomorphicLayoutEffect(() => {
+    const previous = lastFocus.current;
+    lastFocus.current = focusedId ? { id: focusedId, top: lockedTop } : null;
+    if (focusedId || sync !== "document" || !rail.current || matchMedia("(prefers-reduced-motion: reduce)").matches) {
+      setRelease(null);
+      return;
+    }
+    if (!previous) return;
+    const style2 = getComputedStyle(rail.current), value = style2.getPropertyValue("--limr-motion-slow").trim();
+    const milliseconds = parseFloat(value) * (value.endsWith("ms") ? 1 : 1e3);
+    const duration = Number.isFinite(milliseconds) ? Math.max(0, milliseconds) : 460;
+    if (!duration) {
+      setRelease(null);
+      return;
+    }
+    const motion = rail.current.animate([{}, {}], { duration, easing: style2.getPropertyValue("--limr-ease").trim() || "ease-out" });
+    setRelease({ ...previous, progress: 0 });
+    let frame = 0;
+    const step = () => {
+      if (motion.playState === "finished") {
+        setRelease(null);
+        return;
+      }
+      setRelease({ ...previous, progress: motion.effect?.getComputedTiming().progress ?? 0 });
+      frame = requestAnimationFrame(step);
+    };
+    frame = requestAnimationFrame(step);
+    return () => {
+      cancelAnimationFrame(frame);
+      motion.cancel();
+    };
+  }, [focusedId, lockedTop, sync]);
+  const sidebarItems = items.map((item) => ({ id: item.id, anchorTop: anchorTops.get(item.id) ?? 0, height: sizes.get(item.id) ?? 80 }));
+  const positionContext = { activeId: alignmentId, gap, height: sync === "document" && railHeight > 0 ? railHeight : void 0, prioritizeActive: !!(hovered || active) };
+  const positions = new Map(positioner(locked ? sidebarItems.map((item) => item.id === locked.id ? { ...item, anchorTop: locked.top } : item) : sidebarItems, positionContext));
+  const releasing = !focusedId && release;
+  if (releasing) {
+    const origin = positioner(sidebarItems.map((item) => item.id === releasing.id && releasing.top !== void 0 ? { ...item, anchorTop: releasing.top } : item), { ...positionContext, activeId: releasing.id, prioritizeActive: true });
+    for (const [id, top] of positions) positions.set(id, top + ((origin.get(id) ?? top) - top) * (1 - releasing.progress));
+  }
+  const lockedAnchor = locked ? anchorTops.get(locked.id) ?? locked.top : 0;
+  const displacement = sync === "document" && locked ? (positions.get(locked.id) ?? locked.top) - lockedAnchor : 0;
+  useIsomorphicLayoutEffect(() => {
+    if (sync === "document") runtime.documentOffset.set(displacement);
+  }, [runtime, displacement, sync]);
+  const lockCard = (id) => {
+    if (locked?.id === id) return;
+    const card = cards.current.get(id);
+    if (card && rail.current) {
+      const origin = rail.current.getBoundingClientRect().top;
+      const top = card.getBoundingClientRect().top - origin;
+      setCardLock({ id, top });
+    }
+  };
+  return /* @__PURE__ */ jsx3("aside", { ref: rail, "aria-label": locale.annotations, className: `limr-sidebar ${className ?? ""}`, "data-sync": sync, "data-releasing": releasing ? "" : void 0, "data-limr-theme": theme, "data-limr-appearance": appearance, style, children: items.map((occurrence) => {
+    const annotation = decorations.annotations.get(occurrence.annotationIds[0]);
+    const definition = runtime.annotationTypes.get(annotation?.type ?? "citation");
+    const isActive = active === occurrence.id;
+    const palette = definition?.sidebar;
+    const Preview = palette?.Preview;
+    const available = source === "marker" && alignmentId === occurrence.id && !isActive ? Math.max(minimumSizes.get(occurrence.id) ?? 80, railHeight - (anchorTops.get(occurrence.id) ?? 0)) : railHeight;
+    const cardHeight = isActive ? Math.min(available, Math.max(minimumSizes.get(occurrence.id) ?? 80, viewportHeight || railHeight)) : available;
+    const cardStyle = {
+      "--limr-annotation-color": palette?.color ?? definition?.color,
+      "--limr-annotation-border": palette?.borderColor,
+      "--limr-annotation-title": palette?.titleColor,
+      "--limr-annotation-text": palette?.textColor,
+      "--limr-annotation-excerpt": palette?.excerptColor,
+      "--limr-annotation-preview": palette?.previewColor,
+      "--limr-sidebar-preview-lines": String(Math.max(1, Math.floor(palette?.previewLines ?? 2))),
+      ...sync === "document" ? {
+        position: "absolute",
+        top: positions.get(occurrence.id) ?? 0,
+        insetInline: 0,
+        "--limr-sidebar-card-height": `${cardHeight}px`
+      } : { marginBlockEnd: gap }
+    };
+    const collapseOnContentClick = occurrence.annotationIds.every((id) => runtime.annotationTypes.get(decorations.annotations.get(id)?.type ?? "")?.sidebar?.collapseOnContentClick);
+    const activate = () => {
+      const hovering = runtime.interaction.get().hovered === occurrence.id || cards.current.get(occurrence.id)?.matches(":hover");
+      lockCard(occurrence.id);
+      runtime.activate(isActive ? null : occurrence.id, "sidebar");
+      if (hovering) runtime.hover(occurrence.id, "sidebar");
+    };
+    return /* @__PURE__ */ jsx3(
+      "div",
+      {
+        ref: (element) => {
+          if (element) cards.current.set(occurrence.id, element);
+          else cards.current.delete(occurrence.id);
+        },
+        className: "limr-sidebar-card",
+        "data-type": annotation?.type,
+        "data-locked": locked?.id === occurrence.id || void 0,
+        "data-active": isActive || hovered === occurrence.id || void 0,
+        "data-expanded": isActive || void 0,
+        "data-default-card": !renderCard || void 0,
+        "data-content-toggle": collapseOnContentClick || void 0,
+        "data-citations": occurrence.annotationIds.every((id) => decorations.annotations.get(id)?.type === "citation") || void 0,
+        "data-occurrence": occurrence.id,
+        style: cardStyle,
+        onPointerEnter: (event) => {
+          if (event.pointerType !== "touch") {
+            lockCard(occurrence.id);
+            runtime.hover(occurrence.id, "sidebar");
+          }
+        },
+        onPointerLeave: () => {
+          if (runtime.interaction.get().hovered === occurrence.id && runtime.interaction.get().hoverSource === "sidebar") runtime.hover(null);
+        },
+        onClick: (event) => {
+          if ((!isActive || collapseOnContentClick) && !renderCard && !event.defaultPrevented && !event.target.closest('button,a,input,select,textarea,summary,[role="button"],[role="link"],[contenteditable="true"],[data-limr-card-interactive]') && window.getSelection()?.isCollapsed !== false) activate();
+        },
+        children: renderCard ? renderCard({ occurrence, active: isActive, activate }) : /* @__PURE__ */ jsxs3(Fragment2, { children: [
+          references.get(occurrence.id) && /* @__PURE__ */ jsx3("div", { className: "limr-sidebar-reference", title: references.get(occurrence.id), children: /* @__PURE__ */ jsx3("p", { className: "limr-sidebar-excerpt", children: references.get(occurrence.id) }) }),
+          /* @__PURE__ */ jsxs3("div", { className: "limr-sidebar-card-body", children: [
+            /* @__PURE__ */ jsxs3("button", { type: "button", className: "limr-sidebar-card-heading", onClick: activate, "aria-expanded": isActive, children: [
+              definition?.label ?? annotation?.type ?? "Reference",
+              /* @__PURE__ */ jsx3("span", { className: "limr-sidebar-toggle", children: /* @__PURE__ */ jsx3("span", { className: "limr-button-label limr-underline", children: isActive ? locale.collapse : locale.expand }, String(isActive)) })
+            ] }),
+            Preview && annotation && /* @__PURE__ */ jsx3(Collapse, { open: !isActive, keepMounted: true, className: "limr-sidebar-preview-panel", children: /* @__PURE__ */ jsx3("div", { className: "limr-sidebar-preview", children: /* @__PURE__ */ jsx3(Preview, { annotation, data: annotation.data, occurrence, annotations: annotationGroups.get(occurrence.id), referenceText: references.get(occurrence.id) ?? "" }) }) }),
+            /* @__PURE__ */ jsx3(Collapse, { open: isActive, className: "limr-sidebar-expansion", children: /* @__PURE__ */ jsx3("div", { className: "limr-sidebar-card-content", children: /* @__PURE__ */ jsx3(AnnotationGroup, { occurrence, presentation: "sidebar", enabled: isActive }) }) })
+          ] })
+        ] })
+      },
+      occurrence.id
+    );
+  }) });
+}
+
+// src/components/AnnotationOverlay.tsx
+import { useEffect as useEffect5, useState as useState3, useSyncExternalStore as useSyncExternalStore2 } from "react";
+import { autoUpdate, flip, FloatingFocusManager, FloatingOverlay, FloatingPortal, offset, shift, size, useDismiss, useFloating, useInteractions, useRole } from "@floating-ui/react";
+
+// src/components/card-motion.ts
+import { useRef as useRef3 } from "react";
+var moving = (animation) => animation?.playState === "running" || animation?.playState === "paused";
+var durationOf = (value, fallback) => {
+  const duration = parseFloat(value) * (value.endsWith("ms") ? 1 : 1e3);
+  return Number.isFinite(duration) && duration > 0 ? duration : fallback;
+};
+function useCardMotion(element, host, anchor, open, expanded, ready, id, edge, previewRect, onExit) {
+  const previous = useRef3(null);
+  const reveal = useRef3(null);
+  const content = useRef3(null);
+  const hero = useRef3(null);
+  const shape = useRef3(null);
+  const state = useRef3(null);
+  const latest = useRef3({ open, onExit });
+  latest.current = { open, onExit };
+  useIsomorphicLayoutEffect(() => {
+    if (!element || !host || !ready) return;
+    const sameCard = state.current?.id === id;
+    const presentationChanged = sameCard && state.current?.expanded !== expanded;
+    const intentChanged = !sameCard || state.current?.open !== open || presentationChanged;
+    const reduced = matchMedia("(prefers-reduced-motion: reduce)").matches;
+    if (!intentChanged && !reduced) return;
+    const computed = getComputedStyle(element);
+    const shell = element.querySelector(".limr-overlay-surface");
+    const card = element.querySelector(".limr-overlay-card");
+    const previousBody = sameCard ? content.current?.effect?.target : null;
+    const body = presentationChanged || expanded ? card : previousBody?.isConnected ? previousBody : element.querySelector("[data-limr-card-body], .limr-overlay-content");
+    const bodyStyle = body ? getComputedStyle(body) : null;
+    const liveSurface = { opacity: computed.opacity, clipPath: computed.clipPath };
+    const liveTransform = computed.transform;
+    const liveBody = { opacity: bodyStyle?.opacity ?? "1", transform: bodyStyle?.transform ?? "none", clipPath: bodyStyle?.clipPath ?? "none" };
+    let before = sameCard ? previous.current : expanded ? previewRect ?? null : null;
+    if (before && sameCard && hero.current && computed.transform !== "none") {
+      const matrix = new DOMMatrixReadOnly(computed.transform);
+      before = new DOMRect(before.x + matrix.m41, before.y + matrix.m42, before.width, before.height);
+    }
+    if (before && sameCard && shell && shape.current) {
+      const matrix = new DOMMatrixReadOnly(getComputedStyle(shell).transform);
+      before = new DOMRect(before.x, before.y, before.width * matrix.a, before.height * matrix.d);
+    }
+    const target = host.getBoundingClientRect();
+    const anchorRect = anchor?.getBoundingClientRect() ?? target;
+    const originX = Math.max(0, Math.min(100, ((anchorRect.left + anchorRect.right) / 2 - target.left) / Math.max(1, target.width) * 100));
+    const radius = computed.borderRadius || "8px";
+    const collapsed = `inset(${edge === "bottom" ? 100 : 0}% ${100 - originX}% ${edge === "bottom" ? 0 : 100}% ${originX}% round ${radius})`;
+    const overflow = Math.max(48, (before?.width ?? 0) - target.width + 48, (before?.height ?? 0) - target.height + 48);
+    const revealed = `inset(-${overflow}px -${overflow}px -${overflow}px -${overflow}px round ${radius})`;
+    const cancel = () => {
+      reveal.current?.cancel();
+      content.current?.cancel();
+      hero.current?.cancel();
+      shape.current?.cancel();
+      reveal.current = content.current = hero.current = shape.current = null;
+    };
+    cancel();
+    state.current = { id, expanded, open };
+    previous.current = target;
+    if (reduced || !open && !sameCard) {
+      delete element.dataset.motion;
+      if (!open) latest.current.onExit();
+      return;
+    }
+    const previewDuration = durationOf((computed.getPropertyValue("--limr-overlay-duration") || computed.getPropertyValue("--limr-overlay-enter-duration")).trim(), 560);
+    const morphDuration = durationOf(computed.getPropertyValue("--limr-overlay-morph-duration").trim(), 480);
+    const morph = open && !!before && (presentationChanged || !sameCard && expanded);
+    const returning = !open && expanded && !!previewRect;
+    const destination = returning ? previewRect : target;
+    const duration = morph || expanded ? morphDuration : previewDuration;
+    const easing = computed.getPropertyValue("--limr-overlay-ease").trim() || "cubic-bezier(.22,1,.36,1)";
+    element.dataset.motion = !open ? "closing" : morph ? "morphing" : "opening";
+    reveal.current = element.animate([
+      sameCard ? { ...liveSurface, ...morph ? { clipPath: revealed } : {} } : { opacity: 0, clipPath: morph ? revealed : collapsed },
+      { opacity: open ? 1 : 0, clipPath: open || returning ? revealed : collapsed }
+    ], { duration, easing, fill: "both" });
+    if (before && (morph || liveTransform !== "none" || returning)) {
+      const x = before.left - target.left, y = before.top - target.top;
+      const sx = before.width / Math.max(1, target.width), sy = before.height / Math.max(1, target.height);
+      hero.current = element.animate([
+        { transform: `translate(${x}px, ${y}px)` },
+        { transform: `translate(${destination.left - target.left}px, ${destination.top - target.top}px)` }
+      ], { duration, easing, fill: "both" });
+      shape.current = shell?.animate([
+        { transform: `scale(${sx}, ${sy})` },
+        { transform: `scale(${destination.width / Math.max(1, target.width)}, ${destination.height / Math.max(1, target.height)})` }
+      ], { duration, easing, fill: "both" }) ?? null;
+    }
+    const delay = open ? morph ? 50 : !sameCard ? 35 : 0 : 0;
+    content.current = body?.animate([
+      sameCard && !morph ? liveBody : { opacity: 0, transform: "translateY(6px)", clipPath: morph ? `inset(0px ${Math.max(0, target.width - before.width)}px ${Math.max(0, target.height - before.height)}px 0px)` : "inset(0px)" },
+      { opacity: open ? 1 : 0, transform: open ? "translateY(0px)" : "translateY(-4px)", clipPath: returning ? `inset(0px ${Math.max(0, target.width - destination.width)}px ${Math.max(0, target.height - destination.height)}px 0px)` : "inset(0px)" }
+    ], {
+      // Content and surface settle together in either direction.
+      duration: duration - delay,
+      delay,
+      easing,
+      fill: "both"
+    }) ?? null;
+    const current = reveal.current;
+    const finish = () => {
+      if (reveal.current !== current) return;
+      if (![reveal.current, content.current, hero.current, shape.current].some(moving)) {
+        delete element.dataset.motion;
+        if (!latest.current.open) latest.current.onExit();
+        else previous.current = host.getBoundingClientRect();
+      }
+    };
+    for (const animation of [reveal.current, content.current, hero.current, shape.current]) if (animation) animation.onfinish = finish;
+    finish();
+  }, [element, host, anchor, open, expanded, ready, id, edge, previewRect]);
+  useIsomorphicLayoutEffect(() => {
+    if (host && open && ready && !moving(hero.current)) previous.current = host.getBoundingClientRect();
+  });
+  useIsomorphicLayoutEffect(() => {
+    if (!host || !open) return;
+    const observer = new ResizeObserver(() => {
+      if (!moving(hero.current)) previous.current = host.getBoundingClientRect();
+    });
+    observer.observe(host);
+    return () => observer.disconnect();
+  }, [host, open, id]);
+  useIsomorphicLayoutEffect(() => () => {
+    reveal.current?.cancel();
+    content.current?.cancel();
+    hero.current?.cancel();
+    shape.current?.cancel();
+    reveal.current = content.current = hero.current = shape.current = null;
+    state.current = null;
+    previous.current = null;
+    if (element) delete element.dataset.motion;
+  }, [element]);
+}
+
+// src/components/AnnotationOverlay.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var length = (value) => typeof value === "number" ? `${value}px` : value;
+var idleSubscribe = () => () => {
+};
+function AnnotationOverlay({ disabled = false, portalRoot, previewWidth = 340, maxHeight = "80dvh" }) {
+  const runtime = useRuntime();
+  const appearance = useAppearance();
+  const theme = useTheme(), locale = useLocale();
+  const editing = useStoreSelector(runtime.interaction, (state) => state.editing);
+  const active = useStoreSelector(runtime.interaction, (state) => state.active);
+  const hovered = useStoreSelector(runtime.interaction, (state) => state.hovered);
+  const occurrences = useStoreSelector(runtime.decorations, (state) => state.occurrences);
+  useSyncExternalStore2(runtime.layout.subscribe, runtime.layout.get, runtime.layout.get);
+  const [preview, setPreview] = useState3(null);
+  const [collapsedId, setCollapsedId] = useState3(null);
+  const [, setViewportTick] = useState3(0);
+  useEffect5(() => {
+    if (active || disabled) {
+      setPreview(null);
+      return;
+    }
+    if (hovered) {
+      setPreview(hovered);
+      return;
+    }
+    const timer = setTimeout(() => setPreview(null), 90);
+    return () => clearTimeout(timer);
+  }, [hovered, active, disabled]);
+  useEffect5(() => {
+    const update2 = () => setViewportTick((value) => value + 1);
+    window.visualViewport?.addEventListener("resize", update2);
+    window.visualViewport?.addEventListener("scroll", update2);
+    window.addEventListener("resize", update2);
+    return () => {
+      window.visualViewport?.removeEventListener("resize", update2);
+      window.visualViewport?.removeEventListener("scroll", update2);
+      window.removeEventListener("resize", update2);
+    };
+  }, []);
+  const wantedId = active ?? preview;
+  const wanted = occurrences.find((item) => item.id === wantedId);
+  const [retained, setRetained] = useState3(null);
+  const occurrence = wanted ?? retained;
+  const id = occurrence?.id;
+  const annotation = useStoreSelector(runtime.decorations, (state) => state.annotations.get(occurrence?.annotationIds[0] ?? ""));
+  const definition = useStoreSelector(runtime.configuration, () => runtime.annotationTypes.get(annotation?.type ?? "citation"));
+  const policy = definition?.overlay?.expand;
+  const expansion = typeof policy === "function" ? annotation && policy(annotation) : policy;
+  const pinned = active === id;
+  const expanded = pinned && !!expansion && collapsedId !== id;
+  const [lastExpanded, setLastExpanded] = useState3(false);
+  const [lastPinned, setLastPinned] = useState3(false);
+  const open = !!wanted && !disabled;
+  useSyncExternalStore2(open ? runtime.viewport.subscribe : idleSubscribe, runtime.viewport.get, runtime.viewport.get);
+  useEffect5(() => {
+    if (open) {
+      setRetained(wanted);
+      setLastExpanded(expanded);
+      setLastPinned(pinned);
+    }
+  }, [wanted, open, expanded, pinned]);
+  const close = () => {
+    const anchor2 = id ? runtime.anchors.get(id) : null;
+    anchor2?.focus({ preventScroll: true });
+    runtime.activate(null);
+    runtime.hover(null);
+    setPreview(null);
+  };
+  const anchor = id ? runtime.anchors.get(id) : void 0;
+  const [previewGeometry, setPreviewGeometry] = useState3(null);
+  const fromPreview = previewGeometry?.id === id ? previewGeometry : null;
+  const requestedExpanded = open ? expanded : lastExpanded;
+  const measuringPreview = open && requestedExpanded && !fromPreview;
+  const shownExpanded = requestedExpanded && !measuringPreview;
+  const shownPinned = open ? pinned : lastPinned;
+  const centered = shownExpanded && expansion && expansion.placement === "center";
+  const anchoredExpansion = shownExpanded && !centered && fromPreview;
+  const { refs, update, floatingStyles, context, isPositioned, placement, middlewareData } = useFloating({ open, elements: { reference: anchor ?? null }, onOpenChange: (next) => {
+    if (!next) close();
+  }, strategy: "fixed", transform: false, placement: "bottom-start", whileElementsMounted: autoUpdate, middleware: [offset(8), flip({ padding: 12 }), shift({ padding: 12 }), size({ padding: 12, apply: ({ availableHeight: availableHeight2, elements }) => {
+    if (!shownExpanded) elements.floating.style.maxHeight = `${Math.max(0, Math.floor(Math.min(360, availableHeight2)))}px`;
+    else if (!centered && !fromPreview) elements.floating.style.maxHeight = `min(${length(expansion && expansion.maxHeight || maxHeight)}, ${Math.max(0, Math.floor(availableHeight2))}px)`;
+  } }, [shownExpanded, !!centered, !!fromPreview, expansion && expansion.maxHeight, maxHeight]), {
+    name: "limrAnchor",
+    options: shownExpanded,
+    fn: ({ elements }) => ({ data: { id: elements.reference.dataset?.limrAnchor, expanded: shownExpanded } })
+  }] });
+  useIsomorphicLayoutEffect(() => {
+    if (open && anchor) update();
+  }, [anchor, update, open, shownExpanded]);
+  const dismiss = useDismiss(context, { escapeKey: true, outsidePress: true });
+  const role = useRole(context, { role: "dialog" });
+  const { getFloatingProps } = useInteractions([dismiss, role]);
+  const ready = !!centered || !!anchoredExpansion || !open || isPositioned && middlewareData.limrAnchor?.id === id && middlewareData.limrAnchor?.expanded === shownExpanded;
+  const [surface, setSurface] = useState3(null);
+  const edge = (shownExpanded ? fromPreview?.placement ?? "bottom" : placement).startsWith("top") ? "bottom" : "top";
+  useCardMotion(surface, refs.floating.current, anchor, open, shownExpanded, ready && !measuringPreview, id, edge, fromPreview?.rect, () => {
+    setRetained(null);
+    setCollapsedId(null);
+    setPreviewGeometry(null);
+  });
+  useIsomorphicLayoutEffect(() => {
+    if (!shownExpanded && open && ready && refs.floating.current) {
+      const rect = refs.floating.current.getBoundingClientRect();
+      if (!fromPreview || fromPreview.placement !== placement || ["x", "y", "width", "height"].some((key) => Math.abs(rect[key] - fromPreview.rect[key]) > 0.5)) setPreviewGeometry({ id, rect, placement });
+    }
+  });
+  if (!occurrence || disabled) return null;
+  const visual = window.visualViewport;
+  const viewLeft = visual?.offsetLeft ?? 0, viewTop = visual?.offsetTop ?? 0;
+  const availableWidth = visual?.width ?? window.innerWidth, availableHeight = visual?.height ?? window.innerHeight;
+  const top = viewTop + 12;
+  const bottom = viewTop + availableHeight - 12;
+  const heightLimit = Math.max(0, bottom - top);
+  const settings = shownExpanded && expansion ? expansion : void 0;
+  const width = `min(${length(settings?.width ?? (centered ? 640 : definition?.overlay?.previewWidth ?? previewWidth))}, ${Math.max(0, availableWidth - 24)}px)`;
+  let style = { ...floatingStyles, width, maxHeight: Math.min(360, availableHeight - 24) };
+  if (settings) {
+    style = { ...style, height: settings.height === void 0 ? void 0 : `min(${length(settings.height)}, ${heightLimit}px)`, maxHeight: `min(${length(settings.maxHeight ?? maxHeight)}, ${heightLimit}px)` };
+    if (centered) style = { ...style, left: viewLeft + availableWidth / 2, top: viewTop + availableHeight / 2, transform: "translate(-50%, -50%)" };
+    else if (fromPreview) {
+      const upward = fromPreview.placement.startsWith("top");
+      const room = Math.max(0, upward ? fromPreview.rect.bottom - top : bottom - fromPreview.rect.top);
+      style = { ...style, left: fromPreview.rect.left, top: upward ? fromPreview.rect.bottom : fromPreview.rect.top, transform: upward ? "translateY(-100%)" : "none", maxWidth: viewLeft + availableWidth - 12 - fromPreview.rect.left, maxHeight: `min(${length(settings.maxHeight ?? maxHeight)}, ${room}px)` };
+    }
+  }
+  const Card = definition?.overlay?.Card;
+  const cardProps = {
+    annotation: annotation ?? { id: occurrence.annotationIds[0], type: "unknown" },
+    occurrence,
+    presentation: shownExpanded ? "expanded" : "preview",
+    expanded: shownExpanded,
+    pinned: shownPinned,
+    canExpand: !!expansion,
+    expand: () => {
+      setCollapsedId(null);
+      runtime.activate(occurrence.id);
+    },
+    collapse: () => {
+      setCollapsedId(occurrence.id);
+      runtime.activate(occurrence.id);
+    },
+    close,
+    children: /* @__PURE__ */ jsx4(AnnotationGroup, { occurrence, presentation: shownExpanded ? "expanded" : "preview", expanded: shownExpanded })
+  };
+  const modal = open && !!centered;
+  const card = /* @__PURE__ */ jsx4(FloatingFocusManager, { context, modal, disabled: !open || !pinned || measuringPreview, initialFocus: editing ? -1 : refs.floating, returnFocus: false, children: /* @__PURE__ */ jsx4("div", { ref: refs.setFloating, ...getFloatingProps(), tabIndex: -1, "aria-label": definition?.label ?? locale.annotations, className: "limr-overlay-positioner", style: { ...style, pointerEvents: open ? "auto" : "none", visibility: ready && !measuringPreview ? "visible" : "hidden" }, children: /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      ref: setSurface,
+      className: `limr-annotation-overlay ${shownExpanded ? "limr-annotation-expanded" : "limr-annotation-preview"}`,
+      style: { "--limr-annotation-color": definition?.color },
+      "data-type": annotation?.type,
+      "data-state": open ? "open" : "closing",
+      "data-pinned": shownPinned || void 0,
+      "data-placement": centered ? "center" : anchoredExpansion ? fromPreview.placement : placement,
+      "data-limr-theme": theme,
+      "data-limr-appearance": appearance,
+      onPointerEnter: (event) => {
+        if (!pinned && event.pointerType !== "touch") runtime.hover(occurrence.id);
+      },
+      onPointerLeave: () => {
+        if (!pinned) runtime.hover(null);
+      },
+      children: [
+        /* @__PURE__ */ jsx4("div", { className: "limr-overlay-surface", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx4("div", { className: "limr-overlay-card", children: Card && annotation ? /* @__PURE__ */ jsx4(Card, { ...cardProps }) : /* @__PURE__ */ jsx4(AnnotationCard, { ...cardProps, title: definition?.label ?? annotation?.type ?? locale.annotations }) })
+      ]
+    }
+  ) }) });
+  return /* @__PURE__ */ jsx4(FloatingPortal, { root: portalRoot, children: /* @__PURE__ */ jsx4(FloatingOverlay, { className: "limr-backdrop", "data-expanded": modal || void 0, lockScroll: modal, style: { pointerEvents: modal ? "auto" : "none" }, children: card }) });
+}
+
+// src/components/SelectionToolbar.tsx
+import { useEffect as useEffect6, useId, useMemo as useMemo2, useRef as useRef4, useState as useState4 } from "react";
+import { autoUpdate as autoUpdate2, FloatingPortal as FloatingPortal2, offset as offset2, shift as shift2, useFloating as useFloating2 } from "@floating-ui/react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var defaults = [highlightPalette(), highlightSelection(), copyText(), deleteAnnotations()];
+function SelectionToolbar({ actions, portalRoot, maxPanelHeight = 260, className = "", style, render }) {
+  const runtime = useRuntime();
+  const appearance = useAppearance(), theme = useTheme();
+  const selection = useSelection();
+  const interaction = useStoreSelector(runtime.interaction, (value) => value);
+  const decorations = useStoreSelector(runtime.decorations, (value) => value);
+  const config = useStoreSelector(runtime.configuration, (value) => value);
+  const paint = interaction.activeHighlight ? decorations.highlights.get(interaction.activeHighlight) : null;
+  const active = decorations.occurrences.find((item) => item.id === interaction.active);
+  const hiddenActive = active && [...decorations.highlights.values()].some((item) => item.hidden && sameRange(item.range, active.range));
+  const combined = useMemo2(() => {
+    const map = new Map((actions ?? defaults).map((action) => [action.id, action]));
+    config.extensions?.forEach((extension) => extension.actions?.forEach((action) => map.set(action.id, action)));
+    actions?.forEach((action) => map.set(action.id, action));
+    const order = (action) => action.placement === "start" ? -1 : action.placement === "end" ? 1 : 0;
+    return [...map.values()].sort((a, b) => order(a) - order(b));
+  }, [config.extensions, actions]);
+  const [busy, setBusy] = useState4(null);
+  const busyRef = useRef4(false);
+  const [error, setError] = useState4(null);
+  const [expanded, setExpanded] = useState4(null);
+  const [success, setSuccess] = useState4(null);
+  const [deleteHintOpen, setDeleteHintOpen] = useState4(false);
+  const [preferredHighlight, setPreferredHighlight] = useState4(defaultHighlight);
+  const closeTimer = useRef4(void 0);
+  const successTimer = useRef4(void 0);
+  const panelId = useId();
+  const documentSnapshot = runtime.document.getSnapshot();
+  const effectiveSelection = useMemo2(() => {
+    if (selection) return selection;
+    if (interaction.editing && active?.annotationIds.includes(interaction.editing)) return null;
+    const range = paint?.range ?? (hiddenActive ? active?.range : void 0);
+    return range ? selectionFromRange(documentSnapshot, range, {
+      text: paint ? runtime.highlightReference?.text ?? annotationReferenceText(documentSnapshot, { id: paint.id, annotationIds: [], range }) : annotationReferenceText(documentSnapshot, active)
+    }) : null;
+  }, [documentSnapshot, paint, active, selection, interaction.editing, hiddenActive]);
+  const annotations = useMemo2(() => effectiveSelection ? [...decorations.annotations.values()].filter((annotation) => resolveAnnotationAnchors(annotation, documentSnapshot).some((anchor) => [...effectiveSelection.raw.ranges, ...effectiveSelection.syntax.ranges].some((range) => sameRange(anchor.range, range)))) : [], [decorations, effectiveSelection, documentSnapshot]);
+  const highlight = paint ? decorations.annotations.get(paint.annotationId) : annotations.find((annotation) => annotation.type === "highlight");
+  const highlightAppearance = highlight?.data ?? preferredHighlight;
+  const context = effectiveSelection ? {
+    ...runtime.commands,
+    selection: effectiveSelection,
+    annotations,
+    highlight: highlight ?? null,
+    locale: runtime.locale,
+    addAnnotation: (annotation, options) => runtime.commands.addAnnotation(annotation, { highlight: highlightAppearance, ...options }),
+    document: documentSnapshot,
+    signal: runtime.signal,
+    clearSelection: () => runtime.clearSelection()
+  } : null;
+  const available = context ? combined.filter((action) => action.visible?.(context) ?? true) : [];
+  const expandedAction = available.find((action) => action.id === expanded && action.renderExpanded);
+  const hasPanels = available.some((action) => action.renderExpanded);
+  const open = !!context && effectiveSelection.settled && available.length > 0;
+  const { refs, floatingStyles, placement, isPositioned } = useFloating2({
+    open,
+    strategy: "fixed",
+    placement: "bottom",
+    middleware: [offset2(10), { name: "toolbarSpace", options: { hasPanels, maxPanelHeight }, fn({ rects, placement: placement2, elements }) {
+      const viewport = window.visualViewport;
+      const root = runtime.configuration.get().scrollRoot?.getBoundingClientRect();
+      const top = Math.max(viewport?.offsetTop ?? 0, root?.top ?? 0);
+      const bottom = Math.min((viewport?.offsetTop ?? 0) + (viewport?.height ?? window.innerHeight), root?.bottom ?? Infinity);
+      const above = Math.max(0, rects.reference.y - top - 20), below = Math.max(0, bottom - rects.reference.y - rects.reference.height - 20);
+      const row = (elements.floating.querySelector(".limr-toolbar-actions")?.getBoundingClientRect().height ?? 34) + (elements.floating.querySelector(".limr-toolbar-delete-hint")?.getBoundingClientRect().height ?? 0);
+      const limit = Math.max(0, parseFloat(getComputedStyle(elements.floating).getPropertyValue("--limr-toolbar-panel-max-height")) || maxPanelHeight);
+      const needed = row + (hasPanels ? limit : 0) + 24;
+      const next = below >= needed || below >= above ? "bottom" : "top";
+      const room = next === "bottom" ? below : above;
+      elements.floating.style.setProperty("--limr-toolbar-panel-height", `${Math.max(0, Math.min(limit, room - row - 24))}px`);
+      elements.floating.style.setProperty("--limr-toolbar-available-height", `${room}px`);
+      return placement2 !== next ? { reset: { placement: next } } : {};
+    } }, shift2({ padding: 10 })],
+    whileElementsMounted: autoUpdate2
+  });
+  useEffect6(() => {
+    const reference = selection ? runtime.selectionRange : paint ? runtime.highlightReference : active ? runtime.anchors.get(active.id) : null;
+    if (reference) refs.setPositionReference({ getBoundingClientRect: () => reference.getBoundingClientRect(), getClientRects: () => reference.getClientRects(), contextElement: runtime.content ?? void 0 });
+  }, [runtime, refs, selection, paint, active]);
+  const selectionKey = effectiveSelection?.raw.ranges.map((range) => `${range.start}-${range.end}`).join(",") ?? "";
+  useEffect6(() => {
+    setError(null);
+    setExpanded(null);
+    setSuccess(null);
+    setDeleteHintOpen(false);
+    clearTimeout(closeTimer.current);
+    clearTimeout(successTimer.current);
+  }, [selectionKey, open]);
+  useEffect6(() => () => {
+    clearTimeout(closeTimer.current);
+    clearTimeout(successTimer.current);
+  }, []);
+  const dismiss = () => {
+    runtime.clearSelection();
+    runtime.activate(null);
+  };
+  useEffect6(() => {
+    if (!open) return;
+    const down = (event) => {
+      if (event.target instanceof Element && event.target.closest("[data-limr-selection-ui],.limr-sidebar-card,.limr-overlay-positioner,[data-limr-anchor]")) return;
+      if (runtime.interaction.get().activeHighlight) runtime.clearSelection();
+    };
+    const key = (event) => {
+      if (event.key !== "Escape" || event.defaultPrevented) return;
+      if (expanded) {
+        setExpanded(null);
+        refs.floating.current?.querySelector(`[data-action-id="${CSS.escape(expanded)}"] button`)?.focus();
+      } else dismiss();
+      event.preventDefault();
+    };
+    document.addEventListener("pointerdown", down);
+    document.addEventListener("keydown", key);
+    return () => {
+      document.removeEventListener("pointerdown", down);
+      document.removeEventListener("keydown", key);
+    };
+  }, [open, expanded, runtime, refs]);
+  const expand = (id) => {
+    clearTimeout(closeTimer.current);
+    setExpanded(id);
+  };
+  const execute = async (action, operation) => {
+    if (!context || busyRef.current || action.disabled?.(context)) return;
+    busyRef.current = true;
+    setBusy(action.id);
+    setError(null);
+    try {
+      await operation();
+    } catch (cause) {
+      if (!runtime.signal.aborted) setError(cause instanceof Error ? cause.message : String(cause));
+    } finally {
+      busyRef.current = false;
+      if (!runtime.signal.aborted) setBusy(null);
+    }
+  };
+  const actionContext = (action) => ({
+    ...context,
+    busy: !!busy,
+    expanded: expanded === action.id,
+    highlightAppearance,
+    setHighlightAppearance: setPreferredHighlight,
+    expand: () => expand(action.id),
+    collapse: () => setExpanded(null),
+    run: (operation) => execute(action, () => operation(context))
+  });
+  const run = (action) => execute(action, async () => {
+    if (action.run) await action.run(actionContext(action));
+    else if (action.renderExpanded) expanded === action.id ? setExpanded(null) : expand(action.id);
+    if (action.successLabel && !runtime.signal.aborted) {
+      setSuccess(action.id);
+      clearTimeout(successTimer.current);
+      successTimer.current = setTimeout(() => setSuccess(null), 2400);
+    }
+  });
+  if (!open || !context) return null;
+  const label = (action) => {
+    const value = success === action.id && action.successLabel ? action.successLabel : action.label;
+    return typeof value === "function" ? value(context) : value;
+  };
+  const annotationCount = annotations.filter((annotation) => annotation.type !== "highlight").length;
+  const hint = available.some((action) => action.id === "delete-annotations") && annotationCount > 1 ? context.locale.deleteAnnotationsHint.replace("{count}", String(annotationCount)) : null;
+  return /* @__PURE__ */ jsx5(FloatingPortal2, { root: portalRoot, children: /* @__PURE__ */ jsx5(
+    "div",
+    {
+      ref: refs.setFloating,
+      className: `limr-selection-toolbar ${className}`,
+      style: { ...style, ...floatingStyles, visibility: isPositioned ? void 0 : "hidden" },
+      role: "toolbar",
+      "aria-label": "Text actions",
+      "data-limr-selection-ui": "true",
+      "data-limr-theme": theme,
+      "data-limr-appearance": appearance,
+      "data-placement": placement,
+      "data-highlight": highlight?.id,
+      "data-expanded": expandedAction?.id,
+      onMouseDown: (event) => {
+        if (!(event.target instanceof Element) || !event.target.closest("input,textarea,select,[contenteditable]")) event.preventDefault();
+      },
+      onPointerEnter: () => clearTimeout(closeTimer.current),
+      onPointerLeave: (event) => {
+        if (event.pointerType !== "mouse" || event.currentTarget.contains(document.activeElement)) return;
+        closeTimer.current = setTimeout(() => setExpanded(null), 200);
+      },
+      onBlur: (event) => {
+        if (!event.currentTarget.contains(event.relatedTarget) && !event.currentTarget.matches(":hover")) setExpanded(null);
+      },
+      onKeyDown: (event) => {
+        if (event.target instanceof Element && event.target.closest(".limr-toolbar-panel")) return;
+        if (!["ArrowRight", "ArrowLeft", "Home", "End", "ArrowDown", "ArrowUp"].includes(event.key)) return;
+        if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+          const id = event.target.closest("[data-action-id]")?.dataset.actionId;
+          const action = available.find((item) => item.id === id);
+          if (action?.renderExpanded) {
+            expand(action.id);
+            requestAnimationFrame(() => refs.floating.current?.querySelector(".limr-toolbar-panel button,.limr-toolbar-panel input,.limr-toolbar-panel textarea")?.focus());
+          }
+        } else {
+          const buttons = Array.from(event.currentTarget.querySelectorAll(".limr-toolbar-actions button:not(:disabled)"));
+          const current = buttons.indexOf(document.activeElement);
+          const index = event.key === "Home" ? 0 : event.key === "End" ? buttons.length - 1 : (current + (event.key === "ArrowRight" ? 1 : buttons.length - 1)) % buttons.length;
+          buttons[index]?.focus();
+        }
+        event.preventDefault();
+      },
+      children: /* @__PURE__ */ jsxs5("div", { className: "limr-toolbar-surface", "data-ready": isPositioned || void 0, children: [
+        /* @__PURE__ */ jsx5("div", { className: "limr-toolbar-actions", children: render ? render({ context, actions: available, run }) : available.map((action, index) => /* @__PURE__ */ jsx5(
+          "div",
+          {
+            className: "limr-toolbar-item",
+            "data-action-id": action.id,
+            "data-active": expanded === action.id || void 0,
+            "data-tone": action.tone,
+            "data-status": success === action.id ? "success" : void 0,
+            style: { "--limr-tool-index": index },
+            onPointerEnter: (event) => {
+              if (event.pointerType !== "mouse" || busy || action.disabled?.(context)) return;
+              if (expandedAction && expandedAction.id !== action.id && refs.floating.current?.querySelector(".limr-toolbar-panel")?.contains(document.activeElement)) return;
+              clearTimeout(closeTimer.current);
+              if (action.renderExpanded) expand(action.id);
+              else setExpanded(null);
+              try {
+                action.onHover?.(actionContext(action));
+              } catch (cause) {
+                setError(cause instanceof Error ? cause.message : String(cause));
+              }
+            },
+            children: action.render ? action.render(actionContext(action)) : /* @__PURE__ */ jsxs5(
+              "button",
+              {
+                className: "limr-toolbar-action",
+                type: "button",
+                disabled: !!busy || action.disabled?.(context),
+                onClick: () => void run(action),
+                "aria-label": label(action),
+                "aria-busy": busy === action.id,
+                "aria-expanded": action.renderExpanded ? expanded === action.id : void 0,
+                "aria-controls": action.renderExpanded && expanded === action.id ? panelId : void 0,
+                "aria-describedby": action.id === "delete-annotations" && hint && deleteHintOpen ? `${panelId}-delete` : void 0,
+                onPointerEnter: (event) => {
+                  if (action.id === "delete-annotations" && event.pointerType !== "touch") setDeleteHintOpen(true);
+                },
+                onPointerLeave: (event) => {
+                  if (action.id === "delete-annotations") setDeleteHintOpen(event.currentTarget.matches(":focus-visible"));
+                },
+                onFocus: (event) => {
+                  if (action.id === "delete-annotations" && event.currentTarget.matches(":focus-visible")) setDeleteHintOpen(true);
+                },
+                onBlur: (event) => {
+                  if (action.id === "delete-annotations" && !event.currentTarget.matches(":hover")) setDeleteHintOpen(false);
+                },
+                children: [
+                  /* @__PURE__ */ jsxs5("span", { className: "limr-tool-face", "data-visible": success !== action.id || void 0, "aria-hidden": "true", children: [
+                    /* @__PURE__ */ jsx5("span", { className: "limr-tool-icon", children: typeof action.icon === "function" ? action.icon(context) : action.icon }, typeof action.label === "function" ? action.label(context) : action.label),
+                    /* @__PURE__ */ jsx5("span", { className: "limr-tool-label limr-underline", children: typeof action.label === "function" ? action.label(context) : action.label })
+                  ] }),
+                  action.successLabel && /* @__PURE__ */ jsxs5("span", { className: "limr-tool-face", "data-visible": success === action.id || void 0, "aria-hidden": "true", children: [
+                    /* @__PURE__ */ jsx5("span", { className: "limr-tool-icon", children: action.successIcon ?? (typeof action.icon === "function" ? action.icon(context) : action.icon) }),
+                    /* @__PURE__ */ jsx5("span", { className: "limr-tool-label limr-underline", children: typeof action.successLabel === "function" ? action.successLabel(context) : action.successLabel })
+                  ] })
+                ]
+              }
+            )
+          },
+          action.id
+        )) }),
+        expandedAction && /* @__PURE__ */ jsx5("div", { id: panelId, className: "limr-toolbar-panel", role: "group", "aria-label": label(expandedAction), children: /* @__PURE__ */ jsx5(OverlayScrollArea, { active: true, label: label(expandedAction), children: expandedAction.renderExpanded(actionContext(expandedAction)) }) }, expandedAction.id),
+        hint && /* @__PURE__ */ jsx5(Collapse, { open: deleteHintOpen, keepMounted: true, className: "limr-toolbar-delete-warning", children: /* @__PURE__ */ jsx5("p", { id: `${panelId}-delete`, className: "limr-toolbar-delete-hint", children: hint }) }),
+        error && /* @__PURE__ */ jsx5("span", { role: "alert", className: "limr-action-error", children: error })
+      ] }, selectionKey)
+    }
+  ) });
+}
+
+// src/components/Reader.tsx
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function Reader({ actions, toc = true, sidebar = true, followOutput = false, sidebarBreakpoint = 1120, fillHeight = true, className, style, ...provider }) {
+  return /* @__PURE__ */ jsx6(DocumentProvider, { ...provider, children: /* @__PURE__ */ jsx6(ReaderLayout, { actions, toc, sidebar, followOutput, sidebarBreakpoint, fillHeight, className, style }) });
+}
+function ReaderLayout({ actions, toc, sidebar, followOutput, sidebarBreakpoint, fillHeight, className, style }) {
+  const runtime = useRuntime();
+  const scrollRoot = useStoreSelector(runtime.configuration, (config) => config.scrollRoot);
+  const layout = useStoreSelector(runtime.layout, (value) => value);
+  const appearance = useAppearance();
+  const theme = useTheme();
+  const ref = useRef5(null);
+  const tocRail = useRef5(null);
+  const content = useRef5(null);
+  useOverflowFade(content, runtime, ":scope > .limr-prose");
+  const [width, setWidth] = useState5(0);
+  const [availableHeight, setAvailableHeight] = useState5(0);
+  useIsomorphicLayoutEffect(() => {
+    if (!fillHeight || !ref.current) return;
+    const origin = ref.current.getBoundingClientRect().top - runtime.getViewportTop() - (scrollRoot?.clientTop ?? 0) + runtime.getScrollTop();
+    setAvailableHeight(Math.max(0, (scrollRoot?.clientHeight ?? window.innerHeight) - origin));
+  }, [runtime, scrollRoot, fillHeight, layout, width]);
+  useEffect7(() => {
+    const element = ref.current;
+    if (!element) return;
+    const observer = new ResizeObserver(() => {
+      setWidth(element.clientWidth);
+      runtime.requestLayout();
+    });
+    observer.observe(element);
+    if (scrollRoot) observer.observe(scrollRoot);
+    if (element.parentElement) observer.observe(element.parentElement);
+    setWidth(element.clientWidth);
+    return () => observer.disconnect();
+  }, [runtime, scrollRoot, sidebarBreakpoint]);
+  useIsomorphicLayoutEffect(() => {
+    const rail = tocRail.current;
+    if (!rail) return;
+    let frame = 0;
+    const measure = () => {
+      frame = 0;
+      if (!rail.clientWidth) return;
+      const viewport = window.visualViewport;
+      let top = viewport?.offsetTop ?? 0, bottom = top + (viewport?.height ?? window.innerHeight);
+      if (scrollRoot) {
+        const origin = scrollRoot.getBoundingClientRect().top + scrollRoot.clientTop;
+        top = Math.max(top, origin);
+        bottom = Math.min(bottom, origin + scrollRoot.clientHeight);
+      }
+      const reader = ref.current.getBoundingClientRect();
+      rail.toggleAttribute("inert", reader.bottom <= top || reader.top >= bottom);
+      const height = `${Math.max(0, bottom - Math.max(top, rail.getBoundingClientRect().top)).toFixed(2)}px`;
+      if (rail.style.getPropertyValue("--limr-toc-available-height") !== height) rail.style.setProperty("--limr-toc-available-height", height);
+    };
+    const schedule = () => {
+      if (!frame) frame = requestAnimationFrame(measure);
+    };
+    const unsubscribe = [runtime.layout.subscribe(schedule), runtime.viewport.subscribe(schedule)];
+    window.addEventListener("scroll", schedule, { passive: true });
+    window.addEventListener("resize", schedule);
+    window.visualViewport?.addEventListener("resize", schedule);
+    window.visualViewport?.addEventListener("scroll", schedule);
+    measure();
+    return () => {
+      cancelAnimationFrame(frame);
+      unsubscribe.forEach((fn) => fn());
+      window.removeEventListener("scroll", schedule);
+      window.removeEventListener("resize", schedule);
+      window.visualViewport?.removeEventListener("resize", schedule);
+      window.visualViewport?.removeEventListener("scroll", schedule);
+      rail.removeAttribute("inert");
+      rail.style.removeProperty("--limr-toc-available-height");
+    };
+  }, [runtime, scrollRoot, toc]);
+  const sidebarVisible = !!sidebar && width >= sidebarBreakpoint;
+  return /* @__PURE__ */ jsxs6("div", { ref, className: `limr-reader ${className ?? ""}`, style: { "--limr-reader-available-height": fillHeight ? `${availableHeight}px` : void 0, ...style }, "data-fill-height": fillHeight || void 0, "data-sidebar": sidebarVisible || void 0, "data-toc": toc && width >= 800 || void 0, "data-limr-theme": theme, "data-limr-appearance": appearance, children: [
+    toc && /* @__PURE__ */ jsxs6(Fragment3, { children: [
+      /* @__PURE__ */ jsx6("div", { ref: tocRail, className: "limr-reader-toc", children: /* @__PURE__ */ jsx6(TableOfContents, {}) }),
+      /* @__PURE__ */ jsx6(MobileContents, {})
+    ] }),
+    /* @__PURE__ */ jsx6("main", { ref: content, className: "limr-reader-content", children: /* @__PURE__ */ jsx6(Markdown, { followOutput }) }),
+    sidebarVisible && /* @__PURE__ */ jsx6(AnnotationSidebar, {}),
+    /* @__PURE__ */ jsx6(AnnotationOverlay, { disabled: sidebarVisible }),
+    /* @__PURE__ */ jsx6(SelectionToolbar, { actions })
+  ] });
+}
+function MobileContents() {
+  const locale = useLocale();
+  const [open, setOpen] = useState5(false);
+  const id = useId2();
+  return /* @__PURE__ */ jsxs6("div", { className: "limr-reader-mobile-toc", children: [
+    /* @__PURE__ */ jsxs6("button", { type: "button", className: "limr-mobile-toc-toggle", "aria-expanded": open, "aria-controls": id, onClick: () => setOpen((value) => !value), children: [
+      /* @__PURE__ */ jsx6("span", { children: locale.contents }),
+      /* @__PURE__ */ jsx6("svg", { viewBox: "0 0 20 20", fill: "none", "aria-hidden": "true", children: /* @__PURE__ */ jsx6("path", { d: "m6 8 4 4 4-4" }) })
+    ] }),
+    /* @__PURE__ */ jsx6("div", { id, children: /* @__PURE__ */ jsx6(Collapse, { open, keepMounted: true, children: /* @__PURE__ */ jsx6(TableOfContents, {}) }) })
+  ] });
+}
+
+export {
+  TableOfContents,
+  AnnotationContent,
+  AnnotationGroup,
+  alignSidebar,
+  AnnotationSidebar,
+  AnnotationOverlay,
+  SelectionToolbar,
+  Reader
+};
+//# sourceMappingURL=chunk-N77VD2YR.js.map