@linloir/limr 0.0.0-stage → 1.0.0

package/dist/chunk-3ILUZKDB.js

@@ -0,0 +1,3130 @@
+import {
+  annotationReferenceRange,
+  createDocument,
+  defaultHighlight,
+  intersects,
+  mapText,
+  rangeOf,
+  resolveAnnotationAnchors,
+  safeUrl,
+  sameRange,
+  selectionFromRange,
+  textContent,
+  walk
+} from "./chunk-TTISGBST.js";
+import {
+  ResourceCache
+} from "./chunk-6N6TFHEN.js";
+
+// src/react/motion.ts
+var flights = /* @__PURE__ */ new WeakMap();
+function scrollWithMotion(root, top) {
+  flights.get(root)?.();
+  const element = root instanceof Window ? root.document.documentElement : root;
+  const start = root instanceof Window ? root.scrollY : root.scrollTop;
+  const target = Math.max(0, Math.min(top, element.scrollHeight - (root instanceof Window ? root.innerHeight : root.clientHeight)));
+  if (matchMedia("(prefers-reduced-motion: reduce)").matches) {
+    root.scrollTo({ top: target, behavior: "instant" });
+    return;
+  }
+  const duration = Math.min(560, 220 + Math.abs(target - start) * 0.15);
+  let frame = 0, begun = 0;
+  const keyboard = (event) => {
+    if (["ArrowDown", "ArrowUp", "PageDown", "PageUp", "Home", "End", " "].includes(event.key)) stop();
+  };
+  const stop = () => {
+    cancelAnimationFrame(frame);
+    root.removeEventListener("wheel", stop);
+    root.removeEventListener("touchstart", stop);
+    root.removeEventListener("pointerdown", stop);
+    root.removeEventListener("keydown", keyboard);
+    flights.delete(root);
+  };
+  const step = (time) => {
+    begun ||= time;
+    const t = Math.min(1, (time - begun) / duration);
+    root.scrollTo({ top: start + (target - start) * (1 - Math.pow(1 - t, 4)), behavior: "instant" });
+    if (t < 1) frame = requestAnimationFrame(step);
+    else stop();
+  };
+  flights.set(root, stop);
+  root.addEventListener("wheel", stop, { passive: true });
+  root.addEventListener("touchstart", stop, { passive: true });
+  root.addEventListener("pointerdown", stop, { passive: true });
+  root.addEventListener("keydown", keyboard);
+  frame = requestAnimationFrame(step);
+}
+
+// src/react/runtime.ts
+var english = {
+  language: "en",
+  citation: "Citation",
+  contents: "Contents",
+  annotations: "Annotations",
+  expand: "Expand",
+  collapse: "Collapse",
+  close: "Close",
+  copy: "Copy",
+  copied: "Copied",
+  copyFailed: "Copy failed",
+  copyImage: "Copy image URL",
+  copyFigures: "Copy figures Markdown",
+  loading: "Loading\u2026",
+  retry: "Retry",
+  unavailable: "Content unavailable",
+  footnotes: "Footnotes",
+  definition: "Definition",
+  question: "Question",
+  note: "Note",
+  extra: "Extended reading",
+  hint: "Hint",
+  answer: "Answer",
+  submit: "Submit",
+  correct: "Correct",
+  incorrect: "Try again",
+  play: "Play video",
+  highlight: "Highlight",
+  addHighlight: "Add highlight",
+  editHighlight: "Edit highlight",
+  highlightColor: "Color",
+  highlightStyle: "Style",
+  highlightBackground: "Background",
+  highlightUnderline: "Underline",
+  highlightDotted: "Dotted",
+  highlightWavy: "Wavy",
+  hideHighlight: "Hide highlight",
+  showHighlight: "Show highlight",
+  deleteAnnotations: "Delete",
+  deleteAnnotationsHint: "Deletes {count} annotations on this text and any highlight."
+};
+var chinese = {
+  language: "zh-CN",
+  citation: "\u5F15\u7528",
+  contents: "\u76EE\u5F55",
+  annotations: "\u6CE8\u91CA",
+  expand: "\u5C55\u5F00",
+  collapse: "\u6536\u8D77",
+  close: "\u5173\u95ED",
+  copy: "\u590D\u5236",
+  copied: "\u5DF2\u590D\u5236",
+  copyFailed: "\u590D\u5236\u5931\u8D25",
+  copyImage: "\u590D\u5236\u56FE\u7247 URL",
+  copyFigures: "\u590D\u5236\u56FE\u7EC4 Markdown",
+  loading: "\u52A0\u8F7D\u4E2D\u2026",
+  retry: "\u91CD\u8BD5",
+  unavailable: "\u6682\u65E0\u5185\u5BB9",
+  footnotes: "\u811A\u6CE8",
+  definition: "\u91CA\u4E49",
+  question: "\u63D0\u95EE",
+  note: "\u6CE8\u91CA",
+  extra: "\u62D3\u5C55\u9605\u8BFB",
+  hint: "\u63D0\u793A",
+  answer: "\u7B54\u6848",
+  submit: "\u63D0\u4EA4",
+  correct: "\u56DE\u7B54\u6B63\u786E",
+  incorrect: "\u518D\u8BD5\u4E00\u6B21",
+  play: "\u64AD\u653E\u89C6\u9891",
+  highlight: "\u9AD8\u4EAE",
+  addHighlight: "\u6DFB\u52A0\u9AD8\u4EAE",
+  editHighlight: "\u8C03\u6574\u9AD8\u4EAE",
+  highlightColor: "\u989C\u8272",
+  highlightStyle: "\u6837\u5F0F",
+  highlightBackground: "\u5E95\u8272",
+  highlightUnderline: "\u4E0B\u5212\u7EBF",
+  highlightDotted: "\u70B9\u7EBF",
+  highlightWavy: "\u6CE2\u6D6A\u7EBF",
+  hideHighlight: "\u9690\u85CF\u9AD8\u4EAE",
+  showHighlight: "\u663E\u793A\u9AD8\u4EAE",
+  deleteAnnotations: "\u5220\u9664",
+  deleteAnnotationsHint: "\u5C06\u5220\u9664\u8FD9\u6BB5\u6587\u5B57\u5173\u8054\u7684 {count} \u4E2A\u6CE8\u91CA\u53CA\u9AD8\u4EAE\u3002"
+};
+var Store = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  listeners = /* @__PURE__ */ new Set();
+  get = () => this.value;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  set(value) {
+    if (Object.is(this.value, value)) return;
+    this.value = value;
+    for (const listener of this.listeners) listener();
+  }
+};
+var EMPTY = Object.freeze([]);
+var emptyDecorations = Object.freeze({ occurrences: EMPTY, highlights: EMPTY });
+var ReaderRuntime = class {
+  document;
+  interaction = new Store({ selection: null, activeHeading: null, hovered: null, active: null, editing: null, activeHighlight: null, hoveredHighlight: null });
+  layout = new Store(0);
+  viewport = new Store(0);
+  documentOffset = new Store(0);
+  decorations = new Store({ annotations: /* @__PURE__ */ new Map(), highlights: /* @__PURE__ */ new Map(), occurrences: [], referenceRanges: /* @__PURE__ */ new Map(), byBlock: /* @__PURE__ */ new Map() });
+  configuration;
+  resources = new ResourceCache(128);
+  resourceVersions = new Store(/* @__PURE__ */ new Map());
+  resourceKeys = /* @__PURE__ */ new Map();
+  nextResource = 0;
+  anchors = /* @__PURE__ */ new Map();
+  blocks = /* @__PURE__ */ new Map();
+  headings = /* @__PURE__ */ new Map();
+  bindings = /* @__PURE__ */ new WeakMap();
+  textBinders = /* @__PURE__ */ new WeakMap();
+  components = {};
+  annotationTypes = /* @__PURE__ */ new Map();
+  resolvedTypes = /* @__PURE__ */ new WeakMap();
+  locale = english;
+  content = null;
+  selectionRange = null;
+  /** Live geometry supplied by the paint layer; independent of native selection. */
+  highlightReference = null;
+  layoutFrame = 0;
+  observer = null;
+  headingPositions = [];
+  localAnnotations = [];
+  pendingOpen = null;
+  pendingAnnotations;
+  taskController = new AbortController();
+  get signal() {
+    return this.taskController.signal;
+  }
+  commands = {
+    addAnnotation: (annotation, options = {}) => {
+      this.changeAnnotations((items) => {
+        const next = [...items.filter((item) => item.id !== annotation.id), annotation];
+        if (annotation.type !== "highlight" && options.highlight !== false && (options.highlight !== void 0 || this.annotationTypes.get(annotation.type)?.highlight !== "hover")) {
+          const doc = this.document.getSnapshot();
+          for (const anchor of resolveAnnotationAnchors(annotation, doc)) {
+            if (anchor.range.start === anchor.range.end || next.some((item) => item.type === "highlight" && resolveAnnotationAnchors(item, doc).some((other) => sameRange(other.range, anchor.range)))) continue;
+            next.push({ id: `highlight-${crypto.randomUUID()}`, type: "highlight", anchors: [{ ...anchor, id: void 0 }], data: { ...defaultHighlight, ...options.highlight } });
+          }
+        }
+        return next;
+      });
+      if (options.edit) this.commands.editAnnotation(annotation.id);
+    },
+    updateAnnotation: (id, update) => this.changeAnnotations((items) => items.map((item) => item.id === id ? { ...item, ...update, id } : item)),
+    removeAnnotation: (id) => this.changeAnnotations((items) => items.filter((item) => item.id !== id)),
+    removeAnnotationsAt: (ranges) => this.changeAnnotations((items) => items.flatMap((item) => {
+      const anchors = item.anchors ?? (item.range ? [{ range: item.range }] : []);
+      const keep = anchors.filter((anchor) => !resolveAnnotationAnchors({ ...item, range: void 0, anchors: [anchor] }, this.document.getSnapshot()).some((resolved) => ranges.some((range) => sameRange(range, resolved.range))));
+      if (keep.length === anchors.length) return [item];
+      return keep.length ? [{ ...item, range: void 0, anchors: keep }] : [];
+    })),
+    editAnnotation: (id) => {
+      this.updateInteraction({ editing: id });
+      if (id) this.commands.activateAnnotation(id);
+    },
+    activateAnnotation: (id) => {
+      const occurrence = this.decorations.get().occurrences.find((item) => item.id === id || item.annotationIds.includes(id ?? ""));
+      this.pendingOpen = id && !occurrence ? id : null;
+      this.activate(occurrence?.id ?? null);
+    }
+  };
+  changeAnnotations(update) {
+    const config = this.configuration.get();
+    const current = this.pendingAnnotations && this.pendingAnnotations.input === config.annotations ? this.pendingAnnotations.value : config.annotations ?? this.localAnnotations;
+    const next = update(current);
+    if (config.annotations !== void 0 && !config.onAnnotationsChange) throw new Error("Controlled annotations require onAnnotationsChange to accept edits.");
+    if (config.annotations === void 0) {
+      this.localAnnotations = next;
+      this.rebuildDecorations();
+    } else this.pendingAnnotations = { input: config.annotations, value: next };
+    config.onAnnotationsChange?.(next);
+  }
+  start() {
+    if (this.taskController.signal.aborted) this.taskController = new AbortController();
+  }
+  dispose() {
+    this.taskController.abort();
+    this.resources.invalidate();
+    this.resourceKeys.clear();
+  }
+  getResourceKey(annotation) {
+    const old = this.resourceKeys.get(annotation.id);
+    if (old?.annotation === annotation) return old.key;
+    if (old) this.resources.invalidate(old.key);
+    const key = `${annotation.id}:${++this.nextResource}`;
+    this.resourceKeys.set(annotation.id, { annotation, key });
+    return key;
+  }
+  invalidateAnnotation(id) {
+    const current = this.resourceKeys.get(id);
+    if (current) this.resources.invalidate(current.key);
+    const versions = new Map(this.resourceVersions.get());
+    versions.set(id, (versions.get(id) ?? 0) + 1);
+    this.resourceVersions.set(versions);
+  }
+  constructor(id, source, streaming, config) {
+    this.configuration = new Store(config);
+    this.installConfiguration(config);
+    this.document = createDocument(source, { id, streaming, extensions: config.extensions });
+    this.rebuildDecorations();
+    this.document.subscribe(() => {
+      this.rebuildDecorations();
+      const selection = this.interaction.get().selection;
+      if (selection && selection.raw.ranges.length === 1) {
+        const doc = this.document.getSnapshot(), range = selection.raw.ranges[0];
+        this.updateInteraction({ selection: doc.source.slice(range.start, range.end) === selection.raw.sourceText ? selectionFromRange(doc, range, { text: selection.text, quality: selection.quality, settled: selection.settled }) : null });
+      }
+      this.requestLayout();
+      this.configuration.get().onDocumentChange?.(this.document.getSnapshot());
+    });
+  }
+  installConfiguration(config) {
+    this.locale = { ...english, ...config.locale };
+    this.components = Object.assign({}, ...(config.extensions ?? []).map((ext) => ext.components), config.components);
+    const annotationTypes = [...(config.extensions ?? []).flatMap((ext) => [...ext.annotationTypes ?? []]), ...config.annotationTypes ?? []];
+    this.annotationTypes = new Map(annotationTypes.map((type) => {
+      if (typeof type.label === "string") return [type.type, type];
+      const label = type.label(this.locale);
+      const previous = this.resolvedTypes.get(type);
+      const resolved = previous?.label === label ? previous : { ...type, label };
+      this.resolvedTypes.set(type, resolved);
+      return [type.type, resolved];
+    }));
+  }
+  configure(config) {
+    const old = this.configuration.get();
+    if (this.pendingAnnotations?.input !== config.annotations) this.pendingAnnotations = void 0;
+    this.installConfiguration(config);
+    this.configuration.set(config);
+    if (old.extensions !== config.extensions) this.document.setExtensions(config.extensions ?? []);
+    else if (old.annotations !== config.annotations || old.annotationTypes !== config.annotationTypes) this.rebuildDecorations();
+    if (old.annotationTypes !== config.annotationTypes || old.extensions !== config.extensions) this.resources.invalidate();
+  }
+  updateInteraction(patch) {
+    const old = this.interaction.get();
+    if (Object.keys(patch).every((key) => Object.is(old[key], patch[key]))) return;
+    this.interaction.set({ ...old, ...patch });
+    if ("selection" in patch) this.configuration.get().onSelectionChange?.(patch.selection ?? null);
+  }
+  hover(id, source = "marker") {
+    this.updateInteraction({ hovered: id, hoverSource: id ? source : null });
+    this.configuration.get().onAnnotationHover?.(this.decorations.get().occurrences.find((item) => item.id === id) ?? null);
+  }
+  activate(id, source = "marker") {
+    this.updateInteraction({ active: id, activeSource: id ? source : null, hovered: null, hoverSource: null });
+    const occurrence = this.decorations.get().occurrences.find((item) => item.id === id);
+    if (occurrence) this.configuration.get().onAnnotationClick?.(occurrence);
+  }
+  hoverHighlight(id) {
+    if (this.interaction.get().hoveredHighlight === id) return;
+    this.updateInteraction({ hoveredHighlight: id });
+    this.configuration.get().onHighlightHover?.(id ? this.decorations.get().annotations.get(this.decorations.get().highlights.get(id)?.annotationId ?? "") ?? null : null);
+  }
+  activateHighlight(id) {
+    this.updateInteraction({ activeHighlight: id, selection: null });
+    const highlight = id && this.decorations.get().highlights.get(id);
+    if (highlight) this.configuration.get().onHighlightClick?.(this.decorations.get().annotations.get(highlight.annotationId));
+    else this.highlightReference = null;
+  }
+  clearSelection() {
+    this.selectionRange = null;
+    const selection = typeof window === "undefined" ? null : window.getSelection();
+    if (selection?.anchorNode && this.content?.contains(selection.anchorNode)) selection.removeAllRanges();
+    this.highlightReference = null;
+    this.updateInteraction({ selection: null, activeHighlight: null });
+  }
+  prepareTextBindings(element) {
+    const block = element.closest("[data-limr-block]");
+    const bind = block && this.textBinders.get(block);
+    if (bind) {
+      this.textBinders.delete(block);
+      bind();
+    }
+  }
+  rebuildDecorations() {
+    const doc = this.document.getSnapshot();
+    const config = this.configuration.get();
+    const previous = this.decorations.get();
+    const annotations = new Map(doc.annotations.map((annotation) => [annotation.id, annotation]));
+    for (const annotation of config.annotations ?? this.localAnnotations) annotations.set(annotation.id, annotation);
+    for (const [id, resource] of this.resourceKeys) if (!annotations.has(id)) {
+      this.resources.invalidate(resource.key);
+      this.resourceKeys.delete(id);
+    }
+    const versions = this.resourceVersions.get();
+    if ([...versions.keys()].some((id) => !annotations.has(id))) this.resourceVersions.set(new Map([...versions].filter(([id]) => annotations.has(id))));
+    const occurrences = [...doc.occurrences];
+    const allHighlights = [];
+    for (const annotation of config.annotations ?? this.localAnnotations) {
+      resolveAnnotationAnchors(annotation, doc).forEach((anchor, index) => {
+        if (annotation.type === "highlight") {
+          const id = index ? `${annotation.id}:${index}` : annotation.id;
+          const value = { ...annotation.data, id, annotationId: annotation.id, range: anchor.range };
+          const old = previous.highlights.get(id);
+          allHighlights.push(old && !old.occurrenceId && sameRange(old.range, value.range) && old.color === value.color && old.style === value.style && old.hidden === value.hidden ? old : value);
+        } else occurrences.push({ ...anchor, id: anchor.id ?? `${doc.id}-${annotation.id}-${index}`, annotationIds: [annotation.id] });
+      });
+    }
+    occurrences.sort((a, b) => a.range.end - b.range.end || a.id.localeCompare(b.id));
+    const referenceRanges = new Map(occurrences.map((occurrence) => [occurrence.id, annotationReferenceRange(doc, occurrence)]));
+    for (const occurrence of occurrences) {
+      const annotation = annotations.get(occurrence.annotationIds[0]);
+      const definition2 = annotation && this.annotationTypes.get(annotation.type);
+      if (!annotation || definition2?.highlight !== "hover") continue;
+      const range = referenceRanges.get(occurrence.id);
+      if (range.start === range.end) continue;
+      const id = `reference-${occurrence.id}`;
+      const value = { id, annotationId: annotation.id, occurrenceId: occurrence.id, range, color: definition2.color ?? defaultHighlight.color, style: "background" };
+      const old = previous.highlights.get(id);
+      allHighlights.push(old && old.occurrenceId === value.occurrenceId && old.annotationId === value.annotationId && sameRange(old.range, range) && old.color === value.color ? old : value);
+    }
+    const byBlock = /* @__PURE__ */ new Map();
+    for (const block of occurrences.length || allHighlights.length ? doc.blocks : []) {
+      const marks = occurrences.filter((item) => !item.embedded && item.range.end > block.range.start && item.range.end <= block.range.end);
+      const before = previous.byBlock.get(block.id) ?? emptyDecorations;
+      const old = before.occurrences;
+      const same = old && old.length === marks.length && old.every((item, index) => item.id === marks[index].id && item.range.start === marks[index].range.start && item.range.end === marks[index].range.end && item.annotationIds.join("\0") === marks[index].annotationIds.join("\0"));
+      const highlights2 = allHighlights.filter((item) => intersects(item.range, block.range));
+      const oldHighlights = before.highlights;
+      const sameHighlights = oldHighlights.length === highlights2.length && oldHighlights.every((item, i) => item === highlights2[i]);
+      if (marks.length || highlights2.length) byBlock.set(block.id, same && sameHighlights ? before : { occurrences: same ? old : marks, highlights: sameHighlights ? oldHighlights : highlights2 });
+    }
+    const sameBlocks = byBlock.size === previous.byBlock.size && [...byBlock].every(([id, value]) => previous.byBlock.get(id) === value);
+    const highlights = new Map(allHighlights.map((item) => [item.id, item]));
+    this.decorations.set({ annotations, highlights, occurrences, referenceRanges, byBlock: sameBlocks ? previous.byBlock : byBlock });
+    const state = this.interaction.get();
+    if (state.editing && !annotations.has(state.editing) && this.pendingOpen !== state.editing) this.updateInteraction({ editing: null });
+    if (state.activeHighlight && !highlights.has(state.activeHighlight)) this.activateHighlight(null);
+    if (state.hoveredHighlight && !highlights.has(state.hoveredHighlight)) this.hoverHighlight(null);
+    if (state.active && !occurrences.some((item) => item.id === state.active)) this.activate(null);
+    if (state.hovered && !occurrences.some((item) => item.id === state.hovered)) this.hover(null);
+    if (this.pendingOpen) {
+      const occurrence = occurrences.find((item) => item.id === this.pendingOpen || item.annotationIds.includes(this.pendingOpen));
+      if (occurrence) {
+        this.pendingOpen = null;
+        this.activate(occurrence.id);
+      }
+    }
+  }
+  registerAnchor(id, element) {
+    if (element) this.anchors.set(id, element);
+    else this.anchors.delete(id);
+    this.requestLayout();
+  }
+  registerHeading(id, element) {
+    if (element) this.headings.set(id, element);
+    else this.headings.delete(id);
+    this.requestLayout();
+  }
+  observeBlock(element) {
+    if (element) {
+      if (element.dataset.limrBlock) this.blocks.set(element.dataset.limrBlock, element);
+      this.observer?.observe(element);
+    }
+  }
+  unobserveBlock(element) {
+    if (element.dataset.limrBlock) this.blocks.delete(element.dataset.limrBlock);
+    this.observer?.unobserve(element);
+  }
+  getScrollTop() {
+    return this.configuration.get().scrollRoot?.scrollTop ?? (typeof window !== "undefined" ? window.scrollY : 0);
+  }
+  getViewportTop() {
+    return this.configuration.get().scrollRoot?.getBoundingClientRect().top ?? 0;
+  }
+  getContentOffset() {
+    const translate = this.content && getComputedStyle(this.content).translate;
+    return translate ? parseFloat(translate.split(" ")[1] ?? "0") || 0 : 0;
+  }
+  scrollTo(top, behavior = "smooth") {
+    const root = this.configuration.get().scrollRoot ?? window;
+    if (behavior === "smooth") scrollWithMotion(root, top);
+    else root.scrollTo({ top: Math.max(0, top), behavior });
+  }
+  scrollToHeading(id) {
+    const element = this.headings.get(id);
+    if (element) this.scrollTo(element.getBoundingClientRect().top - this.getViewportTop() + this.getScrollTop() - (this.configuration.get().scrollOffset ?? 24));
+  }
+  scrollToOccurrence(id) {
+    const element = this.anchors.get(id);
+    if (element) this.scrollTo(element.getBoundingClientRect().top - this.getViewportTop() + this.getScrollTop() - (this.configuration.get().scrollOffset ?? 24));
+  }
+  followFragment = (event) => {
+    if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+    const link = event.target instanceof Element ? event.target.closest("a[href]") : null;
+    if (!link || link.hasAttribute("download") || link.target && link.target !== "_self" || !this.content?.contains(link)) return;
+    const url = new URL(link.href, document.baseURI);
+    if (!url.hash || url.origin !== location.origin || url.pathname !== location.pathname || url.search !== location.search) return;
+    let id;
+    try {
+      id = decodeURIComponent(url.hash.slice(1));
+    } catch {
+      return;
+    }
+    const target = this.content.querySelector(`[id="${CSS.escape(id)}"]`);
+    if (!target) return;
+    event.preventDefault();
+    this.scrollTo(target.getBoundingClientRect().top - this.getViewportTop() + this.getScrollTop() - (this.configuration.get().scrollOffset ?? 24));
+    if (event.detail === 0) {
+      if (!target.hasAttribute("tabindex")) {
+        target.tabIndex = -1;
+        target.addEventListener("blur", () => target.removeAttribute("tabindex"), { once: true });
+      }
+      target.focus({ preventScroll: true });
+    }
+  };
+  requestLayout = () => {
+    if (typeof window === "undefined" || !this.content || this.layoutFrame) return;
+    this.layoutFrame = window.requestAnimationFrame(() => {
+      this.layoutFrame = 0;
+      const offset = this.getScrollTop() - this.getViewportTop();
+      this.headingPositions = [...this.headings].filter(([, element]) => !element.closest("[inert]")).map(([id, element]) => ({ id, top: element.getBoundingClientRect().top + offset })).sort((a, b) => a.top - b.top);
+      const state = this.interaction.get();
+      if (state.active && this.anchors.get(state.active)?.closest("[inert]")) this.activate(null);
+      if (state.hovered && this.anchors.get(state.hovered)?.closest("[inert]")) this.hover(null);
+      this.layout.set(this.layout.get() + 1);
+      this.trackHeading();
+    });
+  };
+  trackHeading = () => {
+    const positions = this.headingPositions;
+    const top = this.getScrollTop() + (this.configuration.get().scrollOffset ?? 24) + 2;
+    let lo = 0, hi = positions.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (positions[mid].top <= top) lo = mid + 1;
+      else hi = mid;
+    }
+    const root = this.configuration.get().scrollRoot;
+    const maximum = (root?.scrollHeight ?? document.documentElement.scrollHeight) - (root?.clientHeight ?? window.innerHeight);
+    const atEnd = maximum > 0 && this.getScrollTop() >= maximum - 2;
+    this.updateInteraction({ activeHeading: positions[atEnd ? positions.length - 1 : Math.max(0, lo - 1)]?.id ?? null });
+  };
+  mountContent(element) {
+    this.content = element;
+    this.observer = new ResizeObserver(this.requestLayout);
+    this.observer.observe(element);
+    element.querySelectorAll("[data-limr-block]").forEach((block) => this.observer.observe(block));
+    let frame = 0;
+    const scroll = () => {
+      if (frame) return;
+      frame = requestAnimationFrame(() => {
+        frame = 0;
+        this.trackHeading();
+        this.viewport.set(this.viewport.get() + 1);
+      });
+    };
+    const scrollRoot = this.configuration.get().scrollRoot ?? window;
+    scrollRoot.addEventListener("scroll", scroll, { passive: true });
+    window.addEventListener("resize", this.requestLayout);
+    document.fonts?.addEventListener("loadingdone", this.requestLayout);
+    element.addEventListener("load", this.requestLayout, true);
+    element.addEventListener("click", this.followFragment);
+    this.requestLayout();
+    return () => {
+      this.content = null;
+      this.observer?.disconnect();
+      this.observer = null;
+      cancelAnimationFrame(frame);
+      cancelAnimationFrame(this.layoutFrame);
+      this.layoutFrame = 0;
+      scrollRoot.removeEventListener("scroll", scroll);
+      window.removeEventListener("resize", this.requestLayout);
+      document.fonts?.removeEventListener("loadingdone", this.requestLayout);
+      element.removeEventListener("load", this.requestLayout, true);
+      element.removeEventListener("click", this.followFragment);
+    };
+  }
+};
+var emptyList = EMPTY;
+
+// src/extensions/gfm.ts
+import { gfm as syntax } from "micromark-extension-gfm";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+function gfm() {
+  return { name: "gfm", micromark: [syntax()], mdast: gfmFromMarkdown(), scope: "local" };
+}
+
+// src/extensions/math.tsx
+import { lazy, Suspense } from "react";
+import { math as syntax2 } from "micromark-extension-math";
+import { mathFromMarkdown } from "mdast-util-math";
+
+// src/components/CopyButton.tsx
+import { useEffect as useEffect9, useRef as useRef12, useState as useState9 } from "react";
+
+// src/react/context.tsx
+import { createContext as createContext2, useCallback as useCallback2, useContext as useContext3, useEffect as useEffect8, useId, useLayoutEffect, useMemo as useMemo4, useRef as useRef11, useState as useState8, useSyncExternalStore } from "react";
+
+// src/extensions/code.tsx
+import { useEffect, useRef, useState } from "react";
+
+// src/react/literal.ts
+function literalValue(node) {
+  return (node.value ?? "").replace(/\r\n?|\n/g, node.type === "inlineCode" ? " " : "\n");
+}
+function mapLiteral(source, node) {
+  const range = rangeOf(node), raw = source.slice(range.start, range.end), value = literalValue(node);
+  const starts = [], ends = [];
+  if (node.type === "inlineCode") {
+    const fence = /^`+/.exec(raw)?.[0].length ?? 0;
+    let from = fence, until = raw.length - fence;
+    const normalized = raw.slice(from, until).replace(/\r\n?|\n/g, " ");
+    if (normalized.startsWith(" ") && normalized.endsWith(" ") && /[^ ]/.test(normalized)) {
+      from += raw.slice(from, from + 2) === "\r\n" ? 2 : 1;
+      until -= raw.slice(until - 2, until) === "\r\n" ? 2 : 1;
+    }
+    for (let at = from; at < until; at++) {
+      const length = raw[at] === "\r" && raw[at + 1] === "\n" ? 2 : 1;
+      starts.push(range.start + at);
+      ends.push(range.start + at + length);
+      at += length - 1;
+    }
+    return { starts, ends, exact: starts.length === value.length };
+  }
+  const lines = [...raw.matchAll(/[^\r\n]*(?:\r\n|\r|\n|$)/g)].filter((match) => match[0]);
+  const fenced = /^[ \t]*(?:`{3,}|~{3,})/.test(lines[0]?.[0] ?? "");
+  let index = fenced ? 1 : 0;
+  let exact = true;
+  const values = value.split("\n");
+  for (let line = 0; line < values.length; line++, index++) {
+    const match = lines[index], text = values[line];
+    const rawLine = (match?.[0] ?? "").replace(/[\r\n]+$/, "");
+    const at = rawLine.endsWith(text) ? rawLine.length - text.length : -1;
+    if (at < 0 || !match) exact = false;
+    const start = range.start + (match?.index ?? raw.length) + Math.max(0, at);
+    for (let unit = 0; unit < text.length; unit++) {
+      starts.push(start + unit);
+      ends.push(start + unit + 1);
+    }
+    if (line < values.length - 1) {
+      starts.push(range.start + (match?.index ?? 0) + rawLine.length);
+      ends.push(range.start + (match?.index ?? 0) + (match?.[0].length ?? rawLine.length));
+    }
+  }
+  return { starts, ends, exact };
+}
+
+// src/extensions/code.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var cache = new ResourceCache(96);
+var aliases = { js: "javascript", ts: "typescript", py: "python", sh: "bash", yml: "yaml", md: "markdown", rs: "rust", "c++": "cpp", text: "text", txt: "text" };
+function codeHighlight(options = {}) {
+  function CodeNode({ node, pending, renderValue }) {
+    const runtime = useRuntime();
+    const code = literalValue(node);
+    const language = String(node.lang ?? "text").toLowerCase();
+    const normalized = aliases[language] ?? language;
+    const [result, setResult] = useState(null);
+    const [visible, setVisible] = useState(options.eager ?? false);
+    const ref = useRef(null);
+    useEffect(() => {
+      if (visible) return;
+      if (typeof IntersectionObserver === "undefined") {
+        setVisible(true);
+        return;
+      }
+      const observer = new IntersectionObserver((entries) => {
+        if (entries.some((entry) => entry.isIntersecting)) {
+          setVisible(true);
+          observer.disconnect();
+        }
+      }, { root: runtime.configuration.get().scrollRoot, rootMargin: "400px" });
+      if (ref.current) observer.observe(ref.current);
+      return () => observer.disconnect();
+    }, [visible, runtime]);
+    useEffect(() => {
+      if (!visible || code.length > (options.maxLength ?? 1e5)) return;
+      let disposed = false;
+      let release;
+      const timer = setTimeout(() => {
+        if (normalized === "text" || options.languages && !options.languages.includes(normalized)) return;
+        const request = cache.acquire(JSON.stringify([code, normalized, options.lightTheme, options.darkTheme]), async () => {
+          const shiki = await import("shiki");
+          if (!(normalized in shiki.bundledLanguages) && !(normalized in shiki.bundledLanguagesAlias)) return [];
+          const result2 = await shiki.codeToTokens(code, { lang: normalized, themes: { light: options.lightTheme ?? "github-light", dark: options.darkTheme ?? "github-dark" }, defaultColor: false });
+          let offset = 0;
+          return result2.tokens.flatMap((line, index) => {
+            const tokens2 = line.map((token) => {
+              const start = offset;
+              offset += token.content.length;
+              return { content: token.content, offset: start, style: token.htmlStyle };
+            });
+            if (index < result2.tokens.length - 1) {
+              tokens2.push({ content: "\n", offset: offset++ });
+            }
+            return tokens2;
+          });
+        });
+        release = request.release;
+        request.promise.then((tokens2) => {
+          if (!disposed) setResult({ code, tokens: tokens2 });
+        }).catch(() => {
+        });
+      }, pending ? 180 : 0);
+      return () => {
+        disposed = true;
+        clearTimeout(timer);
+        release?.();
+      };
+    }, [code, normalized, pending, visible]);
+    const tokens = result?.code === code ? result.tokens : void 0;
+    return /* @__PURE__ */ jsxs("div", { className: "limr-code-block", ref, children: [
+      /* @__PURE__ */ jsxs("div", { className: "limr-code-header", "data-limr-ignore": "true", children: [
+        /* @__PURE__ */ jsx("span", { children: language }),
+        /* @__PURE__ */ jsx(CopyButton, { value: code })
+      ] }),
+      /* @__PURE__ */ jsx("pre", { className: tokens?.length ? "shiki" : void 0, children: /* @__PURE__ */ jsx("code", { children: renderValue(tokens) }) })
+    ] });
+  }
+  return { name: "code-highlight", scope: "local", components: { code: CodeNode } };
+}
+
+// src/extensions/annotations.tsx
+import { useMemo as useMemo2, useRef as useRef6 } from "react";
+import { fromMarkdown } from "mdast-util-from-markdown";
+
+// src/react/Markdown.tsx
+import { useContext, useEffect as useEffect4, useRef as useRef4 } from "react";
+
+// src/react/render.tsx
+import { cloneElement, Component, createElement, Fragment, isValidElement, memo, useCallback, useMemo, useRef as useRef2 } from "react";
+
+// src/react/text-binding.ts
+var atomic = /* @__PURE__ */ new Set(["inlineCode", "code", "math", "inlineMath", "image", "imageReference", "html"]);
+var hidden = /* @__PURE__ */ new Set(["definition", "footnoteDefinition", "annotationDefinition", "footnoteReference"]);
+var ordinary = /* @__PURE__ */ new Set(["text", "paragraph", "heading", "strong", "emphasis", "delete", "blockquote", "list", "listItem", "link", "linkReference", "table", "tableRow", "tableCell", "thematicBreak", "break", "annotationReference"]);
+function compactTextNodes(node, components) {
+  const texts = [];
+  let supported = true;
+  const visit = (node2) => {
+    if (node2.selection === "atomic" || atomic.has(node2.type) || hidden.has(node2.type)) return;
+    if (!ordinary.has(node2.type) || components[node2.type]) {
+      supported = false;
+      return;
+    }
+    if (node2.type === "text") {
+      if (node2.value) texts.push(node2);
+      return;
+    }
+    node2.children?.forEach(visit);
+  };
+  visit(node);
+  return supported ? texts : null;
+}
+function bindingFor(node, source) {
+  const range = rangeOf(node), value = node.value ?? "";
+  const raw = source.slice(range.start, range.end);
+  const direct = raw === value;
+  let mapping;
+  const mapped = () => mapping ??= mapText(raw, value, { start: 0, end: raw.length });
+  return {
+    range,
+    atomic: false,
+    get exact() {
+      return direct || mapped().exact;
+    },
+    resolve(offset, edge) {
+      const at = Math.max(0, Math.min(value.length, offset));
+      return direct ? range.start + at : range.start + (edge === "start" ? mapped().starts[at] ?? raw.length : mapped().ends[at - 1] ?? 0);
+    }
+  };
+}
+function bindCompactText(element, nodes, runtime) {
+  const bound = [];
+  const clear = () => bound.forEach((node) => runtime.bindings.delete(node));
+  const bindings = nodes.map((node) => bindingFor(node, runtime.document.getSnapshot().source));
+  const walker = element.ownerDocument.createTreeWalker(element, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, {
+    acceptNode(node) {
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        const element2 = node;
+        return element2.hasAttribute("data-limr-ignore") || element2.hasAttribute("data-limr-text") || runtime.bindings.get(element2)?.atomic ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_SKIP;
+      }
+      return NodeFilter.FILTER_ACCEPT;
+    }
+  });
+  let index = 0, inValue = 0;
+  for (let text = walker.nextNode(); text; text = walker.nextNode()) {
+    const value = text.textContent ?? "";
+    if (!value) continue;
+    const parts2 = [];
+    for (let at = 0; at < value.length; ) {
+      const expected = nodes[index]?.value ?? "";
+      const size = Math.min(value.length - at, expected.length - inValue);
+      if (size <= 0 || value.slice(at, at + size) !== expected.slice(inValue, inValue + size)) {
+        clear();
+        return () => {
+        };
+      }
+      parts2.push({ start: at, end: at + size, offset: inValue, binding: bindings[index] });
+      at += size;
+      inValue += size;
+      if (inValue === expected.length) {
+        index++;
+        inValue = 0;
+      }
+    }
+    const first = parts2[0], last = parts2[parts2.length - 1];
+    runtime.bindings.set(text, parts2.length === 1 && first.offset === 0 && value === nodes[index - 1]?.value ? first.binding : {
+      range: { start: first.binding.range.start, end: last.binding.range.end },
+      atomic: false,
+      get exact() {
+        return parts2.every((part) => part.binding.exact);
+      },
+      resolve(offset, edge) {
+        const part = parts2.find((part2) => edge === "start" ? part2.end > offset : part2.end >= offset) ?? last;
+        return part.binding.resolve(part.offset + offset - part.start, edge);
+      }
+    });
+    bound.push(text);
+  }
+  return clear;
+}
+
+// src/react/render.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var blockAttributes = (block) => block ? { "data-limr-block": block.id, "data-source-start": block.range.start, "data-source-end": block.range.end, "data-pending": block.pending || void 0 } : {};
+function AnnotationMarker({ occurrence }) {
+  const runtime = useRuntime();
+  const annotation = useStoreSelector(runtime.decorations, (state) => state.annotations.get(occurrence.annotationIds[0]));
+  const active = useStoreSelector(runtime.interaction, (state) => state.active === occurrence.id);
+  const hovered = useStoreSelector(runtime.interaction, (state) => state.hovered === occurrence.id);
+  const definition2 = useStoreSelector(runtime.configuration, () => runtime.annotationTypes.get(annotation?.type ?? "citation"));
+  const Icon = definition2?.icon;
+  const Custom = definition2?.Marker;
+  const icon = typeof Icon === "function" || Icon && typeof Icon === "object" && !isValidElement(Icon) && "$$typeof" in Icon ? createElement(Icon) : Icon;
+  return /* @__PURE__ */ jsx2("span", { className: "limr-mark-wrap", "data-limr-ignore": "true", "data-limr-marker": occurrence.id, "data-source-start": occurrence.range.start, "data-source-end": occurrence.range.end, children: /* @__PURE__ */ jsxs2(
+    "button",
+    {
+      type: "button",
+      ref: (element) => runtime.registerAnchor(occurrence.id, element),
+      className: "limr-mark",
+      "data-limr-anchor": occurrence.id,
+      "data-active": active || hovered || void 0,
+      style: { "--limr-mark-color": definition2?.color },
+      "aria-label": definition2?.label ?? annotation?.type ?? "Annotation",
+      "aria-expanded": active,
+      onPointerEnter: (event) => {
+        if (event.pointerType !== "touch") runtime.hover(occurrence.id);
+      },
+      onPointerLeave: (event) => {
+        if (event.pointerType !== "touch" && runtime.interaction.get().hovered === occurrence.id && runtime.interaction.get().hoverSource === "marker") runtime.hover(null);
+      },
+      onFocus: (event) => {
+        if (event.currentTarget.matches(":focus-visible")) runtime.hover(occurrence.id);
+      },
+      onBlur: (event) => {
+        if (event.relatedTarget instanceof Element && event.relatedTarget.closest("[data-occurrence]")?.getAttribute("data-occurrence") === occurrence.id) return;
+        if (runtime.interaction.get().hovered === occurrence.id && runtime.interaction.get().hoverSource === "marker") runtime.hover(null);
+      },
+      onClick: () => {
+        const hovering = runtime.interaction.get().hovered === occurrence.id;
+        runtime.activate(active ? null : occurrence.id);
+        if (hovering) runtime.hover(occurrence.id);
+      },
+      children: [
+        /* @__PURE__ */ jsx2("span", { className: "limr-mark-icon", children: Custom && annotation ? /* @__PURE__ */ jsx2(Custom, { annotation, active }) : icon ?? "\u2022" }),
+        occurrence.annotationIds.length > 1 && /* @__PURE__ */ jsx2("span", { className: "limr-mark-count", children: occurrence.annotationIds.length })
+      ]
+    }
+  ) });
+}
+function Text({ node, context, mapping: literalMapping, marks: literalMarks, style, className }) {
+  const { runtime } = context;
+  const value = node.value ?? "";
+  const range = rangeOf(node);
+  const source = runtime.document.getSnapshot().source;
+  const mapped = useMemo(() => {
+    let mapping2;
+    const raw = source.slice(range.start, range.end);
+    return () => {
+      if (literalMapping) return literalMapping;
+      if (!mapping2) {
+        const relative = mapText(raw, value, { start: 0, end: raw.length }, { escapes: node.verbatimEscapes !== true });
+        mapping2 = { starts: relative.starts.map((offset) => offset + range.start), ends: relative.ends.map((offset) => offset + range.start), exact: relative.exact };
+      }
+      return mapping2;
+    };
+  }, [node, literalMapping]);
+  const marks = literalMarks ?? context.marks.get(node) ?? emptyList;
+  const highlights = context.highlights.filter((highlight) => intersects(highlight.range, range));
+  if (!marks.length && !highlights.length) {
+    const direct = !literalMapping && source.slice(range.start, range.end) === value;
+    return /* @__PURE__ */ jsx2("span", { style, className, "data-limr-text": "", "data-source-start": range.start, "data-source-end": range.end, ref: (element) => {
+      if (element) runtime.bindings.set(element, {
+        range,
+        atomic: false,
+        get exact() {
+          return direct || mapped().exact;
+        },
+        resolve: (offset, edge) => direct ? Math.max(range.start, Math.min(range.end, range.start + offset)) : edge === "start" ? mapped().starts[offset] ?? range.end : mapped().ends[offset - 1] ?? range.start
+      });
+    }, children: value });
+  }
+  const mapping = mapped();
+  const markerAt = /* @__PURE__ */ new Map();
+  const boundaries = /* @__PURE__ */ new Set([0, value.length]);
+  for (const mark of marks) {
+    let index = mapping.ends.findIndex((end) => end >= mark.range.end);
+    index = index < 0 ? value.length : index + 1;
+    boundaries.add(index);
+    markerAt.set(index, [...markerAt.get(index) ?? [], mark]);
+  }
+  for (const highlight of highlights) {
+    const start = mapping.ends.findIndex((end2) => end2 > highlight.range.start);
+    const end = mapping.starts.findIndex((start2) => start2 >= highlight.range.end);
+    boundaries.add(Math.max(0, start));
+    boundaries.add(end < 0 ? value.length : end);
+  }
+  const points = [...boundaries].sort((a, b) => a - b);
+  return /* @__PURE__ */ jsx2(Fragment2, { children: points.slice(1).map((end, index) => {
+    const start = points[index];
+    const segmentRange = { start: mapping.starts[start] ?? range.start, end: mapping.ends[end - 1] ?? range.end };
+    const styles = highlights.filter((highlight) => intersects(highlight.range, segmentRange));
+    let text = value.slice(start, end);
+    for (const highlight of styles) text = /* @__PURE__ */ jsx2("mark", { "data-limr-highlight": highlight.id, "data-hidden": highlight.hidden || void 0, className: `limr-highlight limr-highlight-${highlight.style ?? "background"}`, style: { "--limr-highlight": highlight.color ?? "#f3ce7380" }, children: text }, highlight.id);
+    return /* @__PURE__ */ jsxs2("span", { style, className, ref: (element) => {
+      if (element) runtime.bindings.set(element, { range: segmentRange, atomic: false, exact: mapping.exact, resolve: (offset, edge) => {
+        const at = Math.max(start, Math.min(end, start + offset));
+        return edge === "start" ? mapping.starts[at] ?? segmentRange.end : mapping.ends[at - 1] ?? segmentRange.start;
+      } });
+    }, "data-limr-text": "", "data-source-start": segmentRange.start, "data-source-end": segmentRange.end, children: [
+      text,
+      markerAt.get(end)?.map((occurrence) => /* @__PURE__ */ jsx2(AnnotationMarker, { occurrence }, occurrence.id))
+    ] }, start);
+  }) });
+}
+function LiteralValue({ node, context, tokens }) {
+  const source = context.runtime.document.getSnapshot().source;
+  const mapping = useMemo(() => mapLiteral(source, node), [node]);
+  const value = literalValue(node);
+  const marks = context.marks.get(node) ?? emptyList;
+  const segments = tokens?.length ? tokens : [{ content: value, offset: 0 }];
+  return /* @__PURE__ */ jsx2(Fragment2, { children: segments.map((token, index) => {
+    const start = token.offset, end = start + token.content.length;
+    const mapped = { starts: mapping.starts.slice(start, end), ends: mapping.ends.slice(start, end), exact: mapping.exact };
+    const range = { start: mapped.starts[0] ?? rangeOf(node).start, end: mapped.ends.at(-1) ?? rangeOf(node).end };
+    const leaf = { type: "text", value: token.content, position: { start: { offset: range.start, line: 0, column: 0 }, end: { offset: range.end, line: 0, column: 0 } } };
+    return /* @__PURE__ */ jsx2(Text, { className: token.style ? "limr-code-token" : void 0, style: token.style, node: leaf, context, mapping: mapped, marks: marks.filter((mark) => mark.range.end > range.start && mark.range.end <= range.end) }, index);
+  }) });
+}
+function Atomic({ node, context, children, inline, blockElement }) {
+  const range = rangeOf(node);
+  const selected = useStoreSelector(context.runtime.interaction, (state) => state.selection?.raw.ranges.some((selection) => intersects(selection, range)) ?? false);
+  const highlights = context.highlights.filter((highlight) => !highlight.hidden && intersects(highlight.range, range));
+  const Tag = inline ? "span" : "div";
+  const image = ["image", "imageReference"].includes(node.type) || node.type === "component" && node.name === "img";
+  const corner = image || !inline;
+  const marks = [...context.marks.get(node) ?? [], ...corner ? context.afterMarks.get(node) ?? [] : []];
+  const markers = marks.map((occurrence) => /* @__PURE__ */ jsx2(AnnotationMarker, { occurrence }, occurrence.id));
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsxs2(
+      Tag,
+      {
+        ...blockAttributes(blockElement),
+        className: `limr-atomic${image ? " limr-atomic-image" : ""}${corner ? " limr-atomic-corner" : ""}${highlights.length ? " limr-atomic-highlight" : ""}`,
+        "data-selected": selected || void 0,
+        "data-limr-media": image ? "image" : void 0,
+        "data-limr-atomic": inline ? "inline" : "block",
+        "data-source-start": range.start,
+        "data-source-end": range.end,
+        style: { "--limr-highlight": highlights[0]?.color ?? "#f3ce7380" },
+        ref: (element) => {
+          if (element) context.runtime.bindings.set(element, { range, atomic: true });
+          blockElement?.ref(element);
+        },
+        children: [
+          children,
+          corner && !!marks.length && /* @__PURE__ */ jsx2("span", { className: "limr-corner-marks", "data-limr-ignore": "true", children: markers })
+        ]
+      }
+    ),
+    !corner && markers
+  ] });
+}
+function HeadingNode({ node, children, runtime, blockElement }) {
+  const id = (() => {
+    const doc = runtime.document.getSnapshot();
+    const offset = node.position?.start.offset ?? 0;
+    let lo = 0, hi = doc.headings.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (doc.headings[mid].range.start < offset) lo = mid + 1;
+      else hi = mid;
+    }
+    return doc.headings[lo]?.range.start === offset ? doc.headings[lo].id : void 0;
+  })();
+  return createElement(`h${node.depth}`, { ...blockAttributes(blockElement), id, ref: (element) => {
+    if (id) runtime.registerHeading(id, element);
+    blockElement?.ref(element);
+  } }, children);
+}
+function Reference({ node, children, image }) {
+  const definition2 = useDocumentSelector((doc) => doc.definitions.get(String(node.identifier)));
+  if (!definition2) return /* @__PURE__ */ jsx2(Fragment2, { children: children || String(node.alt ?? node.label ?? "") });
+  return image ? /* @__PURE__ */ jsx2("img", { src: safeUrl(definition2.url, true), alt: String(node.alt ?? ""), title: definition2.title ? String(definition2.title) : void 0, loading: "lazy", decoding: "async" }) : /* @__PURE__ */ jsx2("a", { href: safeUrl(definition2.url), title: definition2.title ? String(definition2.title) : void 0, children });
+}
+function FootnoteReference({ node }) {
+  const runtime = useRuntime();
+  const identifier2 = String(node.identifier);
+  const number = useDocumentSelector((doc) => doc.footnoteOrder.indexOf(identifier2) + 1);
+  return /* @__PURE__ */ jsx2("sup", { "data-limr-ignore": "true", children: /* @__PURE__ */ jsx2("a", { href: `#${runtime.document.id}-fn-${encodeURIComponent(identifier2)}`, id: `${runtime.document.id}-fnref-${rangeOf(node).start}`, "aria-label": `Footnote ${number}`, children: number }) });
+}
+var ExtensionBoundary = class extends Component {
+  state = { failed: false };
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  componentDidCatch(_error, _info) {
+  }
+  componentDidUpdate(previous) {
+    if (this.state.failed && previous.fallback !== this.props.fallback) this.setState({ failed: false });
+  }
+  render() {
+    return this.state.failed ? /* @__PURE__ */ jsx2("pre", { className: "limr-extension-error", children: this.props.fallback }) : this.props.children;
+  }
+};
+function containsBlock(node) {
+  return node.type === "component" && !node.inline || ["math", "code", "list", "table", "blockquote"].includes(node.type) || (node.children?.some(containsBlock) ?? false);
+}
+function renderNode(node, context, index = 0, trailing) {
+  const { runtime } = context;
+  if (node.type === "text" && context.compact) return node.value ?? "";
+  const blockElement = node === context.block.node ? context.blockElement : void 0;
+  const key = `${node.type}-${node.position?.start.offset ?? index}-${index}`;
+  const childContext = node.type === "list" ? { ...context, tightList: !node.spread } : context;
+  const renderChildren = (nodes, options) => {
+    let last = -1;
+    nodes.forEach((child, i) => {
+      if (!["definition", "footnoteDefinition", "annotationDefinition"].includes(child.type)) last = i;
+    });
+    if (last < 0 && options?.trailing) return [/* @__PURE__ */ jsx2(Fragment, { children: options.trailing }, "trailing")];
+    return nodes.map((child, i) => renderNode(child, childContext, i, i === last ? options?.trailing : void 0));
+  };
+  const children = node.type === "table" ? [] : node.type === "listItem" && context.tightList ? (node.children ?? []).flatMap((child, index2) => child.type === "paragraph" ? renderChildren(child.children ?? []) : renderNode(child, context, index2)) : renderChildren(node.children ?? []);
+  const Renderer = runtime.components[node.type === "component" ? node.name ?? "" : node.type];
+  let element;
+  if (Renderer) {
+    const range = rangeOf(node);
+    const renderAttribute = (name) => {
+      const attribute = node.attributeNodes?.[name];
+      if (!attribute) return String(node.attributes?.[name] ?? "");
+      const range2 = rangeOf(attribute);
+      return /* @__PURE__ */ jsx2(Text, { node: attribute, context, marks: context.occurrences.filter((item) => item.range.end > range2.start && item.range.end <= range2.end) });
+    };
+    element = /* @__PURE__ */ jsx2(ExtensionBoundary, { fallback: runtime.document.getSnapshot().source.slice(range.start, range.end), children: /* @__PURE__ */ jsx2(Renderer, { node, children, pending: context.block.pending, source: runtime.document.getSnapshot().source.slice(range.start, range.end), renderChildren, renderValue: (tokens) => /* @__PURE__ */ jsx2(LiteralValue, { node, context, tokens }), renderAttribute }) }, key);
+  } else {
+    switch (node.type) {
+      case "text":
+        return /* @__PURE__ */ jsxs2(Fragment, { children: [
+          context.compact ? node.value ?? "" : /* @__PURE__ */ jsx2(Text, { node, context }),
+          trailing
+        ] }, key);
+      case "paragraph":
+        element = containsBlock(node) ? /* @__PURE__ */ jsxs2("div", { className: "limr-paragraph", children: [
+          children,
+          trailing
+        ] }) : /* @__PURE__ */ jsxs2("p", { children: [
+          children,
+          trailing
+        ] });
+        trailing = void 0;
+        break;
+      case "heading":
+        return /* @__PURE__ */ jsxs2(HeadingNode, { node, runtime, blockElement, children: [
+          children,
+          trailing
+        ] }, key);
+      case "strong":
+        element = /* @__PURE__ */ jsx2("strong", { children });
+        break;
+      case "emphasis":
+        element = /* @__PURE__ */ jsx2("em", { children });
+        break;
+      case "delete":
+        element = /* @__PURE__ */ jsx2("del", { children });
+        break;
+      case "inlineCode":
+        element = /* @__PURE__ */ jsx2("code", { className: "limr-inline-code", "data-limr-inline-syntax": "", "data-source-start": rangeOf(node).start, "data-source-end": rangeOf(node).end, children: /* @__PURE__ */ jsx2(LiteralValue, { node, context }) });
+        break;
+      case "code":
+        element = /* @__PURE__ */ jsx2("pre", { children: /* @__PURE__ */ jsx2("code", { children: /* @__PURE__ */ jsx2(LiteralValue, { node, context }) }) });
+        break;
+      case "math":
+      case "inlineMath":
+        element = /* @__PURE__ */ jsx2("code", { children: node.value });
+        break;
+      case "blockquote":
+        element = /* @__PURE__ */ jsxs2("blockquote", { className: "limr-note", children: [
+          /* @__PURE__ */ jsx2("div", { className: "limr-card-label", "data-limr-ignore": "true", children: runtime.locale.note }),
+          /* @__PURE__ */ jsx2("div", { className: "limr-block-content", children })
+        ] });
+        break;
+      case "list":
+        element = node.ordered ? /* @__PURE__ */ jsx2("ol", { start: Number(node.start ?? 1), children }) : /* @__PURE__ */ jsx2("ul", { children });
+        break;
+      case "listItem":
+        element = /* @__PURE__ */ jsxs2("li", { className: typeof node.checked === "boolean" ? "limr-task-item" : void 0, children: [
+          typeof node.checked === "boolean" && /* @__PURE__ */ jsx2("input", { type: "checkbox", checked: node.checked, disabled: true, "aria-label": "Task" }),
+          children
+        ] });
+        break;
+      case "link":
+        element = /* @__PURE__ */ jsx2("a", { href: safeUrl(node.url), title: node.title ? String(node.title) : void 0, children });
+        break;
+      case "image":
+        element = /* @__PURE__ */ jsx2("img", { src: safeUrl(node.url, true), alt: String(node.alt ?? ""), title: node.title ? String(node.title) : void 0, loading: "lazy", decoding: "async" });
+        break;
+      case "linkReference":
+        element = /* @__PURE__ */ jsx2(Reference, { node, image: false, children });
+        break;
+      case "imageReference":
+        element = /* @__PURE__ */ jsx2(Reference, { node, image: true, children });
+        break;
+      case "thematicBreak":
+        element = /* @__PURE__ */ jsx2("hr", {});
+        break;
+      case "break":
+        element = /* @__PURE__ */ jsx2("br", {});
+        break;
+      case "table": {
+        const rows = node.children ?? [], alignment = node.align;
+        element = /* @__PURE__ */ jsx2("div", { className: "limr-table-scroll", children: /* @__PURE__ */ jsxs2("table", { children: [
+          /* @__PURE__ */ jsx2("thead", { children: rows.slice(0, 1).map((row, i) => /* @__PURE__ */ jsx2("tr", { children: row.children?.map((cell, j) => /* @__PURE__ */ jsx2("th", { style: { textAlign: alignment?.[j] }, children: renderChildren(cell.children ?? []) }, j)) }, i)) }),
+          /* @__PURE__ */ jsx2("tbody", { children: rows.slice(1).map((row, i) => /* @__PURE__ */ jsx2("tr", { children: row.children?.map((cell, j) => /* @__PURE__ */ jsx2("td", { style: { textAlign: alignment?.[j] }, children: renderChildren(cell.children ?? []) }, j)) }, i)) })
+        ] }) });
+        break;
+      }
+      case "definition":
+      case "footnoteDefinition":
+      case "annotationDefinition":
+        return null;
+      case "footnoteReference":
+        return /* @__PURE__ */ jsxs2(Fragment, { children: [
+          /* @__PURE__ */ jsx2(FootnoteReference, { node }),
+          trailing
+        ] }, key);
+      case "annotationReference": {
+        const Tag = node.inline ? "span" : "div";
+        element = /* @__PURE__ */ jsxs2(Tag, { children: [
+          children,
+          /* @__PURE__ */ jsx2(AnnotationMarker, { occurrence: { id: `${runtime.document.id}-ref-${rangeOf(node).start}`, range: rangeOf(node), annotationIds: node.annotationIds, embedded: true } })
+        ] });
+        break;
+      }
+      case "html":
+        element = /* @__PURE__ */ jsx2("span", { className: "limr-literal", children: node.value });
+        break;
+      case "component":
+        element = children;
+        break;
+      default:
+        element = children.length ? children : node.value ?? null;
+    }
+  }
+  const atomic2 = node.selection === "atomic" || ["math", "inlineMath", "image", "imageReference", "html"].includes(node.type);
+  const corner = atomic2 && (!node.inline && !["inlineCode", "inlineMath", "html"].includes(node.type) || ["image", "imageReference"].includes(node.type) || node.name === "img");
+  const after = corner ? void 0 : context.afterMarks.get(node);
+  const withMarkers = (element2) => after?.length || trailing ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+    element2,
+    after?.map((occurrence) => /* @__PURE__ */ jsx2(AnnotationMarker, { occurrence }, occurrence.id)),
+    trailing
+  ] }, key) : element2;
+  if (atomic2) return withMarkers(/* @__PURE__ */ jsx2(Atomic, { node, context, blockElement, inline: node.inline || ["inlineCode", "inlineMath", "image", "imageReference", "html"].includes(node.type), children: element }, key));
+  if (blockElement) {
+    const attributes = { ...blockAttributes(blockElement), ref: blockElement.ref };
+    return withMarkers(isValidElement(element) && typeof element.type === "string" ? cloneElement(element, { ...attributes, key }) : /* @__PURE__ */ jsx2("div", { ...attributes, children: element }, key));
+  }
+  return withMarkers(isValidElement(element) ? cloneElement(element, { key }) : /* @__PURE__ */ jsx2(Fragment, { children: element }, key));
+}
+var BlockView = memo(function BlockView2({ block, runtime, components, extensions, decorations, footnoteId }) {
+  const element = useRef2(null);
+  const clearBindings = useRef2(void 0);
+  const { occurrences } = decorations;
+  const highlights = useMemo(() => decorations.highlights.filter((highlight) => !highlight.occurrenceId), [decorations.highlights]);
+  const root = useMemo(() => footnoteId ? { ...block.node, type: "listItem" } : block.node, [block, footnoteId]);
+  const texts = useMemo(() => compactTextNodes(root, runtime.components), [root, runtime, components, extensions]);
+  const compact = !!texts && !occurrences.length && !highlights.length;
+  const observe = useCallback((next) => {
+    clearBindings.current?.();
+    clearBindings.current = void 0;
+    if (element.current) runtime.textBinders.delete(element.current);
+    if (element.current && element.current !== next) runtime.unobserveBlock(element.current);
+    element.current = next;
+    runtime.observeBlock(next);
+    if (next && compact && texts.length) runtime.textBinders.set(next, () => {
+      clearBindings.current = bindCompactText(next, texts, runtime);
+    });
+  }, [runtime, compact, texts]);
+  const { marks, afterMarks } = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    const after = /* @__PURE__ */ new Map();
+    if (!occurrences.length) return { marks: map, afterMarks: after };
+    const leaves = [];
+    const attributes = [];
+    const paths = /* @__PURE__ */ new Map();
+    const outside = /* @__PURE__ */ new Set(["strong", "emphasis", "delete", "link", "linkReference", "inlineCode", "code", "math", "inlineMath", "image", "imageReference", "html"]);
+    function collect(node, ancestors = []) {
+      if (node.attributeNodes) attributes.push(...Object.values(node.attributeNodes));
+      const path = [...ancestors, node];
+      if (node.selection === "atomic" || ["text", "inlineCode", "code", "math", "inlineMath", "image", "imageReference", "html"].includes(node.type)) {
+        leaves.push(node);
+        paths.set(node, path);
+      } else node.children?.forEach((child) => collect(child, path));
+    }
+    collect(block.node);
+    for (const occurrence of occurrences) {
+      const target = [...leaves].reverse().find((node) => rangeOf(node).start < occurrence.range.end) ?? leaves[0];
+      const image = target && (["image", "imageReference"].includes(target.type) || target.name === "img") && rangeOf(target).end >= occurrence.range.end;
+      if (!image && attributes.some((attribute) => {
+        const range = rangeOf(attribute);
+        return occurrence.range.end > range.start && occurrence.range.end <= range.end;
+      })) continue;
+      if (target) {
+        const outer = paths.get(target)?.find((node2) => (outside.has(node2.type) || node2.selection === "atomic") && rangeOf(node2).end <= occurrence.range.end);
+        const destination = outer ? after : map, node = outer ?? target;
+        destination.set(node, [...destination.get(node) ?? [], occurrence]);
+      }
+    }
+    return { marks: map, afterMarks: after };
+  }, [block, occurrences]);
+  if (!footnoteId && ["definition", "footnoteDefinition", "annotationDefinition"].includes(block.node.type)) return null;
+  const context = { runtime, block, marks, afterMarks, highlights, occurrences, compact, blockElement: { id: block.id, range: block.range, pending: block.pending, ref: observe } };
+  if (footnoteId) return /* @__PURE__ */ jsx2("li", { id: `${runtime.document.id}-fn-${encodeURIComponent(footnoteId)}`, ...blockAttributes(context.blockElement), ref: observe, children: block.node.children?.map((child, index) => renderNode(child, { ...context, blockElement: void 0 }, index)) });
+  return renderNode(block.node, context);
+});
+function Footnotes() {
+  const runtime = useRuntime();
+  const doc = useDocumentSelector((snapshot) => snapshot);
+  const components = useStoreSelector(runtime.configuration, (config) => config.components);
+  const extensions = useStoreSelector(runtime.configuration, (config) => config.extensions);
+  const decorations = useStoreSelector(runtime.decorations, (state) => state.byBlock);
+  const blocks = useMemo(() => new Map(doc.blocks.filter((block) => block.node.type === "footnoteDefinition").map((block) => [String(block.node.identifier), block])), [doc.blocks]);
+  if (!doc.footnoteOrder.length) return null;
+  return /* @__PURE__ */ jsxs2("section", { className: "limr-footnotes", "aria-label": runtime.locale.footnotes, children: [
+    /* @__PURE__ */ jsx2("hr", {}),
+    /* @__PURE__ */ jsx2("ol", { children: doc.footnoteOrder.map((id) => {
+      const node = doc.footnotes.get(id);
+      if (!node) return null;
+      const block = blocks.get(id) ?? { id: `${doc.id}-fn-${id}`, range: rangeOf(node), node, pending: false };
+      return /* @__PURE__ */ jsx2(BlockView, { block, runtime, components, extensions, footnoteId: id, decorations: decorations.get(block.id) ?? emptyDecorations }, id);
+    }) })
+  ] });
+}
+
+// src/react/selection.ts
+import { useEffect as useEffect2 } from "react";
+
+// src/react/source-geometry.ts
+function flowOf(element, container) {
+  const known = element.closest("pre,p,figcaption,li,th,td,h1,h2,h3,h4,h5,h6,.limr-choice-text,.limr-definition-title,.limr-question-title,.limr-block-content");
+  return known && container.contains(known) ? known : element.closest("[data-limr-block]") ?? container;
+}
+function leavesIn(block, runtime) {
+  runtime.prepareTextBindings(block);
+  const result = [];
+  const visit = (node, inherited) => {
+    if (node instanceof HTMLElement) {
+      if (node !== block && node.hasAttribute("data-limr-document") || node.hasAttribute("inert")) return;
+      const marker = node.dataset.limrMarker;
+      const atomic2 = node.dataset.limrAtomic;
+      if (marker || atomic2) {
+        const image = node.dataset.limrMedia === "image";
+        result.push({ node, kind: marker ? "marker" : image ? "image" : atomic2 === "block" ? "block" : "inline", range: { start: Number(node.dataset.sourceStart), end: Number(node.dataset.sourceEnd) }, flow: image ? node : flowOf(node, runtime.content), offset: 0 });
+        return;
+      }
+      if (node.hasAttribute("data-limr-ignore")) return;
+      const binding = runtime.bindings.get(node);
+      if (binding) inherited = { binding, offset: 0 };
+    }
+    if (node.nodeType === Node.TEXT_NODE) {
+      const binding = runtime.bindings.get(node) ?? inherited?.binding;
+      const offset = runtime.bindings.has(node) ? 0 : inherited?.offset ?? 0;
+      const length = node.textContent?.length ?? 0;
+      if (binding?.resolve && length) result.push({ node, kind: "text", range: { start: binding.resolve(offset, "start"), end: binding.resolve(offset + length, "end") }, flow: flowOf(node.parentElement, runtime.content), binding, offset });
+      if (inherited) inherited.offset += length;
+      return;
+    }
+    node.childNodes.forEach((child) => visit(child, inherited));
+  };
+  visit(block);
+  return result;
+}
+function textRange(leaf, source, viewport) {
+  const node = leaf.node, length = node.length;
+  const resolve = leaf.binding.resolve;
+  let lo = 0, hi = length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (resolve(leaf.offset + mid + 1, "end") <= source.start) lo = mid + 1;
+    else hi = mid;
+  }
+  let start = lo;
+  lo = start;
+  hi = length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (resolve(leaf.offset + mid, "start") < source.end) lo = mid + 1;
+    else hi = mid;
+  }
+  if (start === lo) return null;
+  let end = lo;
+  const range = document.createRange();
+  if (viewport && end - start > 1024) {
+    range.setStart(node, start);
+    range.setEnd(node, end);
+    const box = range.getBoundingClientRect();
+    if (box.height > viewport.bottom - viewport.top + 80) {
+      lo = start;
+      hi = end;
+      while (lo < hi) {
+        const mid = lo + hi >>> 1;
+        range.setStart(node, mid);
+        range.setEnd(node, mid + 1);
+        if (range.getBoundingClientRect().bottom < viewport.top) lo = mid + 1;
+        else hi = mid;
+      }
+      start = lo;
+      hi = end;
+      while (lo < hi) {
+        const mid = lo + hi >>> 1;
+        range.setStart(node, mid);
+        range.setEnd(node, mid + 1);
+        if (range.getBoundingClientRect().top <= viewport.bottom) lo = mid + 1;
+        else hi = mid;
+      }
+      end = lo;
+    }
+  }
+  if (start === end) return null;
+  range.setStart(node, start);
+  range.setEnd(node, end);
+  return range;
+}
+function sourceRangeStartRect(runtime, source) {
+  for (const block of runtime.document.getSnapshot().blocks) {
+    if (!intersects(block.range, source)) continue;
+    const element = runtime.blocks.get(block.id);
+    if (!element) continue;
+    for (const leaf of leavesIn(element, runtime)) {
+      if (leaf.kind === "marker" || !intersects(leaf.range, source)) continue;
+      if (leaf.kind === "text") {
+        const range = textRange(leaf, source);
+        if (!range) continue;
+        const node = leaf.node, end = range.endOffset;
+        for (let start = range.startOffset; start < end; ) {
+          const next = Math.min(end, start + (node.data.codePointAt(start) > 65535 ? 2 : 1));
+          range.setStart(node, start);
+          range.setEnd(node, next);
+          const rect = range.getBoundingClientRect();
+          if (rect.width && rect.height) return rect;
+          start = next;
+        }
+      } else {
+        const node = leaf.node;
+        const rect = (node.querySelector(leaf.kind === "image" ? "img" : "[data-limr-selection-surface]") ?? node).getBoundingClientRect();
+        if (rect.width && rect.height) return rect;
+      }
+    }
+  }
+  return null;
+}
+
+// src/react/selection.ts
+function visualSelection(runtime, native, options) {
+  if (![...runtime.content.querySelectorAll('[data-limr-selection-order="visual"]')].some((element) => native.intersectsNode(element))) return;
+  const blocks = [...runtime.blocks.values()].filter((block) => native.intersectsNode(block));
+  blocks.sort((a, b) => a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1);
+  const leaves = blocks.flatMap((block) => leavesIn(block, runtime)).filter((leaf) => leaf.kind !== "marker");
+  const selected = [];
+  for (const leaf of leaves) {
+    if (!native.intersectsNode(leaf.node)) continue;
+    if (leaf.kind !== "text") {
+      selected.push(leaf.range);
+      continue;
+    }
+    const node = leaf.node;
+    const start = native.startContainer === node ? native.startOffset : 0;
+    const end = native.endContainer === node ? native.endOffset : node.length;
+    if (start < end) selected.push({ start: leaf.binding.resolve(leaf.offset + start, "start"), end: leaf.binding.resolve(leaf.offset + end, "end") });
+  }
+  if (!selected.length) return;
+  const sourceOrder = leaves.map((leaf) => leaf.range).sort((a, b) => a.end - b.end);
+  const ranges = [];
+  for (const range of selected) {
+    const previous = ranges.at(-1);
+    let lo = 0, hi = sourceOrder.length;
+    if (previous) while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (sourceOrder[mid].end <= previous.end) lo = mid + 1;
+      else hi = mid;
+    }
+    if (previous && range.start >= previous.end && (!sourceOrder[lo] || sourceOrder[lo].start >= range.start)) previous.end = range.end;
+    else ranges.push({ ...range });
+  }
+  const snapshot = runtime.document.getSnapshot();
+  const selections = ranges.map((range) => selectionFromRange(snapshot, range, options));
+  const combine = (key) => {
+    const seen = /* @__PURE__ */ new Set();
+    const ranges2 = selections.flatMap((selection) => selection[key].ranges).filter((range) => {
+      const key2 = `${range.start}:${range.end}`;
+      if (seen.has(key2)) return false;
+      seen.add(key2);
+      return true;
+    });
+    return { ranges: ranges2, sourceText: ranges2.map((range) => snapshot.source.slice(range.start, range.end)).join("\n\n") };
+  };
+  return { ...selections[0], raw: combine("raw"), syntax: combine("syntax"), blocks: combine("blocks") };
+}
+function useSelectionTracking(runtime, enabled) {
+  useEffect2(() => {
+    const container = runtime.content;
+    if (!container || !enabled) return;
+    let frame = 0, dragging = false;
+    let previous;
+    function resolve(node, offset, edge) {
+      let element = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
+      if (!element || element.closest("[data-limr-document]") !== container || element.closest("[data-limr-ignore]")) return null;
+      runtime.prepareTextBindings(element);
+      const native = node.nodeType === Node.TEXT_NODE ? runtime.bindings.get(node) : void 0;
+      if (native?.resolve) return { offset: native.resolve(offset, edge), atomic: false, exact: native.exact !== false };
+      while (element && element !== container) {
+        const binding = runtime.bindings.get(element);
+        if (binding) {
+          if (binding.atomic) return { offset: edge === "start" ? binding.range.start : binding.range.end, atomic: true, exact: true };
+          const range = document.createRange();
+          range.setStart(element, 0);
+          try {
+            range.setEnd(node, offset);
+          } catch {
+            return null;
+          }
+          const localOffset = range.toString().length;
+          return { offset: binding.resolve?.(localOffset, edge) ?? (edge === "start" ? binding.range.start : binding.range.end), atomic: false, exact: binding.exact !== false };
+        }
+        element = element.parentElement;
+      }
+      const children = node.nodeType === Node.ELEMENT_NODE ? Array.from(node.childNodes) : [];
+      const candidates = edge === "start" ? children.slice(offset) : children.slice(0, offset).reverse();
+      const descend = (candidate) => {
+        if (candidate.nodeType === Node.TEXT_NODE && candidate.textContent) return resolve(candidate, edge === "start" ? 0 : candidate.textContent.length, edge);
+        if (candidate instanceof Element) {
+          if (candidate.hasAttribute("data-limr-ignore") || candidate.hasAttribute("inert")) return null;
+          const binding = runtime.bindings.get(candidate);
+          if (binding?.atomic) return { offset: edge === "start" ? binding.range.start : binding.range.end, atomic: true, exact: true };
+        }
+        const list = Array.from(candidate.childNodes);
+        if (edge === "end") list.reverse();
+        for (const child of list) {
+          const result = descend(child);
+          if (result) return result;
+        }
+        return null;
+      };
+      for (const child of candidates) {
+        const result = descend(child);
+        if (result) return result;
+      }
+      return null;
+    }
+    function process() {
+      frame = 0;
+      if (!dragging && document.activeElement instanceof Element && document.activeElement.closest("[data-limr-selection-ui]")) return;
+      const selection = window.getSelection();
+      if (!selection || selection.isCollapsed || !selection.rangeCount) {
+        if (!(document.activeElement instanceof Element) || !document.activeElement.closest("[data-limr-selection-ui]")) {
+          previous = void 0;
+          runtime.selectionRange = null;
+          runtime.updateInteraction({ selection: null });
+        }
+        return;
+      }
+      const range = selection.getRangeAt(0);
+      const revision = runtime.document.getSnapshot().revision;
+      if (runtime.interaction.get().selection && previous?.startNode === range.startContainer && previous.start === range.startOffset && previous.endNode === range.endContainer && previous.end === range.endOffset && previous.revision === revision && previous.settled === !dragging) return;
+      const start = resolve(range.startContainer, range.startOffset, "start");
+      const end = resolve(range.endContainer, range.endOffset, "end");
+      if (!start || !end) {
+        previous = void 0;
+        runtime.selectionRange = null;
+        runtime.updateInteraction({ selection: null });
+        return;
+      }
+      previous = { startNode: range.startContainer, start: range.startOffset, endNode: range.endContainer, end: range.endOffset, revision, settled: !dragging };
+      runtime.selectionRange = range.cloneRange();
+      runtime.highlightReference = null;
+      const options = {
+        text: selection.toString(),
+        settled: !dragging,
+        quality: !start.exact || !end.exact ? "unmapped" : start.atomic || end.atomic ? "atomic" : "exact"
+      };
+      runtime.updateInteraction({ activeHighlight: null, selection: visualSelection(runtime, range, options) ?? selectionFromRange(runtime.document.getSnapshot(), { start: start.offset, end: end.offset }, options) });
+    }
+    const schedule = () => {
+      if (!frame) frame = requestAnimationFrame(process);
+    };
+    const down = () => {
+      dragging = true;
+    };
+    const up = () => {
+      dragging = false;
+      schedule();
+    };
+    document.addEventListener("selectionchange", schedule);
+    container.addEventListener("pointerdown", down);
+    document.addEventListener("pointerup", up);
+    document.addEventListener("pointercancel", up);
+    document.addEventListener("keyup", schedule);
+    if (window.getSelection()?.isCollapsed === false) schedule();
+    return () => {
+      cancelAnimationFrame(frame);
+      document.removeEventListener("selectionchange", schedule);
+      container.removeEventListener("pointerdown", down);
+      document.removeEventListener("pointerup", up);
+      document.removeEventListener("pointercancel", up);
+      document.removeEventListener("keyup", schedule);
+    };
+  }, [runtime, enabled]);
+}
+
+// src/react/selection-paint.tsx
+import { useEffect as useEffect3, useRef as useRef3 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function rectangles(leaves, source, viewport, measure) {
+  const raw = [];
+  const geometry = (leaf, rect, reference) => {
+    const flowMetrics = measure(leaf.flow);
+    const own = measure(reference?.element ?? (leaf.kind === "text" ? leaf.node.parentElement : leaf.flow));
+    const baseline = reference ? reference.rect.top + own.ascent : leaf.kind === "text" ? rect.top + own.ascent : rect.bottom - flowMetrics.descent;
+    return { left: rect.left, top: baseline - flowMetrics.ascent, width: rect.width, height: flowMetrics.height, baseline, flow: leaf.flow };
+  };
+  const neighbor = (index, direction) => {
+    for (let at = index + direction; at >= 0 && at < leaves.length; at += direction) {
+      const candidate = leaves[at];
+      if (candidate.flow !== leaves[index].flow) return;
+      if (candidate.kind === "text") {
+        const value = candidate.node.textContent ?? "";
+        if (value.trim()) return candidate;
+        if (!value.includes("\n")) continue;
+      }
+      if (candidate.kind !== "marker") return;
+    }
+  };
+  const edgeRect = (leaf, edge) => {
+    const node = leaf.node;
+    const range = document.createRange();
+    const offset = edge === "first" ? 0 : Math.max(0, node.length - 1);
+    range.setStart(node, offset);
+    range.setEnd(node, Math.min(node.length, offset + 1));
+    return range.getBoundingClientRect();
+  };
+  const referenceFor = (index, rect) => {
+    const left = neighbor(index, -1), right = neighbor(index, 1);
+    const candidates = [left && { rect: edgeRect(left, "last"), element: left.node.parentElement }, right && { rect: edgeRect(right, "first"), element: right.node.parentElement }].filter((value) => !!value);
+    candidates.sort((a, b) => Math.abs(a.rect.bottom - rect.bottom) - Math.abs(b.rect.bottom - rect.bottom));
+    const nearest = candidates[0];
+    return nearest && Math.abs(nearest.rect.bottom - rect.bottom) < Math.max(rect.height, nearest.rect.height) ? nearest : void 0;
+  };
+  let first = 0, last = leaves.length;
+  if (leaves.length > 80 && leaves[0].flow.tagName === "PRE" && leaves.at(-1)?.flow === leaves[0].flow) {
+    const boxAt = (index) => {
+      const leaf = leaves[index];
+      if (leaf.kind !== "text") return leaf.node.getBoundingClientRect();
+      const range = document.createRange();
+      range.selectNodeContents(leaf.node);
+      return range.getBoundingClientRect();
+    };
+    let lo = 0, hi = leaves.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (boxAt(mid).bottom < viewport.top) lo = mid + 1;
+      else hi = mid;
+    }
+    first = lo;
+    hi = leaves.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (boxAt(mid).top <= viewport.bottom) lo = mid + 1;
+      else hi = mid;
+    }
+    last = lo;
+  }
+  for (let index = first; index < last; index++) {
+    const leaf = leaves[index];
+    if (leaf.kind === "marker") {
+      const left = neighbor(index, -1), right = neighbor(index, 1);
+      if (!left || !right || source.start >= left.range.end || source.end <= right.range.start) continue;
+      const rect = leaf.node.getBoundingClientRect();
+      if (!rect.width || !rect.height || rect.bottom < viewport.top || rect.top > viewport.bottom) continue;
+      const item = geometry(leaf, rect, referenceFor(index, rect));
+      raw.push({ ...item, marker: leaf.node.dataset.limrMarker });
+    } else if (intersects(leaf.range, source)) {
+      if (leaf.kind === "text") {
+        const range = textRange(leaf, source, viewport);
+        const shell = leaf.node.parentElement?.closest("[data-limr-inline-syntax]");
+        const edges = shell ? Array.from(shell.getClientRects()) : [];
+        const css = shell && getComputedStyle(shell);
+        for (const rect of range?.getClientRects() ?? []) if (rect.width && rect.height && rect.bottom >= viewport.top && rect.top <= viewport.bottom) {
+          const item = geometry(leaf, rect), first2 = edges[0], last2 = edges.at(-1);
+          if (shell && css && first2 && source.start <= Number(shell.dataset.sourceStart) && Math.abs(first2.top - rect.top) < rect.height && Math.abs(rect.left - first2.left - parseFloat(css.paddingLeft)) < 1) {
+            item.width += item.left - first2.left;
+            item.left = first2.left;
+          }
+          if (shell && css && last2 && source.end >= Number(shell.dataset.sourceEnd) && Math.abs(last2.top - rect.top) < rect.height && Math.abs(last2.right - parseFloat(css.paddingRight) - rect.right) < 1) item.width = last2.right - item.left;
+          raw.push(item);
+        }
+      } else {
+        const element = leaf.node;
+        const surface = leaf.kind === "image" ? element.querySelector("img") ?? element : leaf.kind === "block" ? element.querySelector("[data-limr-selection-surface]") ?? element : element;
+        const rect = surface.getBoundingClientRect();
+        if (!rect.width || !rect.height || rect.bottom < viewport.top || rect.top > viewport.bottom) continue;
+        if (leaf.kind === "block" || leaf.kind === "image") raw.push({ left: rect.left, top: rect.top, width: rect.width, height: rect.height, atomic: true, image: leaf.kind === "image", baseline: rect.bottom, flow: leaf.kind === "image" ? element : surface, radius: getComputedStyle(surface).borderRadius });
+        else {
+          const item = geometry(leaf, rect, referenceFor(index, rect));
+          raw.push({ ...item, atomic: true });
+        }
+      }
+    }
+  }
+  const lines = /* @__PURE__ */ new Map();
+  const aligned = raw.map((rect) => {
+    if (rect.image || rect.atomic && rect.height > measure(rect.flow).height * 1.5) return rect;
+    let flow = lines.get(rect.flow);
+    if (!flow) {
+      flow = /* @__PURE__ */ new Map();
+      lines.set(rect.flow, flow);
+    }
+    const key = Math.floor(rect.baseline / 3);
+    let line = [flow.get(key), flow.get(key - 1), flow.get(key + 1)].find((line2) => line2 && Math.abs(line2.baseline - rect.baseline) < 3);
+    if (!line) {
+      line = rect;
+      flow.set(key, line);
+    }
+    return { ...rect, top: line.top, height: line.height };
+  });
+  const bridges = [];
+  for (let i = 1; i < aligned.length; i++) {
+    const left = aligned[i - 1], right = aligned[i];
+    const gap = right.left - left.left - left.width;
+    if (left.flow === right.flow && Math.abs(left.top - right.top) < 0.5 && gap > 0.1 && gap < left.height * 0.6) bridges.push({ left: left.left + left.width, top: left.top, width: gap, height: left.height, flow: left.flow });
+  }
+  return [...aligned, ...bridges];
+}
+function SelectionPaint({ runtime, interactive = true }) {
+  const layer = useRef3(null);
+  useEffect3(() => {
+    const container = runtime.content, paint = layer.current;
+    if (!container || !paint) return;
+    let frame = 0, translating = false;
+    let leavesCache = /* @__PURE__ */ new WeakMap();
+    let metrics = /* @__PURE__ */ new WeakMap();
+    const fontMetrics = /* @__PURE__ */ new Map();
+    let blocks;
+    let snapshot = runtime.document.getSnapshot();
+    let lastSelection = runtime.interaction.get().selection;
+    let lastDecorations = runtime.decorations.get().byBlock;
+    let lastHovered = runtime.interaction.get().hoveredHighlight;
+    let lastActive = runtime.interaction.get().activeHighlight;
+    let lastAnnotation = runtime.interaction.get().active;
+    let lastHoveredAnnotation = runtime.interaction.get().hovered;
+    const highlightLayers = /* @__PURE__ */ new Map();
+    let hits = [];
+    const highlightRects = (id) => [...highlightLayers.values()].flatMap((layer2) => Array.from(layer2.children).filter((item) => item.dataset.paint === id).map((item) => item.getBoundingClientRect()));
+    const focusedRange = () => {
+      const state = runtime.interaction.get(), decorations = runtime.decorations.get();
+      return decorations.referenceRanges.get(state.hovered ?? "") ?? (state.activeHighlight ? decorations.highlights.get(state.activeHighlight)?.range : void 0) ?? decorations.referenceRanges.get(state.active ?? "");
+    };
+    const referenceActive = (occurrenceId) => {
+      const state = runtime.interaction.get(), decorations = runtime.decorations.get();
+      if (occurrenceId === state.hovered) return true;
+      if (occurrenceId !== state.active) return false;
+      const hovered = decorations.highlights.get(`reference-${state.hovered}`);
+      return !hovered?.occurrenceId || !sameRange(hovered.range, decorations.referenceRanges.get(occurrenceId));
+    };
+    const feedback = () => {
+      const state = runtime.interaction.get();
+      const decorations = runtime.decorations.get();
+      const focused = focusedRange();
+      for (const layer2 of highlightLayers.values()) for (const item of layer2.children) {
+        item.toggleAttribute("data-hovered", item.dataset.paint === state.hoveredHighlight);
+        const highlight = decorations.highlights.get(item.dataset.paint ?? "");
+        if (highlight?.occurrenceId) {
+          const active = referenceActive(highlight.occurrenceId);
+          item.toggleAttribute("data-active", active);
+          item.toggleAttribute("data-muted", !active);
+          continue;
+        }
+        item.toggleAttribute("data-active", item.dataset.paint === state.activeHighlight || !!focused && !!highlight && sameRange(focused, highlight.range));
+        item.toggleAttribute("data-muted", !!highlight?.hidden || !!focused && !!highlight && !sameRange(focused, highlight.range));
+      }
+    };
+    const removeLayer = (host, layer2) => {
+      layer2.remove();
+      delete host.dataset.limrHighlightHost;
+      delete host.dataset.limrHighlightPosition;
+      highlightLayers.delete(host);
+    };
+    const canvas = document.createElement("canvas"), context = canvas.getContext("2d");
+    const measure = (element) => {
+      const saved = metrics.get(element);
+      if (saved) return saved;
+      const style = getComputedStyle(element), size = parseFloat(style.fontSize), lineHeight = parseFloat(style.lineHeight) || size * 1.5;
+      const font = `${style.fontStyle} ${style.fontWeight} ${size}px ${style.fontFamily}`, key = `${font}/${lineHeight}`;
+      let metric = fontMetrics.get(key);
+      if (!metric) {
+        if (context) context.font = font;
+        const text = context?.measureText("Mg");
+        const ascent = text?.fontBoundingBoxAscent ?? size * 0.9, descent = text?.fontBoundingBoxDescent ?? size * 0.25;
+        const height = Math.min(ascent + descent, lineHeight - 0.5);
+        metric = { ascent: ascent - Math.max(0, ascent + descent - height) / 2, descent, height };
+        fontMetrics.set(key, metric);
+      }
+      metrics.set(element, metric);
+      return metric;
+    };
+    const clear = () => {
+      if (paint.childNodes.length) paint.replaceChildren();
+      for (const [host, layer2] of highlightLayers) removeLayer(host, layer2);
+      hits = [];
+    };
+    const render = () => {
+      cancelAnimationFrame(frame);
+      frame = 0;
+      const selections = runtime.interaction.get().selection?.raw.ranges ?? [];
+      const decorations = runtime.decorations.get().byBlock;
+      if (!selections.length && ![...decorations.values()].some((value) => value.highlights.length)) {
+        clear();
+        return;
+      }
+      const doc = runtime.document.getSnapshot();
+      if (doc !== snapshot) {
+        snapshot = doc;
+        blocks = void 0;
+      }
+      if (!blocks) {
+        const notes = new Map(doc.blocks.filter((block) => block.node.type === "footnoteDefinition").map((block) => [String(block.node.identifier), block]));
+        const ordered = [...doc.blocks.filter((block) => block.node.type !== "footnoteDefinition"), ...doc.footnoteOrder.flatMap((id) => {
+          const block = notes.get(id), node = doc.footnotes.get(id);
+          return block ? [block] : node ? [{ id: `${doc.id}-fn-${id}`, range: { start: node.position.start.offset, end: node.position.end.offset } }] : [];
+        })];
+        blocks = ordered.flatMap((block) => {
+          const element = runtime.blocks.get(block.id);
+          return element ? [{ element, range: block.range, id: block.id }] : [];
+        });
+      }
+      const vv = window.visualViewport;
+      const viewport = { top: vv?.offsetTop ?? 0, bottom: (vv?.offsetTop ?? 0) + (vv?.height ?? window.innerHeight), left: vv?.offsetLeft ?? 0, right: (vv?.offsetLeft ?? 0) + (vv?.width ?? window.innerWidth) };
+      const root = runtime.configuration.get().scrollRoot;
+      if (root) {
+        const box = root.getBoundingClientRect();
+        viewport.top = Math.max(viewport.top, box.top + root.clientTop);
+        viewport.bottom = Math.min(viewport.bottom, box.top + root.clientTop + root.clientHeight);
+        viewport.left = Math.max(viewport.left, box.left + root.clientLeft);
+        viewport.right = Math.min(viewport.right, box.left + root.clientLeft + root.clientWidth);
+      }
+      let lo = 0, hi = blocks.length;
+      while (lo < hi) {
+        const mid = lo + hi >>> 1;
+        if (blocks[mid].element.getBoundingClientRect().bottom < viewport.top - 32) lo = mid + 1;
+        else hi = mid;
+      }
+      const origin = container.getBoundingClientRect();
+      viewport.top = Math.max(viewport.top, origin.top);
+      viewport.bottom = Math.min(viewport.bottom, origin.bottom);
+      const scrollLeft = container.scrollLeft, scrollTop = container.scrollTop;
+      const output = [];
+      const clips = /* @__PURE__ */ new Map();
+      const clipFor = (flow) => {
+        const saved = clips.get(flow);
+        if (saved) return saved;
+        const clip = { ...viewport };
+        for (let element = flow; element && element !== container; element = element.parentElement) {
+          const css = getComputedStyle(element), box = element.getBoundingClientRect();
+          if (/hidden|clip|auto|scroll/.test(css.overflowX)) {
+            clip.left = Math.max(clip.left, box.left + element.clientLeft);
+            clip.right = Math.min(clip.right, box.left + element.clientLeft + element.clientWidth);
+          }
+          if (/hidden|clip|auto|scroll/.test(css.overflowY)) {
+            clip.top = Math.max(clip.top, box.top + element.clientTop);
+            clip.bottom = Math.min(clip.bottom, box.top + element.clientTop + element.clientHeight);
+          }
+        }
+        clips.set(flow, clip);
+        return clip;
+      };
+      for (let index = lo; index < blocks.length; index++) {
+        const block = blocks[index];
+        if (block.element.getBoundingClientRect().top > viewport.bottom + 32) break;
+        const tasks = [...decorations.get(block.id)?.highlights ?? []];
+        for (const range of selections) if (intersects(range, block.range)) tasks.push({ id: "selection", range, selection: true });
+        if (!tasks.length) continue;
+        let leaves = leavesCache.get(block.element);
+        if (!leaves) {
+          leaves = leavesIn(block.element, runtime);
+          leavesCache.set(block.element, leaves);
+        }
+        for (const task of tasks) {
+          const rects = rectangles(leaves, task.range, { ...viewport, top: viewport.top - 32, bottom: viewport.bottom + 32 }, measure);
+          for (const rect of rects) {
+            const clip = clipFor(rect.flow);
+            const left = Math.max(rect.left, clip.left), top = Math.max(rect.top, clip.top);
+            const width = Math.min(rect.left + rect.width, clip.right) - left, height = Math.min(rect.top + rect.height, clip.bottom) - top;
+            if (width <= 0 || height <= 0) continue;
+            output.push({ rect: { ...rect, left: left - origin.left + scrollLeft, top: top - viewport.top, width, height }, task });
+          }
+        }
+      }
+      paint.style.top = `${viewport.top - origin.top + scrollTop}px`;
+      paint.style.height = `${Math.max(0, viewport.bottom - viewport.top)}px`;
+      const hostGeometry = /* @__PURE__ */ new Map();
+      for (const { rect, task } of output) if (!task.selection && !hostGeometry.has(rect.flow)) {
+        const host = rect.flow, box = host.getBoundingClientRect();
+        hostGeometry.set(host, { box, top: Math.max(viewport.top, box.top) - box.top - host.clientTop + host.scrollTop, positioned: getComputedStyle(host).position !== "static" });
+      }
+      const counts = /* @__PURE__ */ new Map();
+      const nextHits = [];
+      output.forEach(({ rect, task }) => {
+        let target = paint, left = rect.left, top = rect.top;
+        if (!task.selection) {
+          const host = rect.flow, geometry = hostGeometry.get(host);
+          let layer2 = highlightLayers.get(host);
+          if (!layer2) {
+            layer2 = document.createElement("span");
+            layer2.className = "limr-highlight-layer";
+            layer2.dataset.limrIgnore = "true";
+            layer2.setAttribute("aria-hidden", "true");
+            host.dataset.limrHighlightHost = "true";
+            if (!geometry.positioned) host.dataset.limrHighlightPosition = "true";
+            host.append(layer2);
+            highlightLayers.set(host, layer2);
+          }
+          layer2.style.top = `${geometry.top}px`;
+          layer2.style.height = `${Math.max(0, Math.min(viewport.bottom, geometry.box.bottom) - Math.max(viewport.top, geometry.box.top))}px`;
+          target = layer2;
+          left += origin.left - geometry.box.left - host.clientLeft + host.scrollLeft;
+          top += viewport.top - geometry.box.top - host.clientTop + host.scrollTop - geometry.top;
+          nextHits.push({ id: task.id, rect: { left: rect.left + origin.left - scrollLeft, top: rect.top + viewport.top, width: rect.width, height: rect.height } });
+        }
+        const index = counts.get(target) ?? 0;
+        counts.set(target, index + 1);
+        const item = target.children[index] ?? document.createElement("span");
+        const className = `limr-paint-rect limr-paint-${task.selection ? "selection" : task.style ?? "background"}`;
+        if (item.className !== className) item.className = className;
+        item.dataset.paint = task.id;
+        item.toggleAttribute("data-reference", !!task.occurrenceId);
+        if (rect.marker) item.dataset.marker = rect.marker;
+        else delete item.dataset.marker;
+        if (rect.atomic) item.dataset.atomic = "true";
+        else delete item.dataset.atomic;
+        if (rect.image) item.dataset.media = "image";
+        else delete item.dataset.media;
+        const css = `left:${left}px;top:${top}px;width:${rect.width}px;height:${rect.height}px;border-radius:${rect.radius ?? "0"};`;
+        if (item.dataset.geometry !== css) {
+          item.style.cssText = css;
+          item.dataset.geometry = css;
+        }
+        if (!task.selection) item.style.setProperty("--limr-highlight", task.color ?? "#F2C744");
+        if (task.occurrenceId) {
+          const active2 = referenceActive(task.occurrenceId);
+          item.toggleAttribute("data-active", active2);
+          item.toggleAttribute("data-muted", !active2);
+        }
+        if (!item.parentNode) target.append(item);
+      });
+      for (const layer2 of [paint, ...highlightLayers.values()]) while (layer2.children.length > (counts.get(layer2) ?? 0)) layer2.lastChild.remove();
+      for (const [host, layer2] of highlightLayers) if (!counts.has(layer2)) removeLayer(host, layer2);
+      hits = nextHits;
+      const active = runtime.interaction.get().activeHighlight;
+      if (active && !hits.some((hit) => hit.id === active)) runtime.clearSelection();
+      feedback();
+      if (translating) {
+        translating = container.getAnimations().some((animation) => animation instanceof CSSTransition && animation.transitionProperty === "translate" && animation.playState === "running");
+        if (translating) schedule();
+      }
+    };
+    const schedule = () => {
+      if (!frame) frame = requestAnimationFrame(render);
+    };
+    const translate = (event) => {
+      if (event.target !== container || event.propertyName !== "translate") return;
+      translating = true;
+      schedule();
+    };
+    container.addEventListener("transitionrun", translate);
+    container.addEventListener("transitionend", translate);
+    container.addEventListener("transitioncancel", translate);
+    const invalidate = () => {
+      blocks = void 0;
+      metrics = /* @__PURE__ */ new WeakMap();
+      schedule();
+    };
+    const fontsChanged = () => {
+      fontMetrics.clear();
+      invalidate();
+    };
+    const unsubscribers = [runtime.interaction.subscribe(() => {
+      const state = runtime.interaction.get(), selection = state.selection;
+      if (state.hoveredHighlight !== lastHovered || state.activeHighlight !== lastActive || state.active !== lastAnnotation || state.hovered !== lastHoveredAnnotation) {
+        lastHovered = state.hoveredHighlight;
+        lastActive = state.activeHighlight;
+        lastAnnotation = state.active;
+        lastHoveredAnnotation = state.hovered;
+        feedback();
+      }
+      if (selection === lastSelection) return;
+      lastSelection = selection;
+      render();
+    }), runtime.decorations.subscribe(() => {
+      const decorations = runtime.decorations.get().byBlock;
+      if (decorations === lastDecorations) return;
+      lastDecorations = decorations;
+      leavesCache = /* @__PURE__ */ new WeakMap();
+      schedule();
+    }), runtime.layout.subscribe(invalidate), runtime.documentOffset.subscribe(schedule), runtime.configuration.subscribe(invalidate)];
+    const observer = new MutationObserver((records) => {
+      let changed = false;
+      for (const record of records) {
+        const target = record.target instanceof Element ? record.target : record.target.parentElement;
+        if (!target || target === paint || paint.contains(target) || target.closest(".limr-highlight-layer")) continue;
+        if (record.type === "childList" && [...record.addedNodes, ...record.removedNodes].every((node) => node instanceof Element && node.classList.contains("limr-highlight-layer"))) continue;
+        const block = target.closest("[data-limr-block]");
+        if (block) leavesCache.delete(block);
+        else blocks = void 0;
+        changed = true;
+      }
+      if (changed) {
+        metrics = /* @__PURE__ */ new WeakMap();
+        schedule();
+      }
+    });
+    observer.observe(container, { subtree: true, childList: true, characterData: true, attributes: true, attributeFilter: ["class", "style", "inert", "open", "data-limr-theme", "data-limr-justify"] });
+    const scroll = () => {
+      runtime.hoverHighlight(null);
+      schedule();
+    };
+    document.addEventListener("scroll", scroll, { capture: true, passive: true });
+    window.visualViewport?.addEventListener("resize", schedule);
+    window.visualViewport?.addEventListener("scroll", schedule);
+    document.fonts?.addEventListener("loadingdone", fontsChanged);
+    const hitAt = (event) => {
+      const element = event.target instanceof Element ? event.target : null;
+      if (!element || element.closest("[data-limr-document]") !== container || element.closest("button,input,textarea,select,[contenteditable],[data-limr-ignore]")) return null;
+      const focused = focusedRange(), decorations = runtime.decorations.get();
+      for (let index = hits.length - 1; index >= 0; index--) {
+        const { rect, id } = hits[index];
+        const highlight = decorations.highlights.get(id);
+        if (highlight?.occurrenceId || highlight?.hidden || focused && highlight && !sameRange(focused, highlight.range)) continue;
+        if (event.clientX >= rect.left && event.clientX <= rect.left + rect.width && event.clientY >= rect.top && event.clientY <= rect.top + rect.height) return id;
+      }
+      return null;
+    };
+    const move = (event) => {
+      if (!event.buttons) runtime.hoverHighlight(hitAt(event));
+    };
+    const leave = () => runtime.hoverHighlight(null);
+    let down = null;
+    const pointerDown = (event) => {
+      down = { x: event.clientX, y: event.clientY };
+    };
+    const click = (event) => {
+      if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || !down || Math.hypot(event.clientX - down.x, event.clientY - down.y) > 4 || window.getSelection()?.isCollapsed === false) return;
+      const id = hitAt(event);
+      if (!id) return;
+      event.preventDefault();
+      const highlight = runtime.decorations.get().highlights.get(id);
+      const text = [];
+      let atomic2 = false;
+      for (const block of runtime.document.getSnapshot().blocks) {
+        if (!intersects(block.range, highlight.range)) continue;
+        const element = runtime.blocks.get(block.id);
+        if (!element) continue;
+        const parts2 = [];
+        for (const leaf of leavesIn(element, runtime)) {
+          if (!intersects(leaf.range, highlight.range) || leaf.kind === "marker") continue;
+          if (leaf.kind !== "text") {
+            atomic2 = true;
+            continue;
+          }
+          const range = textRange(leaf, highlight.range, { top: -Infinity, bottom: Infinity, left: -Infinity, right: Infinity });
+          if (range) parts2.push(range.toString());
+        }
+        if (parts2.length) text.push(parts2.join(""));
+      }
+      runtime.highlightReference = {
+        text: !atomic2 && text.length ? text.join("\n\n") : void 0,
+        getClientRects: () => highlightRects(id),
+        getBoundingClientRect: () => {
+          const rects = highlightRects(id);
+          if (!rects.length) return new DOMRect();
+          const left = Math.min(...rects.map((rect) => rect.left)), top = Math.min(...rects.map((rect) => rect.top));
+          return new DOMRect(left, top, Math.max(...rects.map((rect) => rect.right)) - left, Math.max(...rects.map((rect) => rect.bottom)) - top);
+        }
+      };
+      runtime.activateHighlight(id);
+    };
+    if (interactive) {
+      container.addEventListener("pointermove", move);
+      container.addEventListener("pointerleave", leave);
+      container.addEventListener("pointerdown", pointerDown);
+      container.addEventListener("click", click);
+    }
+    container.dataset.limrPainted = "true";
+    schedule();
+    return () => {
+      cancelAnimationFrame(frame);
+      observer.disconnect();
+      unsubscribers.forEach((unsubscribe) => unsubscribe());
+      document.removeEventListener("scroll", scroll, true);
+      window.visualViewport?.removeEventListener("resize", schedule);
+      window.visualViewport?.removeEventListener("scroll", schedule);
+      document.fonts?.removeEventListener("loadingdone", fontsChanged);
+      container.removeEventListener("transitionrun", translate);
+      container.removeEventListener("transitionend", translate);
+      container.removeEventListener("transitioncancel", translate);
+      container.removeEventListener("pointermove", move);
+      container.removeEventListener("pointerleave", leave);
+      container.removeEventListener("pointerdown", pointerDown);
+      container.removeEventListener("click", click);
+      delete container.dataset.limrPainted;
+      clear();
+    };
+  }, [runtime, interactive]);
+  return /* @__PURE__ */ jsx3("div", { ref: layer, className: "limr-paint-layer", "data-limr-ignore": "true", "aria-hidden": "true" });
+}
+
+// src/react/Markdown.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function Markdown({ className, style, interactive = true, followOutput = false, justify, ...props }) {
+  const parent = useContext(RuntimeContext);
+  if (props.source !== void 0 || !parent) return /* @__PURE__ */ jsx4(DocumentProvider, { ...props, justify, children: /* @__PURE__ */ jsx4(MarkdownBody, { className, style, interactive, followOutput }) });
+  return /* @__PURE__ */ jsx4(MarkdownBody, { className, style, interactive, followOutput, justify });
+}
+function MarkdownBody({ className, style, interactive, followOutput, justify }) {
+  const runtime = useRuntime();
+  const document2 = useDocument();
+  const appearance = useAppearance();
+  const theme = useStoreSelector(runtime.configuration, (config) => config.theme ?? "light");
+  const configuredJustify = useStoreSelector(runtime.configuration, (config) => config.justify ?? false);
+  const scrollRoot = useStoreSelector(runtime.configuration, (config) => config.scrollRoot);
+  const offset = useStoreSelector(runtime.documentOffset, (value) => value);
+  const components = useStoreSelector(runtime.configuration, (config) => config.components);
+  const extensions = useStoreSelector(runtime.configuration, (config) => config.extensions);
+  const decorations = useStoreSelector(runtime.decorations, (state) => state.byBlock);
+  const ref = useRef4(null);
+  const pinned = useRef4(true);
+  useIsomorphicLayoutEffect(() => ref.current ? runtime.mountContent(ref.current) : void 0, [runtime, scrollRoot]);
+  useIsomorphicLayoutEffect(() => runtime.requestLayout(), [runtime, justify, configuredJustify]);
+  useSelectionTracking(runtime, interactive);
+  useEffect4(() => {
+    if (!followOutput) return;
+    const root = scrollRoot ?? window;
+    const onScroll = () => {
+      const element = scrollRoot ?? window.document.documentElement;
+      const viewport = scrollRoot?.clientHeight ?? window.innerHeight;
+      pinned.current = element.scrollHeight - runtime.getScrollTop() - viewport < 48;
+    };
+    root.addEventListener("scroll", onScroll, { passive: true });
+    return () => root.removeEventListener("scroll", onScroll);
+  }, [runtime, followOutput, scrollRoot]);
+  useIsomorphicLayoutEffect(() => {
+    if (!followOutput || !document2.streaming || !pinned.current) return;
+    const frame = requestAnimationFrame(() => runtime.scrollTo(scrollRoot?.scrollHeight ?? window.document.documentElement.scrollHeight, "instant"));
+    return () => cancelAnimationFrame(frame);
+  }, [document2, runtime, followOutput, scrollRoot]);
+  return /* @__PURE__ */ jsxs3("article", { ref, className: `limr-prose ${className ?? ""}`, style: { ...style, translate: offset ? `0 ${offset}px` : style?.translate }, "data-limr-theme": theme, "data-limr-appearance": appearance, "data-limr-document": document2.id, "data-limr-justify": justify ?? configuredJustify, children: [
+    document2.blocks.map((block) => /* @__PURE__ */ jsx4(BlockView, { block, runtime, components, extensions, decorations: decorations.get(block.id) ?? emptyDecorations }, block.id)),
+    /* @__PURE__ */ jsx4(Footnotes, {}),
+    /* @__PURE__ */ jsx4(SelectionPaint, { runtime, interactive })
+  ] });
+}
+
+// src/components/OverlayScrollArea.tsx
+import { useRef as useRef5 } from "react";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function OverlayScrollArea({ children, active, resetKey, label }) {
+  const area = useRef5(null);
+  const content = useRef5(null);
+  const thumb = useRef5(null);
+  const track = useRef5(null);
+  const drag = useRef5(null);
+  const show = useRef5(() => {
+  });
+  useIsomorphicLayoutEffect(() => {
+    const element = area.current, wrapper = element.parentElement;
+    delete wrapper.dataset.scrolling;
+    if (!active) return;
+    element.scrollTop = 0;
+    let frame = 0, timeout, previous = 0;
+    const update = () => {
+      frame = 0;
+      const height = track.current.clientHeight;
+      const overflow = element.scrollHeight - element.clientHeight;
+      const size = Math.min(height, Math.max(20, height * element.clientHeight / Math.max(1, element.scrollHeight)));
+      wrapper.toggleAttribute("data-overflow", overflow > 1);
+      thumb.current.style.height = `${size}px`;
+      thumb.current.style.transform = `translateY(${overflow > 0 ? Math.max(0, Math.min(1, element.scrollTop / overflow)) * (height - size) : 0}px)`;
+    };
+    const schedule = () => {
+      if (!frame) frame = requestAnimationFrame(update);
+    };
+    show.current = () => {
+      clearTimeout(timeout);
+      if (wrapper.closest("[data-motion]")) return;
+      wrapper.dataset.scrolling = "true";
+      timeout = setTimeout(() => {
+        if (!drag.current) delete wrapper.dataset.scrolling;
+      }, 800);
+    };
+    const scroll = () => {
+      schedule();
+      if (element.scrollTop === previous) return;
+      previous = element.scrollTop;
+      show.current();
+    };
+    const observer = new ResizeObserver(schedule);
+    observer.observe(element);
+    observer.observe(content.current);
+    element.addEventListener("scroll", scroll, { passive: true });
+    update();
+    return () => {
+      observer.disconnect();
+      element.removeEventListener("scroll", scroll);
+      cancelAnimationFrame(frame);
+      clearTimeout(timeout);
+      drag.current = null;
+      show.current = () => {
+      };
+      delete wrapper.dataset.scrolling;
+    };
+  }, [active, resetKey]);
+  const startDrag = (event) => {
+    if (event.button !== 0) return;
+    const element = area.current, bar = thumb.current;
+    const travel = track.current.clientHeight - bar.offsetHeight;
+    if (travel <= 0) return;
+    event.preventDefault();
+    event.currentTarget.setPointerCapture(event.pointerId);
+    const scale = (element.scrollHeight - element.clientHeight) / travel;
+    if (event.target !== bar) element.scrollTop = (event.clientY - track.current.getBoundingClientRect().top - bar.offsetHeight / 2) * scale;
+    drag.current = { pointerId: event.pointerId, y: event.clientY, scroll: element.scrollTop, scale };
+    show.current();
+  };
+  const move = (event) => {
+    const current = drag.current;
+    if (current?.pointerId === event.pointerId) area.current.scrollTop = current.scroll + (event.clientY - current.y) * current.scale;
+  };
+  const end = (event) => {
+    if (drag.current?.pointerId !== event.pointerId) return;
+    drag.current = null;
+    if (event.currentTarget.hasPointerCapture(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId);
+    show.current();
+  };
+  return /* @__PURE__ */ jsxs4("div", { className: "limr-overlay-scroll", children: [
+    /* @__PURE__ */ jsx5("div", { ref: area, className: "limr-overlay-content", "data-limr-card-body": "", tabIndex: 0, role: "region", "aria-label": label, children: /* @__PURE__ */ jsx5("div", { ref: content, className: "limr-overlay-scroll-inner", children }) }),
+    /* @__PURE__ */ jsx5("div", { ref: track, className: "limr-overlay-scrollbar", "aria-hidden": "true", onPointerDown: startDrag, onPointerMove: move, onPointerUp: end, onPointerCancel: end, onLostPointerCapture: end, children: /* @__PURE__ */ jsx5("div", { ref: thumb, className: "limr-overlay-scroll-thumb" }) })
+  ] });
+}
+
+// src/components/AnnotationCard.tsx
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function AnnotationCard({ title, bodyLabel, occurrence, expanded, pinned, canExpand, expand, collapse, close, children }) {
+  const locale = useLocale();
+  return /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    /* @__PURE__ */ jsxs5("div", { className: "limr-overlay-header", children: [
+      /* @__PURE__ */ jsx6("span", { children: title }),
+      /* @__PURE__ */ jsxs5("div", { className: "limr-overlay-controls", children: [
+        expanded ? /* @__PURE__ */ jsx6("button", { type: "button", onClick: collapse, children: /* @__PURE__ */ jsx6("span", { className: "limr-underline", children: locale.collapse }) }) : canExpand && /* @__PURE__ */ jsx6("button", { type: "button", onClick: expand, children: /* @__PURE__ */ jsx6("span", { className: "limr-underline", children: locale.expand }) }),
+        pinned && /* @__PURE__ */ jsx6("button", { type: "button", className: "limr-overlay-close", onClick: close, "aria-label": locale.close, children: "\xD7" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx6(OverlayScrollArea, { active: true, resetKey: occurrence.id, label: bodyLabel ?? (typeof title === "string" ? title : locale.annotations), children })
+  ] });
+}
+
+// src/extensions/annotations.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+var CitationParagraph = ({ children }) => /* @__PURE__ */ jsx7("p", { children: /* @__PURE__ */ jsx7("span", { className: "limr-underline", children }) });
+function CitationIcon() {
+  return /* @__PURE__ */ jsx7("svg", { viewBox: "0 0 16 16", "aria-hidden": "true", fill: "currentColor", children: /* @__PURE__ */ jsx7("path", { d: "M2.5 4.2h4.3v4.3c0 2.1-1.2 3.3-3.5 3.8l-.5-1.4c1.4-.4 2-1 2-2H2.5V4.2Zm6.7 0h4.3v4.3c0 2.1-1.2 3.3-3.5 3.8l-.5-1.4c1.4-.4 2-1 2-2H9.2V4.2Z" }) });
+}
+function AnnotationMarkdown({ source, className, ...props }) {
+  const runtime = useRuntime();
+  const config = useStoreSelector(runtime.configuration, (config2) => config2);
+  return /* @__PURE__ */ jsx7(Markdown, { source, extensions: config.extensions, parameters: config.parameters, components: config.components, annotationTypes: config.annotationTypes, theme: config.theme, appearance: config.appearance, locale: config.locale, interactive: false, ...props, className: `limr-annotation-markdown ${className ?? ""}` });
+}
+function citation(options = {}) {
+  function Preview({ annotations }) {
+    const summary = useMemo2(() => annotations.filter((annotation) => annotation.type === (options.type ?? "citation")).map((annotation) => {
+      const data = annotation.data;
+      const source = data?.summary?.trim() || data?.description?.trim();
+      if (source) return fromMarkdown(source).children?.map(textContent).join(" ").replace(/\s+/g, " ").trim();
+      return safeUrl(data?.url) || data?.title;
+    }).filter(Boolean).join(" \xB7 "), [annotations]);
+    return summary ? /* @__PURE__ */ jsx7("span", { title: summary, children: summary }) : null;
+  }
+  function Card(props) {
+    const locale = useLocale();
+    return /* @__PURE__ */ jsx7(AnnotationCard, { ...props, title: locale.citation ?? locale.annotations });
+  }
+  function Content({ data }) {
+    const runtime = useRuntime();
+    const configured = useStoreSelector(runtime.configuration, () => runtime.components);
+    const components = useMemo2(() => ({ ...configured, paragraph: configured.paragraph ?? CitationParagraph }), [configured]);
+    const link = useRef6(null);
+    const url = safeUrl(data?.url);
+    return /* @__PURE__ */ jsxs6("div", { className: "limr-citation-content", "data-linked": !!url || void 0, onClick: (event) => {
+      if (url && !event.defaultPrevented && !event.target.closest('a,button,input,textarea,select,summary,[role="button"],[contenteditable="true"],[data-limr-card-interactive]') && window.getSelection()?.isCollapsed !== false) link.current?.click();
+    }, children: [
+      /* @__PURE__ */ jsx7("a", { ref: link, className: "limr-citation-title", href: url, target: "_blank", rel: "noopener noreferrer", children: /* @__PURE__ */ jsx7("span", { className: "limr-underline", children: data?.title ?? data?.url ?? "Citation" }) }),
+      (data?.description || data?.summary) && /* @__PURE__ */ jsx7(AnnotationMarkdown, { source: data.description || data.summary, components })
+    ] });
+  }
+  return {
+    name: "citation",
+    tags: ["citation", "ref"],
+    scope: "local",
+    annotationTypes: [{ type: "citation", label: (locale) => locale.citation ?? "Citation", icon: CitationIcon, color: "#6366f1", highlight: "hover", Content, ...options, sidebar: { Preview, collapseOnContentClick: false, ...options.sidebar }, overlay: { Card, expand: false, ...options.overlay } }],
+    transform(root) {
+      walk(root, (node) => {
+        if (node.type !== "component") return;
+        if (node.name === "citation") {
+          const attributes = node.attributes ?? {};
+          const id = String(attributes["cite-id"] ?? attributes.id ?? "");
+          node.type = "annotationDefinition";
+          node.annotation = { id, type: "citation", data: { title: attributes.title, url: attributes.url, description: attributes.desc ?? attributes.description, summary: attributes.summary } };
+        } else if (node.name === "ref") {
+          const value = String(node.attributes?.["cite-from-ids"] ?? node.attributes?.ids ?? node.attributes?.id ?? "");
+          let ids;
+          try {
+            const parsed = JSON.parse(value);
+            ids = Array.isArray(parsed) ? parsed.map(String) : [String(parsed)];
+          } catch {
+            ids = value.split(",").map((id) => id.trim()).filter(Boolean);
+          }
+          node.type = "annotationReference";
+          node.annotationIds = ids;
+        }
+      });
+    }
+  };
+}
+
+// src/extensions/translations.tsx
+import { useRef as useRef8, useState as useState3 } from "react";
+
+// src/components/InlineMarker.tsx
+import { forwardRef } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var InlineMarker = forwardRef(function InlineMarker2({ label, color, children, className = "", style, ...props }, ref) {
+  return /* @__PURE__ */ jsx8("span", { className: "limr-mark-wrap", "data-limr-ignore": "true", children: /* @__PURE__ */ jsx8(
+    "button",
+    {
+      ...props,
+      ref,
+      type: "button",
+      "aria-label": label,
+      title: props.title ?? label,
+      className: `limr-mark limr-action-mark ${className}`,
+      style: { "--limr-mark-color": color, ...style },
+      children: /* @__PURE__ */ jsx8("span", { className: "limr-mark-icon", children })
+    }
+  ) });
+});
+
+// src/components/Collapse.tsx
+import { useRef as useRef7, useState as useState2 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+function Collapse({ open, children, className = "", keepMounted = false }) {
+  const [mounted, setMounted] = useState2(open);
+  const [visible, setVisible] = useState2(open);
+  const panel = useRef7(null);
+  useIsomorphicLayoutEffect(() => {
+    if (keepMounted) return;
+    if (open) {
+      if (!mounted) {
+        setMounted(true);
+        return;
+      }
+      panel.current?.getBoundingClientRect();
+      setVisible(true);
+      return;
+    }
+    setVisible(false);
+    const timer = setTimeout(() => setMounted(false), 420);
+    return () => clearTimeout(timer);
+  }, [open, keepMounted, mounted]);
+  return /* @__PURE__ */ jsx9("div", { ref: (element) => {
+    panel.current = element;
+    element?.toggleAttribute("inert", !open);
+  }, className: `limr-collapse ${className}`, "data-open": (keepMounted ? open : visible) || void 0, "aria-hidden": !open, children: /* @__PURE__ */ jsx9("div", { className: "limr-collapse-inner", children: mounted || keepMounted ? children : null }) });
+}
+
+// src/extensions/translations.tsx
+import { Fragment as Fragment4, jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+var modes = ["origin", "translation", "both"];
+var names = { origin: "\u539F\u6587", translation: "\u8BD1\u6587", both: "\u5BF9\u7167" };
+function TranslationIcon({ mode }) {
+  return /* @__PURE__ */ jsx10("svg", { viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.7", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: mode === "both" ? /* @__PURE__ */ jsxs7(Fragment4, { children: [
+    /* @__PURE__ */ jsx10("rect", { x: "2.5", y: "4", width: "8", height: "16", rx: "2.5" }),
+    /* @__PURE__ */ jsx10("rect", { x: "13.5", y: "4", width: "8", height: "16", rx: "2.5" }),
+    /* @__PURE__ */ jsx10("path", { d: "M5 9h3M5 12h3M16 9h3M16 12h3" })
+  ] }) : /* @__PURE__ */ jsxs7(Fragment4, { children: [
+    /* @__PURE__ */ jsx10("rect", { x: "4.5", y: "3", width: "15", height: "18", rx: "3" }),
+    mode === "origin" ? /* @__PURE__ */ jsx10("path", { d: "M8.5 8h7M8.5 12h7M8.5 16h4" }) : /* @__PURE__ */ jsx10("path", { d: "M8 8.5h8M12 6.5v2M14.5 8.5c-.5 4-3 6.5-6.5 8M9.5 11c1.2 2.5 3.2 4.2 6.5 5.5" })
+  ] }) });
+}
+function modeOf(value, fallback) {
+  return modes.includes(value) ? value : fallback;
+}
+function section(node, name) {
+  for (const child of node.children ?? []) {
+    if (child.name === name) return child;
+    if (child.type === "paragraph") {
+      const found = section(child, name);
+      if (found) return found;
+    }
+  }
+}
+function translations(options = {}) {
+  function Translations({ node, children, renderChildren }) {
+    const origin = section(node, "origin"), translation = section(node, "translation");
+    const [localMode, setLocalMode] = useState3();
+    const globalMode = useRendererParameter("translationMode");
+    const onGlobalChange = useRendererParameter("onTranslationModeChange");
+    const requested = modeOf(globalMode ?? localMode ?? node.attributes?.default, options.defaultMode ?? "origin");
+    const mode = !origin ? "translation" : !translation ? "origin" : requested;
+    const next = modes[(modes.indexOf(mode) + 1) % modes.length];
+    const marker = useRef8(null);
+    const restoreFocus = useRef8(false);
+    const locked = globalMode !== void 0 && !onGlobalChange;
+    useIsomorphicLayoutEffect(() => {
+      if (restoreFocus.current) {
+        marker.current?.focus({ preventScroll: true });
+        restoreFocus.current = false;
+      }
+    }, [mode]);
+    if (!origin && !translation) return /* @__PURE__ */ jsx10(Fragment4, { children });
+    const toggle = origin && translation ? /* @__PURE__ */ jsx10(
+      InlineMarker,
+      {
+        ref: marker,
+        "data-translation-switch": "",
+        "data-mode": mode,
+        color: "var(--limr-translation-accent, #6b8fb5)",
+        disabled: locked,
+        label: locked ? `\u5F53\u524D${names[mode]}\uFF0C\u7531\u5168\u5C40\u5C55\u793A\u6A21\u5F0F\u63A7\u5236` : `\u5F53\u524D${names[mode]}\uFF0C\u5207\u6362\u5230${names[next]}`,
+        onClick: () => {
+          restoreFocus.current = document.activeElement === marker.current;
+          if (globalMode !== void 0) onGlobalChange?.(next);
+          else setLocalMode(next);
+        },
+        children: /* @__PURE__ */ jsx10(TranslationIcon, { mode })
+      }
+    ) : void 0;
+    return /* @__PURE__ */ jsxs7("div", { className: "limr-translations", "data-mode": mode, children: [
+      translation && /* @__PURE__ */ jsx10(Collapse, { open: mode !== "origin", keepMounted: true, className: "limr-translation-panel", children: /* @__PURE__ */ jsx10("div", { className: "limr-translation-text", "data-language": "translation", children: renderChildren(translation.children ?? [], { trailing: mode === "translation" ? toggle : void 0 }) }) }),
+      origin && /* @__PURE__ */ jsx10(Collapse, { open: mode !== "translation", keepMounted: true, className: "limr-translation-panel", children: /* @__PURE__ */ jsx10("div", { className: "limr-translation-text", "data-language": "origin", children: renderChildren(origin.children ?? [], { trailing: mode !== "translation" ? toggle : void 0 }) }) })
+    ] });
+  }
+  return {
+    name: "translations",
+    tags: ["translations", "origin", "translation"],
+    directives: ["translations", "origin", "translation"],
+    display: "block",
+    scope: "local",
+    parameters: { translationMode: void 0, onTranslationModeChange: void 0 },
+    components: { translations: Translations, origin: ({ children }) => /* @__PURE__ */ jsx10(Fragment4, { children }), translation: ({ children }) => /* @__PURE__ */ jsx10(Fragment4, { children }) }
+  };
+}
+
+// src/extensions/blocks.tsx
+import { useState as useState7 } from "react";
+
+// src/extensions/define.ts
+function defineBlock({ name, component, tags = [name], directives = [name], selection = "content" }) {
+  return { name, tags, directives, selection, display: "block", scope: "local", components: Object.fromEntries([.../* @__PURE__ */ new Set([...tags, ...directives])].map((tag) => [tag, component])) };
+}
+function defineAnnotation(type) {
+  return { name: `annotation:${type.type}`, annotationTypes: [type], scope: "local" };
+}
+function defineExtension(extension) {
+  return extension;
+}
+
+// src/components/Disclosure.tsx
+import { useEffect as useEffect5, useState as useState4 } from "react";
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+function Disclosure({ title, open, onChange, children }) {
+  const [present, setPresent] = useState4(open);
+  useEffect5(() => {
+    if (open) {
+      setPresent(true);
+      return;
+    }
+    const timer = setTimeout(() => setPresent(false), 420);
+    return () => clearTimeout(timer);
+  }, [open]);
+  return /* @__PURE__ */ jsxs8("details", { className: "limr-disclosure", open: present || open, "data-expanded": open || void 0, children: [
+    /* @__PURE__ */ jsxs8("summary", { "aria-expanded": open, onClick: (event) => {
+      event.preventDefault();
+      onChange(!open);
+    }, "data-limr-ignore": "true", children: [
+      /* @__PURE__ */ jsx11("span", { className: "limr-underline", children: title }),
+      /* @__PURE__ */ jsx11("svg", { viewBox: "0 0 20 20", fill: "none", "aria-hidden": "true", children: /* @__PURE__ */ jsx11("path", { d: "m6 8 4 4 4-4" }) })
+    ] }),
+    /* @__PURE__ */ jsx11(Collapse, { open, keepMounted: true, children: /* @__PURE__ */ jsx11("div", { className: "limr-question-detail", children }) })
+  ] });
+}
+
+// src/components/DiamondCheck.tsx
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+function DiamondCheck({ checked }) {
+  return /* @__PURE__ */ jsxs9("svg", { className: "limr-choice-diamond", width: "14", height: "14", viewBox: "0 0 18 18", fill: "none", "aria-hidden": "true", "data-limr-ignore": "true", "data-checked": checked || void 0, children: [
+    /* @__PURE__ */ jsx12("path", { className: "limr-diamond-outline", d: "M9 1.5L16.5 9L9 16.5L1.5 9Z", fill: "none" }),
+    /* @__PURE__ */ jsx12("path", { className: "limr-diamond-fill", d: "M9 5L13 9L9 13L5 9Z", fill: "currentColor" })
+  ] });
+}
+
+// src/extensions/video.tsx
+import { useEffect as useEffect6, useRef as useRef9, useState as useState5 } from "react";
+import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+function resolveVideo(source, provider = "auto") {
+  const safe = safeUrl(source);
+  if (!safe) return;
+  let parsed;
+  try {
+    parsed = new URL(safe.startsWith("//") ? `https:${safe}` : safe);
+  } catch {
+    return provider === "auto" || provider === "native" ? { url: safe, native: true } : void 0;
+  }
+  if (!["https:", "http:"].includes(parsed.protocol)) return;
+  const youtube = /(?:^|\.)(?:youtube\.com|youtube-nocookie\.com)$/.test(parsed.hostname) || parsed.hostname === "youtu.be";
+  const bilibili = /(?:^|\.)bilibili\.com$/.test(parsed.hostname);
+  const kind = provider === "auto" ? youtube ? "youtube" : bilibili ? "bilibili" : "native" : provider;
+  if (kind === "native") return { url: safe, native: true };
+  if (kind === "youtube" && youtube) {
+    const id = parsed.hostname === "youtu.be" ? parsed.pathname.split("/")[1] : parsed.searchParams.get("v") ?? /^\/(?:embed|shorts|live)\/([\w-]+)/.exec(parsed.pathname)?.[1];
+    if (id && /^[\w-]{11}$/.test(id)) {
+      const embed = new URL(`https://www.youtube.com/embed/${id}`);
+      const time = parsed.searchParams.get("start") ?? parsed.searchParams.get("t");
+      if (time) {
+        const match = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s?)?$/.exec(time);
+        const seconds = match ? Number(match[1] ?? 0) * 3600 + Number(match[2] ?? 0) * 60 + Number(match[3] ?? 0) : 0;
+        if (seconds > 0) embed.searchParams.set("start", String(seconds));
+      }
+      return { url: embed.href, native: false };
+    }
+  }
+  if (kind === "bilibili" && bilibili) {
+    const id = /\/video\/(BV[\w]+|av\d+)(?:\/|$)/.exec(parsed.pathname)?.[1];
+    const bvid = id?.startsWith("BV") ? id : parsed.hostname === "player.bilibili.com" ? parsed.searchParams.get("bvid") : null;
+    const aid = id?.startsWith("av") ? id.slice(2) : parsed.hostname === "player.bilibili.com" ? parsed.searchParams.get("aid") : null;
+    if (bvid && /^BV[\w]+$/.test(bvid) || aid && /^\d+$/.test(aid)) {
+      const embed = new URL("https://player.bilibili.com/player.html");
+      embed.searchParams.set(bvid ? "bvid" : "aid", bvid || aid);
+      embed.searchParams.set("autoplay", "0");
+      embed.searchParams.set("high_quality", "1");
+      embed.searchParams.set("danmaku", "0");
+      const part = parsed.searchParams.get("p") ?? parsed.searchParams.get("page");
+      if (part && /^[1-9]\d*$/.test(part)) embed.searchParams.set("page", part);
+      return { url: embed.href, native: false };
+    }
+  }
+}
+function video(options = {}) {
+  function Video({ node, source: markdown, renderAttribute }) {
+    const runtime = useRuntime();
+    const scrollRoot = useStoreSelector(runtime.configuration, (config) => config.scrollRoot);
+    const element = useRef9(null);
+    const [visible, setVisible] = useState5(false);
+    const [playing, setPlaying] = useState5(false);
+    const [failed, setFailed] = useState5(false);
+    const provider = String(node.attributes?.provider ?? "auto");
+    const source = String(node.attributes?.url ?? node.attributes?.src ?? "");
+    const requested = node.attributes?.loading ?? options.loading ?? "visible";
+    const loading2 = requested === "click" || requested === "eager" ? requested : "visible";
+    const resolved = options.resolveUrl?.(provider, source);
+    const media = resolved && safeUrl(resolved) ? { url: safeUrl(resolved), native: provider === "native" } : resolveVideo(source, provider);
+    useEffect6(() => {
+      setFailed(false);
+      setPlaying(false);
+    }, [source, provider]);
+    useEffect6(() => {
+      if (visible || loading2 !== "visible" || !element.current) return;
+      if (typeof IntersectionObserver === "undefined") {
+        setVisible(true);
+        return;
+      }
+      const observer = new IntersectionObserver((entries) => {
+        if (entries.some((entry) => entry.isIntersecting)) {
+          setVisible(true);
+          observer.disconnect();
+        }
+      }, { root: scrollRoot, rootMargin: "200px" });
+      observer.observe(element.current);
+      return () => observer.disconnect();
+    }, [visible, loading2, scrollRoot]);
+    const enabled = loading2 === "eager" || loading2 === "visible" && visible || playing;
+    const title = String(node.attributes?.title ?? `${provider === "auto" ? "Video" : provider} video`);
+    const original = safeUrl(source);
+    return /* @__PURE__ */ jsxs10("div", { ref: element, className: "limr-video", "data-limr-selection-surface": "", "data-loading": loading2, children: [
+      /* @__PURE__ */ jsx13("div", { className: "limr-video-frame", children: !media || failed ? /* @__PURE__ */ jsxs10("div", { className: "limr-video-error", children: [
+        /* @__PURE__ */ jsx13("span", { children: runtime.locale.unavailable }),
+        original && /* @__PURE__ */ jsx13("a", { href: original, target: "_blank", rel: "noopener noreferrer", children: source })
+      ] }) : enabled ? media.native ? /* @__PURE__ */ jsx13("video", { controls: true, playsInline: true, preload: "metadata", src: media.url, "aria-label": title, onError: () => setFailed(true) }) : /* @__PURE__ */ jsx13("iframe", { src: media.url, title, allow: "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share", allowFullScreen: true, referrerPolicy: "strict-origin-when-cross-origin", onError: () => setFailed(true) }) : /* @__PURE__ */ jsx13("button", { type: "button", className: "limr-video-play", onClick: () => setPlaying(true), "aria-label": runtime.locale.play, children: /* @__PURE__ */ jsx13("svg", { viewBox: "0 0 24 24", "aria-hidden": "true", children: /* @__PURE__ */ jsx13("path", { d: "m8 5 11 7-11 7Z", fill: "currentColor" }) }) }) }),
+      node.attributes?.title && /* @__PURE__ */ jsx13("div", { className: "limr-video-title", children: renderAttribute("title") }),
+      /* @__PURE__ */ jsx13(CopyButton, { className: "limr-video-copy", variant: "glass", value: markdown })
+    ] });
+  }
+  return defineBlock({ name: "video", tags: ["video", "md-video"], component: options.component ?? Video, selection: "atomic" });
+}
+
+// src/extensions/figures.tsx
+import { createContext, useContext as useContext2, useEffect as useEffect7, useMemo as useMemo3, useRef as useRef10, useState as useState6 } from "react";
+
+// src/extensions/figure-layout.ts
+var defaultFigureLimits = { minWidth: 220, maxWidth: 560, minHeight: 120, maxHeight: 480 };
+function figureWidths({ ratio, limits }) {
+  const maximum = Math.min(limits.maxWidth, limits.maxHeight * ratio);
+  return { maximum, minimum: Math.min(maximum, Math.max(limits.minWidth, limits.minHeight * ratio)) };
+}
+function figureColumns(width, items, gap, requested, responsive = true) {
+  if (!items.length || width <= 0) return 1;
+  const bounds = items.map(figureWidths);
+  const fits = (count2) => {
+    const slot = (width - (count2 - 1) * gap) / count2;
+    return bounds.every((item) => slot >= item.minimum);
+  };
+  if (requested) {
+    let count2 = Math.max(1, Math.min(24, Math.floor(requested)));
+    if (responsive) while (count2 > 1 && !fits(count2)) count2--;
+    return count2;
+  }
+  const maximum = Math.max(...bounds.map((item) => item.maximum));
+  const minimum = Math.max(...bounds.map((item) => item.minimum));
+  let count = 1;
+  while (count < items.length && count < 24 && width >= count * maximum + count * gap + minimum && fits(count + 1)) count++;
+  return count;
+}
+function dimension(value, fallback, optional = false) {
+  if (optional && (value === false || value === "false" || value === "none")) return Infinity;
+  if (typeof value !== "number" && (typeof value !== "string" || !/^\d+(?:\.\d+)?(?:px)?$/.test(value))) return fallback;
+  const number = typeof value === "number" ? value : parseFloat(value);
+  return Number.isFinite(number) && number >= 0 ? number : fallback;
+}
+function figureLimits(attributes = {}, defaults2 = defaultFigureLimits) {
+  return {
+    minWidth: dimension(attributes["min-width"], defaults2.minWidth),
+    maxWidth: dimension(attributes["max-width"], defaults2.maxWidth, true),
+    minHeight: dimension(attributes["min-height"], defaults2.minHeight),
+    maxHeight: dimension(attributes["max-height"], defaults2.maxHeight, true)
+  };
+}
+
+// src/extensions/figures.tsx
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+var FigureContext = createContext(defaultFigureLimits);
+var captionNode = (node) => node.name === "figcaption" || node.name === "caption";
+var flatten = (nodes) => nodes.flatMap((node) => node.type === "paragraph" && node.children?.some((child) => child.name === "figure" || captionNode(child)) ? node.children : [node]);
+var identifier = (node) => node.attributes?.id ? String(node.attributes.id) : void 0;
+var ratioOf = (width, height) => {
+  const ratio = Number(width) / Number(height);
+  return Number.isFinite(ratio) && ratio > 0 ? ratio : 1;
+};
+function figures(options = {}) {
+  const defaults2 = figureLimits({ "min-width": options.minWidth, "max-width": options.maxWidth, "min-height": options.minHeight, "max-height": options.maxHeight });
+  function Figures({ node, renderChildren, renderAttribute, source }) {
+    const locale = useLocale();
+    const nodes = flatten(node.children ?? []);
+    const panels = nodes.filter((child) => child.name === "figure");
+    const captions = nodes.filter(captionNode);
+    const body = nodes.filter((child) => !captionNode(child));
+    const limits = useMemo3(() => figureLimits(node.attributes, defaults2), [node.attributes]);
+    const grid = useRef10(null);
+    const [columns, setColumns] = useState6(1);
+    const gap = Math.min(100, dimension(node.attributes?.gap, options.gap ?? 16));
+    const rows = dimension(node.attributes?.rows, options.rows ?? 0);
+    const requested = dimension(node.attributes?.columns ?? node.attributes?.cols, options.columns ?? 0) || (rows > 0 ? Math.ceil(panels.length / rows) : void 0);
+    const responsive = String(node.attributes?.responsive ?? options.responsive ?? true) !== "false";
+    useEffect7(() => {
+      const element = grid.current;
+      if (!element) return;
+      const measure = () => {
+        const elements = [...element.querySelectorAll(":scope > .limr-figure")];
+        const items = panels.map((panel, index) => {
+          const image = elements[index]?.querySelector("img");
+          const ratio = image?.naturalWidth && image.naturalHeight ? image.naturalWidth / image.naturalHeight : ratioOf(panel.attributes?.width, panel.attributes?.height);
+          return { ratio, limits: figureLimits(panel.attributes, limits) };
+        });
+        setColumns(figureColumns(element.clientWidth, items, gap, requested, responsive));
+      };
+      const observer = new ResizeObserver(measure);
+      observer.observe(element);
+      element.addEventListener("load", measure, true);
+      element.addEventListener("error", measure, true);
+      measure();
+      return () => {
+        observer.disconnect();
+        element.removeEventListener("load", measure, true);
+        element.removeEventListener("error", measure, true);
+      };
+    }, [node, limits, gap, requested, responsive]);
+    return /* @__PURE__ */ jsxs11("figure", { id: identifier(node), className: "limr-figures", "data-limr-selection-order": "visual", "data-columns": columns, "data-responsive": responsive, children: [
+      /* @__PURE__ */ jsx14(CopyButton, { value: source, label: locale.copyFigures, variant: "glass", className: "limr-figures-copy" }),
+      /* @__PURE__ */ jsx14(FigureContext.Provider, { value: limits, children: /* @__PURE__ */ jsx14("div", { ref: grid, className: "limr-figures-grid", style: { gridTemplateColumns: `repeat(${columns}, minmax(0, 1fr))`, gridTemplateRows: rows ? `repeat(${Math.max(1, Math.min(24, Math.floor(rows)))}, auto auto)` : void 0, gap }, children: renderChildren(body) }) }),
+      captions.length ? renderChildren(captions) : node.attributes?.caption ? /* @__PURE__ */ jsx14("figcaption", { children: renderAttribute("caption") }) : null
+    ] });
+  }
+  function Figure({ node, renderChildren, renderAttribute }) {
+    const locale = useLocale();
+    const inherited = useContext2(FigureContext);
+    const limits = figureLimits(node.attributes, inherited === defaultFigureLimits ? defaults2 : inherited);
+    const media = useRef10(null);
+    const [ratio, setRatio] = useState6(ratioOf(node.attributes?.width, node.attributes?.height));
+    const nodes = flatten(node.children ?? []);
+    const captions = nodes.filter(captionNode);
+    const body = nodes.filter((child) => !captionNode(child));
+    useEffect7(() => {
+      const element = media.current;
+      if (!element) return;
+      const measure = () => {
+        const image = element.querySelector("img");
+        if (image?.naturalWidth && image.naturalHeight) setRatio(image.naturalWidth / image.naturalHeight);
+      };
+      measure();
+      element.addEventListener("load", measure, true);
+      return () => element.removeEventListener("load", measure, true);
+    }, [node]);
+    const maximum = figureWidths({ ratio, limits }).maximum;
+    return /* @__PURE__ */ jsxs11("figure", { id: identifier(node), className: "limr-figure", "data-limr-selection-order": "visual", style: {
+      "--limr-figure-width": Number.isFinite(maximum) ? `${maximum}px` : "100%",
+      "--limr-figure-min-height": `${Math.min(limits.minHeight, limits.maxHeight)}px`,
+      "--limr-figure-max-height": Number.isFinite(limits.maxHeight) ? `${limits.maxHeight}px` : "none"
+    }, children: [
+      /* @__PURE__ */ jsx14("div", { ref: media, className: "limr-figure-media", children: renderChildren(body) }),
+      /* @__PURE__ */ jsx14(CopyButton, { onCopy: async () => {
+        const url = media.current?.querySelector("img")?.getAttribute("src");
+        if (!url) throw new Error("Image URL unavailable");
+        await navigator.clipboard.writeText(url);
+      }, label: locale.copyImage, variant: "glass", className: "limr-figure-copy" }),
+      captions.length ? renderChildren(captions) : node.attributes?.caption ? /* @__PURE__ */ jsx14("figcaption", { children: renderAttribute("caption") }) : null
+    ] });
+  }
+  const Caption = ({ children }) => /* @__PURE__ */ jsx14("figcaption", { children });
+  return {
+    name: "figures",
+    tags: ["figures", "figure", "figcaption", "caption", "img"],
+    directives: ["figures", "figure", "figcaption"],
+    scope: "local",
+    display: "block",
+    components: {
+      figures: Figures,
+      figure: Figure,
+      figcaption: Caption,
+      caption: Caption,
+      img: ({ node }) => /* @__PURE__ */ jsx14("img", { src: safeUrl(node.attributes?.src, true), alt: String(node.attributes?.alt ?? ""), loading: "lazy", decoding: "async" })
+    },
+    transform(root) {
+      const visit = (node) => {
+        if (node.type === "component" && node.name === "img") {
+          node.selection = "atomic";
+          node.inline = true;
+        }
+        if (node.type === "component" && node.name === "figure" && (node.attributes?.src || node.attributes?.url)) {
+          const image = node.attributeNodes?.[node.attributes.src ? "src" : "url"];
+          node.children = [{ type: "image", url: node.attributes.src ?? node.attributes.url, alt: node.attributes.alt ?? "", position: image?.position ?? node.position }, ...node.children ?? []];
+        }
+        node.children?.forEach(visit);
+      };
+      visit(root);
+    }
+  };
+}
+
+// src/extensions/blocks.tsx
+import { Fragment as Fragment5, jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+function parts(node, name) {
+  const result = [];
+  walk(node, (child) => {
+    if (child !== node && child.name === name) result.push(child);
+  });
+  return result;
+}
+var PassThrough = ({ children }) => /* @__PURE__ */ jsx15(Fragment5, { children });
+function definition(options = {}) {
+  function Definition({ node, children, renderChildren, renderAttribute }) {
+    const runtime = useRuntime();
+    const title = parts(node, "title")[0];
+    const content = parts(node, "content")[0];
+    return /* @__PURE__ */ jsxs12("aside", { className: "limr-definition", children: [
+      /* @__PURE__ */ jsx15("div", { className: "limr-card-label", "data-limr-ignore": "true", children: runtime.locale.definition }),
+      (title || node.attributes?.title) && /* @__PURE__ */ jsx15("div", { className: "limr-definition-title", children: title ? renderChildren(title.children ?? []) : renderAttribute("title") }),
+      /* @__PURE__ */ jsx15("div", { className: "limr-block-content", children: content ? renderChildren(content.children ?? []) : children })
+    ] });
+  }
+  return { ...defineBlock({ name: "definition", component: options.component ?? Definition }), tags: ["definition", "title", "content"], components: { definition: options.component ?? Definition, title: PassThrough, content: PassThrough } };
+}
+function question(options = {}) {
+  function Question({ node, children, renderChildren, renderAttribute }) {
+    const runtime = useRuntime();
+    const [showHint, setHint] = useState7(false), [showAnswer, setAnswer] = useState7(false);
+    const [selected, setSelected] = useState7([]), [checked, setChecked] = useState7(false);
+    const content = parts(node, "question-content")[0];
+    const hint = parts(node, "question-hint")[0];
+    const answer = parts(node, "question-answer")[0];
+    const group = parts(node, "question-sel-grp")[0];
+    const selections = parts(node, "question-sel");
+    const multi = String(group?.attributes?.multi ?? node.attributes?.multi ?? "false") === "true";
+    let correct = [];
+    try {
+      const value = JSON.parse(String(group?.attributes?.answer ?? node.attributes?.answer ?? "[]"));
+      correct = (Array.isArray(value) ? value : [value]).map(Number);
+    } catch {
+    }
+    const success = correct.length === selected.length && correct.every((index) => selected.includes(index));
+    return /* @__PURE__ */ jsxs12("section", { className: "limr-question", children: [
+      /* @__PURE__ */ jsx15("div", { className: "limr-card-label", "data-limr-ignore": "true", children: runtime.locale.question }),
+      node.attributes?.title && /* @__PURE__ */ jsx15("div", { className: "limr-question-title", children: renderAttribute("title") }),
+      /* @__PURE__ */ jsx15("div", { className: "limr-block-content", children: content ? renderChildren(content.children ?? []) : !selections.length && !hint && !answer ? children : null }),
+      selections.length > 0 && /* @__PURE__ */ jsxs12("fieldset", { className: "limr-question-options", children: [
+        /* @__PURE__ */ jsx15("legend", { className: "limr-sr-only", children: String(node.attributes?.title ?? runtime.locale.question) }),
+        selections.map((selection, index) => /* @__PURE__ */ jsxs12("label", { "data-selected": selected.includes(index) || void 0, "data-result": checked ? correct.includes(index) ? "correct" : selected.includes(index) ? "incorrect" : void 0 : void 0, children: [
+          /* @__PURE__ */ jsx15("input", { type: multi ? "checkbox" : "radio", name: `${runtime.document.id}-question-${rangeOf(node).start}`, checked: selected.includes(index), disabled: checked, onChange: () => {
+            setSelected(multi ? selected.includes(index) ? selected.filter((item) => item !== index) : [...selected, index] : [index]);
+          } }),
+          /* @__PURE__ */ jsx15(DiamondCheck, { checked: selected.includes(index) || checked && correct.includes(index) }),
+          /* @__PURE__ */ jsx15("span", { className: "limr-choice-text", children: renderChildren(selection.children ?? []) })
+        ] }, index))
+      ] }),
+      selections.length > 0 && correct.length > 0 && /* @__PURE__ */ jsxs12("div", { className: "limr-question-actions", "data-limr-ignore": "true", children: [
+        /* @__PURE__ */ jsx15("button", { type: "button", "data-checked": checked || void 0, disabled: !checked && !selected.length, onClick: () => {
+          if (checked) {
+            setChecked(false);
+            setSelected([]);
+            setAnswer(false);
+          } else {
+            setChecked(true);
+            setAnswer(true);
+          }
+        }, children: /* @__PURE__ */ jsx15("span", { className: "limr-button-label", children: checked ? runtime.locale.retry : runtime.locale.submit }, checked ? "retry" : "submit") }),
+        /* @__PURE__ */ jsx15(Collapse, { open: checked, children: /* @__PURE__ */ jsx15("span", { role: "status", className: `limr-question-result ${success ? "limr-success" : "limr-error"}`, children: success ? runtime.locale.correct : runtime.locale.incorrect }) })
+      ] }),
+      hint && /* @__PURE__ */ jsx15(Disclosure, { title: runtime.locale.hint, open: showHint, onChange: setHint, children: renderChildren(hint.children ?? []) }),
+      answer && /* @__PURE__ */ jsx15(Disclosure, { title: runtime.locale.answer, open: showAnswer, onChange: setAnswer, children: renderChildren(answer.children ?? []) })
+    ] });
+  }
+  const names2 = ["question-content", "question-hint", "question-answer", "question-sel-grp", "question-sel"];
+  return { ...defineBlock({ name: "question", component: options.component ?? Question }), tags: ["question", ...names2], components: { question: options.component ?? Question, ...Object.fromEntries(names2.map((name) => [name, PassThrough])) } };
+}
+function extras(options = {}) {
+  const Extra = ({ node, children, renderAttribute }) => /* @__PURE__ */ jsxs12("div", { className: "limr-extra", children: [
+    /* @__PURE__ */ jsxs12("a", { className: "limr-extra-link", href: safeUrl(node.attributes?.url), target: "_blank", rel: "noreferrer", children: [
+      /* @__PURE__ */ jsx15("span", { className: "limr-underline", children: renderAttribute(node.attributes?.title ? "title" : "url") }),
+      node.attributes?.desc && /* @__PURE__ */ jsx15("p", { children: /* @__PURE__ */ jsx15("span", { className: "limr-underline", children: renderAttribute("desc") }) })
+    ] }),
+    children
+  ] });
+  const Extras = ({ children }) => {
+    const runtime = useRuntime();
+    return /* @__PURE__ */ jsxs12("aside", { className: "limr-extras", children: [
+      /* @__PURE__ */ jsx15("div", { className: "limr-card-label", "data-limr-ignore": "true", children: runtime.locale.extra }),
+      children
+    ] });
+  };
+  return { ...defineBlock({ name: "extras", component: options.component ?? Extras }), tags: ["extras", "extra"], components: { extras: options.component ?? Extras, extra: Extra } };
+}
+
+// src/extensions/standard.ts
+function standard() {
+  return [gfm(), math(), codeHighlight(), definition(), question(), extras(), video(), figures(), citation(), translations()];
+}
+
+// src/react/context.tsx
+import { jsx as jsx16 } from "react/jsx-runtime";
+var defaults;
+var RuntimeContext = createContext2(null);
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect8;
+function DocumentProvider({ children, source = "", streaming = false, documentId, ...options }) {
+  const generatedId = useId();
+  const extensions = useMemo4(() => {
+    const base = options.extensions ?? (defaults ??= standard());
+    return options.plugins?.length ? [...base, ...options.plugins] : base;
+  }, [options.extensions, options.plugins]);
+  const config = { ...options, extensions };
+  const [runtime] = useState8(() => new ReaderRuntime(documentId ?? `limr-${generatedId.replace(/[^a-z\d_-]/gi, "")}`, source, streaming, config));
+  const previous = useRef11({ source, streaming, config });
+  useIsomorphicLayoutEffect(() => {
+    const old = previous.current;
+    const changed = Object.keys({ ...old.config, ...config }).some((key) => old.config[key] !== config[key]);
+    if (changed) runtime.configure(config);
+    if (old.source !== source || old.streaming !== streaming) runtime.document.update(source, { streaming });
+    previous.current = { source, streaming, config };
+  });
+  useEffect8(() => {
+    runtime.start();
+    return () => runtime.dispose();
+  }, [runtime]);
+  return /* @__PURE__ */ jsx16(RuntimeContext.Provider, { value: runtime, children });
+}
+function useRuntime() {
+  const runtime = useContext3(RuntimeContext);
+  if (!runtime) throw new Error("This LiMR component needs a DocumentProvider or Reader. Markdown can also be used on its own.");
+  return runtime;
+}
+function useRendererParameter(name) {
+  const runtime = useRuntime();
+  return useStoreSelector(runtime.configuration, (config) => {
+    if (config.parameters?.[name] !== void 0) return config.parameters[name];
+    for (let index = (config.extensions?.length ?? 0) - 1; index >= 0; index--) {
+      const parameters = config.extensions[index].parameters;
+      if (parameters && name in parameters) return parameters[name];
+    }
+    return void 0;
+  });
+}
+function useStoreSelector(store, select) {
+  const selectRef = useRef11(select);
+  selectRef.current = select;
+  const cache2 = useRef11(void 0);
+  const get = useCallback2(() => {
+    const state = store.get();
+    if (cache2.current && cache2.current.state === state && cache2.current.select === selectRef.current) return cache2.current.value;
+    const value = selectRef.current(state);
+    cache2.current = { state, select: selectRef.current, value };
+    return value;
+  }, [store]);
+  return useSyncExternalStore(store.subscribe, get, get);
+}
+function useDocument() {
+  const runtime = useRuntime();
+  return useSyncExternalStore(runtime.document.subscribe, runtime.document.getSnapshot, runtime.document.getSnapshot);
+}
+function useDocumentSelector(select) {
+  const runtime = useRuntime();
+  const store = useMemo4(() => ({ subscribe: runtime.document.subscribe, get: runtime.document.getSnapshot }), [runtime]);
+  return useStoreSelector(store, select);
+}
+function useSelection() {
+  return useStoreSelector(useRuntime().interaction, (state) => state.selection);
+}
+function useTheme() {
+  return useStoreSelector(useRuntime().configuration, (config) => config.theme ?? "light");
+}
+function useAppearance() {
+  return useStoreSelector(useRuntime().configuration, (config) => config.appearance ?? "classic");
+}
+function useLocale() {
+  const runtime = useRuntime();
+  useStoreSelector(runtime.configuration, (config) => config.locale);
+  return runtime.locale;
+}
+function useAnnotation(id) {
+  return useStoreSelector(useRuntime().decorations, (state) => state.annotations.get(id));
+}
+function useAnnotations() {
+  const state = useStoreSelector(useRuntime().decorations, (state2) => state2);
+  return useMemo4(() => ({ annotations: state.annotations, occurrences: state.occurrences }), [state.annotations, state.occurrences]);
+}
+function useAnnotationState() {
+  const runtime = useRuntime();
+  const active = useStoreSelector(runtime.interaction, (state) => state.active);
+  const hovered = useStoreSelector(runtime.interaction, (state) => state.hovered);
+  return { active, hovered, activate: (id) => runtime.activate(id), hover: (id) => runtime.hover(id) };
+}
+function useAnchor(id) {
+  const runtime = useRuntime();
+  useSyncExternalStore(runtime.layout.subscribe, runtime.layout.get, runtime.layout.get);
+  useSyncExternalStore(runtime.viewport.subscribe, runtime.viewport.get, runtime.viewport.get);
+  const element = runtime.anchors.get(id);
+  return { element: element ?? null, rect: element?.getBoundingClientRect() ?? null, contentRect: runtime.content?.getBoundingClientRect() ?? null };
+}
+function useLiMR() {
+  const runtime = useRuntime();
+  return useMemo4(() => ({
+    ...runtime.commands,
+    document: runtime.document,
+    get signal() {
+      return runtime.signal;
+    },
+    clearSelection: () => runtime.clearSelection(),
+    scrollToHeading: (id) => runtime.scrollToHeading(id),
+    scrollToAnnotation: (id) => runtime.scrollToOccurrence(id),
+    invalidateAnnotation: (id) => runtime.invalidateAnnotation(id)
+  }), [runtime]);
+}
+
+// src/components/CopyButton.tsx
+import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
+function CopyButton({ value = "", onCopy, label, variant = "plain", className = "" }) {
+  const locale = useLocale();
+  const [status, setStatus] = useState9("idle");
+  const timer = useRef12(void 0);
+  const mounted = useRef12(true);
+  const title = status === "copied" ? locale.copied : status === "error" ? locale.copyFailed : label ?? locale.copy;
+  useEffect9(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      clearTimeout(timer.current);
+    };
+  }, []);
+  const copy = async () => {
+    try {
+      if (onCopy) await onCopy();
+      else await navigator.clipboard.writeText(value);
+      if (!mounted.current) return;
+      setStatus("copied");
+    } catch {
+      if (!mounted.current) return;
+      setStatus("error");
+    }
+    clearTimeout(timer.current);
+    timer.current = setTimeout(() => setStatus("idle"), 2200);
+  };
+  return /* @__PURE__ */ jsxs13(
+    "button",
+    {
+      type: "button",
+      className: `limr-copy-button ${className}`,
+      "data-variant": variant,
+      "data-status": status,
+      "data-limr-ignore": "true",
+      "aria-label": title,
+      title,
+      onClick: copy,
+      children: [
+        /* @__PURE__ */ jsxs13("svg", { className: "limr-copy-glyph", viewBox: "0 0 24 24", fill: "none", "aria-hidden": "true", children: [
+          /* @__PURE__ */ jsxs13("g", { className: "limr-copy-sheets", children: [
+            /* @__PURE__ */ jsx17("rect", { x: "8.5", y: "8", width: "10.5", height: "12", rx: "3" }),
+            /* @__PURE__ */ jsx17("path", { d: "M15.5 8V6.8A2.8 2.8 0 0 0 12.7 4H7A3 3 0 0 0 4 7v6a3 3 0 0 0 3 3h1.5" })
+          ] }),
+          /* @__PURE__ */ jsx17("path", { className: "limr-copy-check", d: "m5.5 12 4.2 4.2 8.8-9", pathLength: "1" })
+        ] }),
+        /* @__PURE__ */ jsx17("span", { className: status === "error" ? "limr-copy-error" : "limr-sr-only", role: "status", children: status === "copied" ? locale.copied : status === "error" ? locale.copyFailed : "" })
+      ]
+    }
+  );
+}
+
+// src/extensions/math.tsx
+import { jsx as jsx18, jsxs as jsxs14 } from "react/jsx-runtime";
+var loaded;
+var loading;
+var load = () => loading ??= import("./math-renderer-L6DOH4RX.js").then((module) => {
+  loaded = module.default;
+  return module;
+});
+var MathContent = lazy(load);
+async function preloadMath() {
+  await load();
+}
+function math(options = {}) {
+  function MathNode({ node }) {
+    const display = node.type === "math";
+    const fallback = /* @__PURE__ */ jsx18("code", { className: "limr-math-source", children: node.value });
+    const Renderer = loaded ?? MathContent;
+    const content = /* @__PURE__ */ jsx18(Suspense, { fallback, children: /* @__PURE__ */ jsx18(Renderer, { value: node.value ?? "", display, options }) });
+    return display ? /* @__PURE__ */ jsxs14("div", { className: "limr-math-block", children: [
+      content,
+      /* @__PURE__ */ jsx18(CopyButton, { className: "limr-math-copy", variant: "glass", label: "Copy LaTeX", value: `$$
+${node.value ?? ""}
+$$` })
+    ] }) : content;
+  }
+  return { name: "math", micromark: [syntax2()], mdast: [mathFromMarkdown()], scope: "local", components: { math: MathNode, inlineMath: MathNode } };
+}
+
+// src/components/ToolIcon.tsx
+import { Fragment as Fragment6, jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
+function ToolIcon({ name, ...props }) {
+  return /* @__PURE__ */ jsx19("svg", { viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.7", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", ...props, children: /* @__PURE__ */ jsxs15("g", { transform: name === "highlight" ? "translate(0 -1.25)" : name === "comment" ? "translate(0 -.5)" : void 0, children: [
+    (name === "eye" || name === "eye-off") && /* @__PURE__ */ jsxs15(Fragment6, { children: [
+      /* @__PURE__ */ jsx19("path", { d: "M3 12s3.3-6 9-6 9 6 9 6-3.3 6-9 6-9-6-9-6Z" }),
+      /* @__PURE__ */ jsx19("circle", { cx: "12", cy: "12", r: "2.7" }),
+      name === "eye-off" && /* @__PURE__ */ jsx19("path", { d: "m4 4 16 16" })
+    ] }),
+    name === "question" && /* @__PURE__ */ jsxs15(Fragment6, { children: [
+      /* @__PURE__ */ jsx19("circle", { cx: "12", cy: "12", r: "8.5" }),
+      /* @__PURE__ */ jsx19("path", { d: "M9.4 9a2.7 2.7 0 0 1 5.2 1c0 1.8-2.6 2-2.6 3.7M12 17h.01" })
+    ] }),
+    name === "highlight" && /* @__PURE__ */ jsxs15(Fragment6, { children: [
+      /* @__PURE__ */ jsx19("path", { d: "m8 15 7.6-9a2 2 0 0 1 2.8-.2l.8.7a2 2 0 0 1 .2 2.8L12 18l-4-3Z" }),
+      /* @__PURE__ */ jsx19("path", { d: "m8 15-2 3 3 1 3-1M4 21h10M14 8l4 3.5" })
+    ] }),
+    name === "edit" && /* @__PURE__ */ jsx19(Fragment6, { children: /* @__PURE__ */ jsx19("path", { d: "m14.5 5.5 4 4M4.5 19.5l4.5-1 11-11a2.1 2.1 0 0 0 0-3 2.1 2.1 0 0 0-3 0l-11 11-1.5 4Z" }) }),
+    name === "close" && /* @__PURE__ */ jsx19("path", { d: "m6 6 12 12M18 6 6 18" }),
+    name === "copy" && /* @__PURE__ */ jsxs15(Fragment6, { children: [
+      /* @__PURE__ */ jsx19("rect", { x: "8.5", y: "8", width: "10.5", height: "12", rx: "3" }),
+      /* @__PURE__ */ jsx19("path", { d: "M15.5 8V6.8A2.8 2.8 0 0 0 12.7 4H7A3 3 0 0 0 4 7v6a3 3 0 0 0 3 3h1.5" })
+    ] }),
+    ["background", "underline", "dotted", "wavy"].includes(name) && /* @__PURE__ */ jsxs15(Fragment6, { children: [
+      name === "background" && /* @__PURE__ */ jsx19("rect", { x: "3", y: "3", width: "18", height: "18", rx: "5", fill: "currentColor", fillOpacity: ".13", stroke: "none" }),
+      /* @__PURE__ */ jsx19("path", { d: "m8 15 3-8a1.05 1.05 0 0 1 2 0l3 8M9.2 12h5.6" }),
+      name === "background" && /* @__PURE__ */ jsx19("path", { d: "M7 19h10", strokeWidth: "2.5" }),
+      name === "underline" && /* @__PURE__ */ jsx19("path", { d: "M5 20h14" }),
+      name === "dotted" && /* @__PURE__ */ jsx19("path", { d: "M5 20h14", strokeDasharray: ".1 3.4", strokeWidth: "2.4" }),
+      name === "wavy" && /* @__PURE__ */ jsx19("path", { d: "M4 20c1.3-2 2.7-2 4 0s2.7 2 4 0 2.7-2 4 0 2.7 2 4 0" })
+    ] }),
+    name === "chevron" && /* @__PURE__ */ jsx19("path", { d: "m8 10 4 4 4-4" }),
+    name === "check" && /* @__PURE__ */ jsx19("path", { d: "m5.5 12 4.2 4.2 8.8-9" }),
+    name === "trash" && /* @__PURE__ */ jsx19(Fragment6, { children: /* @__PURE__ */ jsx19("path", { d: "M4.5 7h15M9 7V5a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2M7 7l.7 12a2 2 0 0 0 2 2h4.6a2 2 0 0 0 2-2L17 7M10 11v6M14 11v6" }) }),
+    name === "note" && /* @__PURE__ */ jsxs15(Fragment6, { children: [
+      /* @__PURE__ */ jsx19("path", { d: "M14 3H7a3 3 0 0 0-3 3v12a3 3 0 0 0 3 3h10a3 3 0 0 0 3-3V9l-6-6Z" }),
+      /* @__PURE__ */ jsx19("path", { d: "M14 3v4a2 2 0 0 0 2 2h4M8 13h8M8 17h5" })
+    ] }),
+    name === "comment" && /* @__PURE__ */ jsxs15(Fragment6, { children: [
+      /* @__PURE__ */ jsx19("path", { d: "M8 19 4 21V7a3 3 0 0 1 3-3h10a3 3 0 0 1 3 3v9a3 3 0 0 1-3 3H8Z" }),
+      /* @__PURE__ */ jsx19("path", { d: "M8 9h8M8 13h5" })
+    ] }),
+    name === "footnote" && /* @__PURE__ */ jsxs15(Fragment6, { children: [
+      /* @__PURE__ */ jsx19("path", { d: "M5 7h9M5 11h12M5 15h8M5 20h14M18 4h2v5" }),
+      /* @__PURE__ */ jsx19("path", { d: "M17.5 9h4" })
+    ] }),
+    name === "sparkles" && /* @__PURE__ */ jsxs15(Fragment6, { children: [
+      /* @__PURE__ */ jsx19("path", { d: "m10.5 4 1.8 4.8 4.7 1.7-4.7 1.8-1.8 4.7-1.7-4.7L4 10.5l4.8-1.7L10.5 4Z" }),
+      /* @__PURE__ */ jsx19("path", { d: "m19 15 .8 2.2L22 18l-2.2.8L19 21l-.8-2.2L16 18l2.2-.8L19 15ZM19 3v4M17 5h4" })
+    ] })
+  ] }) });
+}
+
+// src/extensions/selection-actions.tsx
+import { jsx as jsx20, jsxs as jsxs16 } from "react/jsx-runtime";
+var highlightColors = [
+  { color: "#E57373", label: "Rose", labelZh: "\u73AB\u7470" },
+  { color: "#F2C744", label: "Gold", labelZh: "\u6696\u9EC4" },
+  { color: "#81B29A", label: "Sage", labelZh: "\u9F20\u5C3E\u8349" },
+  { color: "#6B9BD2", label: "Blue", labelZh: "\u96FE\u84DD" },
+  { color: "#B39DDB", label: "Lavender", labelZh: "\u85B0\u8863\u8349" },
+  { color: "#E5A06E", label: "Apricot", labelZh: "\u674F\u6A59" },
+  { color: "#61AAA5", label: "Teal", labelZh: "\u9752\u74F7" }
+];
+function copyText(options = {}) {
+  return {
+    id: `copy-${options.format ?? "text"}`,
+    label: options.label ?? ((context) => context.locale.copy),
+    icon: /* @__PURE__ */ jsx20(ToolIcon, { name: "copy" }),
+    successLabel: (context) => context.locale.copied,
+    successIcon: /* @__PURE__ */ jsx20(ToolIcon, { name: "check" }),
+    run: async ({ selection }) => {
+      const format = options.format ?? "text";
+      await navigator.clipboard.writeText(format === "text" ? selection.text : selection[format].sourceText);
+    }
+  };
+}
+function HighlightSettings({ context, options }) {
+  const { locale, highlight, highlightAppearance } = context;
+  const color = highlightAppearance.color ?? defaultHighlight.color;
+  const style = highlightAppearance.style ?? "background";
+  const styles = [
+    ["background", locale.highlightBackground],
+    ["underline", locale.highlightUnderline],
+    ["dotted", locale.highlightDotted],
+    ["wavy", locale.highlightWavy]
+  ];
+  const change = (nextColor, nextStyle) => {
+    const appearance = { ...highlightAppearance, color: nextColor, style: nextStyle };
+    context.setHighlightAppearance(appearance);
+    if (highlight) void context.run((current) => current.updateAnnotation(highlight.id, { data: appearance }));
+  };
+  return /* @__PURE__ */ jsxs16("div", { className: "limr-highlight-settings", children: [
+    /* @__PURE__ */ jsxs16("fieldset", { disabled: context.busy, children: [
+      /* @__PURE__ */ jsx20("legend", { children: locale.highlightStyle }),
+      /* @__PURE__ */ jsx20("div", { className: "limr-highlight-styles", children: styles.map(([value, label]) => /* @__PURE__ */ jsxs16("button", { type: "button", "aria-pressed": style === value, onClick: () => change(color, value), children: [
+        /* @__PURE__ */ jsx20(ToolIcon, { name: value }),
+        /* @__PURE__ */ jsx20("span", { className: "limr-highlight-style-label", children: /* @__PURE__ */ jsx20("span", { className: "limr-underline", children: label }) })
+      ] }, value)) })
+    ] }),
+    /* @__PURE__ */ jsxs16("fieldset", { disabled: context.busy, children: [
+      /* @__PURE__ */ jsx20("legend", { children: locale.highlightColor }),
+      /* @__PURE__ */ jsx20("div", { className: "limr-highlight-colors", children: (options.colors ?? highlightColors).map((item) => /* @__PURE__ */ jsx20("button", { type: "button", className: "limr-color-swatch", "aria-label": locale.highlight === "\u9AD8\u4EAE" ? item.labelZh ?? item.label : item.label, title: locale.highlight === "\u9AD8\u4EAE" ? item.labelZh ?? item.label : item.label, "aria-pressed": color.toLowerCase() === item.color.toLowerCase(), style: { "--swatch": item.color }, onClick: () => change(item.color, style), children: /* @__PURE__ */ jsx20(ToolIcon, { name: "check" }) }, item.color)) })
+    ] })
+  ] });
+}
+function highlightPalette(options = {}) {
+  return {
+    id: "highlight-palette",
+    label: (context) => context.locale.editHighlight,
+    icon: /* @__PURE__ */ jsx20(ToolIcon, { name: "background" }),
+    placement: "start",
+    render: (context) => /* @__PURE__ */ jsx20("button", { type: "button", className: "limr-toolbar-swatch", "aria-label": context.locale.editHighlight, "aria-expanded": context.expanded, disabled: context.busy, onClick: () => context.expanded ? context.collapse() : context.expand(), style: { "--swatch": context.highlightAppearance.color ?? defaultHighlight.color } }),
+    renderExpanded: (context) => /* @__PURE__ */ jsx20(HighlightSettings, { context, options })
+  };
+}
+function highlightSelection() {
+  return {
+    id: "highlight",
+    label: (context) => !context.highlight ? context.locale.addHighlight : context.highlight.data?.hidden ? context.locale.showHighlight : context.locale.hideHighlight,
+    icon: (context) => /* @__PURE__ */ jsx20(ToolIcon, { name: !context.highlight ? "highlight" : context.highlight.data?.hidden ? "eye" : "eye-off" }),
+    visible: (context) => !context.highlight || context.annotations.some((annotation) => annotation.type !== "highlight"),
+    run: (context) => {
+      if (context.highlight) context.updateAnnotation(context.highlight.id, { data: { ...context.highlight.data, hidden: !context.highlight.data?.hidden } });
+      else {
+        context.addAnnotation({ id: `highlight-${crypto.randomUUID()}`, type: "highlight", data: { ...context.highlightAppearance, hidden: false }, anchors: context.selection.syntax.ranges.map((range) => ({ range, documentId: context.document.id, quote: context.document.source.slice(range.start, range.end) })) });
+        context.clearSelection();
+      }
+    }
+  };
+}
+function deleteAnnotations() {
+  return {
+    id: "delete-annotations",
+    label: (context) => context.locale.deleteAnnotations,
+    icon: /* @__PURE__ */ jsx20(ToolIcon, { name: "trash" }),
+    placement: "end",
+    tone: "danger",
+    visible: (context) => context.annotations.length > 0,
+    run: (context) => {
+      context.removeAnnotationsAt([...context.selection.raw.ranges, ...context.selection.syntax.ranges]);
+      context.activateAnnotation(null);
+      context.clearSelection();
+    }
+  };
+}
+
+export {
+  scrollWithMotion,
+  english,
+  chinese,
+  gfm,
+  preloadMath,
+  math,
+  codeHighlight,
+  sourceRangeStartRect,
+  Markdown,
+  OverlayScrollArea,
+  AnnotationCard,
+  AnnotationMarkdown,
+  citation,
+  InlineMarker,
+  Collapse,
+  translations,
+  defineBlock,
+  defineAnnotation,
+  defineExtension,
+  video,
+  figures,
+  definition,
+  question,
+  extras,
+  standard,
+  useIsomorphicLayoutEffect,
+  DocumentProvider,
+  useRuntime,
+  useRendererParameter,
+  useStoreSelector,
+  useDocument,
+  useDocumentSelector,
+  useSelection,
+  useTheme,
+  useAppearance,
+  useLocale,
+  useAnnotation,
+  useAnnotations,
+  useAnnotationState,
+  useAnchor,
+  useLiMR,
+  ToolIcon,
+  highlightColors,
+  copyText,
+  highlightPalette,
+  highlightSelection,
+  deleteAnnotations
+};
+//# sourceMappingURL=chunk-3ILUZKDB.js.map