@nulib/clover 0.0.0-stage → 4.0.0-beta.0

package/dist/components/Transcript/Transcript.mjs

@@ -0,0 +1,377 @@
+"use client";
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { forwardRef, useMemo, useState, useEffect, useSyncExternalStore, useRef } from "react";
+import { useUniqueId } from "../../ui/useUniqueId.mjs";
+import { createPortal } from "react-dom";
+import { canvasCaptions, canvasTextTranscripts } from "../Canvas/layout.mjs";
+import { selectVisibleCanvases } from "../../core/selectors.mjs";
+import { localize } from "../../core/value.mjs";
+import { loadVtt, loadText, parseVtt, paragraphsOf, cueAt } from "../../core/vtt.mjs";
+import { useCloverTranslation } from "../../i18n/useCloverTranslation.mjs";
+import { join } from "../../lib/classnames.mjs";
+import { playFrom } from "../../lib/time.mjs";
+import { useClover, useCloverSelector } from "../../react/context.mjs";
+import { bringIntoView, scrollerOf } from "../../ui/bringIntoView.mjs";
+import { CueTime } from "../../ui/Cue.mjs";
+import { FieldPill } from "../../ui/FieldPill.mjs";
+import { languageCode } from "../../ui/languageCode.mjs";
+import { useSectionActions } from "../../ui/Sections.mjs";
+import { Tip } from "../../ui/Tip.mjs";
+import { useContainerName } from "../../ui/useContainerName.mjs";
+import { visuallyHidden } from "../../ui/visuallyHidden.mjs";
+const CHUNK = 40;
+const fold = (text) => text.toLocaleLowerCase();
+function marked(text, query) {
+  if (!query) return text;
+  const folded = fold(text);
+  const parts = [];
+  let from = 0;
+  for (let at = folded.indexOf(query); at >= 0; at = folded.indexOf(query, at + query.length)) {
+    if (at > from) parts.push(text.slice(from, at));
+    parts.push(/* @__PURE__ */ jsx("mark", { children: text.slice(at, at + query.length) }, at));
+    from = at + query.length;
+  }
+  if (from < text.length) parts.push(text.slice(from));
+  return parts;
+}
+const Transcript = forwardRef(
+  function Transcript2({
+    as: Tag = "div",
+    follow = true,
+    find = true,
+    sticky = false,
+    size = "large",
+    className,
+    ...rest
+  }, ref) {
+    const { t, langOf } = useCloverTranslation();
+    const { clover, language } = useClover("Transcript");
+    const canvases = useCloverSelector(
+      (state) => selectVisibleCanvases(state.manifest, state.canvasId)
+    );
+    const canvas = canvases.find(
+      (candidate) => canvasCaptions(candidate).length > 0 || canvasTextTranscripts(candidate).length > 0
+    );
+    const tracks = useMemo(
+      () => canvas ? [
+        ...canvasCaptions(canvas).map((each) => ({
+          ...each,
+          kind: "captions"
+        })),
+        ...canvasTextTranscripts(canvas).map((each) => ({
+          ...each,
+          kind: "text"
+        }))
+      ] : [],
+      [canvas]
+    );
+    const [choice, setChoice] = useState(0);
+    const track = tracks[choice] ?? tracks[0];
+    useEffect(() => {
+      const follow2 = (id2) => {
+        const index = tracks.findIndex(
+          (option) => option.kind === "captions" && option.id === id2
+        );
+        if (index >= 0) setChoice(index);
+      };
+      follow2(clover.captions.get());
+      return clover.captions.subscribe(follow2);
+    }, [clover, tracks]);
+    const [cues, setCues] = useState([]);
+    const [paragraphs, setParagraphs] = useState([]);
+    useEffect(() => {
+      setCues([]);
+      setParagraphs([]);
+      if (!track) return;
+      let live = true;
+      (track.kind === "captions" ? loadVtt(track.id, clover.request).then(
+        (text) => live && setCues(parseVtt(text))
+      ) : loadText(track.id, clover.request).then(
+        (text) => live && setParagraphs(paragraphsOf(text))
+      )).catch(() => void 0);
+      return () => {
+        live = false;
+      };
+    }, [track, clover]);
+    const element = useSyncExternalStore(
+      clover.media.subscribe,
+      clover.media.get,
+      clover.media.get
+    );
+    const active = useActiveCue(element, cues);
+    const list = useRef(null);
+    useEffect(() => {
+      var _a;
+      if (!follow || active < 0 || !element || element.paused) return;
+      const item = (_a = list.current) == null ? void 0 : _a.children[active];
+      if (item) bringIntoView(item, "nearest");
+    }, [active, follow, element]);
+    const [draft, setDraft] = useState("");
+    const query = fold(draft.trim());
+    const matches = useMemo(
+      () => query ? cues.flatMap(
+        (cue, index) => fold(cue.text).includes(query) ? [index] : []
+      ) : [],
+      [cues, query]
+    );
+    const [match, setMatch] = useState({
+      query: "",
+      at: 0
+    });
+    const at = match.query === query ? match.at : 0;
+    const field = useRef(null);
+    const stepped = useRef(false);
+    const [more, setMore] = useState({
+      cues: [],
+      count: CHUNK
+    });
+    const limit = more.cues === cues ? more.count : CHUNK;
+    const extend = () => setMore({ cues, count: limit + CHUNK });
+    const extendRef = useRef(extend);
+    extendRef.current = extend;
+    const lazy = typeof IntersectionObserver !== "undefined";
+    const drawn = lazy ? Math.min(
+      cues.length,
+      Math.max(limit, active + 1, (matches[at] ?? -1) + 1)
+    ) : cues.length;
+    const end = useRef(null);
+    useEffect(() => {
+      const node = end.current;
+      if (!node || !lazy || drawn >= cues.length) return;
+      const observer = new IntersectionObserver(
+        (entries) => {
+          if (entries.some((entry) => entry.isIntersecting))
+            extendRef.current();
+        },
+        { root: scrollerOf(node), rootMargin: "0px 0px 400px 0px" }
+      );
+      observer.observe(node);
+      return () => observer.disconnect();
+    }, [lazy, drawn, cues.length]);
+    const currentMatch = matches[at];
+    useEffect(() => {
+      var _a;
+      if (currentMatch === void 0) return;
+      const item = (_a = list.current) == null ? void 0 : _a.children[currentMatch];
+      if (item) bringIntoView(item, "nearest");
+      stepped.current = false;
+    }, [currentMatch, query]);
+    const hasCues = cues.length > 0;
+    useEffect(() => {
+      var _a;
+      const held = (_a = field.current) == null ? void 0 : _a.closest(
+        ".clover-transcript-find"
+      );
+      const part = held == null ? void 0 : held.parentElement;
+      if (!sticky || !held || !part || typeof ResizeObserver === "undefined")
+        return;
+      const observer = new ResizeObserver(
+        () => part.style.setProperty(
+          "--clover-transcript-find",
+          `${held.offsetHeight}px`
+        )
+      );
+      observer.observe(held);
+      return () => {
+        observer.disconnect();
+        part.style.removeProperty("--clover-transcript-find");
+      };
+    }, [sticky, hasCues, find]);
+    const id = useUniqueId();
+    const actions = useSectionActions();
+    const nameKey = tracks.every((each) => each.kind === "captions") ? "playerCaptions" : "transcriptLabel";
+    const name = useContainerName(t(nameKey), langOf(nameKey));
+    if (!canvas || !track) return null;
+    const texts = tracks.filter((each) => each.kind === "text").length;
+    const shown = tracks.map((each) => {
+      const code = languageCode(each.language);
+      if (each.kind === "captions") return code;
+      return texts > 1 && code ? `TXT ${code}` : "TXT";
+    });
+    const codes = shown.map(
+      (code) => code && shown.filter((each) => each === code).length === 1 ? code : void 0
+    );
+    const lang = track.language && track.language !== "none" ? track.language : void 0;
+    const languages = tracks.length > 1 && /* @__PURE__ */ jsxs(Fragment, { children: [
+      name.node,
+      /* @__PURE__ */ jsx("fieldset", { ...name.props, className: "clover-transcript-languages", children: tracks.map((option, index) => {
+        const label = localize(option.label, language);
+        const code = codes[index];
+        const text = label.text || option.language || String(index + 1);
+        return /* @__PURE__ */ jsxs("label", { className: "clover-transcript-language", children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "radio",
+              name: `${id}-language`,
+              checked: index === choice,
+              onChange: () => {
+                setChoice(index);
+                if (option.kind === "captions")
+                  clover.captions.emit(option.id);
+              }
+            }
+          ),
+          code && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx("span", { className: "clover-transcript-code", children: code }),
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              style: code ? visuallyHidden : void 0,
+              lang: label.text ? label.lang : void 0,
+              children: text
+            }
+          ),
+          code && label.text && /* @__PURE__ */ jsx(Tip, { label: label.text, lang: label.lang })
+        ] }, option.id);
+      }) })
+    ] });
+    const seek = (cue, play = true) => {
+      if (element) {
+        if (play) playFrom(element, cue.start);
+        else element.currentTime = cue.start;
+        return;
+      }
+      clover.goTo(canvas.id, { time: cue.start });
+    };
+    const go = (index) => {
+      const cue = cues[matches[index]];
+      if (!cue) return;
+      stepped.current = true;
+      setMatch({ query, at: index });
+      seek(cue, false);
+    };
+    const steps = {
+      position: matches.length ? at : -1,
+      total: matches.length,
+      step: (by) => go(at + by)
+    };
+    const count = matches.length;
+    const statusKey = !query ? null : count === 0 ? "contentSearchResultsNone" : count === 1 ? "contentSearchResult" : "contentSearchResults";
+    const finding = find && track.kind === "captions" && cues.length > 0 && /* @__PURE__ */ jsxs("div", { className: "clover-transcript-find", children: [
+      /* @__PURE__ */ jsx(
+        FieldPill,
+        {
+          ref: field,
+          id: `${id}-find`,
+          value: draft,
+          onChange: setDraft,
+          onSubmit: () => {
+            if (!count) return;
+            const gone = match.query === query && stepped.current;
+            go(gone ? (at + 1) % count : at);
+          },
+          onClear: () => {
+            var _a;
+            setDraft("");
+            (_a = field.current) == null ? void 0 : _a.focus();
+          },
+          results: query ? steps : null,
+          size,
+          classes: { form: "clover-transcript-find-field" }
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "p",
+        {
+          className: "clover-transcript-find-status",
+          role: "status",
+          lang: statusKey ? langOf(statusKey) : void 0,
+          children: statusKey ? t(statusKey, { count }) : ""
+        }
+      )
+    ] });
+    return /* @__PURE__ */ jsxs(
+      Tag,
+      {
+        ref,
+        className: join("clover-transcript", className),
+        "data-sticky": sticky || void 0,
+        ...rest,
+        children: [
+          languages && (actions ? createPortal(languages, actions) : languages),
+          finding,
+          track.kind === "text" ? (
+            // Untimed: the words alone, a paragraph each, nothing to press.
+            /* @__PURE__ */ jsx("div", { className: "clover-transcript-body", lang, children: paragraphs.map((paragraph, index) => /* @__PURE__ */ jsx("p", { children: paragraph }, index)) })
+          ) : /* @__PURE__ */ jsx(
+            "ol",
+            {
+              ref: list,
+              className: "clover-transcript-cues",
+              id: `${id}-cues`,
+              lang,
+              children: cues.slice(0, drawn).map((cue, index) => /* @__PURE__ */ jsx(
+                "li",
+                {
+                  className: "clover-transcript-cue",
+                  "aria-current": index === active ? "true" : void 0,
+                  "data-match": query && matches.includes(index) ? index === currentMatch ? "current" : "true" : void 0,
+                  children: /* @__PURE__ */ jsxs(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: () => seek(cue),
+                      onFocus: () => {
+                        if (drawn < cues.length && index >= drawn - 5) extend();
+                      },
+                      children: [
+                        /* @__PURE__ */ jsx(
+                          CueTime,
+                          {
+                            start: cue.start,
+                            className: "clover-transcript-time"
+                          }
+                        ),
+                        /* @__PURE__ */ jsxs("span", { className: "clover-transcript-text clover-cue-text", children: [
+                          cue.voice && /* @__PURE__ */ jsxs("span", { className: "clover-transcript-voice", children: [
+                            cue.voice,
+                            ":",
+                            " "
+                          ] }),
+                          marked(cue.text, query)
+                        ] })
+                      ]
+                    }
+                  )
+                },
+                `${cue.start}-${index}`
+              ))
+            }
+          ),
+          track.kind === "captions" && drawn < cues.length && /* @__PURE__ */ jsx(
+            "div",
+            {
+              ref: end,
+              className: "clover-transcript-more",
+              "aria-hidden": "true"
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+function useActiveCue(element, cues) {
+  const [active, setActive] = useState(-1);
+  useEffect(() => {
+    if (!element || !cues.length) {
+      setActive(-1);
+      return;
+    }
+    const update = () => setActive(cueAt(cues, element.currentTime));
+    update();
+    element.addEventListener("timeupdate", update);
+    element.addEventListener("seeked", update);
+    return () => {
+      element.removeEventListener("timeupdate", update);
+      element.removeEventListener("seeked", update);
+    };
+  }, [element, cues]);
+  return active;
+}
+export {
+  Transcript
+};

package/dist/components/Viewer/Viewer.mjs

@@ -0,0 +1,19 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { lazy, Suspense } from "react";
+const LazyDefault = lazy(
+  () => import("../../templates/default/Default.mjs").then((module) => ({
+    default: module.Default
+  }))
+);
+function Viewer({
+  template,
+  ...props
+}) {
+  const Template = template ?? LazyDefault;
+  const drawn = /* @__PURE__ */ jsx(Template, { ...props });
+  return template ? drawn : /* @__PURE__ */ jsx(Suspense, { fallback: null, children: drawn });
+}
+export {
+  Viewer
+};

package/dist/core/annotation-bodies.mjs

@@ -0,0 +1,29 @@
+"use client";
+import { bodiesOf } from "./painting.mjs";
+import { asArray } from "../lib/asArray.mjs";
+const isCaptionFile = (body) => (body == null ? void 0 : body.format) === "text/vtt" || typeof (body == null ? void 0 : body.id) === "string" && /\.vtt(\?|$)/i.test(body.id);
+function readBodies(annotation) {
+  const bodies = [];
+  for (let body of bodiesOf(annotation)) {
+    if ((body == null ? void 0 : body.type) === "Choice") body = asArray(body.items)[0];
+    if (!body || isCaptionFile(body)) continue;
+    if (body.type === "TextualBody" || typeof body.value === "string") {
+      bodies.push({
+        value: String(body.value ?? ""),
+        format: body.format,
+        language: asArray(body.language)[0]
+      });
+    } else if (body.type === "Image" && body.id) {
+      const label = body.label ?? annotation.label;
+      bodies.push({
+        image: body.id,
+        format: body.format,
+        ...label ? { label } : {}
+      });
+    }
+  }
+  return bodies;
+}
+export {
+  readBodies
+};

package/dist/core/annotation-collection.mjs

@@ -0,0 +1,55 @@
+"use client";
+import { readPage } from "./annotation-sets.mjs";
+import { upgradePage } from "./pages.mjs";
+import { fetchJson } from "./request.mjs";
+import { asArray } from "../lib/asArray.mjs";
+const MAX_PAGES = 100;
+async function resolve(item, request, signal) {
+  if (typeof item === "string") {
+    return await fetchJson(request, item, signal);
+  }
+  const json = item;
+  if ((json == null ? void 0 : json.id) && json.type === "AnnotationPage" && !json.items) {
+    return await fetchJson(request, json.id, signal);
+  }
+  return json;
+}
+async function pagesOf(json, request, signal) {
+  const type = String((json == null ? void 0 : json.type) ?? (json == null ? void 0 : json["@type"]) ?? "");
+  const collection = /AnnotationCollection/.test(type);
+  const pages = collection ? [] : [json];
+  const seen = new Set(collection ? [] : [json.id]);
+  let next = collection ? json.first : json.next;
+  while (next && pages.length < MAX_PAGES) {
+    const id = typeof next === "string" ? next : next.id;
+    if (seen.has(id ?? next)) break;
+    seen.add(id ?? next);
+    const page = await resolve(next, request, signal);
+    pages.push(page);
+    next = page.next;
+  }
+  return pages;
+}
+async function loadAnnotationSets(input, { request, signal } = {}) {
+  const sets = [];
+  for (const item of asArray(input)) {
+    const json = await resolve(item, request, signal);
+    for (const raw of await pagesOf(json, request, signal)) {
+      const page = await upgradePage(raw);
+      const id = page.id ?? `added-${sets.length}`;
+      const entries = readPage(page, id);
+      if (entries.length) {
+        sets.push({
+          id,
+          label: page.label ?? json.label,
+          source: "added",
+          entries
+        });
+      }
+    }
+  }
+  return sets;
+}
+export {
+  loadAnnotationSets
+};

package/dist/core/annotation-name.mjs

@@ -0,0 +1,31 @@
+"use client";
+import { toPlainText, readAs, markdownToPlainText } from "./text.mjs";
+import { localize } from "./value.mjs";
+function annotationName(bodies, language) {
+  const named = (text2, lang) => text2 ? { text: text2, ...lang ? { lang } : {} } : {};
+  const texts = bodies.filter((body2) => {
+    var _a;
+    return (_a = body2.value) == null ? void 0 : _a.trim();
+  });
+  if (!texts.length) {
+    const image = bodies.find((body2) => body2.image && body2.label);
+    if (!image) return {};
+    const { text: text2, lang } = localize(image.label, language);
+    return named(toPlainText(text2).trim(), lang);
+  }
+  const tagOf = (body2) => body2.language && body2.language !== "none" ? body2.language : "none";
+  const first = {};
+  texts.forEach((body2, index) => {
+    var _a;
+    first[_a = tagOf(body2)] ?? (first[_a] = [String(index)]);
+  });
+  const body = texts[Number(localize(first, language).text) || 0];
+  const value = body.value;
+  const kind = readAs(body.format, value);
+  const text = kind === "markdown" ? markdownToPlainText(value) : kind === "html" ? toPlainText(value) : value;
+  const tag = tagOf(body);
+  return named(text.trim(), tag === "none" ? void 0 : tag);
+}
+export {
+  annotationName
+};

package/dist/core/annotation-sets.mjs

@@ -0,0 +1,155 @@
+"use client";
+import { isRegionText, parseAnnotationTarget } from "./annotations.mjs";
+import { readBodies } from "./annotation-bodies.mjs";
+import { asArray } from "../lib/asArray.mjs";
+import { SEARCH_SET_ID } from "./search-service.mjs";
+import { selectCanvas, selectSequence } from "./selectors.mjs";
+const isLinking = (annotation) => asArray(annotation == null ? void 0 : annotation.motivation).includes("linking");
+function readPage(page, setId, fallbackCanvasId) {
+  const entries = [];
+  for (const annotation of asArray(page == null ? void 0 : page.items)) {
+    const motivation = asArray(annotation == null ? void 0 : annotation.motivation);
+    if (motivation.includes("painting")) continue;
+    const bodies = readBodies(annotation);
+    if (!bodies.length && !isLinking(annotation)) continue;
+    const target = parseAnnotationTarget(asArray(annotation.target)[0]);
+    const canvasId = target.id || fallbackCanvasId;
+    if (!canvasId || !annotation.id) continue;
+    entries.push({
+      id: annotation.id,
+      setId,
+      canvasId,
+      target,
+      motivation,
+      bodies,
+      annotation
+    });
+  }
+  return entries;
+}
+const manifestSets = /* @__PURE__ */ new WeakMap();
+function selectManifestSets(manifest) {
+  if (!manifest) return [];
+  let sets = manifestSets.get(manifest);
+  if (!sets) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const canvas of selectSequence(manifest).canvases) {
+      for (const page of asArray(canvas.annotations)) {
+        if (!Array.isArray(page == null ? void 0 : page.items)) continue;
+        const id = page.id ?? `${canvas.id}#annotations`;
+        let set = byId.get(id);
+        if (!set) {
+          set = { id, label: page.label, source: "manifest", entries: [] };
+          byId.set(id, set);
+        }
+        set.entries.push(...readPage(page, id, canvas.id));
+      }
+    }
+    sets = [...byId.values()].filter((set) => set.entries.length);
+    manifestSets.set(manifest, sets);
+  }
+  return sets;
+}
+const allSets = /* @__PURE__ */ new WeakMap();
+const NO_SETS = [];
+function selectAnnotationSets(manifest, added) {
+  const own = selectManifestSets(manifest);
+  if (!added.length) return own.length ? own : NO_SETS;
+  const key = manifest ?? NO_SETS;
+  let byAdded = allSets.get(key);
+  if (!byAdded) allSets.set(key, byAdded = /* @__PURE__ */ new Map());
+  let sets = byAdded.get(added);
+  if (!sets) {
+    sets = [...own, ...added];
+    byAdded.set(added, sets);
+  }
+  return sets;
+}
+const drawnSets = /* @__PURE__ */ new WeakMap();
+function selectDrawnSets(manifest, added, searchSet) {
+  const sets = selectAnnotationSets(manifest, added);
+  if (!(searchSet == null ? void 0 : searchSet.entries.length)) return sets;
+  let bySearch = drawnSets.get(sets);
+  if (!bySearch) drawnSets.set(sets, bySearch = /* @__PURE__ */ new Map());
+  let drawn = bySearch.get(searchSet);
+  if (!drawn) {
+    drawn = [...sets, searchSet];
+    bySearch.set(searchSet, drawn);
+  }
+  return drawn;
+}
+const plays = (canvas) => Number(canvas == null ? void 0 : canvas.duration) > 0;
+function startsHidden(set, canvasOf) {
+  if (set.source === "search" || !set.entries.length) return false;
+  return set.entries.every(
+    (entry) => isRegionText(entry.motivation, entry.target) && !plays(canvasOf(entry.canvasId))
+  );
+}
+const listedOf = /* @__PURE__ */ new WeakMap();
+function selectListedSets(manifest, added) {
+  const sets = selectAnnotationSets(manifest, added);
+  let listed = listedOf.get(sets);
+  if (!listed) {
+    const kept = sets.filter(
+      (set) => !startsHidden(set, (id) => selectCanvas(manifest, id) ?? void 0)
+    );
+    listed = kept.length === sets.length ? sets : kept;
+    listedOf.set(sets, listed);
+  }
+  return listed;
+}
+const hiddenOf = /* @__PURE__ */ new WeakMap();
+function selectHiddenSets(manifest, added, hidden, shown) {
+  const sets = selectAnnotationSets(manifest, added);
+  const cached = hiddenOf.get(sets);
+  if (cached && cached.hidden === hidden && cached.shown === shown)
+    return cached.ids;
+  const quiet = sets.filter(
+    (set) => !hidden.includes(set.id) && !shown.includes(set.id) && startsHidden(set, (id) => selectCanvas(manifest, id) ?? void 0)
+  ).map((set) => set.id);
+  const ids = quiet.length ? [...hidden, ...quiet] : hidden;
+  hiddenOf.set(sets, { hidden, shown, ids });
+  return ids;
+}
+const unlistedOf = /* @__PURE__ */ new WeakMap();
+function selectUnlistedSets(manifest, added, hidden, shown) {
+  const drawnHidden = selectHiddenSets(manifest, added, hidden, shown);
+  const cached = unlistedOf.get(drawnHidden);
+  if (cached && cached.hidden === hidden) return cached.ids;
+  const ids = [
+    SEARCH_SET_ID,
+    ...drawnHidden.filter((id) => !hidden.includes(id))
+  ];
+  unlistedOf.set(drawnHidden, { hidden, ids });
+  return ids;
+}
+function manifestOfAnnotation(annotation) {
+  for (const target of asArray(annotation == null ? void 0 : annotation.target)) {
+    const source = (target == null ? void 0 : target.type) === "SpecificResource" ? target.source : target;
+    const part = asArray(source == null ? void 0 : source.partOf).find(
+      (each) => (each == null ? void 0 : each.id) && (!each.type || each.type === "Manifest")
+    );
+    if (part) return part.id;
+  }
+  return void 0;
+}
+function findEntry(sets, id) {
+  if (!id) return null;
+  for (const set of sets) {
+    const entry = set.entries.find((candidate) => candidate.id === id);
+    if (entry) return entry;
+  }
+  return null;
+}
+export {
+  findEntry,
+  manifestOfAnnotation,
+  readPage,
+  selectAnnotationSets,
+  selectDrawnSets,
+  selectHiddenSets,
+  selectListedSets,
+  selectManifestSets,
+  selectUnlistedSets,
+  startsHidden
+};

package/dist/core/annotations-content.mjs

@@ -0,0 +1,27 @@
+"use client";
+import { loadAnnotationSets } from "./annotation-collection.mjs";
+import { manifestOfAnnotation } from "./annotation-sets.mjs";
+import { CloverContentError, loadManifest } from "./load.mjs";
+async function annotationsContent(json, options) {
+  const annotationSets = await loadAnnotationSets(json, options);
+  const entries = annotationSets.flatMap((set) => set.entries);
+  const first = entries.find(
+    (entry) => options.manifestId && manifestOfAnnotation(entry.annotation) === options.manifestId
+  ) ?? entries.find((entry) => manifestOfAnnotation(entry.annotation));
+  if (!first) {
+    throw new CloverContentError("The annotations name no Manifest");
+  }
+  const manifest = await loadManifest(
+    { id: manifestOfAnnotation(first.annotation), type: "Manifest" },
+    options
+  );
+  return {
+    manifest,
+    target: { canvasId: first.canvasId },
+    annotationSets,
+    pick: first.id
+  };
+}
+export {
+  annotationsContent
+};