@segnavia/html 0.37.0 → 0.39.0

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-sequence.d.ts

@@ -1,4 +1,4 @@
 import { PaginateBookInput, PaginateBookResult, PaginatePageFill, PaginatePageNote, PaginateUnit } from "./paginate-types.js";
 //#region src/book/paginate-sequence.d.ts
-export declare function paginateSequence(input: PaginateBookInput, fillPage: (units: PaginateUnit[], index: number, pending: PaginatePageNote[]) => PaginatePageFill): PaginateBookResult;
+export declare function paginateSequence(input: PaginateBookInput, fillPage: (units: PaginateUnit[], index: number, pending: PaginatePageNote[], textHeight: number, textArea?: string) => PaginatePageFill): PaginateBookResult;
 //#endregion

package/dist/book/paginate-sequence.js

@@ -1,7 +1,23 @@
+import { selectBookParent } from "../printed-pages.js";
 import { paginateColumns } from "./paginate-columns.js";
 import { paginateMarks } from "./paginate-marks.js";
 //#region src/book/paginate-sequence.ts
 function paginateSequence(input, fillPage) {
+	function selected(flow, opening, blank, role, pageIndex, parents = flow.parents) {
+		const fact = {
+			blank,
+			sectionOpening: opening,
+			...role === void 0 ? {} : { role },
+			...parents === void 0 ? {} : { parents }
+		};
+		return selectBookParent(fact, pageIndex, pageIndex, input.settings.direction, input.parentNames);
+	}
+	function pageHeight(parent) {
+		return input.parents[parent]?.height ?? 0;
+	}
+	function notesOnlyOpeningPage(page, opener) {
+		return opener && page.placed.length === 0 && page.fragments.length > 0 && !page.refusal;
+	}
 	function emptyMarks() {
 		return Object.create(null);
 	}
@@ -37,7 +53,7 @@ function paginateSequence(input, fillPage) {
 		}
 	}
 	function isFront(flow) {
-		if (flow.kind === "fixed") return flow.sequence === "front";
+		if (flow.sequence !== void 0) return flow.sequence === "front";
 		return flow.kind === "front" || flow.kind === "contents";
 	}
 	function unitsOf(flow) {
@@ -62,9 +78,6 @@ function paginateSequence(input, fillPage) {
 		}
 		return units;
 	}
-	function flowParents(flow) {
-		return flow.parents === void 0 ? {} : { parents: flow.parents };
-	}
 	function openingOf(flow) {
 		if (flow.opens === "recto" || flow.opens === "verso" || flow.opens === "any") return flow.opens;
 		return input.settings.rectoOpenings ? "recto" : "any";
@@ -75,7 +88,8 @@ function paginateSequence(input, fillPage) {
 		if (opens === "verso") return nextIsRecto;
 		return false;
 	}
-	function makeBlank(number, sequence, flow) {
+	function makeBlank(number, sequence, flow, physicalIndex) {
+		const planned = selected(flow, false, true, "body", physicalIndex);
 		return {
 			kind: "blank",
 			number,
@@ -86,10 +100,11 @@ function paginateSequence(input, fillPage) {
 			notes: [],
 			blank: true,
 			sectionOpening: false,
-			...flowParents(flow)
+			parent: planned.parent,
+			side: planned.side
 		};
 	}
-	function makeContent(part, number, flow, opener, placed, fragments, marks) {
+	function makeContent(part, number, flow, opener, placed, fragments, marks, planned) {
 		const layout = paginateColumns(placed);
 		return {
 			kind: part,
@@ -103,12 +118,15 @@ function paginateSequence(input, fillPage) {
 			blank: false,
 			sectionOpening: opener,
 			...opener || flow.runningHead === void 0 ? {} : { runningHead: flow.runningHead },
+			...flow.parts === void 0 ? {} : { parts: flow.parts },
 			marks,
-			...flowParents(flow)
+			parent: planned.parent,
+			side: planned.side
 		};
 	}
-	function makeFixed(part, number, flow, opener, marks) {
+	function makeFixed(part, number, flow, opener, marks, physicalIndex, parents = flow.parents) {
 		const templated = flow.kind === "fixed" && flow.role === "body";
+		const planned = selected(flow, opener, false, templated ? "body" : "fixed", physicalIndex, parents);
 		return {
 			kind: part,
 			number,
@@ -120,38 +138,47 @@ function paginateSequence(input, fillPage) {
 			blank: false,
 			sectionOpening: opener,
 			...opener && !templated || flow.runningHead === void 0 ? {} : { runningHead: flow.runningHead },
+			...flow.parts === void 0 ? {} : { parts: flow.parts },
 			marks,
-			...flowParents(flow)
+			parent: planned.parent,
+			side: planned.side
 		};
 	}
-	function emitMarked(part, flow, opener, placed, fragments, pages, carried) {
+	function emitMarked(part, flow, opener, placed, fragments, pages, carried, planned) {
 		const marked = paginateMarks(placed, carried);
-		pages.push(makeContent(part, pages.length + 1, flow, opener, placed, fragments, marked.marks));
+		pages.push(makeContent(part, pages.length + 1, flow, opener, placed, fragments, marked.marks, planned));
 		return marked.carried;
 	}
-	function appendFixed(flow, part, pages, continued, carried) {
+	function appendFixed(flow, part, pages, continued, carried, physicalOffset) {
 		const count = flow.kind === "fixed" ? flow.pages : 0;
 		let next = carried;
 		for (let index = 0; index < count; index += 1) {
 			const opener = index === 0;
 			const marked = paginateMarks([], next);
 			next = marked.carried;
-			pages.push(makeFixed(part, pages.length + 1, flow, opener, marked.marks));
+			pages.push(makeFixed(part, pages.length + 1, flow, opener, marked.marks, physicalOffset + pages.length + 1, flow.kind === "fixed" ? flow.pageParents?.[index] : void 0));
 		}
 		return {
 			pending: continued,
 			carried: next
 		};
 	}
-	function paginateFlow(flow, part, pages, continued, carried) {
-		if (flow.kind === "fixed") return appendFixed(flow, part, pages, continued, carried);
+	function paginateFlowing(flow, part, pages, continued, carried, physicalOffset) {
 		const units = unitsOf(flow);
 		let index = 0;
 		let pending = continued;
 		let opener = true;
 		let nextCarried = carried;
 		while (index < units.length || pending.length > 0) {
-			const page = fillPage(units, index, pending);
+			let planned = selected(flow, opener, false, void 0, physicalOffset + pages.length + 1);
+			const height = pageHeight(planned.parent);
+			const textArea = opener ? `the "${planned.parent}" opener parent's ${height}px text area` : void 0;
+			let page = fillPage(units, index, pending, height, textArea);
+			const isOpening = opener && page.placed.length > 0;
+			if (notesOnlyOpeningPage(page, opener)) {
+				planned = selected(flow, isOpening, false, void 0, physicalOffset + pages.length + 1);
+				page = fillPage(units, index, pending, pageHeight(planned.parent));
+			}
 			if (page.refusal) return {
 				refusal: page.refusal,
 				pending,
@@ -161,7 +188,7 @@ function paginateSequence(input, fillPage) {
 				pending,
 				carried: nextCarried
 			};
-			nextCarried = emitMarked(part, flow, opener && page.placed.length > 0, page.placed, page.fragments, pages, nextCarried);
+			nextCarried = emitMarked(part, flow, isOpening, page.placed, page.fragments, pages, nextCarried, planned);
 			opener = opener && page.placed.length === 0;
 			index = page.index;
 			pending = page.pending;
@@ -171,27 +198,32 @@ function paginateSequence(input, fillPage) {
 			carried: nextCarried
 		};
 	}
-	function flushNotes(continued, flow, part, pages, carried) {
+	function paginateFlow(flow, part, pages, continued, carried, physicalOffset) {
+		if (flow.kind === "fixed") return appendFixed(flow, part, pages, continued, carried, physicalOffset);
+		return paginateFlowing(flow, part, pages, continued, carried, physicalOffset);
+	}
+	function flushNotes(continued, flow, part, pages, carried, physicalOffset) {
 		let pending = continued;
 		let nextCarried = carried;
 		while (pending.length > 0) {
-			const page = fillPage([], 0, pending);
+			const planned = selected(flow, false, false, "body", physicalOffset + pages.length + 1);
+			const page = fillPage([], 0, pending, pageHeight(planned.parent));
 			if (page.refusal) return {
 				refusal: page.refusal,
 				carried: nextCarried
 			};
 			if (page.done || page.placed.length === 0 && page.fragments.length === 0) return { carried: nextCarried };
-			nextCarried = emitMarked(part, flow, false, page.placed, page.fragments, pages, nextCarried);
+			nextCarried = emitMarked(part, flow, false, page.placed, page.fragments, pages, nextCarried, planned);
 			pending = page.pending;
 		}
 		return { carried: nextCarried };
 	}
-	function flushBeforeFixed(flow, previous, continued, carried, part, pages) {
+	function flushBeforeFixed(flow, previous, continued, carried, part, pages, physicalOffset) {
 		if (flow.kind !== "fixed" || continued.length === 0 || !previous) return {
 			continued,
 			carried
 		};
-		const flushed = flushNotes(continued, previous, part, pages, carried);
+		const flushed = flushNotes(continued, previous, part, pages, carried, physicalOffset);
 		if ("refusal" in flushed && flushed.refusal) return { refusal: flushed.refusal };
 		return {
 			continued: [],
@@ -199,10 +231,10 @@ function paginateSequence(input, fillPage) {
 		};
 	}
 	function emitFlow(flow, previous, continued, carried, part, pages, physicalOffset) {
-		const held = flushBeforeFixed(flow, previous, continued, carried, part, pages);
+		const held = flushBeforeFixed(flow, previous, continued, carried, part, pages, physicalOffset);
 		if ("refusal" in held && held.refusal) return { refusal: held.refusal };
-		if (needsOpeningBlank(openingOf(flow), physicalOffset + pages.length)) pages.push(makeBlank(pages.length + 1, part, flow));
-		const result = paginateFlow(flow, part, pages, held.continued, held.carried);
+		if (needsOpeningBlank(openingOf(flow), physicalOffset + pages.length)) pages.push(makeBlank(pages.length + 1, part, flow, physicalOffset + pages.length + 1));
+		const result = paginateFlow(flow, part, pages, held.continued, held.carried, physicalOffset);
 		if ("refusal" in result && result.refusal) return { refusal: result.refusal };
 		return {
 			continued: result.pending,
@@ -226,7 +258,7 @@ function paginateSequence(input, fillPage) {
 		}
 		const last = flows[flows.length - 1];
 		if (last) {
-			const flushed = flushNotes(continued, last, part, pages, carried);
+			const flushed = flushNotes(continued, last, part, pages, carried, physicalOffset);
 			if ("refusal" in flushed && flushed.refusal) return {
 				pages,
 				refusals: [flushed.refusal]
@@ -248,7 +280,7 @@ function paginateSequence(input, fillPage) {
 	const firstBody = bodyFlows[0];
 	const lastFront = frontFlows[frontFlows.length - 1];
 	const padFront = input.settings.rectoOpenings ? front.pages.length % 2 === 1 : firstBody !== void 0 && needsOpeningBlank(openingOf(firstBody), front.pages.length);
-	if (front.pages.length > 0 && lastFront && padFront) front.pages.push(makeBlank(front.pages.length + 1, "front", lastFront));
+	if (front.pages.length > 0 && lastFront && padFront) front.pages.push(makeBlank(front.pages.length + 1, "front", lastFront, front.pages.length + 1));
 	const body = paginatePart(bodyFlows, "body", front.pages.length);
 	if (body.refusals.length > 0) return {
 		pages: [...front.pages, ...body.pages],

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

@@ -1,4 +1,4 @@
-import { BookOpens, BookSectionParents } from "@segnavia/format";
+import { BOOK_PARENT_NAMES, BookOpens, BookSectionParents, TextArea } from "@segnavia/format";
 //#region src/book/paginate-types.d.ts
 export type PaginateSequence = 'front' | 'body';
 export type PaginatePageRole = 'opener' | 'body' | 'blank' | 'fixed';
@@ -36,30 +36,39 @@ export type PaginateFlowParents = BookSectionParents;
 export type PaginateOpens = BookOpens;
 interface PaginateFlowBase {
   id: string;
+  sequence?: PaginateSequence;
   runningHead?: string;
   opens?: PaginateOpens;
   parents?: PaginateFlowParents;
+  parts?: Record<string, string>;
 }
 export type PaginateFlow = (PaginateFlowBase & {
-  kind: 'front' | 'contents' | 'chapter' | 'endnotes';
+  kind: 'front' | 'contents' | 'part' | 'chapter' | 'endnotes';
   blocks: PaginateBlock[];
 }) | (PaginateFlowBase & {
   kind: 'fixed';
   pages: number;
-  sequence?: PaginateSequence;
   role?: 'fixed' | 'body';
+  pageParents?: PaginateFlowParents[];
 });
 export interface PaginateNote {
   id: string;
+  series: string;
   lines: PaginateLine[];
 }
+export interface PaginateNoteSeriesGeometry {
+  name: string;
+  gap: number;
+}
 export interface PaginateBookInput {
   flows: PaginateFlow[];
   notes: PaginateNote[];
   geometry: {
-    textHeight: number;
     notesGap: number;
+    noteSeries?: PaginateNoteSeriesGeometry[];
   };
+  parents: Record<string, TextArea>;
+  parentNames: typeof BOOK_PARENT_NAMES;
   settings: {
     orphans?: number;
     widows?: number;
@@ -78,6 +87,7 @@ export interface PaginateWindow {
 }
 export interface PaginatePageNote {
   id: string;
+  series: string;
   whole: boolean;
   start: number;
   end: number;
@@ -98,8 +108,10 @@ export interface PaginateBookPage {
   blank: boolean;
   sectionOpening: boolean;
   runningHead?: string;
+  parts?: Record<string, string>;
   marks?: PaginatePageMarks;
-  parents?: PaginateFlowParents;
+  parent: string;
+  side: 'left' | 'right';
 }
 export type PaginateBookRefusal = {
   tag: string;
@@ -143,6 +155,7 @@ interface PaginateNotesBase {
   geometry: {
     textHeight: number;
     notesGap: number;
+    noteSeries?: PaginateNoteSeriesGeometry[];
   };
 }
 export type PaginateNotesOp = (PaginateNotesBase & {

package/dist/book/region-fit.d.ts

@@ -0,0 +1,16 @@
+//#region src/book/region-fit.d.ts
+export declare const ABSOLUTE_UNITS: readonly ["px", "pt", "pc", "in", "cm", "mm", "q"];
+type AbsoluteUnit = (typeof ABSOLUTE_UNITS)[number];
+export declare const ABSOLUTE_PX: Record<AbsoluteUnit, number>;
+export declare function parseCssLength(value: string): {
+  value: number;
+  unit: string;
+} | undefined;
+export declare function lengthPx(value: string, table: Readonly<Record<string, number>>): number | undefined;
+export declare function fitRegionSize(max: number, min: number, step: number, overflows: (size: number) => boolean): {
+  overflow: boolean;
+  size: number;
+} | {
+  usable: false;
+};
+//#endregion

package/dist/book/region-fit.js

@@ -0,0 +1,111 @@
+import { PX_PER_MM, PX_PER_PT } from "@segnavia/format";
+//#region src/book/region-fit.ts
+const ABSOLUTE_UNITS = [
+	"px",
+	"pt",
+	"pc",
+	"in",
+	"cm",
+	"mm",
+	"q"
+];
+const ABSOLUTE_PX = {
+	px: 1,
+	pt: PX_PER_PT,
+	pc: 12 * PX_PER_PT,
+	in: 72 * PX_PER_PT,
+	cm: 10 * PX_PER_MM,
+	mm: PX_PER_MM,
+	q: PX_PER_MM / 4
+};
+function listedAbsoluteUnits() {
+	const last = ABSOLUTE_UNITS.length - 1;
+	return `${ABSOLUTE_UNITS.slice(0, last).join(", ")} or ${ABSOLUTE_UNITS[last]}`;
+}
+function isAbsoluteUnit(unit) {
+	return ABSOLUTE_UNITS.includes(unit);
+}
+function parseCssLength(value) {
+	const held = value.trim().replace(/\s*!important\s*$/i, "");
+	const match = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+))([a-z%]+)$/i.exec(held);
+	const amount = match?.[1];
+	const unit = match?.[2];
+	if (amount === void 0 || unit === void 0) return void 0;
+	return {
+		value: Number(amount),
+		unit: unit.toLowerCase()
+	};
+}
+function lengthPx(value, table) {
+	const parsed = parseCssLength(value);
+	if (parsed === void 0 || !(parsed.value > 0)) return void 0;
+	const factor = table[parsed.unit];
+	return factor === void 0 ? void 0 : parsed.value * factor;
+}
+function fitExample(attribute) {
+	return attribute === "data-fit-min" ? "48pt" : "1pt";
+}
+function fitLengthIssues(where, attribute, value) {
+	const example = fitExample(attribute);
+	const parsed = parseCssLength(value);
+	if (parsed === void 0) return [`${where} ${attribute} "${value}" is not an absolute CSS length; use an absolute CSS length such as ${example} to clear this refusal`];
+	if (!isAbsoluteUnit(parsed.unit)) return [`${where} ${attribute} "${value}" uses unit "${parsed.unit}"; use an absolute CSS length (${listedAbsoluteUnits()}) such as ${example} to clear this refusal`];
+	if (!(parsed.value > 0)) return [`${where} ${attribute} "${value}" is not a positive absolute CSS length; use a positive absolute CSS length such as ${example} to clear this refusal`];
+	return [];
+}
+function regionFitIssues(where, attribs) {
+	const minText = attribs["data-fit-min"];
+	const stepText = attribs["data-fit-step"];
+	if (minText === void 0 && stepText === void 0) return [];
+	const issues = [];
+	if (minText !== void 0) issues.push(...fitLengthIssues(where, "data-fit-min", minText));
+	if (minText !== void 0 || stepText !== void 0) issues.push(...fitLengthIssues(where, "data-fit-step", stepText ?? ""));
+	return issues;
+}
+function namedRegionFitIssues(where, regions) {
+	return regions.flatMap((node) => {
+		const region = node.attribs["data-region"];
+		return region ? regionFitIssues(`${where} region "${region}"`, node.attribs) : [];
+	});
+}
+function templateRegionFitIssues(template, regions) {
+	return namedRegionFitIssues(`template "${template}"`, regions);
+}
+function fitRegionSize(max, min, step, overflows) {
+	function sizeAt(index) {
+		return max - index * step;
+	}
+	if (!(max >= min) || !(step > 0) || !Number.isFinite(max) || !Number.isFinite(min) || !Number.isFinite(step)) return { usable: false };
+	const last = Math.floor((max - min) / step + 1e-9);
+	if (!Number.isSafeInteger(last)) {
+		if (!overflows(max)) return {
+			size: max,
+			overflow: false
+		};
+		return {
+			size: min,
+			overflow: overflows(min)
+		};
+	}
+	let low = 0;
+	let high = last;
+	let fitted = last + 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		if (overflows(sizeAt(mid))) low = mid + 1;
+		else {
+			fitted = mid;
+			high = mid - 1;
+		}
+	}
+	if (fitted > last) return {
+		size: sizeAt(last),
+		overflow: true
+	};
+	return {
+		size: sizeAt(fitted),
+		overflow: false
+	};
+}
+//#endregion
+export { ABSOLUTE_PX, ABSOLUTE_UNITS, fitRegionSize, lengthPx, namedRegionFitIssues, parseCssLength, templateRegionFitIssues };

package/dist/book/types.d.ts

@@ -10,22 +10,25 @@ export interface BookDocumentOptions {
 export type BookBuild = 'print' | 'galley' | 'flow';
 export interface BookSectionInfo {
   id: string;
-  kind: 'front' | 'contents' | 'chapter' | 'endnotes' | 'designed' | 'templated';
+  kind: 'front' | 'contents' | 'part' | 'chapter' | 'endnotes' | 'designed' | 'templated';
+  division: 'front' | 'body' | 'end';
   title?: string;
   runningHead?: string;
 }
 export type BookPrintPart = 'front' | 'body';
-export declare function bookPrintPart(kind: BookSectionInfo['kind']): BookPrintPart;
+export declare function bookPrintPart(division: BookSectionInfo['division']): BookPrintPart;
 export interface BookHeading {
   id: string;
   level: number;
   text: string;
   sectionId: string;
+  depth?: number;
 }
 export interface BookDocument {
   html: string;
   sections: BookSectionInfo[];
   headings: BookHeading[];
+  pageReferenceTargets: string[];
   issues: string[];
 }
 //#endregion

package/dist/book/types.js

@@ -1,6 +1,6 @@
 //#region src/book/types.ts
-function bookPrintPart(kind) {
-	return kind === "front" || kind === "contents" ? "front" : "body";
+function bookPrintPart(division) {
+	return division === "front" ? "front" : "body";
 }
 //#endregion
 export { bookPrintPart };

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,20 +1,23 @@
 import { base64ToBytes, bytesToBase64 } from "./base64.js";
-import { REFUSED_ELEMENTS, SanitizeOptions, findActiveContent, sanitize } from "./sanitize.js";
+import { REFUSED_ELEMENTS, SanitizeOptions, findActiveContent, safeImageSource, 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 { bookDocument } from "./book/book-document.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";
 import { PaginateTarget, PaginateTargetPage, heldPageNumber, openerPageIndex, pageIndexForTarget, windowPageIndex } from "./book/paginate-target.js";
+import { ABSOLUTE_PX, ABSOLUTE_UNITS, fitRegionSize, lengthPx, parseCssLength } from "./book/region-fit.js";
 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 { ExpandMotifsOptions, ExpandedMotifs, MOTIF_DEPTH_LIMIT, MotifRefusedError, PlacedMotif, documentLanguage, expandMotifs, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements } from "./motifs.js";
-import { BookPageFacts, BookPrintedPagePlan, BookPrintedPageRole, BookSectionParents, PrintedPagePlan, PrintedPageSide, planBookPages, planPrintedPages, printedPageAt, selectBookParent } from "./printed-pages.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";
@@ -24,4 +27,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 { 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, fontCss, fontFaceCss, fontFormat, fontReferenceRefusals, furnitureScript, hasBindings, hasMotifPlacement, hasSlotWork, heldPageNumber, isSlotCopyRefusal, libraryMotifPlacementRefusal, mergeSlotFitResults, motifPlacementRefusals, openerPageIndex, pageIndexForTarget, paginateBook, paginateScript, parseBookPositionKey, parseUnicodeRange, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, sanitize, sanitizeBookCss, selectBookParent, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal, windowPageIndex };
+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, 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, assertSingleSlotCopy, assertSlotPrintOptions, base64ToBytes, bindingNames, bindingRoot, 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, isSlotCopyRefusal, lengthPx, libraryMotifPlacementRefusal, mergeSlotFitResults, motifPlacementRefusals, openerPageIndex, pageIndexForTarget, pageReferenceTarget, paginateBook, paginateScript, parseBookPositionKey, parseCssLength, parseUnicodeRange, placementCropEdges, placementPlaceholderSource, placementPlan, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, resolvePlacements, safeImageSource, sanitize, sanitizeBookCss, selectBookParent, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal, windowPageIndex };