@segnavia/html 0.38.0 → 0.40.0

package/dist/book/book-contents.js

@@ -14,11 +14,11 @@ function contentsList(book, headings, options) {
 		return element("li", attributes, [element("a", {
 			href: options.crossLinks ? `segnavia:target/${heading.id}` : `#${heading.id}`,
 			dir: resolveDirection(book.dir, book.lang, heading.text)
-		}, [text(heading.text)]), element("span", {
+		}, [text(heading.text)]), book.contents.pageNumbers ? element("a", {
 			class: "segnavia-contents-page",
-			"data-target": heading.id,
-			dir: resolveDirection(book.dir, book.lang, page)
-		}, [text(page)])]);
+			href: `#${heading.id}`,
+			"data-ref": "page"
+		}, [text(page)]) : element("span", { class: "segnavia-contents-page" }, [])]);
 	});
 	return element("ol", { class: "segnavia-contents-list" }, entries);
 }

package/dist/book/book-document-nodes.js

@@ -11,13 +11,20 @@ function targetLinks(sections) {
 		tabindex: "-1"
 	}, [text("​")])));
 }
-function notesGalley(paragraphs) {
+function notesGalley(series, paragraphs) {
 	const notes = paragraphs.map((paragraph) => element("div", { "data-segnavia-note": paragraph.attribs.id ?? "" }, [paragraph]));
 	return element("aside", {
 		"data-segnavia-notes-galley": "",
+		"data-segnavia-note-series": series,
 		"aria-hidden": "true"
 	}, notes);
 }
+function notesGalleys(series, paragraphs) {
+	return series.flatMap((item) => {
+		const held = paragraphs.get(item.name);
+		return item.placement === "page" && held?.length ? [notesGalley(item.name, held)] : [];
+	});
+}
 function withBlankPages(sections, blankBefore) {
 	const counts = /* @__PURE__ */ new Map();
 	for (const id of blankBefore ?? []) counts.set(id, (counts.get(id) ?? 0) + 1);
@@ -27,4 +34,4 @@ function withBlankPages(sections, blankBefore) {
 	})), section.node]);
 }
 //#endregion
-export { notesGalley, targetLinks, withBlankPages };
+export { notesGalleys, targetLinks, withBlankPages };

package/dist/book/book-document.js

@@ -1,10 +1,11 @@
 import { elements, parse, serialize } from "../sanitize.js";
 import { element, linkChildren, text } from "./dom.js";
 import { addContents } from "./book-contents.js";
-import { notesGalley, targetLinks, withBlankPages } from "./book-document-nodes.js";
+import { notesGalleys, targetLinks, withBlankPages } from "./book-document-nodes.js";
 import { bookDocumentCss, bookFlowPageGeometry, markBlockPositions, resolveBookBuild } from "./book-flow.js";
 import { authoredSection, collectHeadings, designedSection, flowAttribs, markPlacementIssues, sectionNode, templateHolders, templateRegionIssues, templatedSection, templatedSectionIssues } from "./book-held.js";
-import { duplicateIdIssues, reservedIdIssues } from "./book-issues.js";
+import { pageReferenceNodes, pageReferenceTarget, pageReferenceTargets } from "./book-page-reference.js";
+import { duplicateIdIssues, pageReferenceIssues, reservedIdIssues } from "./book-issues.js";
 import { addPart, attachPendingPartHeadings, partNames } from "./book-part-build.js";
 import { noteState, transformNotes } from "./notes.js";
 import { bookPrintPart } from "./types.js";
@@ -159,6 +160,7 @@ function addFrontMatter(book, build) {
 			appendTemplated(entry, `segnavia-templated-${build.templatedNumber}`, "front", book, build, sectionEntry);
 			continue;
 		}
+		if (!("html" in entry)) continue;
 		frontNumber += 1;
 		const section = authoredSection(entry, `segnavia-front-${frontNumber}`, build.build);
 		build.sections.push(section);
@@ -238,6 +240,17 @@ function insertCollectedSections(book, build) {
 		build.sections.splice(index < 0 ? build.sections.length : index, 0, notesSection(book, notes, build.build, collectedSectionId(notes), notes.series.title));
 	}
 }
+function writePageReferenceNumbers(book, roots, options) {
+	for (const node of pageReferenceNodes(roots)) {
+		const id = pageReferenceTarget(node.attribs);
+		if (!id) continue;
+		const page = options.pageNumbers?.[id] ?? "";
+		node.children = [text(page)];
+		node.attribs.dir = resolveDirection(book.dir, book.lang, page);
+		if (options.crossLinks) node.attribs.href = `segnavia:target/${id}`;
+		linkChildren(node);
+	}
+}
 function bookDocument(book, options = {}) {
 	const { build: requestedBuild, issue: buildIssue } = resolveBookBuild(book, options.build);
 	const build = {
@@ -259,6 +272,18 @@ function bookDocument(book, options = {}) {
 	const { notes, sections, headings, issues } = build;
 	insertCollectedSections(book, build);
 	if (contents) addContents(book, contents, headings, options);
+	const noteGalleys = notesGalleys(book.notes, notes.pageParagraphs);
+	const scopes = [...sections.map((section) => ({
+		owner: `${section.info.title ?? section.info.id} (${section.info.id})`,
+		roots: [section.node]
+	})), ...noteGalleys.map((galley) => ({
+		owner: `page-placed note series ${galley.attribs["data-segnavia-note-series"] ?? ""}`,
+		roots: [galley]
+	}))];
+	const referenceIssues = pageReferenceIssues(sections, scopes);
+	const referenceRoots = scopes.flatMap((scope) => scope.roots);
+	const referenceTargets = pageReferenceTargets(referenceRoots);
+	writePageReferenceNumbers(book, referenceRoots, options);
 	if (requestedBuild !== "print") markBlockPositions(sections);
 	const visible = sections.filter((section) => options.part === void 0 || bookPrintPart(section.info.division) === options.part);
 	const document = parse("");
@@ -268,7 +293,7 @@ function bookDocument(book, options = {}) {
 		element("div", { "data-segnavia-galleys": "" }, [
 			...templateHolders(book.templates),
 			...visible.map((section) => section.node),
-			...notes.pageParagraphs.length > 0 ? [notesGalley(notes.pageParagraphs)] : []
+			...noteGalleys
 		])
 	] : [
 		element("style", {}, [text(bookDocumentCss(book, requestedBuild))]),
@@ -280,6 +305,7 @@ function bookDocument(book, options = {}) {
 		html: serialize(document),
 		sections: sections.map((section) => section.info),
 		headings,
+		pageReferenceTargets: referenceTargets,
 		issues: [
 			...buildIssue ? [buildIssue] : [],
 			...noteMarkerIssues(book.notes, notes.used),
@@ -287,7 +313,8 @@ function bookDocument(book, options = {}) {
 			...markPlacementIssues(book.parentPages),
 			...templateRegionIssues(book.templates),
 			...issues,
-			...duplicateIdIssues(sections, headings)
+			...duplicateIdIssues(sections, headings),
+			...referenceIssues
 		]
 	};
 }

package/dist/book/book-flow.js

@@ -6,7 +6,7 @@ const BOOK_COLUMN_MIN = 2;
 const BOOK_COLUMN_MAX = 4;
 const CONTENTS_INDENTS = Array.from({ length: 5 }, (_, index) => index + 2).map((level) => `:where(.segnavia-contents-entry[data-level="${level}"]){padding-inline-start:${level - 1}em}`).join("");
 const DEEP_CONTENTS_INDENTS = Array.from({ length: MAX_PART_DEPTH }, (_, index) => index + 7).map((level) => `:where(.segnavia-contents-entry[data-level="${level}"]){padding-inline-start:${level - 1}em}`).join("");
-const CONTENTS_PREFIX = `:where(.segnavia-contents-list){list-style:none;padding:0;margin:0}:where(.segnavia-contents-entry){display:flex}:where(.segnavia-contents-page){margin-inline-start:auto}${CONTENTS_INDENTS}`;
+const CONTENTS_PREFIX = `:where(.segnavia-contents-list){list-style:none;padding:0;margin:0}:where(.segnavia-contents-entry){display:flex}:where(.segnavia-contents-page){margin-inline-start:auto}:where([data-ref="page"]){unicode-bidi:isolate}${CONTENTS_INDENTS}`;
 const CONTENTS_SUFFIX = ":where(.segnavia-targets){position:absolute;inline-size:1px;block-size:1px;overflow:hidden;clip-path:inset(50%)}";
 const GALLEY_SUFFIX = ":where([data-segnavia-galleys]){position:relative}:where([data-segnavia-flow]){orphans:inherit;widows:inherit}:where([data-segnavia-kind=\"fixed\"],[data-segnavia-kind=\"templated\"],[data-segnavia-template]){display:none}:where([data-segnavia-notes-galley]){border-block-start:1px solid;padding-block-start:8px}:where([data-segnavia-note]){break-inside:avoid}:where([data-segnavia-galleys] img,[data-segnavia-window] img,[data-segnavia-page-note] img){display:block;max-block-size:var(--segnavia-text-height);max-inline-size:100%;block-size:auto;inline-size:auto}";
 function hasParts(book) {

package/dist/book/book-issues.js

@@ -1,24 +1,42 @@
 import { elements } from "../sanitize.js";
+import { pageReferenceNodes, pageReferenceTarget } from "./book-page-reference.js";
 //#region src/book/book-issues.ts
+function sectionIds(section) {
+	return [section.info.id, ...elements(section.node.children).flatMap((node) => node.attribs.id ? [node.attribs.id] : [])];
+}
+function sectionName(section) {
+	return `${section.title ?? section.id} (${section.id})`;
+}
+function ownersById(sections) {
+	const occurrences = /* @__PURE__ */ new Map();
+	for (const section of sections) for (const id of sectionIds(section)) occurrences.set(id, [...occurrences.get(id) ?? [], section.info]);
+	return occurrences;
+}
 function duplicateIdIssues(sections, headings) {
 	const listed = new Set(headings.map((heading) => heading.id));
-	const occurrences = /* @__PURE__ */ new Map();
-	for (const section of sections) {
-		const ids = [section.info.id, ...elements(section.node.children).flatMap((node) => node.attribs.id ? [node.attribs.id] : [])];
-		for (const id of ids) occurrences.set(id, [...occurrences.get(id) ?? [], section.info]);
-	}
-	return [...occurrences].flatMap(([id, owners]) => {
+	return [...ownersById(sections)].flatMap(([id, owners]) => {
 		if (!listed.has(id) || owners.length < 2) return [];
-		const named = owners.slice(0, 2).map((owner) => `${owner.title ?? owner.id} (${owner.id})`);
+		const named = owners.slice(0, 2).map(sectionName);
 		return [`destination id ${id} is used in both ${named[0]} and ${named[1]}; listed heading and generated destination ids must be unique`];
 	});
 }
+function pageReferenceIssues(sections, scopes) {
+	const targets = ownersById(sections);
+	return scopes.flatMap((scope) => pageReferenceNodes(scope.roots).flatMap((node) => {
+		const id = pageReferenceTarget(node.attribs);
+		if (!id) return [];
+		const owners = targets.get(id) ?? [];
+		if (owners.length === 0) return [`page reference to ${id} in ${scope.owner} has no target; add the id or remove the reference`];
+		if (owners.length === 1) return [];
+		return [`page reference target ${id} is used in ${owners.length} sections: ${owners.map(sectionName).join(", ")}; make the target id unique to clear this refusal`];
+	}));
+}
 function reservedIdIssues(section) {
 	return elements(section.node.children).flatMap((node) => {
 		const id = node.attribs.id;
 		if (!id?.startsWith("segnavia-")) return [];
-		return [`authored id ${id} in ${section.info.title ?? section.info.id} (${section.info.id}) uses the reserved segnavia- prefix`];
+		return [`authored id ${id} in ${sectionName(section.info)} uses the reserved segnavia- prefix`];
 	});
 }
 //#endregion
-export { duplicateIdIssues, reservedIdIssues };
+export { duplicateIdIssues, pageReferenceIssues, reservedIdIssues };

package/dist/book/book-page-reference.d.ts

@@ -0,0 +1,7 @@
+import { Element } from "domhandler";
+//#region src/book/book-page-reference.d.ts
+export declare const PAGE_REFERENCE_ATTRIBUTE = "data-ref";
+export declare const PAGE_REFERENCE_VALUE = "page";
+export declare const PAGE_REFERENCE_SELECTOR = "a[data-ref=\"page\"]";
+export declare function pageReferenceTarget(attribs: Record<string, string>): string | undefined;
+//#endregion

package/dist/book/book-page-reference.js

@@ -0,0 +1,19 @@
+import { elements } from "../sanitize.js";
+//#region src/book/book-page-reference.ts
+const PAGE_REFERENCE_ATTRIBUTE = "data-ref";
+const PAGE_REFERENCE_VALUE = "page";
+const PAGE_REFERENCE_SELECTOR = "a[data-ref=\"page\"]";
+function pageReferenceTarget(attribs) {
+	if (attribs["data-ref"] !== "page") return void 0;
+	const href = attribs.href;
+	if (href?.startsWith("#") && href.length > 1) return href.slice(1);
+	return href?.startsWith("segnavia:target/") && href.length > 16 ? href.slice(16) : void 0;
+}
+function pageReferenceNodes(roots) {
+	return roots.flatMap((root) => [root, ...elements(root.children)]).filter((node) => node.name === "a" && pageReferenceTarget(node.attribs) !== void 0);
+}
+function pageReferenceTargets(roots) {
+	return [...new Set(pageReferenceNodes(roots).flatMap((node) => pageReferenceTarget(node.attribs) ?? []))];
+}
+//#endregion
+export { PAGE_REFERENCE_ATTRIBUTE, PAGE_REFERENCE_SELECTOR, PAGE_REFERENCE_VALUE, pageReferenceNodes, pageReferenceTarget, pageReferenceTargets };

package/dist/book/notes.js

@@ -35,7 +35,7 @@ function noteState() {
 		used: /* @__PURE__ */ new Set(),
 		counters: /* @__PURE__ */ new Map(),
 		collected: /* @__PURE__ */ new Map(),
-		pageParagraphs: [],
+		pageParagraphs: /* @__PURE__ */ new Map(),
 		authored: /* @__PURE__ */ new Map(),
 		repeatCount: 0,
 		issues: []
@@ -87,8 +87,9 @@ function noteIds(series, scope, chapter, number) {
 		refId: `segnavia-${series.idStem}ref${scopePart}-${number}`
 	};
 }
-function addPageBlock(block, paragraph, blocks, series) {
-	const existing = blocks.get(block);
+function addPageBlock(block, paragraph, blocks, series, seriesOrder) {
+	const blockSeries = blocks.get(block) ?? /* @__PURE__ */ new Map();
+	const existing = blockSeries.get(series.name);
 	if (existing) {
 		append(existing, paragraph);
 		return;
@@ -98,9 +99,16 @@ function addPageBlock(block, paragraph, blocks, series) {
 		...series.markBlockSeries ? { "data-segnavia-note-series": series.name } : {}
 	};
 	const notes = element("div", attributes, [paragraph]);
-	blocks.set(block, notes);
-	if (INSIDE_BLOCKS.has(block.name)) append(block, notes);
-	else insertAfter(block, notes);
+	const index = seriesOrder.get(series.name) ?? seriesOrder.size;
+	const next = [...blockSeries.entries()].filter(([name]) => (seriesOrder.get(name) ?? seriesOrder.size) > index).sort(([left], [right]) => (seriesOrder.get(left) ?? seriesOrder.size) - (seriesOrder.get(right) ?? seriesOrder.size))[0]?.[1];
+	if (next?.prev) insertAfter(next.prev, notes);
+	else if (INSIDE_BLOCKS.has(block.name)) append(block, notes);
+	else {
+		const previous = [...blockSeries.entries()].filter(([name]) => (seriesOrder.get(name) ?? seriesOrder.size) < index).sort(([left], [right]) => (seriesOrder.get(right) ?? seriesOrder.size) - (seriesOrder.get(left) ?? seriesOrder.size))[0]?.[1];
+		insertAfter(previous ?? block, notes);
+	}
+	blockSeries.set(series.name, notes);
+	blocks.set(block, blockSeries);
 }
 function collectedNotes(series, context, state) {
 	const key = placementKey(series, context);
@@ -119,7 +127,7 @@ function collectedNotes(series, context, state) {
 	state.collected.set(mapKey, collected);
 	return collected;
 }
-function transformAuthoredNote(note, series, context, state, blocks, galley) {
+function transformAuthoredNote(note, series, context, state, blocks, seriesOrder, galley) {
 	const block = nearestBlock(note);
 	if (!block) return;
 	const { number, scope } = nextNumber(series, context, state);
@@ -130,8 +138,11 @@ function transformAuthoredNote(note, series, context, state, blocks, galley) {
 	replace(note, element("sup", { class: "segnavia-note-ref" }, [markerLink(refId, noteId, marker)]));
 	const paragraph = noteParagraph(series.bodyClass, noteId, refId, marker, content);
 	if (series.placement === "page") {
-		if (galley) state.pageParagraphs.push(paragraph);
-		else addPageBlock(block, paragraph, blocks, series);
+		if (galley) {
+			const paragraphs = state.pageParagraphs.get(series.name) ?? [];
+			paragraphs.push(paragraph);
+			state.pageParagraphs.set(series.name, paragraphs);
+		} else addPageBlock(block, paragraph, blocks, series, seriesOrder);
 	} else collectedNotes(series, context, state).paragraphs.push(paragraph);
 	if (authoredId) state.authored.set(authoredId, {
 		noteId,
@@ -156,6 +167,7 @@ function transformRepeat(node, state) {
 function transformNotes(root, book, context, state, galley = false) {
 	const blocks = /* @__PURE__ */ new Map();
 	const byName = new Map(book.notes.map((series) => [series.name, series]));
+	const seriesOrder = new Map(book.notes.map((series, index) => [series.name, index]));
 	const nodes = elements(root.children).filter((node) => node.name === "span" && node.attribs["data-note"] !== void 0 || node.name === "a" && node.attribs["data-note-ref"] !== void 0);
 	for (const node of nodes) {
 		if (node.name === "a") {
@@ -168,7 +180,7 @@ function transformNotes(root, book, context, state, galley = false) {
 			state.issues.push(`data-note names unknown note series ${name}; declare the series in notes or use a declared series name`);
 			continue;
 		}
-		transformAuthoredNote(node, series, context, state, blocks, galley);
+		transformAuthoredNote(node, series, context, state, blocks, seriesOrder, galley);
 	}
 }
 //#endregion

package/dist/book/paginate-notes.js

@@ -2,7 +2,13 @@
 function paginateNotes(payload) {
 	const notesById = new Map(payload.notes.map((note) => [note.id, note]));
 	const notesGap = payload.geometry.notesGap;
+	const noteSeries = payload.geometry.noteSeries;
 	const textHeight = payload.geometry.textHeight;
+	const seriesOrder = new Map(noteSeries?.map((series, index) => [series.name, index]));
+	function ordered(fragments) {
+		if (!noteSeries) return fragments;
+		return fragments.slice().sort((left, right) => (seriesOrder.get(left.series) ?? noteSeries.length) - (seriesOrder.get(right.series) ?? noteSeries.length));
+	}
 	function noteEnd(id) {
 		return notesById.get(id)?.lines.length ?? 0;
 	}
@@ -15,8 +21,13 @@ function paginateNotes(payload) {
 	function notesSpace(fragments) {
 		if (fragments.length === 0) return 0;
 		let height = 0;
-		for (const fragment of fragments) height += fragmentHeight(fragment);
-		return notesGap + height;
+		let previous;
+		for (const fragment of noteSeries ? ordered(fragments) : fragments) {
+			if (fragment.series !== previous) height += noteSeries?.find(({ name }) => name === fragment.series)?.gap ?? notesGap;
+			height += fragmentHeight(fragment);
+			previous = fragment.series;
+		}
+		return height;
 	}
 	function measure(placed, fragments) {
 		if (payload.op === "continue" || payload.op === "allocate" || payload.op === "recompute") return payload.used(placed, fragments);
@@ -25,13 +36,14 @@ function paginateNotes(payload) {
 	function makeFragment(id, start, end) {
 		return {
 			id,
+			series: notesById.get(id)?.series ?? "",
 			whole: start === 0 && end === noteEnd(id),
 			start,
 			end
 		};
 	}
 	function leftoverFrom(fragments) {
-		return fragments.flatMap((fragment) => fragment.end < noteEnd(fragment.id) ? [makeFragment(fragment.id, fragment.end, noteEnd(fragment.id))] : []);
+		return ordered(fragments.flatMap((fragment) => fragment.end < noteEnd(fragment.id) ? [makeFragment(fragment.id, fragment.end, noteEnd(fragment.id))] : []));
 	}
 	function takeContinued(continued) {
 		if (continued.length === 0) return {
@@ -41,7 +53,7 @@ function paginateNotes(payload) {
 		const fragments = [];
 		const leftover = [];
 		let pending = true;
-		for (const item of continued) {
+		for (const item of ordered(continued)) {
 			const total = noteEnd(item.id);
 			if (!pending) {
 				leftover.push(item);
@@ -59,8 +71,8 @@ function paginateNotes(payload) {
 			pending = false;
 		}
 		return {
-			fragments,
-			leftover
+			fragments: ordered(fragments),
+			leftover: ordered(leftover)
 		};
 	}
 	function fitNote(trial, fragments, id) {
@@ -84,7 +96,7 @@ function paginateNotes(payload) {
 			if (!fragment) return void 0;
 			fragments.push(fragment);
 		}
-		return fragments;
+		return ordered(fragments);
 	}
 	function notesFor(placed, seed) {
 		let fragments = seed;

package/dist/book/paginate-types.d.ts

@@ -53,13 +53,19 @@ export type PaginateFlow = (PaginateFlowBase & {
 });
 export interface PaginateNote {
   id: string;
+  series: string;
   lines: PaginateLine[];
 }
+export interface PaginateNoteSeriesGeometry {
+  name: string;
+  gap: number;
+}
 export interface PaginateBookInput {
   flows: PaginateFlow[];
   notes: PaginateNote[];
   geometry: {
     notesGap: number;
+    noteSeries?: PaginateNoteSeriesGeometry[];
   };
   parents: Record<string, TextArea>;
   parentNames: typeof BOOK_PARENT_NAMES;
@@ -81,6 +87,7 @@ export interface PaginateWindow {
 }
 export interface PaginatePageNote {
   id: string;
+  series: string;
   whole: boolean;
   start: number;
   end: number;
@@ -148,6 +155,7 @@ interface PaginateNotesBase {
   geometry: {
     textHeight: number;
     notesGap: number;
+    noteSeries?: PaginateNoteSeriesGeometry[];
   };
 }
 export type PaginateNotesOp = (PaginateNotesBase & {

package/dist/book/types.d.ts

@@ -28,6 +28,7 @@ export interface BookDocument {
   html: string;
   sections: BookSectionInfo[];
   headings: BookHeading[];
+  pageReferenceTargets: string[];
   issues: string[];
 }
 //#endregion

package/dist/font-css.js

@@ -1,7 +1,7 @@
 import { bytesToBase64 } from "./base64.js";
 import { hasControlChar } from "./control-char.js";
 import { UNICODE_RANGE_CLEARANCE, parseUnicodeRange } from "./unicode-range.js";
-import { APP_FONT_NAME, FONT_FORMATS } from "@segnavia/format";
+import { APP_FONT_NAME, FONT_FORMATS, FontFaceRefusedError, resolveFontFace } from "@segnavia/format";
 //#region src/font-css.ts
 var FontCssRefusedError = class extends Error {
 	constructor(message) {
@@ -59,7 +59,18 @@ function validatedFace(font) {
 	return font;
 }
 function fontFaceCss(font) {
-	const face = validatedFace(font);
+	const validated = validatedFace(font);
+	let resolved;
+	try {
+		resolved = resolveFontFace(validated.data, validated.format, validated.postscriptName);
+	} catch (error) {
+		if (error instanceof FontFaceRefusedError) throw new FontCssRefusedError(error.message);
+		throw error;
+	}
+	const face = {
+		...validated,
+		...resolved
+	};
 	return `@font-face{font-family:${quoteFamily(face.family)};src:url(data:font/${mimeType(face.format)};base64,${bytesToBase64(face.data)}) format(${JSON.stringify(face.format)});font-weight:${face.weight ?? "normal"};font-style:${face.style ?? "normal"};${unicodeRangeDeclaration(face)}font-display:block}`;
 }
 function customProperty(name, font) {

package/dist/font-format.js

@@ -1,11 +1,7 @@
+import { classifyFont } from "@segnavia/format";
 //#region src/font-format.ts
 function fontFormat(data) {
-	if (data.length < 4) return;
-	const tag = String.fromCharCode(data[0] ?? 0, data[1] ?? 0, data[2] ?? 0, data[3] ?? 0);
-	if (tag === "wOF2") return "woff2";
-	if (tag === "wOFF") return "woff";
-	if (tag === "OTTO") return "opentype";
-	if (tag === "true" || data[0] === 0 && data[1] === 1 && data[2] === 0 && data[3] === 0) return "truetype";
+	return classifyFont(data);
 }
 //#endregion
 export { fontFormat };

package/dist/index.d.ts

@@ -1,11 +1,12 @@
 import { base64ToBytes, bytesToBase64 } from "./base64.js";
-import { REFUSED_ELEMENTS, SanitizeOptions, findActiveContent, sanitize } from "./sanitize.js";
+import { REFUSED_ELEMENTS, SanitizeOptions, UrlPolicy, findActiveContent, safeImageSource, safeMarkdownUrl, sanitize } from "./sanitize.js";
 import { BINDINGS, FillOptions, Filled, bindingNames, bindingRoot, fill, hasBindings } from "./bindings.js";
 import { BookBuild, BookDocument, BookDocumentOptions, BookHeading, BookPrintPart, BookSectionInfo, bookPrintPart } from "./book/types.js";
 import { BOOK_COLUMN_MAX, BOOK_COLUMN_MIN, BOOK_FLOW_COLUMN_MIN_PX, BookPositionKey, parseBookPositionKey } from "./book/book-flow.js";
 import { bookDocument } from "./book/book-document.js";
+import { PAGE_REFERENCE_ATTRIBUTE, PAGE_REFERENCE_SELECTOR, PAGE_REFERENCE_VALUE, pageReferenceTarget } from "./book/book-page-reference.js";
 import { bookView, bookViewFromHtml } from "./book/book-view.js";
-import { PaginateBlock, PaginateBookInput, PaginateBookPage, PaginateBookRefusal, PaginateBookResult, PaginateFlow, PaginateFlowParents, PaginateLine, PaginateMark, PaginateNote, PaginateNoteRef, PaginateOpens, PaginatePageMarks, PaginatePageNote, PaginatePageRole, PaginateSequence, PaginateWindow } from "./book/paginate-types.js";
+import { PaginateBlock, PaginateBookInput, PaginateBookPage, PaginateBookRefusal, PaginateBookResult, PaginateFlow, PaginateFlowParents, PaginateLine, PaginateMark, PaginateNote, PaginateNoteRef, PaginateNoteSeriesGeometry, PaginateOpens, PaginatePageMarks, PaginatePageNote, PaginatePageRole, PaginateSequence, PaginateWindow } from "./book/paginate-types.js";
 import { BookFurnitureValues, embedFunction, fillBookFurniture, furnitureScript } from "./book/furniture.js";
 import { BookPageFacts, BookPrintedPagePlan, BookPrintedPageRole, BookSectionParents, PrintedPagePlan, PrintedPageSide, planBookPages, planPrintedPages, printedPageAt, selectBookParent } from "./printed-pages.js";
 import { PAGINATE_FUNCTIONS, paginateBook, paginateScript } from "./book/paginate-book.js";
@@ -15,7 +16,9 @@ import { bookStylesheet, sanitizeBookCss } from "./book-css.js";
 import { FontCssRefusedError, fontCss, fontFaceCss } from "./font-css.js";
 import { fontFormat } from "./font-format.js";
 import { fontReferenceRefusals } from "./font-references.js";
+import { AlertKind, AlertLabels, BodyHtmlOptions, HtmlPage, MarkdownHeading, alertLabels, bodyHtml, isDiagramFence, isGithubAlertBlock, markdownOutline, resolvePageHtml } from "./markdown.js";
 import { ExpandMotifsOptions, ExpandedMotifs, MOTIF_DEPTH_LIMIT, MotifRefusedError, PlacedMotif, documentLanguage, expandMotifs, hasHostMotifPlacement, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements } from "./motifs.js";
+import { MediaAnswer, PLACEMENT_ATTRIBUTES, PlacementPlan, PlacementPlanEntry, PlacementRefusal, PlacementReport, PlacementsOptions, ResolvePlacement, ResolvedPlacement, classifyMediaAnswer, placementCropEdges, placementPlaceholderSource, placementPlan, resolvePlacements } from "./placements.js";
 import { SlotFillEntry, SlotFillRefusal, SlotFillsConflictError, SlotFillsRefusedError, SlotPrintOptions, assertSingleSlotCopy, assertSlotPrintOptions, collectSlotPrintCopies, isSlotCopyRefusal, slotFillCopyId, slotFillsConflict } from "./slot-print.js";
 import { RequiredSlotsRefusedError, UnmeasuredSlotsRefusedError, mergeSlotFitResults, requiredSlotRefusal, unmeasuredSlotRefusal } from "./slot-policy.js";
 import { MAX_SLOT_DECLARATIONS, PreparedSlots, SlotFillRefusedError, hasSlotWork, prepareSlotCollection, prepareSlots, slotFillRefusal } from "./slots.js";
@@ -25,4 +28,4 @@ export type HtmlKind = 'plain' | 'live-data' | 'scripted' | 'refused';
 export declare function classify(html: string, prefix: string): HtmlKind;
 export declare function searchText(html: string): string;
 //#endregion
-export { ABSOLUTE_PX, ABSOLUTE_UNITS, BINDINGS, BOOK_COLUMN_MAX, BOOK_COLUMN_MIN, BOOK_FLOW_COLUMN_MIN_PX, type BookBuild, type BookDocument, type BookDocumentOptions, type BookFurnitureValues, type BookHeading, BookPageFacts, type BookPositionKey, type BookPrintPart, BookPrintedPagePlan, BookPrintedPageRole, type BookSectionInfo, type BookSectionParents, type ExpandMotifsOptions, type ExpandedMotifs, type FillOptions, type Filled, FontCssRefusedError, MAX_SLOT_DECLARATIONS, MOTIF_DEPTH_LIMIT, MotifRefusedError, PAGINATE_FUNCTIONS, type PaginateBlock, type PaginateBookInput, type PaginateBookPage, type PaginateBookRefusal, type PaginateBookResult, type PaginateFlow, type PaginateFlowParents, type PaginateLine, type PaginateMark, type PaginateNote, type PaginateNoteRef, type PaginateOpens, type PaginatePageMarks, type PaginatePageNote, type PaginatePageRole, type PaginateSequence, type PaginateTarget, type PaginateTargetPage, type PaginateWindow, type PlacedMotif, type PreparedSlots, PrintedPagePlan, PrintedPageSide, REFUSED_ELEMENTS, RequiredSlotsRefusedError, type SanitizeOptions, type SlotFillEntry, type SlotFillRefusal, SlotFillRefusedError, SlotFillsConflictError, SlotFillsRefusedError, type SlotPrintOptions, UNICODE_RANGE_CLEARANCE, type UnicodeRangeParse, UnmeasuredSlotsRefusedError, assertSingleSlotCopy, assertSlotPrintOptions, base64ToBytes, bindingNames, bindingRoot, bookDocument, bookPrintPart, bookStylesheet, bookView, bookViewFromHtml, bytesToBase64, collectSlotPrintCopies, documentLanguage, embedFunction, expandMotifs, fill, fillBookFurniture, findActiveContent, fitRegionSize, fontCss, fontFaceCss, fontFormat, fontReferenceRefusals, furnitureScript, hasBindings, hasHostMotifPlacement, hasMotifPlacement, hasSlotWork, heldPageNumber, isSlotCopyRefusal, lengthPx, libraryMotifPlacementRefusal, mergeSlotFitResults, motifPlacementRefusals, openerPageIndex, pageIndexForTarget, paginateBook, paginateScript, parseBookPositionKey, parseCssLength, parseUnicodeRange, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, sanitize, sanitizeBookCss, selectBookParent, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal, windowPageIndex };
+export { ABSOLUTE_PX, ABSOLUTE_UNITS, type AlertKind, type AlertLabels, BINDINGS, BOOK_COLUMN_MAX, BOOK_COLUMN_MIN, BOOK_FLOW_COLUMN_MIN_PX, type BodyHtmlOptions, type BookBuild, type BookDocument, type BookDocumentOptions, type BookFurnitureValues, type BookHeading, BookPageFacts, type BookPositionKey, type BookPrintPart, BookPrintedPagePlan, BookPrintedPageRole, type BookSectionInfo, type BookSectionParents, type ExpandMotifsOptions, type ExpandedMotifs, type FillOptions, type Filled, FontCssRefusedError, type HtmlPage, MAX_SLOT_DECLARATIONS, MOTIF_DEPTH_LIMIT, type MarkdownHeading, type MediaAnswer, MotifRefusedError, PAGE_REFERENCE_ATTRIBUTE, PAGE_REFERENCE_SELECTOR, PAGE_REFERENCE_VALUE, PAGINATE_FUNCTIONS, PLACEMENT_ATTRIBUTES, type PaginateBlock, type PaginateBookInput, type PaginateBookPage, type PaginateBookRefusal, type PaginateBookResult, type PaginateFlow, type PaginateFlowParents, type PaginateLine, type PaginateMark, type PaginateNote, type PaginateNoteRef, type PaginateNoteSeriesGeometry, type PaginateOpens, type PaginatePageMarks, type PaginatePageNote, type PaginatePageRole, type PaginateSequence, type PaginateTarget, type PaginateTargetPage, type PaginateWindow, type PlacedMotif, type PlacementPlan, type PlacementPlanEntry, type PlacementRefusal, type PlacementReport, type PlacementsOptions, type PreparedSlots, PrintedPagePlan, PrintedPageSide, REFUSED_ELEMENTS, RequiredSlotsRefusedError, type ResolvePlacement, type ResolvedPlacement, type SanitizeOptions, type SlotFillEntry, type SlotFillRefusal, SlotFillRefusedError, SlotFillsConflictError, SlotFillsRefusedError, type SlotPrintOptions, UNICODE_RANGE_CLEARANCE, type UnicodeRangeParse, UnmeasuredSlotsRefusedError, type UrlPolicy, alertLabels, assertSingleSlotCopy, assertSlotPrintOptions, base64ToBytes, bindingNames, bindingRoot, bodyHtml, bookDocument, bookPrintPart, bookStylesheet, bookView, bookViewFromHtml, bytesToBase64, classifyMediaAnswer, collectSlotPrintCopies, documentLanguage, embedFunction, expandMotifs, fill, fillBookFurniture, findActiveContent, fitRegionSize, fontCss, fontFaceCss, fontFormat, fontReferenceRefusals, furnitureScript, hasBindings, hasHostMotifPlacement, hasMotifPlacement, hasSlotWork, heldPageNumber, isDiagramFence, isGithubAlertBlock, isSlotCopyRefusal, lengthPx, libraryMotifPlacementRefusal, markdownOutline, mergeSlotFitResults, motifPlacementRefusals, openerPageIndex, pageIndexForTarget, pageReferenceTarget, paginateBook, paginateScript, parseBookPositionKey, parseCssLength, parseUnicodeRange, placementCropEdges, placementPlaceholderSource, placementPlan, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, resolvePageHtml, resolvePlacements, safeImageSource, safeMarkdownUrl, sanitize, sanitizeBookCss, selectBookParent, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal, windowPageIndex };

package/dist/index.js

@@ -1,8 +1,9 @@
-import { REFUSED_ELEMENTS, elements, findActiveContent, parse, sanitize } from "./sanitize.js";
+import { REFUSED_ELEMENTS, elements, findActiveContent, parse, safeImageSource, safeMarkdownUrl, sanitize } from "./sanitize.js";
 import { BINDINGS, bindingNames, bindingRoot, fill, hasBindings } from "./bindings.js";
 import { base64ToBytes, bytesToBase64 } from "./base64.js";
 import { BOOK_COLUMN_MAX, BOOK_COLUMN_MIN, BOOK_FLOW_COLUMN_MIN_PX, parseBookPositionKey } from "./book/book-flow.js";
 import { ABSOLUTE_PX, ABSOLUTE_UNITS, fitRegionSize, lengthPx, parseCssLength } from "./book/region-fit.js";
+import { PAGE_REFERENCE_ATTRIBUTE, PAGE_REFERENCE_SELECTOR, PAGE_REFERENCE_VALUE, pageReferenceTarget } from "./book/book-page-reference.js";
 import { bookPrintPart } from "./book/types.js";
 import { bookDocument } from "./book/book-document.js";
 import { bookView, bookViewFromHtml } from "./book/book-view.js";
@@ -15,7 +16,9 @@ import { UNICODE_RANGE_CLEARANCE, parseUnicodeRange } from "./unicode-range.js";
 import { FontCssRefusedError, fontCss, fontFaceCss } from "./font-css.js";
 import { fontFormat } from "./font-format.js";
 import { fontReferenceRefusals } from "./font-references.js";
+import { alertLabels, bodyHtml, isDiagramFence, isGithubAlertBlock, markdownOutline, resolvePageHtml } from "./markdown.js";
 import { MOTIF_DEPTH_LIMIT, MotifRefusedError, documentLanguage, expandMotifs, hasHostMotifPlacement, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements } from "./motifs.js";
+import { PLACEMENT_ATTRIBUTES, classifyMediaAnswer, placementCropEdges, placementPlaceholderSource, placementPlan, resolvePlacements } from "./placements.js";
 import { RequiredSlotsRefusedError, UnmeasuredSlotsRefusedError, mergeSlotFitResults, requiredSlotRefusal, unmeasuredSlotRefusal } from "./slot-policy.js";
 import { MAX_SLOT_DECLARATIONS, SlotFillRefusedError, hasSlotWork, prepareSlotCollection, prepareSlots, slotFillRefusal } from "./slots.js";
 import { SlotFillsConflictError, SlotFillsRefusedError, assertSingleSlotCopy, assertSlotPrintOptions, collectSlotPrintCopies, isSlotCopyRefusal, slotFillCopyId, slotFillsConflict } from "./slot-print.js";
@@ -31,4 +34,4 @@ function searchText(html) {
 	return html.replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
 }
 //#endregion
-export { ABSOLUTE_PX, ABSOLUTE_UNITS, BINDINGS, BOOK_COLUMN_MAX, BOOK_COLUMN_MIN, BOOK_FLOW_COLUMN_MIN_PX, FontCssRefusedError, MAX_SLOT_DECLARATIONS, MOTIF_DEPTH_LIMIT, MotifRefusedError, PAGINATE_FUNCTIONS, REFUSED_ELEMENTS, RequiredSlotsRefusedError, SlotFillRefusedError, SlotFillsConflictError, SlotFillsRefusedError, UNICODE_RANGE_CLEARANCE, UnmeasuredSlotsRefusedError, assertSingleSlotCopy, assertSlotPrintOptions, base64ToBytes, bindingNames, bindingRoot, bookDocument, bookPrintPart, bookStylesheet, bookView, bookViewFromHtml, bytesToBase64, classify, collectSlotPrintCopies, documentLanguage, embedFunction, expandMotifs, fill, fillBookFurniture, findActiveContent, fitRegionSize, fontCss, fontFaceCss, fontFormat, fontReferenceRefusals, furnitureScript, hasBindings, hasHostMotifPlacement, hasMotifPlacement, hasSlotWork, heldPageNumber, isSlotCopyRefusal, lengthPx, libraryMotifPlacementRefusal, mergeSlotFitResults, motifPlacementRefusals, openerPageIndex, pageIndexForTarget, paginateBook, paginateScript, parseBookPositionKey, parseCssLength, parseUnicodeRange, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, sanitize, sanitizeBookCss, searchText, selectBookParent, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal, windowPageIndex };
+export { ABSOLUTE_PX, ABSOLUTE_UNITS, BINDINGS, BOOK_COLUMN_MAX, BOOK_COLUMN_MIN, BOOK_FLOW_COLUMN_MIN_PX, FontCssRefusedError, MAX_SLOT_DECLARATIONS, MOTIF_DEPTH_LIMIT, MotifRefusedError, PAGE_REFERENCE_ATTRIBUTE, PAGE_REFERENCE_SELECTOR, PAGE_REFERENCE_VALUE, PAGINATE_FUNCTIONS, PLACEMENT_ATTRIBUTES, REFUSED_ELEMENTS, RequiredSlotsRefusedError, SlotFillRefusedError, SlotFillsConflictError, SlotFillsRefusedError, UNICODE_RANGE_CLEARANCE, UnmeasuredSlotsRefusedError, alertLabels, assertSingleSlotCopy, assertSlotPrintOptions, base64ToBytes, bindingNames, bindingRoot, bodyHtml, bookDocument, bookPrintPart, bookStylesheet, bookView, bookViewFromHtml, bytesToBase64, classify, classifyMediaAnswer, collectSlotPrintCopies, documentLanguage, embedFunction, expandMotifs, fill, fillBookFurniture, findActiveContent, fitRegionSize, fontCss, fontFaceCss, fontFormat, fontReferenceRefusals, furnitureScript, hasBindings, hasHostMotifPlacement, hasMotifPlacement, hasSlotWork, heldPageNumber, isDiagramFence, isGithubAlertBlock, isSlotCopyRefusal, lengthPx, libraryMotifPlacementRefusal, markdownOutline, mergeSlotFitResults, motifPlacementRefusals, openerPageIndex, pageIndexForTarget, pageReferenceTarget, paginateBook, paginateScript, parseBookPositionKey, parseCssLength, parseUnicodeRange, placementCropEdges, placementPlaceholderSource, placementPlan, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, resolvePageHtml, resolvePlacements, safeImageSource, safeMarkdownUrl, sanitize, sanitizeBookCss, searchText, selectBookParent, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal, windowPageIndex };

package/dist/markdown-policy.js

@@ -0,0 +1,20 @@
+//#region src/markdown-policy.ts
+const MARKDOWN_CONVERTER_POLICY = {
+	urls: {
+		linkProtocols: [
+			"https:",
+			"http:",
+			"mailto:"
+		],
+		imageProtocols: ["https:", "http:"],
+		linkFragments: true,
+		dataImages: true
+	},
+	inertControls: [{
+		element: "input",
+		type: "checkbox",
+		attribute: "disabled"
+	}]
+};
+//#endregion
+export { MARKDOWN_CONVERTER_POLICY };

package/dist/markdown.d.ts

@@ -0,0 +1,29 @@
+import { Page, PageBody } from "@segnavia/format";
+//#region src/markdown.d.ts
+export type MarkdownHeading = {
+  id: string;
+  level: number;
+  title: string;
+};
+export type AlertKind = 'note' | 'tip' | 'important' | 'warning' | 'caution';
+export type AlertLabels = Record<AlertKind, string>;
+export declare const alertLabels: Readonly<Record<'en' | 'he', AlertLabels>>;
+/** Whether the reader recognizes a blockquote source as a GitHub alert. */
+export declare function isGithubAlertBlock(raw: string): boolean;
+/** Whether the reader turns a fenced language into a diagram placeholder. */
+export declare function isDiagramFence(language: string | undefined): boolean;
+export interface BodyHtmlOptions {
+  alertLabels?: Partial<AlertLabels>;
+  dir?: 'ltr' | 'rtl' | 'auto';
+  lang?: string;
+}
+export declare function bodyHtml(body: PageBody, options?: BodyHtmlOptions): string;
+export declare function markdownOutline(markdown: string | Extract<PageBody, {
+  markdown: string;
+}>): MarkdownHeading[];
+export type HtmlPage = Omit<Page, 'body'> & {
+  html: string;
+};
+export declare function resolvePageHtml(page: Page, options: Pick<BodyHtmlOptions, 'alertLabels'>): HtmlPage;
+export declare function resolvePageHtml(page: Page): HtmlPage;
+//#endregion

package/dist/markdown.js

@@ -0,0 +1,278 @@
+import { MARKDOWN_CONVERTER_POLICY } from "./markdown-policy.js";
+import { sanitize } from "./sanitize.js";
+import { resolveDirection } from "@segnavia/format";
+import rehypeStringify from "rehype-stringify";
+import remarkDirective from "remark-directive";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+import { parse } from "yaml";
+//#region src/markdown.ts
+const alertLabels = {
+	en: {
+		note: "Note",
+		tip: "Tip",
+		important: "Important",
+		warning: "Warning",
+		caution: "Caution"
+	},
+	he: {
+		note: "הערה",
+		tip: "עצה",
+		important: "חשוב",
+		warning: "אזהרה",
+		caution: "זהירות"
+	}
+};
+function alertMarker(value) {
+	const match = /^\[!([A-Za-z]+)\](?:\r?\n|\s*)/.exec(value);
+	const kind = match?.[1]?.toLowerCase();
+	return kind && match && Object.hasOwn(alertLabels.en, kind) ? {
+		kind,
+		length: match[0].length
+	} : void 0;
+}
+/** Whether the reader recognizes a blockquote source as a GitHub alert. */
+function isGithubAlertBlock(raw) {
+	const content = raw.split("\n").map((line) => /^ {0,3}>[ \t]?(.*)$/.exec(line)?.[1] ?? "").find((line) => line.trim() !== "");
+	return Boolean(content && alertMarker(content));
+}
+/** Whether the reader turns a fenced language into a diagram placeholder. */
+function isDiagramFence(language) {
+	return (language ?? "").trim().split(/[ \t]/, 1)[0]?.toLowerCase() === "mermaid";
+}
+const GEOMETRY_STYLE = "<style>:where([data-segnavia-overflow]){max-inline-size:100%;overflow-x:auto}:where([data-segnavia-overflow]>table){inline-size:max-content;min-inline-size:100%}@media print{:where([data-segnavia-overflow]){overflow-x:visible}:where([data-segnavia-overflow]>table){inline-size:100%;max-inline-size:100%;min-inline-size:0}:where([data-segnavia-overflow]>pre){white-space:pre-wrap}}</style>";
+const memo = /* @__PURE__ */ new WeakMap();
+function textNode(value) {
+	return {
+		type: "text",
+		value
+	};
+}
+function element(tagName, children, properties) {
+	return {
+		type: "element",
+		tagName,
+		properties,
+		children
+	};
+}
+function propertyValue(value, ancestors) {
+	if (typeof value === "boolean") return [textNode(value ? "yes" : "no")];
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) return [textNode("(cycle)")];
+		const next = new Set(ancestors).add(value);
+		return value.flatMap((item) => [element("span", propertyValue(item, next))]);
+	}
+	if (value !== null && typeof value === "object") {
+		if (ancestors.has(value)) return [textNode("(cycle)")];
+		return [propertyList(value, new Set(ancestors).add(value))];
+	}
+	return [textNode(value == null ? "" : String(value))];
+}
+function propertyList(properties, ancestors) {
+	return element("dl", Object.entries(properties).flatMap(([key, value]) => [element("dt", [textNode(key)]), element("dd", propertyValue(value, ancestors))]));
+}
+function unreadableFrontmatter(source) {
+	return [element("p", [textNode("Frontmatter could not be read.")]), element("pre", [element("code", [textNode(`---\n${source}\n---`)])])];
+}
+function frontmatter(source) {
+	let value;
+	try {
+		value = parse(source);
+	} catch {
+		return unreadableFrontmatter(source);
+	}
+	if (value == null) return [];
+	if (typeof value !== "object" || Array.isArray(value)) return unreadableFrontmatter(source);
+	const properties = value;
+	return Object.keys(properties).length === 0 ? [] : propertyList(properties, /* @__PURE__ */ new Set([properties])).children ?? [];
+}
+function visibleText(node) {
+	if (node.type === "text" || node.type === "inlineCode") return node.value ?? "";
+	return (node.children ?? []).map(visibleText).join("");
+}
+function slug(title) {
+	return title.trim().toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "") || "section";
+}
+function directiveSource(node, source) {
+	const start = node.position?.start.offset;
+	const end = node.position && "end" in node.position ? node.position.end?.offset : void 0;
+	return start === void 0 || end === void 0 ? `:${node.name ?? ""}` : source.slice(start, end);
+}
+function applyFrontmatter(node) {
+	if (node.type !== "yaml" || typeof node.value !== "string") return;
+	node.type = "paragraph";
+	node.children = [];
+	node.data = {
+		hName: "dl",
+		hProperties: { dataSegnaviaFrontmatter: "" },
+		hChildren: frontmatter(node.value)
+	};
+}
+function applyHeading(node, seen, outline) {
+	if (node.type !== "heading" || !node.depth) return;
+	const title = visibleText(node);
+	const base = slug(title);
+	const count = seen.get(base) ?? 0;
+	seen.set(base, count + 1);
+	const id = count === 0 ? base : `${base}-${count + 1}`;
+	node.data = {
+		...node.data,
+		hProperties: {
+			...node.data?.hProperties,
+			id
+		}
+	};
+	outline.push({
+		id,
+		level: node.depth,
+		title
+	});
+}
+function applyDirective(node) {
+	if (node.type !== "containerDirective") return;
+	const attributes = Object.fromEntries(Object.entries(node.attributes ?? {}).map(([name, value]) => [`dataSegnaviaDirective${name.charAt(0).toUpperCase()}${name.slice(1).replace(/[^a-zA-Z0-9]+(.)/g, (_, next) => next.toUpperCase())}`, value ?? ""]));
+	node.data = {
+		hName: "div",
+		hProperties: {
+			dataSegnaviaDirective: node.name ?? "",
+			...attributes
+		}
+	};
+}
+function applyAlert(node, labels) {
+	if (node.type !== "blockquote") return;
+	const first = node.children?.[0]?.children?.find((child) => child.type === "text");
+	if (!first) return;
+	const marker = alertMarker(first.value ?? "");
+	if (!marker) return;
+	const { kind } = marker;
+	first.value = (first.value ?? "").slice(marker.length);
+	node.data = {
+		hName: "div",
+		hProperties: { dataSegnaviaAlert: kind }
+	};
+	node.children = [{
+		type: "paragraph",
+		children: [{
+			type: "text",
+			value: labels[kind]
+		}],
+		data: { hName: "bdi" }
+	}, ...node.children ?? []];
+}
+function literalDirectives(node, source) {
+	if (!node.children) return;
+	node.children = node.children.map((child) => child.type === "textDirective" || child.type === "leafDirective" ? {
+		type: "text",
+		value: directiveSource(child, source)
+	} : child);
+}
+function markdownPlugin(outline, labels) {
+	return (tree, file) => {
+		const source = String(file.value);
+		const seen = /* @__PURE__ */ new Map();
+		const visit = (node) => {
+			applyFrontmatter(node);
+			applyHeading(node, seen, outline);
+			applyDirective(node);
+			applyAlert(node, labels);
+			literalDirectives(node, source);
+			for (const child of node.children ?? []) visit(child);
+		};
+		visit(tree);
+	};
+}
+function alertLanguage(markdown, options) {
+	const primary = options.lang?.trim().toLowerCase().split(/[-_]/)[0];
+	if (primary === "en" || primary === "he") return primary;
+	const text = markdown.replace(/^>\s*\[![A-Za-z]+\]\s*$/gm, "");
+	return resolveDirection(options.dir, options.lang, text) === "rtl" ? "he" : "en";
+}
+function hastPlugin() {
+	return (tree) => {
+		const wrap = (node) => {
+			const copy = {
+				...node,
+				children: node.children
+			};
+			node.tagName = "div";
+			node.properties = { dataSegnaviaOverflow: "" };
+			node.children = [copy];
+		};
+		const transform = (node) => {
+			if (node.type !== "element") return;
+			if (node.tagName === "table") wrap(node);
+			if (node.tagName !== "pre") return;
+			const code = node.children?.[0];
+			if ((Array.isArray(code?.properties?.className) ? code.properties.className.map(String) : []).some((name) => name.startsWith("language-") && isDiagramFence(name.slice(9)))) node.properties = {
+				...node.properties,
+				dataSegnaviaDiagram: "mermaid"
+			};
+			else wrap(node);
+		};
+		const visit = (node) => {
+			for (const child of node.children ?? []) visit(child);
+			transform(node);
+		};
+		visit(tree);
+	};
+}
+function convert(markdown, options) {
+	const outline = [];
+	const language = alertLanguage(markdown, options);
+	const labels = {
+		...alertLabels[language],
+		...options.alertLabels
+	};
+	const result = unified().use(remarkParse).use(remarkGfm).use(remarkFrontmatter).use(remarkDirective).use(markdownPlugin, outline, labels).use(remarkRehype).use(hastPlugin).use(rehypeStringify).processSync(markdown);
+	return {
+		html: `${GEOMETRY_STYLE}${sanitize(String(result), { converterPolicy: MARKDOWN_CONVERTER_POLICY })}`,
+		outline
+	};
+}
+function optionKey(options) {
+	return JSON.stringify([
+		options.dir,
+		options.lang,
+		options.alertLabels
+	]);
+}
+function markdownResult(body, options) {
+	let entries = memo.get(body);
+	if (!entries) {
+		entries = /* @__PURE__ */ new Map();
+		memo.set(body, entries);
+	}
+	const key = optionKey(options);
+	const found = entries.get(key);
+	if (found !== void 0) return found;
+	const result = convert(body.markdown, options);
+	entries.set(key, result);
+	return result;
+}
+function outlinedMarkdownResult(body) {
+	return memo.get(body)?.values().next().value ?? markdownResult(body, {});
+}
+function bodyHtml(body, options = {}) {
+	return "html" in body ? body.html : markdownResult(body, options).html;
+}
+function markdownOutline(markdown) {
+	return outlinedMarkdownResult(typeof markdown === "string" ? { markdown } : markdown).outline;
+}
+function resolvePageHtml(page, options = {}) {
+	const { body, ...fields } = page;
+	return {
+		...fields,
+		html: bodyHtml(body, {
+			dir: page.dir,
+			lang: page.lang,
+			alertLabels: options.alertLabels
+		})
+	};
+}
+//#endregion
+export { alertLabels, bodyHtml, isDiagramFence, isGithubAlertBlock, markdownOutline, resolvePageHtml };

package/dist/placements.d.ts

@@ -0,0 +1,89 @@
+import { Media, Page, Placement } from "@segnavia/format";
+//#region src/placements.d.ts
+export declare const PLACEMENT_ATTRIBUTES: readonly ["data-segnavia-media", "data-segnavia-page", "data-segnavia-box", "data-segnavia-crop"];
+export type ResolvedPlacement = {
+  kind: 'media';
+  media: Media;
+  src: string;
+} | {
+  kind: 'page';
+  page: Page;
+};
+export type ResolvePlacement<R extends {
+  kind: string;
+} = ResolvedPlacement> = (placement: Placement, context: {
+  purpose: 'screen' | 'print';
+  width?: number;
+  signal: AbortSignal;
+}) => Promise<R | undefined>;
+export interface PlacementPlanEntry {
+  index: number;
+  placement: Placement;
+  alt?: string;
+  lang?: string;
+  dir?: string;
+  width?: number;
+}
+export interface PlacementRefusal {
+  index: number;
+  address?: string;
+  page?: string | number;
+  message: string;
+}
+export interface PlacementPlan {
+  entries: PlacementPlanEntry[];
+  refusals: PlacementRefusal[];
+}
+export type PlacementReport = (entry: {
+  address: string | undefined;
+  page: string | number | undefined;
+  reason: 'missing' | 'refused-src' | 'invalid' | 'failed';
+  message?: string;
+}) => void;
+export interface PlacementsOptions<R extends {
+  kind: string;
+} = ResolvedPlacement> {
+  resolve: ResolvePlacement<R>;
+  report?: PlacementReport;
+}
+type ResolvedMedia = Extract<ResolvedPlacement, {
+  kind: 'media';
+}>;
+export type MediaAnswer = {
+  status: 'ok';
+  value: ResolvedMedia;
+} | {
+  status: 'missing' | 'refused-src';
+  message?: undefined;
+} | {
+  status: 'invalid';
+  message: string;
+} | {
+  status: 'failed';
+  message: string;
+};
+export declare function classifyMediaAnswer(input: {
+  answer: {
+    kind: string;
+  } | undefined;
+}): Exclude<MediaAnswer, {
+  status: 'failed';
+}>;
+export declare function classifyMediaAnswer(input: {
+  error: unknown;
+}): Extract<MediaAnswer, {
+  status: 'failed';
+}>;
+export declare function placementCropEdges(crop: Placement['crop']): string | undefined;
+export declare function placementPlan(html: string): PlacementPlan;
+export declare function placementPlaceholderSource(width?: number, height?: number): string;
+export declare function resolvePlacements<R extends {
+  kind: string;
+}>(html: string, options: {
+  resolvePlacement: ResolvePlacement<R>;
+  purpose: 'screen' | 'print';
+  width: number;
+  signal: AbortSignal;
+  report?: PlacementReport;
+}): Promise<string>;
+//#endregion

package/dist/placements.js

@@ -0,0 +1,189 @@
+import { elements, parse, safeImageSource, serialize } from "./sanitize.js";
+import { Placement, mediaTextDirection } from "@segnavia/format";
+//#region src/placements.ts
+const PLACEMENT_ATTRIBUTES = [
+	"data-segnavia-media",
+	"data-segnavia-page",
+	"data-segnavia-box",
+	"data-segnavia-crop"
+];
+const [MEDIA_ATTRIBUTE, PAGE_ATTRIBUTE, BOX_ATTRIBUTE, CROP_ATTRIBUTE] = PLACEMENT_ATTRIBUTES;
+function classifyMediaAnswer(input) {
+	if ("error" in input) return {
+		status: "failed",
+		message: input.error instanceof Error ? input.error.message : String(input.error)
+	};
+	const answer = input.answer;
+	if (!answer) return { status: "missing" };
+	if (answer.kind !== "media" || !("src" in answer) || !("media" in answer)) return {
+		status: "invalid",
+		message: `resolved ${answer.kind}, not media`
+	};
+	const media = answer;
+	return safeImageSource(media.src) ? {
+		status: "ok",
+		value: media
+	} : { status: "refused-src" };
+}
+function placementCropEdges(crop) {
+	if (!crop) return void 0;
+	return `${crop.top ?? 0} ${crop.right ?? 0} ${crop.bottom ?? 0} ${crop.left ?? 0}`;
+}
+function positiveInteger(value) {
+	return value !== void 0 && /^[1-9][0-9]*$/.test(value) ? Number(value) : void 0;
+}
+function pageSelector(value) {
+	if (value === void 0) return void 0;
+	return /^[1-9][0-9]*$/.test(value) ? Number(value) : value;
+}
+function cropValue(value) {
+	if (value === void 0) return void 0;
+	const edges = value.trim().split(/\s+/);
+	if (edges.length < 1 || edges.length > 4) return { top: value };
+	const [top, second, third, fourth] = edges;
+	return {
+		top,
+		right: second ?? top,
+		bottom: third ?? top,
+		left: fourth ?? second ?? top
+	};
+}
+function plannedElement(element, index) {
+	const address = element.attribs[MEDIA_ATTRIBUTE];
+	const page = pageSelector(element.attribs[PAGE_ATTRIBUTE]);
+	try {
+		return {
+			index,
+			placement: Placement.parse({
+				kind: "media",
+				address,
+				...page === void 0 ? {} : { page },
+				...element.attribs[BOX_ATTRIBUTE] === void 0 ? {} : { box: element.attribs[BOX_ATTRIBUTE] },
+				...element.attribs[CROP_ATTRIBUTE] === void 0 ? {} : { crop: cropValue(element.attribs[CROP_ATTRIBUTE]) }
+			}, "page"),
+			..."alt" in element.attribs ? { alt: element.attribs.alt } : {},
+			..."lang" in element.attribs ? { lang: element.attribs.lang } : {},
+			..."dir" in element.attribs ? { dir: element.attribs.dir } : {},
+			...positiveInteger(element.attribs.width) === void 0 ? {} : { width: positiveInteger(element.attribs.width) }
+		};
+	} catch (error) {
+		return {
+			index,
+			address,
+			page,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function planElements(found) {
+	const planned = found.flatMap((element, index) => element.name.toLowerCase() === "img" && MEDIA_ATTRIBUTE in element.attribs ? [plannedElement(element, index)] : []);
+	return {
+		entries: planned.filter((entry) => "placement" in entry),
+		refusals: planned.filter((entry) => !("placement" in entry))
+	};
+}
+function placementPlan(html) {
+	return planElements(elements(parse(html).children));
+}
+function placementPlaceholderSource(width = 400, height = 300) {
+	const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><rect width="100%" height="100%" fill="#eee"/><rect x="0.5" y="0.5" width="${width - 1}" height="${height - 1}" fill="none" stroke="#aaa"/></svg>`;
+	return `data:image/svg+xml,${encodeURIComponent(svg)}`;
+}
+function placeholder(element) {
+	const authoredWidth = positiveInteger(element.attribs.width);
+	const authoredHeight = positiveInteger(element.attribs.height);
+	const width = authoredWidth ?? (authoredHeight === void 0 ? 400 : Math.round(authoredHeight * 4 / 3));
+	const height = authoredHeight ?? (authoredWidth === void 0 ? 300 : Math.round(authoredWidth * 3 / 4));
+	element.attribs.src = placementPlaceholderSource(width, height);
+	element.attribs["data-segnavia-placement"] = "missing";
+	if (!("alt" in element.attribs)) element.attribs.alt = "";
+	for (const attribute of PLACEMENT_ATTRIBUTES) delete element.attribs[attribute];
+}
+function applyResolved(element, entry, resolved) {
+	element.attribs.src = resolved.src;
+	if (entry.alt === void 0 && resolved.media.alt) {
+		element.attribs.alt = resolved.media.alt.text;
+		if (entry.lang === void 0 && entry.dir === void 0) {
+			if (resolved.media.alt.lang) element.attribs.lang = resolved.media.alt.lang;
+			element.attribs.dir = mediaTextDirection(resolved.media.alt);
+		}
+	}
+	const crop = placementCropEdges(entry.placement.crop);
+	if (crop) {
+		const declaration = `object-view-box: inset(${crop})`;
+		const authored = element.attribs.style?.trim();
+		element.attribs.style = authored ? `${authored.replace(/;?$/, ";")} ${declaration}` : declaration;
+	}
+	for (const attribute of PLACEMENT_ATTRIBUTES) delete element.attribs[attribute];
+}
+function abortable(work, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		const aborted = () => reject(signal.reason);
+		signal.addEventListener("abort", aborted, { once: true });
+		work().then((value) => {
+			signal.removeEventListener("abort", aborted);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", aborted);
+			reject(error);
+		});
+	});
+}
+async function resolvePlacements(html, options) {
+	const document = parse(html);
+	const found = elements(document.children);
+	const plan = planElements(found);
+	if (plan.entries.length === 0 && plan.refusals.length === 0) return html;
+	options.signal.throwIfAborted();
+	for (const refusal of plan.refusals) {
+		const element = found[refusal.index];
+		if (element) placeholder(element);
+		options.report?.({
+			address: refusal.address,
+			page: refusal.page,
+			reason: "invalid",
+			message: refusal.message
+		});
+	}
+	await Promise.all(plan.entries.map(async (entry) => {
+		const element = found[entry.index];
+		if (!element) return;
+		try {
+			const resolved = await abortable(() => options.resolvePlacement(entry.placement, {
+				purpose: options.purpose,
+				width: entry.width ?? options.width,
+				signal: options.signal
+			}), options.signal);
+			options.signal.throwIfAborted();
+			const classified = classifyMediaAnswer({ answer: resolved });
+			if (classified.status === "ok") applyResolved(element, entry, classified.value);
+			else {
+				placeholder(element);
+				options.report?.({
+					address: entry.placement.address,
+					page: entry.placement.page,
+					reason: classified.status,
+					...classified.message === void 0 ? {} : { message: classified.message }
+				});
+			}
+		} catch (error) {
+			if (options.signal.aborted) throw options.signal.reason;
+			const classified = classifyMediaAnswer({ error });
+			placeholder(element);
+			options.report?.({
+				address: entry.placement.address,
+				page: entry.placement.page,
+				reason: classified.status,
+				message: classified.message
+			});
+		}
+	}));
+	options.signal.throwIfAborted();
+	return serialize(document);
+}
+//#endregion
+export { PLACEMENT_ATTRIBUTES, classifyMediaAnswer, placementCropEdges, placementPlaceholderSource, placementPlan, resolvePlacements };

package/dist/sanitize.d.ts

@@ -7,7 +7,25 @@ export interface SanitizeOptions {
   dependencyOrigins?: Iterable<string>;
   dataFonts?: boolean;
   refuseElements?: Iterable<string>;
+  converterPolicy?: ConverterPolicy;
 }
+export interface UrlPolicy {
+  linkProtocols: readonly string[];
+  imageProtocols: readonly string[];
+  linkFragments: boolean;
+  dataImages: boolean;
+}
+export interface ConverterPolicy {
+  urls: UrlPolicy;
+  inertControls: readonly {
+    element: 'input';
+    type: 'checkbox';
+    attribute: 'disabled';
+  }[];
+}
+export declare function safeImageSource(value: string): boolean;
+/** The URL decision used when schema-based authoring admits a link or image. */
+export declare function safeMarkdownUrl(attribute: 'href' | 'src', value: string, linkOrigins?: Iterable<string>): boolean;
 export declare function findActiveContent(html: string, options?: SanitizeOptions): string[];
 export declare function sanitize(html: string, options?: SanitizeOptions): string;
 //#endregion

package/dist/sanitize.js

@@ -1,3 +1,4 @@
+import { MARKDOWN_CONVERTER_POLICY } from "./markdown-policy.js";
 import { sanitizeCss } from "./sanitize-css.js";
 import { isTag } from "domhandler";
 import { dependencyDecision, dependencyOriginSet, originSet } from "@segnavia/format";
@@ -80,25 +81,50 @@ function insideSvg(element) {
 function normalizeUrl(value) {
 	return [...value].filter((c) => c.charCodeAt(0) > 32 && c.charCodeAt(0) !== 127).join("").toLowerCase();
 }
-function safeUrl(attribute, value, allowed) {
+function safeImageSource(value) {
+	return DATA_IMAGE.test(normalizeUrl(value));
+}
+function safeUrl(attribute, value, allowed, policy) {
 	const url = normalizeUrl(value);
 	if (attribute === "href" || attribute === "xlink:href") {
-		if (url.startsWith("#")) return true;
+		if (url.startsWith("#")) return policy?.linkFragments ?? true;
 		try {
 			const parsed = new URL(url);
+			if (policy) return policy.linkProtocols.includes(parsed.protocol);
 			return parsed.protocol === "https:" && allowed.has(parsed.origin);
 		} catch {
 			return false;
 		}
 	}
 	if (attribute === "srcset") return DATA_IMAGE_SRCSET.test(url);
-	if (attribute === "src" || attribute === "poster") return DATA_IMAGE.test(url);
+	if (attribute === "src" || attribute === "poster") {
+		if (policy?.dataImages && safeImageSource(value)) return true;
+		if (!policy) return safeImageSource(value);
+		try {
+			return policy.imageProtocols.includes(new URL(url).protocol);
+		} catch {
+			return false;
+		}
+	}
 	return false;
 }
-function refusedElement(element, refused, keepScripts) {
+/** The URL decision used when schema-based authoring admits a link or image. */
+function safeMarkdownUrl(attribute, value, linkOrigins) {
+	if (!safeUrl(attribute, value, /* @__PURE__ */ new Set(), MARKDOWN_CONVERTER_POLICY.urls)) return false;
+	if (attribute === "src" || linkOrigins === void 0 || value.startsWith("#")) return true;
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		return true;
+	}
+	return parsed.protocol !== "http:" && parsed.protocol !== "https:" || originSet(linkOrigins).has(parsed.origin.toLowerCase());
+}
+function refusedElement(element, refused, options, keepScripts) {
 	const name = element.name.toLowerCase();
 	if (name === "script") return !keepScripts;
 	if (name === "link" && keepScripts && element.attribs.rel?.toLowerCase() === "stylesheet") return false;
+	if (options.converterPolicy?.inertControls.some((control) => control.element === name && element.attribs.type?.toLowerCase() === control.type && control.attribute in element.attribs)) return false;
 	if (refused.has(name)) return true;
 	if (insideSvg(element) && REFUSED_SVG_ELEMENTS.has(name)) return true;
 	return name === "meta" && Object.keys(element.attribs).some((attribute) => attribute.toLowerCase() === "http-equiv");
@@ -115,7 +141,7 @@ function refusedAttribute(element, name, value, allowed, options, dependencies)
 	if (attribute.startsWith("on")) return options.keepScripts ? void 0 : "";
 	const dependency = dependencyAttribute(element, attribute, value, options, dependencies);
 	if (dependency !== void 0) return dependency || void 0;
-	return REFUSED_ATTRIBUTES.has(attribute) || URL_ATTRIBUTES.has(attribute) && !safeUrl(attribute, value, allowed) ? "" : void 0;
+	return REFUSED_ATTRIBUTES.has(attribute) || URL_ATTRIBUTES.has(attribute) && !safeUrl(attribute, value, allowed, options.converterPolicy?.urls) ? "" : void 0;
 }
 function refusedSet(options) {
 	const defaults = options.keepScripts ? Object.entries(REFUSED).filter(([, rule]) => rule === "always").map(([name]) => name) : REFUSED_ELEMENTS;
@@ -165,7 +191,7 @@ function findActiveContent(html, options = {}) {
 	const keepScripts = options.keepScripts ?? false;
 	const found = [];
 	for (const element of elements(parse(html).children)) {
-		if (refusedElement(element, refused, keepScripts)) found.push(`<${element.name}>`);
+		if (refusedElement(element, refused, options, keepScripts)) found.push(`<${element.name}>`);
 		found.push(...styleFindings(element, options, dependencies));
 		for (const [name, value] of Object.entries(element.attribs)) {
 			const reason = refusedAttribute(element, name, value, allowed, options, dependencies);
@@ -198,7 +224,7 @@ function sanitize(html, options = {}) {
 	const document = parse(html);
 	const prune = (nodes) => nodes.filter((node) => {
 		if (!isTag(node)) return true;
-		if (refusedElement(node, refused, keepScripts)) return false;
+		if (refusedElement(node, refused, options, keepScripts)) return false;
 		cleanStyleElement(node, options, dependencies);
 		cleanAttributes(node, allowed, options, dependencies);
 		node.children = prune(node.children);
@@ -208,4 +234,4 @@ function sanitize(html, options = {}) {
 	return serialize(document);
 }
 //#endregion
-export { REFUSED_ELEMENTS, elements, findActiveContent, parse, sanitize, serialize };
+export { REFUSED_ELEMENTS, elements, findActiveContent, parse, safeImageSource, safeMarkdownUrl, sanitize, serialize };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/html",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,10 +26,18 @@
     }
   },
   "dependencies": {
-    "@segnavia/format": "0.38.0",
+    "@segnavia/format": "0.40.0",
     "dom-serializer": "^2.0.0",
     "domhandler": "^5.0.3",
     "htmlparser2": "^10.0.0",
-    "qrcode-generator": "2.0.4"
+    "qrcode-generator": "2.0.4",
+    "rehype-stringify": "10.0.1",
+    "remark-directive": "4.0.0",
+    "remark-frontmatter": "5.0.0",
+    "remark-gfm": "4.0.1",
+    "remark-parse": "11.0.0",
+    "remark-rehype": "11.1.2",
+    "unified": "11.0.5",
+    "yaml": "2.9.1"
   }
 }