@segnavia/html 0.37.0 → 0.38.0

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,18 +36,20 @@ 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;
@@ -57,9 +59,10 @@ export interface PaginateBookInput {
   flows: PaginateFlow[];
   notes: PaginateNote[];
   geometry: {
-    textHeight: number;
     notesGap: number;
   };
+  parents: Record<string, TextArea>;
+  parentNames: typeof BOOK_PARENT_NAMES;
   settings: {
     orphans?: number;
     widows?: number;
@@ -98,8 +101,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;

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,17 +10,19 @@ 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;

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/index.d.ts

@@ -2,19 +2,20 @@ import { base64ToBytes, bytesToBase64 } from "./base64.js";
 import { REFUSED_ELEMENTS, SanitizeOptions, findActiveContent, 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 { 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 { 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 { 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 +25,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, 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 };

package/dist/index.js

@@ -2,10 +2,12 @@ import { REFUSED_ELEMENTS, elements, findActiveContent, parse, sanitize } from "
 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 { bookPrintPart } from "./book/types.js";
 import { bookDocument } from "./book/book-document.js";
 import { bookView, bookViewFromHtml } from "./book/book-view.js";
 import { embedFunction, fillBookFurniture, furnitureScript } from "./book/furniture.js";
+import { planBookPages, planPrintedPages, printedPageAt, selectBookParent } from "./printed-pages.js";
 import { PAGINATE_FUNCTIONS, paginateBook, paginateScript } from "./book/paginate-book.js";
 import { heldPageNumber, openerPageIndex, pageIndexForTarget, windowPageIndex } from "./book/paginate-target.js";
 import { bookStylesheet, sanitizeBookCss } from "./book-css.js";
@@ -13,8 +15,7 @@ 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 { MOTIF_DEPTH_LIMIT, MotifRefusedError, documentLanguage, expandMotifs, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements } from "./motifs.js";
-import { planBookPages, planPrintedPages, printedPageAt, selectBookParent } from "./printed-pages.js";
+import { MOTIF_DEPTH_LIMIT, MotifRefusedError, documentLanguage, expandMotifs, hasHostMotifPlacement, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements } from "./motifs.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";
@@ -30,4 +31,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 { 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, 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, 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, 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 };

package/dist/motifs.d.ts

@@ -11,6 +11,7 @@ export interface ExpandMotifsOptions {
   dataFonts?: boolean;
   signal: AbortSignal;
   deferPaths?: Iterable<string>;
+  deferLibrary?: boolean;
 }
 export interface PlacedMotif extends MotifPlacement {
   version: number;
@@ -26,6 +27,7 @@ export declare class MotifRefusedError extends Error {
 }
 export declare function libraryMotifPlacementRefusal(html: string): string | undefined;
 export declare function hasMotifPlacement(html: string): boolean;
+export declare function hasHostMotifPlacement(html: string): boolean;
 export declare function renderMotifPlacements(html: string, replacement: (key: string) => string | undefined): string;
 export declare function documentLanguage(html: string): string | undefined;
 export declare function expandMotifs(html: string, options: ExpandMotifsOptions): Promise<ExpandedMotifs>;

package/dist/motifs.js

@@ -26,6 +26,9 @@ function libraryMotifPlacementRefusal(html) {
 function hasMotifPlacement(html) {
 	return motifElements(html).length > 0;
 }
+function hasHostMotifPlacement(html) {
+	return motifElements(html).some((element) => !(element.attribs[MOTIF_ATTRIBUTE] ?? "").startsWith(LIBRARY_MOTIF_PREFIX));
+}
 function renderMotifPlacements(html, replacement) {
 	const document = parse(html);
 	const visit = (nodes) => {
@@ -207,7 +210,7 @@ async function expandNodes(nodes, inheritedLang, stack, state) {
 	for (const node of [...nodes]) {
 		state.options.signal.throwIfAborted();
 		if (!isTag(node)) continue;
-		if (Object.hasOwn(node.attribs, MOTIF_ATTRIBUTE)) await expandPlacement(node, inheritedLang, stack, state);
+		if (Object.hasOwn(node.attribs, MOTIF_ATTRIBUTE) && !(state.options.deferLibrary && (node.attribs[MOTIF_ATTRIBUTE] ?? "").startsWith(LIBRARY_MOTIF_PREFIX))) await expandPlacement(node, inheritedLang, stack, state);
 		else await expandNodes(node.children, inheritedLang, stack, state);
 	}
 }
@@ -246,4 +249,4 @@ async function motifPlacementRefusals(html, options) {
 	return (await run(html, options, true)).state.refusals;
 }
 //#endregion
-export { MOTIF_DEPTH_LIMIT, MotifRefusedError, documentLanguage, expandMotifs, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements };
+export { MOTIF_DEPTH_LIMIT, MotifRefusedError, documentLanguage, expandMotifs, hasHostMotifPlacement, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements };

package/dist/printed-pages.d.ts

@@ -1,4 +1,4 @@
-import { BookSectionParents as BookSectionParents$1, NumberSystem, PrintedPageRole, PrintedPageRules } from "@segnavia/format";
+import { BOOK_PARENT_NAMES, BookSectionParents as BookSectionParents$1, NumberSystem, PrintedPageRole, PrintedPageRules } from "@segnavia/format";
 //#region src/printed-pages.d.ts
 export type PrintedPageSide = 'left' | 'right';
 export interface PrintedPagePlan {
@@ -26,12 +26,7 @@ export interface BookPrintedPagePlan extends Omit<BookPageFacts, 'blank' | 'sect
 }
 export declare function printedPageAt(rules: PrintedPageRules, index: number, count: number, direction: 'ltr' | 'rtl'): Pick<PrintedPagePlan, 'role' | 'parent' | 'side'>;
 export declare function planPrintedPages(rules: PrintedPageRules, count: number, direction: 'ltr' | 'rtl', numbering?: NumberSystem): PrintedPagePlan[];
-export declare function selectBookParent(fact: BookPageFacts, index: number, count: number, direction: 'ltr' | 'rtl', names?: {
-  readonly recto: "segnavia:recto";
-  readonly verso: "segnavia:verso";
-  readonly opener: "segnavia:opener";
-  readonly blank: "segnavia:blank";
-}): Pick<BookPrintedPagePlan, 'role' | 'parent' | 'side'>;
+export declare function selectBookParent(fact: BookPageFacts, index: number, count: number, direction: 'ltr' | 'rtl', names: typeof BOOK_PARENT_NAMES): Pick<BookPrintedPagePlan, 'role' | 'parent' | 'side'>;
 export declare function planBookPages(facts: BookPageFacts[], direction: 'ltr' | 'rtl', names?: {
   readonly recto: "segnavia:recto";
   readonly verso: "segnavia:verso";

package/dist/printed-pages.js

@@ -39,7 +39,7 @@ function planPrintedPages(rules, count, direction, numbering = "arabic") {
 		};
 	});
 }
-function selectBookParent(fact, index, count, direction, names = BOOK_PARENT_NAMES) {
+function selectBookParent(fact, index, count, direction, names) {
 	const physical = printedPageAt({
 		every: names.recto,
 		recto: names.recto,

package/dist/sanitize.d.ts

@@ -4,6 +4,7 @@ export declare const REFUSED_ELEMENTS: Set<string>;
 export interface SanitizeOptions {
   linkOrigins?: Iterable<string>;
   keepScripts?: boolean;
+  dependencyOrigins?: Iterable<string>;
   dataFonts?: boolean;
   refuseElements?: Iterable<string>;
 }