@segnavia/html 0.26.0 → 0.27.0

package/dist/base64.d.ts

@@ -0,0 +1,4 @@
+//#region src/base64.d.ts
+export declare function bytesToBase64(data: Uint8Array): string;
+export declare function base64ToBytes(value: string): Uint8Array | undefined;
+//#endregion

package/dist/base64.js

@@ -0,0 +1,51 @@
+//#region src/base64.ts
+const TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function triplet(data, index, count) {
+	let value = 0;
+	for (let offset = 0; offset < 3; offset += 1) {
+		const byte = offset < count ? data[index + offset] : 0;
+		value = value << 8 | (byte ?? 0);
+	}
+	return value;
+}
+function encodeTriplet(value, chars) {
+	const shifts = [
+		18,
+		12,
+		6,
+		0
+	];
+	let out = "";
+	for (let i = 0; i < 4; i += 1) {
+		const shift = shifts[i] ?? 0;
+		out += i < chars ? TABLE[value >> shift & 63] ?? "" : "=";
+	}
+	return out;
+}
+function bytesToBase64(data) {
+	let out = "";
+	const full = Math.floor(data.length / 3) * 3;
+	for (let i = 0; i < full; i += 3) out += encodeTriplet(triplet(data, i, 3), 4);
+	const rest = data.length - full;
+	if (rest > 0) out += encodeTriplet(triplet(data, full, rest), rest + 1);
+	return out;
+}
+function base64ToBytes(value) {
+	if (value.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) return;
+	const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+	const bytes = new Uint8Array(value.length / 4 * 3 - padding);
+	let output = 0;
+	for (let index = 0; index < value.length; index += 4) {
+		const a = TABLE.indexOf(value[index] ?? "");
+		const b = TABLE.indexOf(value[index + 1] ?? "");
+		const c = value[index + 2] === "=" ? 0 : TABLE.indexOf(value[index + 2] ?? "");
+		const d = value[index + 3] === "=" ? 0 : TABLE.indexOf(value[index + 3] ?? "");
+		const triplet = a << 18 | b << 12 | c << 6 | d;
+		if (output < bytes.length) bytes[output++] = triplet >> 16 & 255;
+		if (output < bytes.length) bytes[output++] = triplet >> 8 & 255;
+		if (output < bytes.length) bytes[output++] = triplet & 255;
+	}
+	return bytes;
+}
+//#endregion
+export { base64ToBytes, bytesToBase64 };

package/dist/bindings.d.ts

@@ -1,12 +1,15 @@
 import { SanitizeOptions } from "./sanitize.js";
 //#region src/bindings.d.ts
 export declare const BINDINGS: readonly ["value", "href", "src", "each", "when", "present", "width"];
+export declare function bindingRoot(path: string): string;
 export declare function bindingNames(prefix: string): Record<(typeof BINDINGS)[number], string>;
 export interface FillOptions extends Pick<SanitizeOptions, 'linkOrigins'> {
   prefix: string;
   data: Record<string, unknown>;
   unavailable?: Iterable<string>;
   preserveUnavailable?: boolean;
+  registerHrefOrigins?: boolean;
+  deferPaths?: Iterable<string>;
 }
 export interface Filled {
   html: string;

package/dist/bindings.js

@@ -10,6 +10,9 @@ const BINDINGS = [
 	"present",
 	"width"
 ];
+function bindingRoot(path) {
+	return path.replace(/^(?:\.\.\/)+/, "").split(".")[0] ?? "";
+}
 function bindingNames(prefix) {
 	return Object.fromEntries(BINDINGS.map((binding) => [binding, `data-${prefix}-${binding}`]));
 }
@@ -57,6 +60,13 @@ function safeHref(value, origins) {
 		return false;
 	}
 }
+function registerHrefOrigin(origins, attribute, value, register) {
+	if (attribute !== "href" || !register || typeof value !== "string") return;
+	try {
+		const url = new URL(value);
+		if (url.protocol === "https:") origins.add(url.origin);
+	} catch {}
+}
 function hasBindings(html, prefix) {
 	const names = new Set(Object.values(bindingNames(prefix)));
 	return elements(parse(html).children).some((element) => Object.keys(element.attribs).some((name) => names.has(name)));
@@ -66,6 +76,7 @@ function fill(html, options) {
 	const origins = new Set([...options.linkOrigins ?? []].map((origin) => new URL(origin).origin));
 	const unavailable = new Set(options.unavailable ?? []);
 	const values = [];
+	const deferred = new Set(options.deferPaths ?? []);
 	const document = parse(sanitize(html, { linkOrigins: options.linkOrigins }));
 	const resolve = (path, stack) => {
 		const { context, rest } = contextAt(stack, path);
@@ -75,6 +86,8 @@ function fill(html, options) {
 	};
 	const take = (element, name) => {
 		const value = element.attribs[name];
+		const root = value === void 0 ? void 0 : bindingRoot(value);
+		if (root && deferred.has(root)) return void 0;
 		delete element.attribs[name];
 		return value;
 	};
@@ -113,6 +126,7 @@ function fill(html, options) {
 			if (path === void 0) continue;
 			const value = resolve(path, stack);
 			if (preserves(value)) continue;
+			registerHrefOrigin(origins, attribute, value, options.registerHrefOrigins);
 			if (typeof value === "string" && (attribute === "href" ? safeHref(value, origins) : /^data:image\//i.test(value))) element.attribs[attribute] = value;
 			else {
 				delete element.attribs[attribute];
@@ -155,4 +169,4 @@ function fill(html, options) {
 	};
 }
 //#endregion
-export { BINDINGS, bindingNames, fill, hasBindings };
+export { BINDINGS, bindingNames, bindingRoot, fill, hasBindings };

package/dist/control-char.js

@@ -0,0 +1,10 @@
+//#region src/control-char.ts
+function hasControlChar(value) {
+	for (let i = 0; i < value.length; i += 1) {
+		const code = value.charCodeAt(i);
+		if (code <= 31 || code === 127) return true;
+	}
+	return false;
+}
+//#endregion
+export { hasControlChar };

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,20 @@
+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 { 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, PrintedPagePlan, PrintedPageSide, planBookPages, planPrintedPages, printedPageAt } 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 BookHeading, BookPageFacts, type BookPrintPart, BookPrintedPagePlan, BookPrintedPageRole, type BookSectionInfo, type ExpandMotifsOptions, type ExpandedMotifs, type FillOptions, type Filled, FontCssRefusedError, MAX_SLOT_DECLARATIONS, MOTIF_DEPTH_LIMIT, MotifRefusedError, 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, bytesToBase64, collectSlotPrintCopies, expandMotifs, fill, findActiveContent, fontCss, fontFaceCss, fontFormat, fontReferenceRefusals, hasBindings, hasMotifPlacement, hasSlotWork, isSlotCopyRefusal, libraryMotifPlacementRefusal, mergeSlotFitResults, motifPlacementRefusals, parseUnicodeRange, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, sanitize, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal };

package/dist/index.js

@@ -1,7 +1,14 @@
 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 { 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 } 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 +24,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, REFUSED_ELEMENTS, RequiredSlotsRefusedError, SlotFillRefusedError, SlotFillsConflictError, SlotFillsRefusedError, UNICODE_RANGE_CLEARANCE, UnmeasuredSlotsRefusedError, assertSingleSlotCopy, assertSlotPrintOptions, base64ToBytes, bindingNames, bindingRoot, bookDocument, bookPrintPart, bytesToBase64, classify, collectSlotPrintCopies, expandMotifs, fill, findActiveContent, fontCss, fontFaceCss, fontFormat, fontReferenceRefusals, hasBindings, hasMotifPlacement, hasSlotWork, isSlotCopyRefusal, libraryMotifPlacementRefusal, mergeSlotFitResults, motifPlacementRefusals, parseUnicodeRange, planBookPages, planPrintedPages, prepareSlotCollection, prepareSlots, printedPageAt, renderMotifPlacements, requiredSlotRefusal, sanitize, searchText, slotFillCopyId, slotFillRefusal, slotFillsConflict, unmeasuredSlotRefusal };

package/dist/motifs.d.ts

@@ -0,0 +1,31 @@
+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>;
+  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

package/dist/motifs.js

@@ -0,0 +1,241 @@
+import { elements, parse, sanitize, serialize } from "./sanitize.js";
+import { bindingNames, bindingRoot, fill, hasBindings } from "./bindings.js";
+import { isTag } from "domhandler";
+import { LIBRARY_MOTIF_PREFIX, MOTIF_ATTRIBUTE, PRINTED_PAGE_CONTEXT, chooseMotifVersion, motifFieldAttribute, resolveDirection } from "@segnavia/format";
+//#region src/motifs.ts
+const MOTIF_DEPTH_LIMIT = 8;
+var MotifRefusedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "MotifRefusedError";
+	}
+};
+function placementName(element) {
+	return `motif placement ${Object.entries(element.attribs).filter(([name]) => name === MOTIF_ATTRIBUTE || name.startsWith(`${MOTIF_ATTRIBUTE}-`)).sort(([left], [right]) => left.localeCompare(right)).map(([name, value]) => `${name}=${JSON.stringify(value)}`).join(", ") || `${MOTIF_ATTRIBUTE}=""`}`;
+}
+function refusal(element, problem, remedy) {
+	return `${placementName(element)} could not establish ${problem}; ${remedy} to clear this refusal.`;
+}
+function motifElements(html) {
+	return elements(parse(html).children).filter((element) => Object.hasOwn(element.attribs, MOTIF_ATTRIBUTE));
+}
+function libraryMotifPlacementRefusal(html) {
+	const placed = motifElements(html).find((element) => (element.attribs[MOTIF_ATTRIBUTE] ?? "").startsWith(LIBRARY_MOTIF_PREFIX));
+	return placed ? refusal(placed, `a host motif key because "${LIBRARY_MOTIF_PREFIX}" is reserved for library motifs`, "rename the motif key") : void 0;
+}
+function hasMotifPlacement(html) {
+	return motifElements(html).length > 0;
+}
+function renderMotifPlacements(html, replacement) {
+	const document = parse(html);
+	const visit = (nodes) => {
+		for (const node of [...nodes]) {
+			if (!isTag(node)) continue;
+			if (Object.hasOwn(node.attribs, MOTIF_ATTRIBUTE)) {
+				const rendered = replacement(node.attribs[MOTIF_ATTRIBUTE] ?? "");
+				if (rendered === void 0) {
+					const index = nodes.indexOf(node);
+					if (index >= 0) nodes.splice(index, 1);
+					continue;
+				}
+				delete node.attribs[MOTIF_ATTRIBUTE];
+				replaceChildren(node, rendered);
+			}
+			visit(node.children);
+		}
+	};
+	visit(document.children);
+	return serialize(document);
+}
+function refuse(state, element, problem, remedy) {
+	const message = refusal(element, problem, remedy);
+	if (!state.validateOnly) throw new MotifRefusedError(message);
+	state.refusals.push(message);
+	return false;
+}
+function placementValues(element, motif, inheritedLang, state) {
+	const known = new Set(motif.fields.map((field) => motifFieldAttribute(field.key).toLowerCase()));
+	known.add(motifFieldAttribute("lang").toLowerCase());
+	const unknown = Object.keys(element.attribs).filter((name) => name.startsWith(`${MOTIF_ATTRIBUTE}-`) && !known.has(name));
+	if (unknown.length > 0) {
+		refuse(state, element, `fields for ${unknown.join(", ")}`, "remove the unknown field attributes");
+		return;
+	}
+	const values = {};
+	for (const field of motif.fields) {
+		const value = element.attribs[motifFieldAttribute(field.key).toLowerCase()] ?? field.default;
+		if (value === void 0) {
+			if (field.required) {
+				refuse(state, element, `a value for required field "${field.key}"`, `set ${motifFieldAttribute(field.key)}`);
+				return;
+			}
+			continue;
+		}
+		if (field.choices && !field.choices.includes(value)) {
+			refuse(state, element, `an allowed value for field "${field.key}"`, `set ${motifFieldAttribute(field.key)} to one of ${field.choices.join(", ")}`);
+			return;
+		}
+		values[field.key] = value;
+	}
+	const lang = element.attribs[motifFieldAttribute("lang")] ?? inheritedLang;
+	if (lang !== void 0) values.lang = lang;
+	return values;
+}
+function replaceChildren(element, html) {
+	const children = parse(html).children;
+	for (const child of children) child.parent = element;
+	element.children = children;
+}
+function needsHostData(html, options) {
+	const deferred = new Set(options.deferPaths ?? []);
+	const names = new Set(Object.values(bindingNames(options.prefix)));
+	return elements(parse(html).children).some((held) => Object.entries(held.attribs).some(([name, path]) => names.has(name) && !deferred.has(bindingRoot(path))));
+}
+async function fillVersion(html, placement, element, state) {
+	const data = await state.options.source.data?.(placement, { signal: state.options.signal });
+	state.options.signal.throwIfAborted();
+	if (data && new Set(state.options.deferPaths ?? []).has(PRINTED_PAGE_CONTEXT) && Object.hasOwn(data, PRINTED_PAGE_CONTEXT)) {
+		refuse(state, element, `the reserved ${PRINTED_PAGE_CONTEXT} context because host data contains that key`, `remove ${PRINTED_PAGE_CONTEXT} from MotifSource.data`);
+		return;
+	}
+	const filled = fill(html, {
+		prefix: state.options.prefix,
+		data: data ?? {},
+		linkOrigins: state.options.linkOrigins,
+		registerHrefOrigins: true,
+		deferPaths: state.options.deferPaths
+	});
+	for (const path of filled.unavailable) state.unavailable.add(path);
+	return filled.html;
+}
+async function motifFor(element, state) {
+	const key = element.attribs[MOTIF_ATTRIBUTE] ?? "";
+	if (!key) {
+		refuse(state, element, "a motif key", `set ${MOTIF_ATTRIBUTE} to a known motif key`);
+		return;
+	}
+	if (key.startsWith(LIBRARY_MOTIF_PREFIX)) {
+		refuse(state, element, `a host motif key because "${LIBRARY_MOTIF_PREFIX}" is reserved for library motifs`, "rename the motif key");
+		return;
+	}
+	const revision = state.options.pins && Object.hasOwn(state.options.pins, key) ? state.options.pins[key] : void 0;
+	const cacheKey = JSON.stringify([key, revision]);
+	let request = state.motifCache.get(cacheKey);
+	if (!request) {
+		request = state.options.source.motif(key, {
+			...revision === void 0 ? {} : { revision },
+			signal: state.options.signal
+		});
+		state.motifCache.set(cacheKey, request);
+	}
+	const motif = await request;
+	state.options.signal.throwIfAborted();
+	if (!motif) {
+		refuse(state, element, `motif "${key}"${revision ? ` at revision "${revision}"` : ""}`, "make that motif available from the source");
+		return;
+	}
+	if (motif.key.startsWith(LIBRARY_MOTIF_PREFIX)) {
+		refuse(state, element, `a host MotifSource result key because "${LIBRARY_MOTIF_PREFIX}" is reserved for library motifs`, "rename the motif key");
+		return;
+	}
+	return motif;
+}
+async function expandPlacement(element, inheritedLang, stack, state) {
+	state.options.signal.throwIfAborted();
+	state.placements += 1;
+	if (state.placements > 256) {
+		refuse(state, element, `at most 256 expanded motif placements`, "reduce the number of motif placements");
+		return;
+	}
+	const motif = await motifFor(element, state);
+	if (!motif) return;
+	if (stack.includes(motif.key)) {
+		refuse(state, element, `an acyclic motif path because "${motif.key}" occurs in ${[...stack, motif.key].join(" -> ")}`, "remove the motif cycle");
+		return;
+	}
+	if (stack.length >= 8) {
+		refuse(state, element, `a nesting depth within 8`, "reduce the motif nesting depth");
+		return;
+	}
+	const values = placementValues(element, motif, inheritedLang, state);
+	if (!values) return;
+	const choice = chooseMotifVersion(motif, values);
+	if (!choice.ok) {
+		refuse(state, element, `a unique matching version: ${choice.reason}`, "add or revise a matching motif version or its placement values");
+		return;
+	}
+	const bound = hasBindings(choice.version.html, state.options.prefix);
+	if (bound && state.options.scripts !== "refuse") {
+		refuse(state, element, "a data-free motif version for a scripted page", "remove its bindings or refuse page scripts");
+		return;
+	}
+	if (needsHostData(choice.version.html, state.options) && !state.options.source.data) {
+		refuse(state, element, "data for the motif version bindings", "provide MotifSource.data or remove the bindings");
+		return;
+	}
+	const lang = choice.version.lang;
+	const fields = Object.fromEntries(Object.entries(values).filter(([key]) => key !== "lang"));
+	const placement = {
+		key: motif.key,
+		revision: motif.revision,
+		lang,
+		fields
+	};
+	let versionHtml = sanitize(choice.version.html, { linkOrigins: state.options.linkOrigins });
+	if (bound && !state.validateOnly) {
+		const filled = await fillVersion(versionHtml, placement, element, state);
+		if (filled === void 0) return;
+		versionHtml = filled;
+	}
+	element.attribs.lang = lang;
+	element.attribs.dir = choice.version.dir ?? resolveDirection(void 0, lang, versionHtml);
+	replaceChildren(element, versionHtml);
+	if (!state.validateOnly) {
+		state.placed.push({
+			...placement,
+			version: choice.index
+		});
+		for (const font of motif.fonts) state.fonts.set(JSON.stringify(font), font);
+	}
+	await expandNodes(element.children, lang, [...stack, motif.key], state);
+}
+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);
+		else await expandNodes(node.children, inheritedLang, stack, state);
+	}
+}
+async function run(html, options, validateOnly) {
+	const document = parse(html);
+	const state = {
+		options,
+		validateOnly,
+		refusals: [],
+		placed: [],
+		fonts: /* @__PURE__ */ new Map(),
+		unavailable: /* @__PURE__ */ new Set(),
+		motifCache: /* @__PURE__ */ new Map(),
+		placements: 0
+	};
+	await expandNodes(document.children, options.lang, [], state);
+	return {
+		document,
+		state
+	};
+}
+async function expandMotifs(html, options) {
+	const { document, state } = await run(html, options, false);
+	return {
+		html: serialize(document),
+		placed: state.placed,
+		fonts: [...state.fonts.values()],
+		unavailable: [...state.unavailable]
+	};
+}
+async function motifPlacementRefusals(html, options) {
+	return (await run(html, options, true)).state.refusals;
+}
+//#endregion
+export { MOTIF_DEPTH_LIMIT, MotifRefusedError, expandMotifs, hasMotifPlacement, libraryMotifPlacementRefusal, motifPlacementRefusals, renderMotifPlacements };

package/dist/printed-pages.d.ts

@@ -0,0 +1,28 @@
+import { NumberSystem, PrintedPageRole, PrintedPageRules } from "@segnavia/format";
+//#region src/printed-pages.d.ts
+export type PrintedPageSide = 'left' | 'right';
+export interface PrintedPagePlan {
+  index: number;
+  role: PrintedPageRole;
+  parent: string;
+  side: PrintedPageSide;
+  number: string;
+  total: string;
+}
+export interface BookPageFacts {
+  blank: boolean;
+  sectionOpening: boolean;
+  folio?: string;
+  runningHead?: string;
+}
+export type BookPrintedPageRole = 'recto' | 'verso' | 'opener' | 'blank';
+export interface BookPrintedPagePlan extends Omit<BookPageFacts, 'blank' | 'sectionOpening'> {
+  index: number;
+  role: BookPrintedPageRole;
+  parent: string;
+  side: PrintedPageSide;
+}
+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 planBookPages(facts: BookPageFacts[], direction: 'ltr' | 'rtl'): BookPrintedPagePlan[];
+//#endregion

package/dist/printed-pages.js

@@ -0,0 +1,75 @@
+import { BOOK_PARENT_NAMES, formatNumber } from "@segnavia/format";
+//#region src/printed-pages.ts
+function printedPageAt(rules, index, count, direction) {
+	const recto = index % 2 === 1;
+	const side = recto === (direction === "ltr") ? "right" : "left";
+	let role = "every";
+	let parent = rules.every;
+	if (recto && rules.recto) {
+		role = "recto";
+		parent = rules.recto;
+	} else if (!recto && rules.verso) {
+		role = "verso";
+		parent = rules.verso;
+	}
+	if (index === count && rules.last) {
+		role = "last";
+		parent = rules.last;
+	}
+	if (index === 1 && rules.first) {
+		role = "first";
+		parent = rules.first;
+	}
+	return {
+		role,
+		parent,
+		side
+	};
+}
+function planPrintedPages(rules, count, direction, numbering = "arabic") {
+	if (!Number.isSafeInteger(count) || count < 1) throw new RangeError("A printed-page plan needs a positive safe page count.");
+	const total = formatNumber(count, numbering);
+	return Array.from({ length: count }, (_, offset) => {
+		const index = offset + 1;
+		return {
+			index,
+			...printedPageAt(rules, index, count, direction),
+			number: formatNumber(index, numbering),
+			total
+		};
+	});
+}
+const BOOK_RULES = {
+	every: BOOK_PARENT_NAMES.recto,
+	recto: BOOK_PARENT_NAMES.recto,
+	verso: BOOK_PARENT_NAMES.verso
+};
+function planBookPages(facts, direction) {
+	return facts.map((fact, offset) => {
+		const index = offset + 1;
+		const selected = printedPageAt(BOOK_RULES, index, facts.length, direction);
+		if (fact.blank) return {
+			index,
+			role: "blank",
+			parent: BOOK_PARENT_NAMES.blank,
+			side: selected.side
+		};
+		if (fact.sectionOpening) return {
+			index,
+			role: "opener",
+			parent: BOOK_PARENT_NAMES.opener,
+			side: selected.side,
+			...fact.folio === void 0 ? {} : { folio: fact.folio }
+		};
+		return {
+			index,
+			role: selected.role === "verso" ? "verso" : "recto",
+			parent: selected.parent,
+			side: selected.side,
+			...fact.folio === void 0 ? {} : { folio: fact.folio },
+			...fact.runningHead === void 0 ? {} : { runningHead: fact.runningHead }
+		};
+	});
+}
+//#endregion
+export { planBookPages, planPrintedPages, printedPageAt };

package/dist/unicode-range.d.ts

@@ -0,0 +1,11 @@
+//#region src/unicode-range.d.ts
+export type UnicodeRangeParse = {
+  ok: true;
+  value: string;
+} | {
+  ok: false;
+  reason: string;
+};
+export declare const UNICODE_RANGE_CLEARANCE: string;
+export declare function parseUnicodeRange(range: string): UnicodeRangeParse;
+//#endregion

package/dist/unicode-range.js

@@ -0,0 +1,86 @@
+//#region src/unicode-range.ts
+const MAX_CODE_POINT = 1114111;
+const MAX_CODE_POINT_HEX = MAX_CODE_POINT.toString(16).toUpperCase();
+const DESCRIPTOR_FORM = "U+hex, U+hex-hex, or U+hex with ? wildcards";
+const UNICODE_RANGE_CLEARANCE = `${DESCRIPTOR_FORM}; code points at most ${MAX_CODE_POINT_HEX}`;
+function codePoint(hex) {
+	return Number.parseInt(hex, 16);
+}
+function aboveMax(hex, token) {
+	if (codePoint(hex) > MAX_CODE_POINT) return {
+		ok: false,
+		reason: `${token} has a code point above ${MAX_CODE_POINT_HEX}`
+	};
+}
+function malformed(token) {
+	return {
+		ok: false,
+		reason: `${token} is not a CSS unicode-range descriptor (${DESCRIPTOR_FORM})`
+	};
+}
+function parseRange(token) {
+	const match = /^[Uu]\+([0-9A-Fa-f]{1,6})-([0-9A-Fa-f]{1,6})$/.exec(token);
+	if (!match) return;
+	const start = match[1] ?? "";
+	const end = match[2] ?? "";
+	const high = aboveMax(start, token) ?? aboveMax(end, token);
+	if (high) return high;
+	if (codePoint(start) > codePoint(end)) return {
+		ok: false,
+		reason: `${token} has start greater than end`
+	};
+	return {
+		ok: true,
+		value: `U+${start.toUpperCase()}-${end.toUpperCase()}`
+	};
+}
+function parseWildcard(token) {
+	const match = /^[Uu]\+([0-9A-Fa-f]{0,5})(\?+)$/.exec(token);
+	if (!match) return;
+	const hex = match[1] ?? "";
+	const marks = match[2] ?? "";
+	if (hex.length + marks.length > 6) return malformed(token);
+	const high = aboveMax(`${hex}${"0".repeat(marks.length)}`, token) ?? aboveMax(`${hex}${"F".repeat(marks.length)}`, token);
+	if (high) return high;
+	return {
+		ok: true,
+		value: `U+${hex.toUpperCase()}${marks}`
+	};
+}
+function parseSingle(token) {
+	const match = /^[Uu]\+([0-9A-Fa-f]{1,6})$/.exec(token);
+	if (!match) return;
+	const hex = match[1] ?? "";
+	const high = aboveMax(hex, token);
+	if (high) return high;
+	return {
+		ok: true,
+		value: `U+${hex.toUpperCase()}`
+	};
+}
+function parseDescriptor(token) {
+	return parseRange(token) ?? parseWildcard(token) ?? parseSingle(token) ?? malformed(token);
+}
+function parseUnicodeRange(range) {
+	if (range.trim() === "") return {
+		ok: false,
+		reason: "the list is empty"
+	};
+	const tokens = range.split(",").map((part) => part.trim());
+	if (tokens.some((token) => token.length === 0)) return {
+		ok: false,
+		reason: "the list has an empty entry"
+	};
+	const parsed = [];
+	for (const token of tokens) {
+		const result = parseDescriptor(token);
+		if (!result.ok) return result;
+		parsed.push(result.value);
+	}
+	return {
+		ok: true,
+		value: parsed.join(", ")
+	};
+}
+//#endregion
+export { UNICODE_RANGE_CLEARANCE, parseUnicodeRange };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/html",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "@segnavia/format": "0.26.0",
+    "@segnavia/format": "0.27.0",
     "dom-serializer": "^2.0.0",
     "domhandler": "^5.0.3",
     "htmlparser2": "^10.0.0",