@nulib/clover 4.1.0 → 4.3.0

package/dist/core/presentation.mjs

@@ -8,18 +8,17 @@ function isPresentation4(resource) {
   );
 }
 let upgrader = null;
+let reader = null;
 function preloadUpgrader() {
+  reader ?? (reader = import("./upgrade.mjs"));
   upgrader ?? (upgrader = import("@iiif/parser/presentation-4/upgrader").then(
     ({ upgradePresentation3To4 }) => upgradePresentation3To4
   ));
-  return upgrader;
+  return Promise.all([upgrader, reader]);
 }
 async function toPresentation4(resource) {
   if (isPresentation4(resource)) return resource;
-  const [toFour, { upgrade }] = await Promise.all([
-    preloadUpgrader(),
-    import("./upgrade.mjs")
-  ]);
+  const [toFour, { upgrade }] = await preloadUpgrader();
   return await upgrade(resource, toFour);
 }
 export {

package/dist/core/sanitize.mjs

@@ -1,5 +1,6 @@
 "use client";
 import DOMPurify from "dompurify";
+import { trustedPolicy, trusted } from "./trusted.mjs";
 const TAGS = ["a", "b", "br", "i", "img", "p", "small", "span", "sub", "sup"];
 const ATTRIBUTES = ["href", "alt", "src", "height", "width", "lang", "dir"];
 const URI_SAFE = ["height", "width", "lang", "dir"];
@@ -87,7 +88,7 @@ function tidy(html) {
   var _a;
   if (!html) return html;
   const box = document.createElement("template");
-  box.innerHTML = html;
+  box.innerHTML = trusted(html);
   for (const image of box.content.querySelectorAll("img:not([src])"))
     image.remove();
   for (const paragraph of box.content.querySelectorAll("p"))
@@ -150,8 +151,19 @@ function purifier() {
 }
 function sanitizeHTML(html, { markdown = false } = {}) {
   if (typeof window === "undefined") return html;
-  return tidy(purifier().sanitize(html, markdown ? MARKDOWN_CONFIG : CONFIG));
+  const config = markdown ? MARKDOWN_CONFIG : CONFIG;
+  const policy = trustedPolicy();
+  return tidy(
+    purifier().sanitize(
+      html,
+      policy ? {
+        ...config,
+        TRUSTED_TYPES_POLICY: policy
+      } : config
+    )
+  );
 }
 export {
-  sanitizeHTML
+  sanitizeHTML,
+  trusted
 };

package/dist/core/svg-shape.mjs

@@ -1,4 +1,5 @@
 "use client";
+import { trusted } from "./trusted.mjs";
 const NUMBER = /^-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?$/i;
 const POINTS = /^[\d\s.,eE+-]*$/;
 const PATH = /^[\d\s.,eE+\-MmLlHhVvCcSsQqTtAaZz]*$/;
@@ -16,7 +17,7 @@ function readSvgShape(svg) {
   if (typeof DOMParser === "undefined" || !svg) return null;
   let doc;
   try {
-    doc = new DOMParser().parseFromString(svg, "image/svg+xml");
+    doc = new DOMParser().parseFromString(trusted(svg), "image/svg+xml");
   } catch {
     return null;
   }

package/dist/core/thumbnail.mjs

@@ -17,27 +17,38 @@ function regionShare(region, { width, height }) {
   const [across, down] = match[1] ? [100, 100] : [width, height];
   return { x: x / across, y: y / down, width: w / across, height: h / down };
 }
-function imageSource(image, region = "full") {
+function imageSource(image, region = "full", sized = false) {
   if (!image) return null;
   const service = findImageServiceId(image.service);
   if (service) {
-    return region === "full" ? { service, fallback: image.id } : { service, region, fallback: image.id };
+    if (region !== "full") return { service, region, fallback: image.id };
+    const { width, height } = image;
+    return sized && image.id && width > 0 && height > 0 ? { service, fallback: image.id, fallbackSize: { width, height } } : { service, fallback: image.id };
   }
   return image.id ? { src: image.id } : null;
 }
 function thumbnailSource(resource) {
   const value = resource;
   if (!value) return null;
-  return imageSource(asArray(value.thumbnail)[0]) ?? imageSource(firstPaintedImage(value)) ?? imageSource(firstPaintedImage(value.placeholderContainer)) ?? imageSource(firstPaintedImage(value.accompanyingContainer));
+  return imageSource(
+    asArray(value.thumbnail)[0],
+    "full",
+    true
+  ) ?? imageSource(firstPaintedImage(value)) ?? imageSource(firstPaintedImage(value.placeholderContainer)) ?? imageSource(firstPaintedImage(value.accompanyingContainer));
 }
 function stillSource(resource) {
   const value = resource;
   if (!value) return null;
-  return imageSource(firstPaintedImage(value)) ?? imageSource(firstPaintedImage(value.placeholderContainer)) ?? imageSource(firstPaintedImage(value.accompanyingContainer)) ?? imageSource(asArray(value.thumbnail)[0]);
+  return imageSource(firstPaintedImage(value)) ?? imageSource(firstPaintedImage(value.placeholderContainer)) ?? imageSource(firstPaintedImage(value.accompanyingContainer)) ?? imageSource(asArray(value.thumbnail)[0], "full", true);
 }
 async function resolveThumbnail(source, size = 200, request) {
   if (source.src) return source.src;
   if (!source.service) return source.fallback;
+  const own = source.fallbackSize;
+  if (own && source.fallback && source.region === void 0) {
+    const longer = Math.max(own.width, own.height);
+    if (longer >= size && longer <= size * 2) return source.fallback;
+  }
   try {
     const info = await fetchInfo(source.service, { request });
     const share = typeof source.region === "string" ? regionShare(source.region, info) : source.region;

package/dist/core/trusted.mjs

@@ -0,0 +1,26 @@
+"use client";
+let policy;
+function trustedPolicy() {
+  if (policy === void 0) {
+    const factory = globalThis.trustedTypes;
+    try {
+      policy = (factory == null ? void 0 : factory.createPolicy("clover", {
+        createHTML: (html) => html,
+        createScriptURL: () => {
+          throw new TypeError("Clover makes no script URLs");
+        }
+      })) ?? null;
+    } catch {
+      policy = null;
+    }
+  }
+  return policy;
+}
+function trusted(html) {
+  var _a;
+  return ((_a = trustedPolicy()) == null ? void 0 : _a.createHTML(html)) ?? html;
+}
+export {
+  trusted,
+  trustedPolicy
+};

package/dist/core/vtt.mjs

@@ -22,8 +22,7 @@ function cueText(raw) {
     return code > 0 && code <= 1114111 ? String.fromCodePoint(code) : entity;
   });
 }
-function parseVtt(text) {
-  var _a, _b;
+function vttBlocks(text) {
   const cues = [];
   const blocks = text.replace(/\r\n?/g, "\n").split(/\n{2,}/);
   for (const block of blocks) {
@@ -32,14 +31,25 @@ function parseVtt(text) {
     if (timing === -1) continue;
     const [from, rest] = lines[timing].split("-->");
     const start = seconds(from);
-    const end = seconds(rest.trim().split(/\s+/)[0]);
+    const [until, ...settings] = rest.trim().split(/\s+/);
+    const end = seconds(until);
     if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
-    const raw = lines.slice(timing + 1).join("\n");
-    const voice = (_b = (_a = /<v(?:\.[^\s>]+)*\s+([^>]+)>/.exec(raw)) == null ? void 0 : _a[1]) == null ? void 0 : _b.trim();
-    const body = cueText(raw);
-    cues.push({ start, end, text: body, ...voice ? { voice } : {} });
+    cues.push({
+      id: timing ? lines[0] : "",
+      start,
+      end,
+      settings: settings.join(" "),
+      raw: lines.slice(timing + 1).join("\n")
+    });
   }
-  return cues.sort((a, b) => a.start - b.start);
+  return cues;
+}
+function parseVtt(text) {
+  return vttBlocks(text).map(({ start, end, raw }) => {
+    var _a, _b;
+    const voice = (_b = (_a = /<v(?:\.[^\s>]+)*\s+([^>]+)>/.exec(raw)) == null ? void 0 : _a[1]) == null ? void 0 : _b.trim();
+    return { start, end, text: cueText(raw), ...voice ? { voice } : {} };
+  }).sort((a, b) => a.start - b.start);
 }
 function cueAt(cues, time) {
   let low = 0;
@@ -107,5 +117,6 @@ export {
   loadText,
   loadVtt,
   paragraphsOf,
-  parseVtt
+  parseVtt,
+  vttBlocks
 };

package/dist/index.d.mts

@@ -721,6 +721,15 @@ export interface GestureOptions {
 	 * or sound, always fitted to the Body).
 	 */
 	navigable: boolean;
+	/**
+	 * A mouse or pen drag tracks the pointer 1:1 and glides on after a fast release. Off,
+	 * the drag is eased instead and stops where the pointer does. A finger always tracks 1:1 and flicks.
+	 */
+	flickEnabled: boolean;
+	/** Release speed, px/s, below which a drag does not flick. */
+	flickMinSpeed: number;
+	/** Seconds of release velocity the flick travels. */
+	flickMomentum: number;
 }
 export type BackendPreference = "auto" | BackendKind;
 export type CanvasRendererEvent = 
@@ -793,6 +802,9 @@ export interface RegionShare {
  *   nor than its limits, at level 0 only a size it lists (Mat, 2026-10-24: "be
  *   responsible when making IIIF image server requests"). What a manifest says of a
  *   service is not trusted to say what its server does.
+ * - A `thumbnail` whose own `width` and `height` already fit the size (`resolveThumbnail`)
+ *   is used as the manifest gives it, with no `info.json` read: the publisher's own URL,
+ *   not one built from what a service says.
  * - Without a service, the image itself is used.
  */
 export interface ThumbnailSource {
@@ -807,6 +819,11 @@ export interface ThumbnailSource {
 	region?: RegionShare | string;
 	/** Used if the service cannot answer. */
 	fallback?: string;
+	/** The pixels `fallback` is, as its own `width` and `height` say (a `thumbnail`'s). */
+	fallbackSize?: {
+		width: number;
+		height: number;
+	};
 }
 /**
  * Where a resource's thumbnail comes from, to be sized by `resolveThumbnail`. Null if it
@@ -823,6 +840,9 @@ export declare function stillSource(resource: unknown): ThumbnailSource | null;
 /**
  * A source's URL at about `size` pixels on its longer side: a service's, made from its own
  * `info.json` (`sizedImageUrl`), else the fallback, as where the service cannot answer.
+ * The fallback itself, with no `info.json` read, when it is all of the image and its
+ * longer side is from `size` to twice it: no blurrier than the service would be asked
+ * for, and not much heavier.
  */
 export declare function resolveThumbnail(source: ThumbnailSource, size?: number, request?: CloverRequest): Promise<string | undefined>;
 /**
@@ -919,7 +939,14 @@ export type ControlButtonProps = {
 		lang?: string;
 		/** The key the Canvas answers to for this control, when it has one. */
 		"aria-keyshortcuts"?: string;
+		/** Absent while the control would do nothing, as at the greatest zoom. */
 		onClick?: React.MouseEventHandler<HTMLButtonElement>;
+		/**
+		 * `true` while the control would do nothing: zoom in at the greatest zoom, zoom out at
+		 * the least, reset at home. Spread it with the rest, never as `disabled`, which would
+		 * take the button from the keyboard (WCAG 2.4.3), and dim it.
+		 */
+		"aria-disabled"?: true;
 		/** On a control that opens a menu (the Choice control): its state and target. */
 		"aria-expanded"?: boolean;
 		"aria-controls"?: string;
@@ -987,11 +1014,20 @@ export interface CloverCanvasOptions {
 	minZoomImageRatio?: number;
 	/** Seconds for an animation to close most of its distance. 0 disables easing. */
 	animationTime?: number;
+	/**
+	 * Seconds each animation (zoom, glide, home) takes, on a fixed-length spring. Unset,
+	 * the camera eases by `animationTime` instead.
+	 */
+	animationDuration?: number;
+	/** With `animationDuration`, how much of the movement comes early: higher starts faster. Default 6.5. */
+	springStiffness?: number;
+	/** Hold the image inside its bounds while dragging. Default true; false lets it spring back on release. */
+	constrainDuringPan?: boolean;
 	/**
 	 * Milliseconds the controls and navigator stay after a mouse (or a pen that hovers)
-	 * stops moving, as the Player's `hideDelay`. Default 2000; `Infinity` keeps them once
-	 * shown. A finger, or a pen that does not hover, has no timer: a tap on the picture
-	 * shows them, and another hides them. Focus that no press brought holds them too.
+	 * stops moving, or a finger lifts, as the Player's `hideDelay`. Default 3000; `Infinity`
+	 * keeps them once shown. A tap on the picture shows them, and another hides them. Focus
+	 * that no press brought holds them, and so does a paused recording.
 	 * A Timeline's: a Canvas's controls stay in sight, for now (Mat, 2026-11-01).
 	 */
 	hideDelay?: number;
@@ -1611,8 +1647,36 @@ export interface LogoProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement
  * picture.
  */
 export declare function Logo({ of, value, alt, className, ...rest }: LogoProps): React.JSX.Element | null;
+/**
+ * A section `Panel` draws by itself, from what the Root's resource holds. `sections`
+ * chooses among them; each still shows only where there is data for it.
+ */
+export type PanelSection = "about" | "targets" | "collection" | "contents" | "search" | "map" | "transcript" | "annotations";
+/**
+ * The default sections a `Panel` in this Root would have, in its order: About, and each
+ * other one the resource has data for, narrowed to `sections` where the page names the
+ * ones it wants. None of them, and the panel draws nothing, so a layout of your own can
+ * ask first and leave out the pane that would hold it:
+ *
+ * ```jsx
+ * const sections = Clover.usePanelSections(["contents", "search"]);
+ * return sections.length ? <Clover.Panel sections={sections} /> : null;
+ * ```
+ *
+ * Asking costs nothing a `Panel` does not already cost: the same reads of the Root, one
+ * for each section, so a change that moves none of them re-renders nothing.
+ */
+export declare function usePanelSections(sections?: readonly PanelSection[]): PanelSection[];
 /** How the sections are laid out. */
 export type SectionsLayout = "tabs" | "accordion";
+/**
+ * What a page calls a section, in place of Clover's own word for it: its words, taken to
+ * be in the page's language, or its words by language tag, one of which the tab carries
+ * as its `lang` where it is not the page's (WCAG 3.1.2).
+ */
+export type PanelSectionLabel = string | Readonly<Record<string, string>>;
+/** A label for any of the default sections, by its value. */
+export type PanelSectionLabels = Partial<Record<PanelSection, PanelSectionLabel>>;
 export interface TabProps {
 	/** Identifies the tab, for `value` / `defaultValue` on the panel. */
 	value: string;
@@ -1678,7 +1742,22 @@ export interface PanelProps extends Omit<React.HTMLAttributes<HTMLElement>, "def
 	 */
 	languages?: boolean;
 	/**
-	 * `Clover.Tab`s. Without any, the panel has the tabs Clover has data for: About,
+	 * Which of the default sections the panel may have, in Clover's own order: with
+	 * `["contents", "search"]` it has those two and no About. Each still shows only where
+	 * the resource has data for it, so a resource with none of them draws no panel at all.
+	 * `Tab` children win over it. Default: every section.
+	 */
+	sections?: readonly PanelSection[];
+	/**
+	 * What a default section's tab or heading says, in place of Clover's own word for it:
+	 * `{ annotations: "Chapters" }`, or `{ annotations: { en: "Chapters", de: "Kapitel" } }`
+	 * to say it in several, read in the one Clover speaks and marked with its language
+	 * where that is not the page's (WCAG 3.1.2). A `Tab` of your own says it in `label`.
+	 */
+	labels?: PanelSectionLabels;
+	/**
+	 * `Clover.Tab`s, the panel's sections whole, in their order: they win over `sections`.
+	 * Without any, the panel has the tabs Clover has data for: About,
 	 * Contents when the Manifest has Ranges, Search when it has a Content Search service, a
 	 * Map when it (or a Canvas or annotation) has navPlace or a georeference,
 	 * a Transcript when the view's media has captions or a plain-text transcript, and
@@ -1698,6 +1777,14 @@ export interface PanelProps extends Omit<React.HTMLAttributes<HTMLElement>, "def
  *   <Clover.Tab value="notes" label="Notes"><MyNotes /></Clover.Tab>
  * </Clover.Panel>
  * ```
+ *
+ * To keep Clover's own sections but not all of them, name the ones you want in
+ * `sections`: each still shows only where the resource has data for it, and a resource
+ * with none of them has no panel.
+ *
+ * ```jsx
+ * <Clover.Panel sections={["contents", "search", "transcript", "annotations"]} />
+ * ```
  */
 export declare const Panel: React.ForwardRefExoticComponent<PanelProps & React.RefAttributes<HTMLElement>>;
 export interface AboutProps extends React.HTMLAttributes<HTMLElement> {
@@ -1940,6 +2027,167 @@ export declare function search(service: SearchService, query: string, { request,
 	request?: CloverRequest;
 	signal?: AbortSignal;
 }): Promise<SearchResults>;
+/**
+ * Whether a Manifest has anything to put on a map: navPlace on the Collection, Manifest,
+ * a Canvas or an annotation, a GeoJSON annotation body, or a georeferencing annotation.
+ * Only a look, never a read: the panel asks it to offer a Map tab, and the reading
+ * (`core/geo.ts`) belongs to the map entry, so an app without a map carries none of it.
+ */
+export declare function hasMapData(manifest: Manifest | null, collection?: Presentation4Collection | null): boolean;
+/**
+ * Where a IIIF resource is, read for a map: navPlace (on a Collection, Manifest, Canvas
+ * or Annotation, and annotation bodies that are GeoJSON), and Georeference Extension
+ * annotations, reduced to what a basic overlay needs. Framework-free and small: the map
+ * itself, and MapLibre, load only when a `Map` is shown.
+ *
+ * - navPlace: https://iiif.io/api/extension/navplace/
+ * - Georeference: https://iiif.io/api/extension/georef/
+ */
+export type Position = [
+	number,
+	number
+];
+export interface GeoGeometry {
+	type: string;
+	coordinates?: unknown;
+	geometries?: GeoGeometry[];
+}
+export interface MapFeature {
+	type: "Feature";
+	id?: string | number;
+	geometry: GeoGeometry;
+	/**
+	 * Flat, for MapLibre (which turns nested objects into strings): the text to show and
+	 * its language, the Canvas it belongs to, and any simplestyle keys it carried (`fill`,
+	 * `stroke`, …).
+	 */
+	properties: Record<string, string | number | boolean> & {
+		title?: string;
+		titleLang?: string;
+		canvasId?: string;
+		/** The annotation it is a body of (Cookbook 0139), which a press on it selects. */
+		annotationId?: string;
+		/** The Collection's member it locates (Cookbook 0318), which a press on it opens. */
+		manifestId?: string;
+		/** Its owner's `navDate`, as written, shown with its name (Cookbook 0318). */
+		navDate?: string;
+	};
+}
+export interface MapFeatureCollection {
+	type: "FeatureCollection";
+	features: MapFeature[];
+}
+/** A georeferenced image, reduced to an affine overlay. */
+export interface Georeference {
+	id: string;
+	/** The Canvas it georeferences, when it targets one. */
+	canvasId?: string;
+	/** Ground control points: image pixel [x, y] ↔ [longitude, latitude]. */
+	points: Array<{
+		resource: Position;
+		geo: Position;
+	}>;
+	/** The extent the points are measured in: the Canvas, or the image service. */
+	width: number;
+	height: number;
+	/** The part of the image that is map (an SvgSelector polygon), in the same units. */
+	mask?: Position[];
+	/** Its name: the annotation's label, or the Canvas's. */
+	label?: LanguageMapLike;
+	/** What to draw: an image body (or a bare image service), sized by `overlayImageUrl`. */
+	image: Record<string, unknown>;
+}
+/**
+ * Every navPlace feature of the Root's resource: the Collection's, each of its members'
+ * (Cookbook 0318: a Collection of Manifests, each where it is), the Manifest's, each
+ * Canvas's, and each loaded annotation's (its `navPlace`, or a GeoJSON body as Cookbook
+ * 0139 has). A feature from a member names that member, the open one's place its own
+ * Manifest's where it gives one, in the member's place in the Collection's order; one
+ * from a Canvas or annotation names that Canvas. Memoized on the Manifest (and the
+ * Collection), so the same collection comes back while nothing changes.
+ */
+export declare function navPlaceOf(manifest: Manifest | null, collection?: Presentation4Collection | null, language?: string): MapFeatureCollection;
+/**
+ * One Georeference Extension annotation as an overlay: its control points, the extent
+ * they are measured in, its mask, and the image to draw (the Canvas's painted image, or
+ * the image service it targets directly). Null when it cannot be drawn: fewer than three
+ * points, no extent, or nothing to draw.
+ */
+export declare function readGeoreference(annotation: Json, canvas?: Json): Georeference | null;
+/**
+ * The georeferenced images of the Manifest's Canvases, from their loaded annotation pages.
+ * Memoized on the Manifest: embedding a fetched page makes a new one.
+ */
+export declare function georeferencesOf(manifest: Manifest | null): Georeference[];
+/**
+ * The first-order polynomial (affine) transform that best fits the control points, image
+ * pixels to [longitude, latitude], by least squares in Web Mercator. Exact for three
+ * points. Null when the points are collinear.
+ */
+export declare function affineTransform(points: Georeference["points"]): ((pixel: Position) => Position) | null;
+/**
+ * Where the image's corners land, in the order MapLibre's image and canvas sources take
+ * them: top left, top right, bottom right, bottom left. Null when the points do not fix
+ * a transform.
+ */
+export declare function cornersOf(georeference: Georeference): [
+	Position,
+	Position,
+	Position,
+	Position
+] | null;
+/** The [[west, south], [east, north]] that holds the features and the overlays. */
+export declare function boundsOf(features: MapFeature[], overlays?: Georeference[]): [
+	Position,
+	Position
+] | null;
+export interface MapProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect"> {
+	/**
+	 * Standalone: a IIIF resource (URL or object) to map: its navPlace, and its Canvases'
+	 * georeferenced images. Inside a `Root`, leave it out to map the Root's.
+	 */
+	iiifContent?: IIIFContent;
+	/** GeoJSON to draw (a FeatureCollection, Feature or geometry), as navPlace is. */
+	navPlace?: unknown;
+	/** Georeference Extension annotations to overlay, on a Canvas or an image service. */
+	georeferences?: unknown[];
+	/** Draw georeferenced images over the basemap. Default true. */
+	overlay?: boolean;
+	/** The overlays' opacity, 0 to 1. Default 0.75. */
+	overlayOpacity?: number;
+	/** A MapLibre style URL, used as it is. Default: Clover's relief basemap (OpenFreeMap). */
+	styleUrl?: string;
+	/**
+	 * Where MapLibre's worker is served from, to serve your own (see the Map docs). By
+	 * default Clover brings it, from a `blob:` URL.
+	 */
+	workerUrl?: string;
+	/** Zoom with the wheel or trackpad. Default false, so an embedded map never traps page scroll. */
+	scrollZoom?: boolean;
+	/**
+	 * A place was chosen, on the map or in its list. Inside a `Root`, choosing one on a
+	 * Canvas also goes there.
+	 */
+	onSelect?: (feature: MapFeature) => void;
+	/** Standalone: credentials, headers and `fetch`. */
+	request?: CloverRequest;
+	/** Standalone: the language to read IIIF text in. */
+	language?: string;
+	/**
+	 * Clover's higher-contrast mode: the accent kept to rings, outlines and marks, and never
+	 * under words or a glyph, where the controls' dark fill takes its place, edged in the
+	 * accent. Inside a `Root`, the Root's too; on wherever the reader's system asks for more
+	 * contrast. Default `false`.
+	 */
+	highContrast?: boolean;
+	/**
+	 * The basemap's credits, behind an ⓘ in the map's lower corner. Default true. A basemap's license
+	 * may ask for its credits: give them on the page yourself before setting this false.
+	 */
+	credits?: boolean;
+	as?: React.ElementType;
+}
+declare const CloverMap: React.ForwardRefExoticComponent<MapProps & React.RefAttributes<HTMLElement>>;
 /** Serve MapLibre's worker from `url` for every map Clover draws (a Viewer's Map tab included). */
 export declare function setMapWorkerUrl(url: string | undefined): void;
 export interface CollectionProps extends React.HTMLAttributes<HTMLElement> {
@@ -2085,7 +2333,7 @@ export interface SceneProps {
 	options?: {
 		/** Credentials and headers for the Scene and its models. Inside a `Root`, the Root's. */
 		request?: CloverRequest;
-		/** Milliseconds the controls stay after a mouse stops moving, as `Canvas`'s. */
+		/** Milliseconds the controls stay after a mouse stops or a finger lifts, as `Canvas`'s. */
 		hideDelay?: number;
 	};
 	/**
@@ -2541,6 +2789,19 @@ export type DefaultProps = Omit<RootProps, "children"> & {
 	 * stacked boxes each opened by its heading, or `"tabs"`.
 	 */
 	panelLayout?: PanelLayout;
+	/**
+	 * The panel's sections, from Clover's own: with
+	 * `["contents", "search", "transcript", "annotations"]` it has those four, each still
+	 * only where the resource has data for it, and no panel at all where it has none of
+	 * them. Default: every section.
+	 */
+	panelSections?: readonly PanelSection[];
+	/**
+	 * What a panel section's tab or heading says, in place of Clover's own word for it:
+	 * `{ annotations: "Chapters" }`, or a word by language tag to say it in several (the
+	 * Panel's `labels`).
+	 */
+	panelLabels?: PanelSectionLabels;
 	/** The downloads, from a Download button beside the panel's About heading. Default `true`. */
 	download?: boolean;
 	/**
@@ -2573,8 +2834,10 @@ export type DefaultProps = Omit<RootProps, "children"> & {
 	 * The Body's `collapseControls`.
 	 */
 	collapseControls?: "auto" | "always";
+	/** The Body's Canvas `options`: its gestures, zoom limits and motion. */
+	canvasOptions?: CloverCanvasOptions;
 };
-declare function Default({ className, header, headingLevel, panel, defaultPanelOpen, panelLayout, download, languages, items, singleItem, storageKey, fill, collapseControls, ...root }: DefaultProps): React.JSX.Element;
+declare function Default({ className, header, headingLevel, panel, defaultPanelOpen, panelLayout, panelSections, panelLabels, download, languages, items, singleItem, storageKey, fill, collapseControls, canvasOptions, ...root }: DefaultProps): React.JSX.Element;
 /**
  * A layout the Viewer draws: one from `@nulib/clover/templates`, or a component of your
  * own that takes the `Clover.Root` props.

package/dist/index.mjs

@@ -11,6 +11,7 @@ import { Status } from "./components/Status/Status.mjs";
 import { Homepage, Id, Metadata, PartOf, Rendering, RequiredStatement, Rights, SeeAlso, Summary, Thumbnail, Value } from "./components/Primitives/Primitives.mjs";
 import { Logo, Provider } from "./components/Provider/Provider.mjs";
 import { Panel, Tab } from "./components/Panel/Panel.mjs";
+import { usePanelSections } from "./components/Panel/sections.mjs";
 import { About } from "./components/Panel/About.mjs";
 import { Annotations } from "./components/Annotations/Annotations.mjs";
 import { Transcript } from "./components/Transcript/Transcript.mjs";
@@ -20,6 +21,9 @@ import { Split, SplitHandle, SplitPane } from "./components/Split/Split.mjs";
 import { Search } from "./components/Search/Search.mjs";
 import { search } from "./core/search.mjs";
 import { SEARCH_SET_ID, searchServiceOf } from "./core/search-service.mjs";
+import { CloverMap } from "./components/Map/Map.mjs";
+import { affineTransform, boundsOf, cornersOf, georeferencesOf, navPlaceOf, readGeoreference } from "./core/geo.mjs";
+import { hasMapData } from "./core/geo-detect.mjs";
 import { setMapWorkerUrl } from "./core/map-config.mjs";
 import { Collection } from "./components/Collection/Collection.mjs";
 import { CollectionSelect } from "./components/CollectionSelect/CollectionSelect.mjs";
@@ -63,6 +67,7 @@ export {
   Items,
   Label,
   Logo,
+  CloverMap as Map,
   Metadata,
   Next,
   Panel,
@@ -92,18 +97,25 @@ export {
   Transcript,
   Value,
   Viewer,
+  affineTransform,
+  boundsOf,
   buildContentState,
   chaptersOf,
+  cornersOf,
   cueAt,
   currentContents,
   decodeContentState,
   Viewer2 as default,
   encodeContentState,
+  georeferencesOf,
   groupViews,
+  hasMapData,
   initCloverI18n,
   localize,
+  navPlaceOf,
   parseVtt,
   readAs,
+  readGeoreference,
   regionSource,
   resolveBehavior,
   resolveDirection,
@@ -127,6 +139,7 @@ export {
   useManifest,
   useNavigation,
   useOneOpen,
+  usePanelSections,
   useProvider,
   useSequence,
   useStatus,

package/dist/lib/pointer.mjs

@@ -20,7 +20,7 @@ function isInteractive(target, bodyBox) {
   var _a;
   let node = target;
   while (node && node !== bodyBox) {
-    if (node instanceof HTMLButtonElement || node instanceof HTMLAnchorElement || node instanceof HTMLInputElement || node instanceof HTMLSelectElement || ((_a = node.dataset) == null ? void 0 : _a.cloverCanvasInteractive) !== void 0) {
+    if (node instanceof HTMLButtonElement || node instanceof HTMLAnchorElement || node instanceof HTMLInputElement || node instanceof HTMLLabelElement || node instanceof HTMLSelectElement || ((_a = node.dataset) == null ? void 0 : _a.cloverCanvasInteractive) !== void 0) {
       return true;
     }
     node = node.parentElement;