@segnavia/html 0.26.0 → 0.28.0

package/dist/css-tokens.js

@@ -0,0 +1,189 @@
+//#region src/css-tokens.ts
+function newlineEnd(source, at) {
+	return source[at] === "\r" && source[at + 1] === "\n" ? at + 2 : at + 1;
+}
+function cssEscape(source, at) {
+	let end = at + 1;
+	if (end >= source.length) return ["", end];
+	if (/[0-9a-f]/i.test(source[end] ?? "")) {
+		const start = end;
+		while (end < source.length && end - start < 6 && /[0-9a-f]/i.test(source[end] ?? "")) end++;
+		const point = Number.parseInt(source.slice(start, end), 16);
+		if (source[end] === "\r" && source[end + 1] === "\n") end += 2;
+		else if (/\s/.test(source[end] ?? "")) end++;
+		return [point === 0 || point > 1114111 ? "�" : String.fromCodePoint(point), end];
+	}
+	if (source[end] === "\n" || source[end] === "\r" || source[end] === "\f") return ["", newlineEnd(source, end)];
+	return [source[end] ?? "", end + 1];
+}
+function name(source, at) {
+	let value = "";
+	let end = at;
+	while (end < source.length) {
+		const character = source[end] ?? "";
+		if (/[\w-]/.test(character) || character.charCodeAt(0) >= 128) {
+			value += character;
+			end++;
+			continue;
+		}
+		if (character !== "\\") break;
+		const escaped = cssEscape(source, end);
+		value += escaped[0];
+		end = escaped[1];
+	}
+	return [value.toLowerCase(), end];
+}
+function skipTrivia(source, at) {
+	if (/\s/.test(source[at] ?? "")) return at + 1;
+	if (!source.startsWith("/*", at)) return at;
+	const close = source.indexOf("*/", at + 2);
+	return close < 0 ? source.length : close + 2;
+}
+function stringToken(source, start) {
+	const quote = source[start] ?? "";
+	let at = start + 1;
+	let value = "";
+	while (at < source.length && source[at] !== quote) {
+		if (source[at] === "\n" || source[at] === "\r" || source[at] === "\f") break;
+		if (source[at] === "\\") {
+			const escaped = cssEscape(source, at);
+			value += escaped[0];
+			at = escaped[1];
+		} else value += source[at++] ?? "";
+	}
+	if (source[at] === quote) at++;
+	return {
+		end: at,
+		kind: "string",
+		start,
+		value
+	};
+}
+function badUrlEnd(source, at) {
+	while (at < source.length) {
+		if (source[at] === ")") return at + 1;
+		if (source[at] === "\\") at = cssEscape(source, at)[1];
+		else at++;
+	}
+	return at;
+}
+function invalidUrlCharacter(character) {
+	const code = character.charCodeAt(0);
+	return character === "\"" || character === "'" || character === "(" || code <= 8 || code === 11 || code >= 14 && code <= 31 || code === 127;
+}
+function urlAfterWhitespace(source, start, at, value) {
+	let end = at;
+	while (/\s/.test(source[end] ?? "")) end++;
+	if (source[end] === ")") return {
+		end: end + 1,
+		kind: "url",
+		start,
+		value: value.trim().toLowerCase()
+	};
+	return {
+		end: badUrlEnd(source, end),
+		kind: "bad-url",
+		start,
+		value
+	};
+}
+function escapedUrlPart(source, start, at, value) {
+	const escaped = cssEscape(source, at);
+	if (escaped[1] === at + 1 || escaped[0] === "") return {
+		end: badUrlEnd(source, escaped[1]),
+		kind: "bad-url",
+		start,
+		value
+	};
+	return [escaped[0], escaped[1]];
+}
+function urlToken(source, start, content) {
+	let at = content;
+	let value = "";
+	while (/\s/.test(source[at] ?? "")) at++;
+	if (source[at] === "\"" || source[at] === "'") return {
+		end: content,
+		kind: "function",
+		start,
+		value: "url"
+	};
+	while (at < source.length) {
+		const character = source[at] ?? "";
+		if (character === ")") return {
+			end: at + 1,
+			kind: "url",
+			start,
+			value: value.trim().toLowerCase()
+		};
+		if (/\s/.test(character)) return urlAfterWhitespace(source, start, at, value);
+		if (invalidUrlCharacter(character)) return {
+			end: badUrlEnd(source, at + 1),
+			kind: "bad-url",
+			start,
+			value
+		};
+		if (character === "\\") {
+			const escaped = escapedUrlPart(source, start, at, value);
+			if (!Array.isArray(escaped)) return escaped;
+			value += escaped[0];
+			at = escaped[1];
+		} else {
+			value += character;
+			at++;
+		}
+	}
+	return {
+		end: at,
+		kind: "url",
+		start,
+		value: value.trim().toLowerCase()
+	};
+}
+function tokenAt(source, at) {
+	const character = source[at] ?? "";
+	if (character === "\"" || character === "'") return stringToken(source, at);
+	const offset = character === "@" ? 1 : 0;
+	const parsed = name(source, at + offset);
+	if (parsed[0]) {
+		const isFunction = offset === 0 && source[parsed[1]] === "(";
+		if (isFunction && parsed[0] === "url") return urlToken(source, at, parsed[1] + 1);
+		const kind = offset === 1 ? "at" : isFunction ? "function" : "word";
+		return {
+			end: parsed[1] + (isFunction ? 1 : 0),
+			kind,
+			start: at,
+			value: parsed[0]
+		};
+	}
+	return {
+		end: at + 1,
+		kind: {
+			"{": "open",
+			"}": "close",
+			";": "semicolon",
+			"(": "open",
+			"[": "open",
+			")": "close",
+			"]": "close"
+		}[character] ?? "word",
+		start: at,
+		value: character
+	};
+}
+function cssTokens(source) {
+	const found = [];
+	let at = 0;
+	while (at < source.length) {
+		const significant = skipTrivia(source, at);
+		if (significant !== at) {
+			at = significant;
+			continue;
+		}
+		const token = tokenAt(source, at);
+		found.push(token);
+		at = token.end;
+	}
+	return found;
+}
+//#endregion
+export { cssEscape, cssTokens };

package/dist/font-css.d.ts

@@ -0,0 +1,11 @@
+import { AppFont, FontFace } from "@segnavia/format";
+//#region src/font-css.d.ts
+export declare class FontCssRefusedError extends Error {
+  constructor(message: string);
+}
+export declare function fontFaceCss(font: FontFace): string;
+export declare function fontCss(options: {
+  app: Map<string, AppFont>;
+  local?: readonly FontFace[];
+}): string;
+//#endregion

package/dist/font-css.js

@@ -0,0 +1,75 @@
+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";
+//#region src/font-css.ts
+var FontCssRefusedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FontCssRefusedError";
+	}
+};
+const CSS_WEIGHT_KEYWORD = /^(?:normal|bold|bolder|lighter)$/;
+const CSS_WEIGHT_NUMBER = /^(?:[1-9]\d{0,2}|1000)$/;
+function mimeType(format) {
+	if (format === "truetype") return "ttf";
+	if (format === "opentype") return "otf";
+	return format;
+}
+function unicodeRangeDeclaration(font) {
+	const range = font.unicodeRange;
+	if (range === void 0) return "";
+	const refused = (reason) => new FontCssRefusedError(`The unicode-range ${JSON.stringify(range)} on face ${JSON.stringify(font.family)} (${font.weight ?? "normal"}, ${font.style ?? "normal"}) is malformed: ${reason}. Supply a CSS unicode-range list (${UNICODE_RANGE_CLEARANCE}) to clear this refusal.`);
+	if (typeof range !== "string") throw refused(`it is not a string (${typeof range})`);
+	const parsed = parseUnicodeRange(range);
+	if (!parsed.ok) throw refused(parsed.reason);
+	return `unicode-range:${parsed.value};`;
+}
+function faceRefusal(font, problem, remedy) {
+	return new FontCssRefusedError(`The face ${JSON.stringify(font.family)} could not establish ${problem}; ${remedy} to clear this refusal.`);
+}
+function isCssWeight(value) {
+	if (value === void 0) return true;
+	if (typeof value === "number") return Number.isInteger(value) && value >= 1 && value <= 1e3;
+	return CSS_WEIGHT_KEYWORD.test(value) || CSS_WEIGHT_NUMBER.test(value) && Number(value) >= 1 && Number(value) <= 1e3;
+}
+function isFontFormat(value) {
+	return FONT_FORMATS.some((format) => format === value);
+}
+function quoteFamily(family) {
+	if (hasControlChar(family)) throw new FontCssRefusedError(`The family ${JSON.stringify(family)} contains a control character; remove control characters from the family name to clear this refusal.`);
+	let quoted = "\"";
+	for (const ch of family) if (ch === "\\" || ch === "\"") quoted += `\\${ch}`;
+	else if (ch === "<") quoted += "\\3c ";
+	else quoted += ch;
+	return `${quoted}"`;
+}
+function validatedFace(font) {
+	if (!isFontFormat(font.format)) throw faceRefusal(font, `a font format that is one of ${FONT_FORMATS.join(", ")}`, `supply one of ${FONT_FORMATS.join(", ")}`);
+	if (!isCssWeight(font.weight)) throw faceRefusal(font, "a CSS font-weight", "supply a number 1-1000 or a CSS weight keyword");
+	if (font.style !== void 0 && font.style !== "normal" && font.style !== "italic") throw faceRefusal(font, "a font-style of 'normal' or 'italic'", "supply 'normal' or 'italic'");
+	return font;
+}
+function fontFaceCss(font) {
+	const face = validatedFace(font);
+	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) {
+	if (!APP_FONT_NAME.test(name)) throw new FontCssRefusedError(`The app font name ${JSON.stringify(name)} could not establish an app font name matching ${APP_FONT_NAME}; use a lowercase name of letters, digits and hyphens to clear this refusal.`);
+	const generic = font.generic ? `,${font.generic}` : "";
+	return `--segnavia-font-${name}:${quoteFamily(font.family)}${generic}`;
+}
+function fontCss(options) {
+	const faces = [];
+	const properties = [];
+	for (const [name, font] of options.app) {
+		faces.push(...font.faces);
+		properties.push(customProperty(name, font));
+	}
+	for (const font of options.local ?? []) faces.push(font);
+	const rules = faces.map(fontFaceCss).join("");
+	if (properties.length === 0) return rules;
+	return `${rules}:root{${properties.join(";")}}`;
+}
+//#endregion
+export { FontCssRefusedError, fontCss, fontFaceCss };

package/dist/font-format.d.ts

@@ -0,0 +1,4 @@
+import { FontFormat } from "@segnavia/format";
+//#region src/font-format.d.ts
+export declare function fontFormat(data: Uint8Array): FontFormat | undefined;
+//#endregion

package/dist/font-format.js

@@ -0,0 +1,11 @@
+//#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";
+}
+//#endregion
+export { fontFormat };

package/dist/font-references.d.ts

@@ -0,0 +1,4 @@
+import { FontReference } from "@segnavia/format";
+//#region src/font-references.d.ts
+export declare function fontReferenceRefusals(html: string, references: FontReference[], known: ReadonlySet<string>): string[];
+//#endregion

package/dist/font-references.js

@@ -0,0 +1,192 @@
+import { elements, parse } from "./sanitize.js";
+import { hasControlChar } from "./control-char.js";
+import { APP_FONT_NAME } from "@segnavia/format";
+//#region src/font-references.ts
+const FONT_PROPERTY = /(?:^|[;{])\s*(font-family|font)\s*:([^;{}]+)/gi;
+const FONT_PREFIX_KEYWORD = /^(?:italic|oblique|normal|small-caps|bold|bolder|lighter|(?:ultra-|extra-|semi-)?(?:condensed|expanded)|[1-9]00)\s+/i;
+const FONT_SIZE = /^(?:xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large|smaller|larger|\d+(?:\.\d+)?(?:px|em|rem|pt|pc|in|cm|mm|ex|ch|vw|vh|%))(?:\s*\/\s*(?:normal|\d+(?:\.\d+)?(?:px|em|rem|pt|pc|in|cm|mm|ex|ch|vw|vh|%)?))?\s*/i;
+const FONT_VAR = /var\(\s*--segnavia-font-([A-Za-z0-9-]+)\s*\)/g;
+function refusal(place, problem, remedy) {
+	return `${place} could not establish ${problem}; ${remedy} to clear this refusal.`;
+}
+function referencePlace(ref) {
+	if ("app" in ref) return `font reference {app:${JSON.stringify(ref.app)}}`;
+	return `font reference {local:${JSON.stringify(ref.local)}, fallback:${JSON.stringify(ref.fallback)}}`;
+}
+function appName(ref) {
+	return "app" in ref ? ref.app : void 0;
+}
+function localRef(ref) {
+	return "local" in ref ? {
+		local: ref.local,
+		fallback: ref.fallback
+	} : void 0;
+}
+function styleText(element) {
+	return element.children.map((child) => "data" in child ? child.data : "").join("");
+}
+function cssChunks(html) {
+	const chunks = [];
+	for (const element of elements(parse(html).children)) {
+		const style = element.attribs.style;
+		if (style) chunks.push(style);
+		if (element.name.toLowerCase() === "style") chunks.push(styleText(element));
+	}
+	return chunks;
+}
+function skipSpace(value, index) {
+	let i = index;
+	while (i < value.length && /\s/.test(value[i] ?? "")) i += 1;
+	return i;
+}
+function readQuoted(value, index) {
+	const quote = value[index] ?? "";
+	let i = index + 1;
+	let text = "";
+	while (i < value.length) {
+		const ch = value[i] ?? "";
+		if (ch === "\\" && i + 1 < value.length) {
+			text += value[i + 1] ?? "";
+			i += 2;
+			continue;
+		}
+		if (ch === quote) return {
+			text,
+			next: i + 1
+		};
+		text += ch;
+		i += 1;
+	}
+	return {
+		text,
+		next: i
+	};
+}
+function readVar(value, index) {
+	let depth = 0;
+	let i = index;
+	while (i < value.length) {
+		const ch = value[i] ?? "";
+		if (ch === "(") depth += 1;
+		if (ch === ")") {
+			depth -= 1;
+			if (depth === 0) return {
+				text: value.slice(index, i + 1).replace(/\s+/g, ""),
+				next: i + 1
+			};
+		}
+		i += 1;
+	}
+	return {
+		text: value.slice(index).replace(/\s+/g, ""),
+		next: value.length
+	};
+}
+function readIdent(value, index) {
+	let i = index;
+	while (i < value.length && value[i] !== ",") i += 1;
+	return {
+		text: value.slice(index, i).trim(),
+		next: i
+	};
+}
+function stripFontShorthand(value) {
+	let rest = value.trim();
+	while (FONT_PREFIX_KEYWORD.test(rest)) rest = rest.replace(FONT_PREFIX_KEYWORD, "");
+	if (!FONT_SIZE.test(rest)) return value.trim();
+	return rest.replace(FONT_SIZE, "");
+}
+function familyItems(value) {
+	const items = [];
+	let i = 0;
+	while (i < value.length) {
+		i = skipSpace(value, i);
+		if (i >= value.length) break;
+		const next = value.startsWith("var(", i) ? readVar(value, i) : value[i] === "\"" || value[i] === "'" ? readQuoted(value, i) : readIdent(value, i);
+		if (next.text) items.push(next.text);
+		i = next.next;
+		i = skipSpace(value, i);
+		if (value[i] === ",") i += 1;
+	}
+	return items;
+}
+function familyLists(css) {
+	const lists = [];
+	FONT_PROPERTY.lastIndex = 0;
+	for (const match of css.matchAll(FONT_PROPERTY)) {
+		const property = (match[1] ?? "").toLowerCase();
+		const value = match[2] ?? "";
+		const items = familyItems(property === "font" ? stripFontShorthand(value) : value);
+		if (items.length > 0) lists.push(items);
+	}
+	return lists;
+}
+function appNames(references) {
+	const names = /* @__PURE__ */ new Set();
+	for (const ref of references) {
+		const name = appName(ref);
+		if (name) names.add(name);
+	}
+	return names;
+}
+function referenceRefusals(references, known) {
+	const refusals = [];
+	for (const ref of references) {
+		const app = appName(ref);
+		const local = localRef(ref);
+		const name = app ?? local?.fallback ?? "";
+		if (!APP_FONT_NAME.test(name)) {
+			refusals.push(refusal(referencePlace(ref), `an app font name matching ${APP_FONT_NAME}`, "use a lowercase name of letters, digits and hyphens"));
+			continue;
+		}
+		if (!known.has(name)) refusals.push(refusal(referencePlace(ref), `app font ${JSON.stringify(name)}`, "make that font available from the source"));
+		if (local && hasControlChar(local.local)) refusals.push(refusal(referencePlace(ref), "a local family without control characters", "remove control characters from the family name"));
+	}
+	return refusals;
+}
+function fallbackVar(fallback) {
+	return `var(--segnavia-font-${fallback})`;
+}
+function localCssRefusals(lists, references) {
+	const refusals = [];
+	for (const ref of references) {
+		const local = localRef(ref);
+		if (!local) continue;
+		const expected = fallbackVar(local.fallback);
+		for (const items of lists) {
+			const index = items.indexOf(local.local);
+			if (index < 0) continue;
+			const next = items[index + 1];
+			if (next === expected) continue;
+			const place = `page CSS font-family ${JSON.stringify(items.join(", "))}`;
+			if (!next?.startsWith("var(--segnavia-font-")) refusals.push(refusal(place, `the declared fallback after ${JSON.stringify(local.local)}`, `write font-family: ${JSON.stringify(local.local)}, ${expected}`));
+			else refusals.push(refusal(place, `fallback ${next} matching declared ${expected}`, `write font-family: ${JSON.stringify(local.local)}, ${expected}`));
+		}
+	}
+	return refusals;
+}
+function undeclaredVarRefusals(chunks, declared) {
+	const refusals = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const css of chunks) {
+		FONT_VAR.lastIndex = 0;
+		for (const match of css.matchAll(FONT_VAR)) {
+			const name = match[1] ?? "";
+			if (declared.has(name) || seen.has(name)) continue;
+			seen.add(name);
+			refusals.push(refusal(`page CSS ${match[0]}`, `a fonts reference {app:${JSON.stringify(name)}}`, `add {app:${JSON.stringify(name)}} to the page or placed motif fonts`));
+		}
+	}
+	return refusals;
+}
+function fontReferenceRefusals(html, references, known) {
+	const chunks = cssChunks(html);
+	const lists = chunks.flatMap(familyLists);
+	return [
+		...referenceRefusals(references, known),
+		...localCssRefusals(lists, references),
+		...undeclaredVarRefusals(chunks, appNames(references))
+	];
+}
+//#endregion
+export { fontReferenceRefusals };

package/dist/index.d.ts

@@ -1,13 +1,26 @@
+import { base64ToBytes, bytesToBase64 } from "./base64.js";
 import { REFUSED_ELEMENTS, SanitizeOptions, findActiveContent, sanitize } from "./sanitize.js";
-import { BINDINGS, FillOptions, Filled, bindingNames, fill, hasBindings } from "./bindings.js";
+import { BINDINGS, FillOptions, Filled, bindingNames, bindingRoot, fill, hasBindings } from "./bindings.js";
 import { BookDocument, BookDocumentOptions, BookHeading, BookPrintPart, BookSectionInfo, bookPrintPart } from "./book/types.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 { PAGINATE_FUNCTIONS, paginateBook, paginateScript } from "./book/paginate-book.js";
+import { PaginateTarget, PaginateTargetPage, heldPageNumber, openerPageIndex, pageIndexForTarget, windowPageIndex } from "./book/paginate-target.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, expandMotifs, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements } from "./motifs.js";
+import { BookPageFacts, BookPrintedPagePlan, BookPrintedPageRole, BookSectionParents, PrintedPagePlan, PrintedPageSide, planBookPages, planPrintedPages, printedPageAt, selectBookParent } from "./printed-pages.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";
+import { UNICODE_RANGE_CLEARANCE, UnicodeRangeParse, parseUnicodeRange } from "./unicode-range.js";
 //#region src/index.d.ts
 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, type BookDocument, type BookDocumentOptions, type BookHeading, type BookPrintPart, type BookSectionInfo, type FillOptions, type Filled, MAX_SLOT_DECLARATIONS, type PreparedSlots, REFUSED_ELEMENTS, RequiredSlotsRefusedError, type SanitizeOptions, type SlotFillEntry, type SlotFillRefusal, SlotFillRefusedError, SlotFillsConflictError, SlotFillsRefusedError, type SlotPrintOptions, UnmeasuredSlotsRefusedError, assertSingleSlotCopy, assertSlotPrintOptions, bindingNames, bookDocument, bookPrintPart, collectSlotPrintCopies, fill, findActiveContent, hasBindings, hasSlotWork, isSlotCopyRefusal, mergeSlotFitResults, prepareSlotCollection, prepareSlots, requiredSlotRefusal, sanitize, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal };
+export { BINDINGS, type BookDocument, type BookDocumentOptions, type BookFurnitureValues, type BookHeading, BookPageFacts, 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, embedFunction, expandMotifs, fill, fillBookFurniture, findActiveContent, fontCss, fontFaceCss, fontFormat, fontReferenceRefusals, furnitureScript, hasBindings, hasMotifPlacement, hasSlotWork, heldPageNumber, isSlotCopyRefusal, libraryMotifPlacementRefusal, mergeSlotFitResults, motifPlacementRefusals, openerPageIndex, pageIndexForTarget, paginateBook, paginateScript, parseUnicodeRange, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, sanitize, sanitizeBookCss, selectBookParent, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal, windowPageIndex };

package/dist/index.js

@@ -1,7 +1,19 @@
 import { REFUSED_ELEMENTS, elements, findActiveContent, parse, sanitize } from "./sanitize.js";
-import { BINDINGS, bindingNames, fill, hasBindings } from "./bindings.js";
+import { BINDINGS, bindingNames, bindingRoot, fill, hasBindings } from "./bindings.js";
+import { base64ToBytes, bytesToBase64 } from "./base64.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 { 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";
+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, expandMotifs, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements } from "./motifs.js";
+import { planBookPages, planPrintedPages, printedPageAt, selectBookParent } from "./printed-pages.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";
@@ -17,4 +29,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, MAX_SLOT_DECLARATIONS, REFUSED_ELEMENTS, RequiredSlotsRefusedError, SlotFillRefusedError, SlotFillsConflictError, SlotFillsRefusedError, UnmeasuredSlotsRefusedError, assertSingleSlotCopy, assertSlotPrintOptions, bindingNames, bookDocument, bookPrintPart, classify, collectSlotPrintCopies, fill, findActiveContent, hasBindings, hasSlotWork, isSlotCopyRefusal, mergeSlotFitResults, prepareSlotCollection, prepareSlots, requiredSlotRefusal, sanitize, searchText, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal };
+export { BINDINGS, 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, embedFunction, expandMotifs, fill, fillBookFurniture, findActiveContent, fontCss, fontFaceCss, fontFormat, fontReferenceRefusals, furnitureScript, hasBindings, hasMotifPlacement, hasSlotWork, heldPageNumber, isSlotCopyRefusal, libraryMotifPlacementRefusal, mergeSlotFitResults, motifPlacementRefusals, openerPageIndex, pageIndexForTarget, paginateBook, paginateScript, parseUnicodeRange, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, sanitize, sanitizeBookCss, searchText, selectBookParent, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal, windowPageIndex };

package/dist/motifs.d.ts

@@ -0,0 +1,32 @@
+import { FontReference, MotifPlacement, MotifSource, Scripts } from "@segnavia/format";
+//#region src/motifs.d.ts
+export declare const MOTIF_DEPTH_LIMIT = 8;
+export interface ExpandMotifsOptions {
+  source: MotifSource;
+  pins?: Record<string, string>;
+  lang?: string;
+  scripts: Scripts;
+  prefix: string;
+  linkOrigins?: Iterable<string>;
+  dataFonts?: boolean;
+  signal: AbortSignal;
+  deferPaths?: Iterable<string>;
+}
+export interface PlacedMotif extends MotifPlacement {
+  version: number;
+}
+export interface ExpandedMotifs {
+  html: string;
+  placed: PlacedMotif[];
+  fonts: FontReference[];
+  unavailable: string[];
+}
+export declare class MotifRefusedError extends Error {
+  constructor(message: string);
+}
+export declare function libraryMotifPlacementRefusal(html: string): string | undefined;
+export declare function hasMotifPlacement(html: string): boolean;
+export declare function renderMotifPlacements(html: string, replacement: (key: string) => string | undefined): string;
+export declare function expandMotifs(html: string, options: ExpandMotifsOptions): Promise<ExpandedMotifs>;
+export declare function motifPlacementRefusals(html: string, options: ExpandMotifsOptions): Promise<string[]>;
+//#endregion