@segnavia/idml 0.29.0 → 0.30.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { IdmlFontUse, IdmlReportData } from "./report.js";
 import { IdmlImportOptions, IdmlImportReport, IdmlImportResult, importIdml } from "./import.js";
 import { IDML_LIMITS, MAX_IDML_ENTRIES, MAX_IDML_PACKAGE_BYTES, MAX_IDML_PART_BYTES, MAX_IDML_TOTAL_INFLATED_BYTES, MAX_IDML_XML_DEPTH } from "./limits.js";
-import { IdmlStory } from "./types.js";
-import { IdmlDocumentPreferences, IdmlMargin, IdmlMasterSpread, IdmlModel, IdmlPage, IdmlSpread } from "./model.js";
+import { IdmlDocumentPreferences, IdmlMargin, IdmlMasterSpread, IdmlPage, IdmlSpread, IdmlStory } from "./types.js";
+import { IdmlModel } from "./model.js";
 export { IDML_LIMITS, type IdmlDocumentPreferences, type IdmlFontUse, type IdmlImportOptions, type IdmlImportReport, type IdmlImportResult, type IdmlMargin, type IdmlMasterSpread, type IdmlModel, type IdmlPage, type IdmlReportData, type IdmlSpread, type IdmlStory, MAX_IDML_ENTRIES, MAX_IDML_PACKAGE_BYTES, MAX_IDML_PART_BYTES, MAX_IDML_TOTAL_INFLATED_BYTES, MAX_IDML_XML_DEPTH, importIdml };

package/dist/map-book.js

@@ -1,7 +1,10 @@
 import { refusal } from "./refusal.js";
-import { ReportCollector } from "./report.js";
+import { logicalMargin } from "./margins.js";
 import { storyHtml } from "./stories.js";
+import { chapterParents, mapMasters } from "./masters.js";
+import { ReportCollector } from "./report.js";
 import { StyleMapper } from "./styles.js";
+import { matchVariables } from "./variables.js";
 import { Book, MM_PER_PT } from "@segnavia/format";
 import { findActiveContent } from "@segnavia/html";
 //#region src/map-book.ts
@@ -25,26 +28,38 @@ function bodyColumnGap(model, stories, report) {
 	}
 	return selected;
 }
+function refuseActiveBookHtml(chapters, parents) {
+	const html = [...chapters.map((chapter) => chapter.html), ...parents.flatMap((parent) => [parent.head ?? "", parent.foot ?? ""])].join("");
+	const active = findActiveContent(html);
+	if (active.length > 0) throw refusal(`the imported Book contains active content (${active.join(", ")})`, "remove that active content");
+}
 function modelToBook(model, report = new ReportCollector(model.report)) {
 	const preferences = model.preferences;
 	const rightBinding = preferences.binding === "right-to-left";
 	const bookDirection = rightBinding ? "rtl" : "ltr";
 	const styles = new StyleMapper(model.styles ?? [], model.swatches ?? [], report, bookDirection);
+	const matchedVariables = matchVariables(model.textVariables ?? [], report);
 	const bookLanguage = styles.rootLanguage();
 	const stories = orderedStories(model);
+	const masters = mapMasters(model, matchedVariables, styles, report);
 	const chapters = stories.map((story) => ({
 		story,
-		mapped: storyHtml(story, styles, report, bookDirection, bookLanguage)
-	})).map(({ story, mapped: value }) => ({
-		title: story.id,
-		html: value.html
-	}));
+		mapped: storyHtml({
+			...story,
+			textVariables: matchedVariables
+		}, styles, report, bookDirection, bookLanguage)
+	})).map(({ story, mapped: value }) => {
+		const parents = chapterParents(story.id, model, masters, report);
+		return {
+			title: story.id,
+			html: value.html,
+			...parents ? { parents } : {}
+		};
+	});
 	if (chapters.length === 0) throw refusal("the IDML has no stories", "add at least one Story");
-	const html = chapters.map((chapter) => chapter.html).join("");
-	const active = findActiveContent(html);
-	if (active.length > 0) throw refusal(`the imported Book contains active content (${active.join(", ")})`, "remove that active content");
+	refuseActiveBookHtml(chapters, masters.parents);
 	const columnGap = bodyColumnGap(model, stories, report);
-	const css = styles.css();
+	const css = `${styles.css()}${masters.css}`;
 	return Book.parse({
 		title: model.id,
 		mode: "paginated",
@@ -54,20 +69,16 @@ function modelToBook(model, report = new ReportCollector(model.report)) {
 				height: preferences.pageHeight,
 				unit: "pt"
 			},
-			margin: {
-				top: preferences.margin.top * MM_PER_PT,
-				bottom: preferences.margin.bottom * MM_PER_PT,
-				inner: (rightBinding ? preferences.margin.right : preferences.margin.left) * MM_PER_PT,
-				outer: (rightBinding ? preferences.margin.left : preferences.margin.right) * MM_PER_PT
-			},
+			margin: masters.bookMargin ?? logicalMargin(preferences.margin, rightBinding ? "left" : "right"),
 			...columnGap === void 0 ? {} : { columnGap: columnGap * MM_PER_PT }
 		},
 		dir: bookDirection,
 		...bookLanguage ? { lang: bookLanguage } : {},
 		...css ? { css } : {},
 		rectoOpenings: preferences.facingPages,
+		parentPages: masters.parents,
 		chapters
 	});
 }
 //#endregion
-export { modelToBook };
+export { modelToBook, refuseActiveBookHtml };

package/dist/margins.js

@@ -0,0 +1,21 @@
+import { numberAttribute } from "./xml.js";
+import { MM_PER_PT } from "@segnavia/format";
+//#region src/margins.ts
+function readMargin(element) {
+	return {
+		top: numberAttribute(element, "Top", 0),
+		bottom: numberAttribute(element, "Bottom", 0),
+		left: numberAttribute(element, "Left", 0),
+		right: numberAttribute(element, "Right", 0)
+	};
+}
+function logicalMargin(margin, side) {
+	return {
+		top: margin.top * MM_PER_PT,
+		bottom: margin.bottom * MM_PER_PT,
+		inner: (side === "left" ? margin.right : margin.left) * MM_PER_PT,
+		outer: (side === "left" ? margin.left : margin.right) * MM_PER_PT
+	};
+}
+//#endregion
+export { logicalMargin, readMargin };

package/dist/masters.js

@@ -0,0 +1,200 @@
+import { logicalMargin } from "./margins.js";
+import { storyHtml } from "./stories.js";
+import { BOOK_PARENT_NAMES, MM_PER_PT } from "@segnavia/format";
+import serialize from "dom-serializer";
+import { Element } from "domhandler";
+import { parseDocument } from "htmlparser2";
+const slug = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "master";
+const mm = (points) => `${Number((points * MM_PER_PT).toFixed(6))}mm`;
+function roleFor(page, rtl, ordinal) {
+	if (!page.side || page.side === "single") return (ordinal ?? 0) % 2 === 0 ? "recto" : "verso";
+	return page.side === (rtl ? "left" : "right") ? "recto" : "verso";
+}
+function masterPage(master, role, rtl) {
+	if (master.pages.length === 1) return master.pages[0];
+	const side = role === "recto" ? rtl ? "left" : "right" : rtl ? "right" : "left";
+	return master.pages.find((page) => page.side === side);
+}
+function parentName(master, role) {
+	return `idml-${slug(master.name)}-${master.pages.length === 1 ? "recto" : role}`;
+}
+function frameRegion(page, frame, height) {
+	if (frame.bounds.top + frame.bounds.height <= page.margin.top) return "head";
+	if (frame.bounds.top >= height - page.margin.bottom) return "foot";
+}
+function regionHtml(master, page, region, context) {
+	const boxes = [];
+	for (const frame of page.frames) {
+		if (frameRegion(page, frame, context.model.preferences.pageHeight) !== region) continue;
+		const story = context.stories.get(frame.story);
+		if (!story) {
+			context.report.add(context.report.unsupportedElements, "master story missing", `${master.name}#${frame.id}`);
+			continue;
+		}
+		const className = `idml-master-frame-${context.css.length}`;
+		const mapped = storyHtml({
+			...story,
+			textVariables: context.variables,
+			master: true
+		}, context.styles, context.report, context.rtl ? "rtl" : "ltr", void 0);
+		const nodes = parseDocument(mapped.html, { xmlMode: false }).children;
+		boxes.push(new Element("div", { class: className }, nodes));
+		const right = frame.bounds.left + frame.bounds.width;
+		const inlineStart = context.rtl ? context.model.preferences.pageWidth - page.margin.right - right : frame.bounds.left - page.margin.left;
+		const blockStart = region === "head" ? frame.bounds.top : frame.bounds.top - (context.model.preferences.pageHeight - page.margin.bottom);
+		context.css.push(`:where(.${className}){position:absolute;inset-inline-start:${mm(inlineStart)};inline-size:${mm(frame.bounds.width)};inset-block-start:${mm(blockStart)};block-size:${mm(frame.bounds.height)}}`);
+		context.mappedStories.add(frame.story);
+	}
+	if (boxes.length === 0) return void 0;
+	return serialize(new Element("div", { class: "idml-master-region" }, boxes), {
+		xmlMode: false,
+		encodeEntities: "utf8"
+	});
+}
+function pageSide(page, role, rtl) {
+	if (page.side === "left" || page.side === "right") return page.side;
+	return role === "recto" ? rtl ? "left" : "right" : rtl ? "right" : "left";
+}
+function buildParent(master, role, byId, context) {
+	const page = masterPage(master, role, context.rtl);
+	if (!page) return void 0;
+	const base = master.basedOn ? byId.get(master.basedOn) : void 0;
+	const head = regionHtml(master, page, "head", context);
+	const foot = regionHtml(master, page, "foot", context);
+	for (const frame of page.frames) if (!frameRegion(page, frame, context.model.preferences.pageHeight)) context.report.add(context.report.unsupportedElements, "master TextFrame", `${master.name}#${frame.id}`);
+	return {
+		name: parentName(master, role),
+		...base ? { basedOn: parentName(base, role) } : {},
+		margin: logicalMargin(page.margin, pageSide(page, role, context.rtl)),
+		...head ? { head } : {},
+		...foot ? { foot } : {}
+	};
+}
+function reportExtraPages(master, selected, report) {
+	for (const page of master.pages) {
+		if (selected.has(page.id)) continue;
+		report.add(report.unsupportedElements, "master page", `${master.name}#${page.id}`);
+		for (const frame of page.frames) report.add(report.unsupportedElements, "master TextFrame", `${master.name}#${frame.id}`);
+	}
+}
+function buildParents(masters, byId, context) {
+	const result = [];
+	for (const master of masters) {
+		const roles = master.pages.length === 1 ? ["recto"] : ["recto", "verso"];
+		const selected = /* @__PURE__ */ new Set();
+		for (const role of roles) {
+			const page = masterPage(master, role, context.rtl);
+			if (page) selected.add(page.id);
+			const parent = buildParent(master, role, byId, context);
+			if (parent) result.push(parent);
+		}
+		reportExtraPages(master, selected, context.report);
+		for (const item of master.unmappedItems) context.report.add(context.report.unsupportedElements, `master ${item.type}`, `${master.name}#${item.id}`);
+	}
+	return result;
+}
+function emittedMasters(model, applied) {
+	const byId = new Map(model.masterSpreads.map((master) => [master.id, master]));
+	const emitted = new Set(applied);
+	for (const id of emitted) {
+		const basedOn = byId.get(id)?.basedOn;
+		if (basedOn) emitted.add(basedOn);
+	}
+	return model.masterSpreads.filter((master) => emitted.has(master.id));
+}
+function appliedBookMargin(model, applied, report) {
+	const masters = model.masterSpreads.filter((master) => applied.has(master.id));
+	if (masters.length !== applied.size) return void 0;
+	const pages = masters.flatMap((master) => master.pages.map((page) => ({
+		master,
+		page
+	})));
+	const first = pages[0]?.page.margin;
+	if (!first) return void 0;
+	const signature = (margin) => `${margin.top},${margin.bottom},${margin.left},${margin.right}`;
+	if (pages.some(({ page }) => signature(page.margin) !== signature(first))) {
+		for (const master of masters) {
+			const margins = [...new Set(master.pages.map((page) => signature(page.margin)))];
+			report.add(report.unsupportedElements, "master margins disagree", `${master.name}:${margins.join("|")}`);
+		}
+		return;
+	}
+	return logicalMargin(first, model.preferences.binding === "right-to-left" ? "left" : "right");
+}
+function mapMasters(model, variables, styles, report) {
+	const rtl = model.preferences.binding === "right-to-left";
+	const applied = new Set(model.spreads.flatMap((spread) => spread.pages.map((page) => page.appliedMaster).filter((id) => Boolean(id && id !== "n"))));
+	const masters = emittedMasters(model, applied);
+	const byId = new Map(model.masterSpreads.map((master) => [master.id, master]));
+	for (const spread of model.spreads) for (const page of spread.pages) {
+		const id = page.appliedMaster;
+		if (id && id !== "n" && !byId.has(id)) report.addOnce(report.unsupportedElements, `applied master unknown:${id}`, page.id);
+	}
+	const css = [":where(.idml-master-region){position:relative;block-size:100%}"];
+	const mappedStories = /* @__PURE__ */ new Set();
+	const parents = buildParents(masters, byId, {
+		model,
+		variables,
+		styles,
+		report,
+		rtl,
+		stories: new Map(model.stories.map((story) => [story.id, story])),
+		mappedStories,
+		css
+	});
+	if (model.spreads.some((spread) => spread.pages.some((page) => !page.appliedMaster || page.appliedMaster === "n"))) parents.push({
+		name: "idml-none",
+		basedOn: BOOK_PARENT_NAMES.blank
+	});
+	for (const story of model.masterStoryIds) if (!mappedStories.has(story)) report.add(report.unsupportedElements, "master story", story);
+	const parentFor = (masterId, role, location) => {
+		if (!masterId || masterId === "n") return "idml-none";
+		const master = byId.get(masterId);
+		if (master && applied.has(masterId)) return parentName(master, role);
+		report.addOnce(report.unsupportedElements, `applied master unknown:${masterId}`, location);
+		return role === "recto" ? BOOK_PARENT_NAMES.recto : BOOK_PARENT_NAMES.verso;
+	};
+	return {
+		parents,
+		css: css.join(""),
+		bookMargin: appliedBookMargin(model, applied, report),
+		parentFor,
+		mappedStories
+	};
+}
+function chapterParents(story, model, mapping, report) {
+	const rtl = model.preferences.binding === "right-to-left";
+	const pages = [];
+	let ordinal = 0;
+	for (const spread of model.spreads) for (const page of spread.pages) {
+		if (page.stories.includes(story)) pages.push({
+			page,
+			ordinal
+		});
+		ordinal += 1;
+	}
+	const first = pages[0];
+	if (!first) return void 0;
+	const firstRole = roleFor(first.page, rtl, first.ordinal);
+	const result = { opener: mapping.parentFor(first.page.appliedMaster, firstRole, first.page.id) };
+	for (const role of ["recto", "verso"]) {
+		const candidates = pages.slice(1).filter((entry) => roleFor(entry.page, rtl, entry.ordinal) === role);
+		if (candidates.length === 0) continue;
+		const counts = /* @__PURE__ */ new Map();
+		for (const entry of candidates) {
+			const id = entry.page.appliedMaster ?? "n";
+			counts.set(id, (counts.get(id) ?? 0) + 1);
+		}
+		const chosen = [...counts].sort((a, b) => b[1] - a[1])[0]?.[0];
+		if (chosen) result[role] = mapping.parentFor(chosen, role, candidates[0]?.page.id ?? story);
+		if (chosen && counts.size > 1) report.mixedMasterChapters.push({
+			chapter: story,
+			side: role,
+			masters: [...counts.keys()],
+			chosen
+		});
+	}
+	return result;
+}
+//#endregion
+export { chapterParents, mapMasters };

package/dist/model.d.ts

@@ -1,32 +1,6 @@
 import { IdmlReportData } from "./report.js";
-import { IdmlFramePreference, IdmlStory, IdmlStyle, IdmlSwatch } from "./types.js";
+import { IdmlDocumentPreferences, IdmlFramePreference, IdmlMargin, IdmlMasterPage, IdmlMasterSpread, IdmlPage, IdmlSpread, IdmlStory, IdmlStyle, IdmlSwatch, IdmlTextVariable } from "./types.js";
 //#region src/model.d.ts
-export interface IdmlMargin {
-  top: number;
-  bottom: number;
-  left: number;
-  right: number;
-}
-export interface IdmlDocumentPreferences {
-  pageWidth: number;
-  pageHeight: number;
-  facingPages: boolean;
-  binding: 'left-to-right' | 'right-to-left';
-  margin: IdmlMargin;
-}
-export interface IdmlPage {
-  id: string;
-  appliedMaster?: string;
-  stories: string[];
-}
-export interface IdmlSpread {
-  id: string;
-  pages: IdmlPage[];
-}
-export interface IdmlMasterSpread {
-  id: string;
-  pages: IdmlPage[];
-}
 export interface IdmlModel {
   id: string;
   preferences: IdmlDocumentPreferences;
@@ -38,7 +12,8 @@ export interface IdmlModel {
   styles?: IdmlStyle[];
   swatches?: IdmlSwatch[];
   bodyFramePreferences?: IdmlFramePreference[];
+  textVariables?: IdmlTextVariable[];
   report?: IdmlReportData;
 }
 //#endregion
-export type { IdmlStory };
+export type { IdmlDocumentPreferences, IdmlMargin, IdmlMasterSpread, IdmlPage, IdmlSpread, IdmlStory };

package/dist/model.js

@@ -1,13 +1,14 @@
 import { refusal } from "./refusal.js";
-import { ReportCollector } from "./report.js";
 import { localName, numberAttribute } from "./xml.js";
+import { readMargin } from "./margins.js";
+import { ReportCollector } from "./report.js";
 import { parseStyles, parseSwatches } from "./styles.js";
 import { FramePreferenceIndex, framePreference } from "./frame-preferences.js";
 import { IDML_LIMITS } from "./limits.js";
+import { parseParts } from "./parse-parts.js";
 import { parseStories } from "./story-model.js";
 import { collectUnsupportedElements } from "./unsupported-elements.js";
 import { isTag } from "domhandler";
-import { Parser, parseDocument } from "htmlparser2";
 //#region src/model.ts
 function elements(root, name) {
 	const found = [];
@@ -35,57 +36,14 @@ function boolAttribute(element, name, fallback) {
 	if (raw === "false") return false;
 	throw refusal(`IDML ${name} must be true or false`, `set ${name} to true or false`);
 }
-function checkXmlDepth(source, part, limit) {
-	let depth = 0;
-	new Parser({
-		onopentag() {
-			depth += 1;
-			if (depth > limit) throw refusal(`IDML XML part ${part} exceeds the ${limit} level XML depth limit`, `reduce its nesting to ${limit} levels or fewer`);
-		},
-		onclosetag() {
-			depth -= 1;
-		}
-	}, {
-		xmlMode: true,
-		recognizeSelfClosing: true
-	}).end(source);
-}
-function parseParts(entries, limits) {
-	const decoder = new TextDecoder("utf-8", { fatal: true });
-	return entries.filter((entry) => entry.name.toLowerCase().endsWith(".xml")).map((entry) => {
-		let source;
-		try {
-			source = decoder.decode(entry.bytes);
-		} catch {
-			throw refusal(`IDML XML part ${entry.name} is not valid UTF-8`, "export that XML part as UTF-8");
-		}
-		let document;
-		try {
-			checkXmlDepth(source, entry.name, limits.xmlDepth);
-			document = parseDocument(source, {
-				xmlMode: true,
-				recognizeSelfClosing: true
-			});
-		} catch (error) {
-			if (error instanceof Error && error.message.includes("XML depth limit")) throw error;
-			throw refusal(`IDML XML part ${entry.name} could not be parsed: ${String(error)}`, "export well-formed XML");
-		}
-		const all = elements(document);
-		if (all.length === 0) throw refusal(`IDML XML part ${entry.name} has no root element`, "export a non-empty well-formed XML part");
-		return {
-			name: entry.name,
-			document,
-			all
-		};
-	});
-}
 function page(element) {
 	const id = attribute(element, "Self");
 	if (!id) throw refusal("an IDML Page has no Self identifier", "give every Page a Self identifier");
 	return {
 		id,
 		appliedMaster: attribute(element, "AppliedMaster"),
-		stories: []
+		stories: [],
+		side: "single"
 	};
 }
 const IDENTITY = [
@@ -127,12 +85,19 @@ function pageArea(element) {
 		apply(matrix, [left, bottom])
 	];
 }
-function frameCenter(element, matrix) {
-	const anchors = elements(element).map((candidate) => attribute(candidate, "Anchor")).filter((value) => value !== void 0).map((value) => value.trim().split(/\s+/).map(Number)).filter((value) => value.length === 2 && value.every(Number.isFinite)).map((point) => apply(matrix, point));
-	if (anchors.length === 0) return void 0;
-	const xs = anchors.map(([x]) => x);
-	const ys = anchors.map(([, y]) => y);
-	return [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2];
+function bounds(points) {
+	if (points.length === 0) return void 0;
+	const xs = points.map(([x]) => x);
+	const ys = points.map(([, y]) => y);
+	return {
+		left: Math.min(...xs),
+		top: Math.min(...ys),
+		right: Math.max(...xs),
+		bottom: Math.max(...ys)
+	};
+}
+function frameBounds(element, matrix) {
+	return bounds(elements(element).map((candidate) => attribute(candidate, "Anchor")).filter((value) => value !== void 0).map((value) => value.trim().split(/\s+/).map(Number)).filter((value) => value.length === 2 && value.every(Number.isFinite)).map((point) => apply(matrix, point)));
 }
 function contains(area, [x, y]) {
 	let inside = false;
@@ -148,9 +113,14 @@ function framePlacement(element, matrix, location) {
 	const story = attribute(element, "ParentStory");
 	if (!story) return void 0;
 	const preference = framePreference(element, location);
+	const box = frameBounds(element, matrix);
 	return {
+		id: attribute(element, "Self") ?? story,
 		story,
-		center: frameCenter(element, matrix),
+		...box ? {
+			bounds: box,
+			center: [(box.left + box.right) / 2, (box.top + box.bottom) / 2]
+		} : {},
 		...preference ? { preference } : {}
 	};
 }
@@ -178,10 +148,83 @@ function spreadFrames(spread, location) {
 	}
 	return result;
 }
-function placeStories(element, pageElements, pages, report, framePreferences, location) {
+function assignSides(pageElements, pages) {
+	if (pages.length < 2) return;
+	const order = pageElements.map((element) => {
+		const area = pageArea(element);
+		return area ? bounds(area) : void 0;
+	}).map((area, index) => ({
+		index,
+		x: area ? (area.left + area.right) / 2 : index
+	})).sort((a, b) => a.x - b.x);
+	const left = order[0];
+	const right = order.at(-1);
+	const leftPage = left ? pages[left.index] : void 0;
+	const rightPage = right ? pages[right.index] : void 0;
+	if (leftPage) leftPage.side = "left";
+	if (rightPage && right?.index !== left?.index) rightPage.side = "right";
+}
+function masterFrames(frames, pageElements, pages) {
+	const result = pages.map(() => []);
+	const areas = pageElements.map((candidate) => {
+		const area = pageArea(candidate);
+		return area ? bounds(area) : void 0;
+	});
+	for (const frame of frames) {
+		const absolute = frame.bounds;
+		if (!absolute || !frame.center) continue;
+		const index = pageElements.findIndex((candidate) => {
+			const area = pageArea(candidate);
+			return area ? contains(area, frame.center) : false;
+		});
+		const area = areas[index];
+		if (index < 0 || !area) continue;
+		result[index]?.push({
+			id: frame.id,
+			story: frame.story,
+			bounds: {
+				left: absolute.left - area.left,
+				top: absolute.top - area.top,
+				width: absolute.right - absolute.left,
+				height: absolute.bottom - absolute.top
+			}
+		});
+	}
+	return result;
+}
+function masterSpread(element, pageElements, pages, placements) {
+	const frames = masterFrames(placements, pageElements, pages);
+	const prefix = attribute(element, "NamePrefix") ?? "";
+	const base = attribute(element, "BaseName") ?? attribute(element, "Name") ?? attribute(element, "Self") ?? "master";
+	const name = prefix ? `${prefix}-${base}` : base;
+	const frameIds = new Set(frames.flat().map((frame) => frame.id));
+	const unmappedItems = element.children.flatMap((child) => {
+		if (!isTag(child)) return [];
+		const type = localName(child.name);
+		if (type === "Page" || type === "Properties") return [];
+		const id = attribute(child, "Self") ?? type;
+		if (type === "TextFrame" && frameIds.has(id)) return [];
+		return [{
+			type,
+			id
+		}];
+	});
+	return {
+		id: attribute(element, "Self") ?? base,
+		name,
+		...attribute(element, "BasedOn") ? { basedOn: attribute(element, "BasedOn") } : {},
+		pages: pages.map((value, index) => ({
+			...value,
+			margin: readMargin(elements(pageElements[index], "MarginPreference")[0]),
+			frames: frames[index] ?? []
+		})),
+		unmappedItems
+	};
+}
+function placeStories(frames, pageElements, pages, report, framePreferences) {
 	const areas = pageElements.map(pageArea);
 	const frameStories = /* @__PURE__ */ new Set();
-	for (const frame of spreadFrames(element, location)) {
+	for (const frame of frames) {
 		frameStories.add(frame.story);
 		framePreferences.add(frame.story, frame.preference);
 		const pageIndex = frame.center ? areas.findIndex((area) => area !== void 0 && contains(area, frame.center)) : -1;
@@ -206,8 +249,10 @@ function spreads(parts, kind, orderedNames, report, framePreferences) {
 			if (!id) continue;
 			const pageElements = elements(element, "Page");
 			const pages = pageElements.map(page);
-			for (const story of placeStories(element, pageElements, pages, report, framePreferences, name)) frameStories.add(story);
-			result.push({
+			assignSides(pageElements, pages);
+			const frames = spreadFrames(element, name);
+			for (const story of placeStories(frames, pageElements, pages, report, framePreferences)) frameStories.add(story);
+			result.push(kind === "MasterSpread" ? masterSpread(element, pageElements, pages, frames) : {
 				id,
 				pages
 			});
@@ -218,6 +263,21 @@ function spreads(parts, kind, orderedNames, report, framePreferences) {
 		frameStories
 	};
 }
+function textVariables(designmap) {
+	return designmap.all.filter((element) => localName(element.name) === "TextVariable").flatMap((element) => {
+		const id = attribute(element, "Self");
+		if (!id) return [];
+		const preference = element.children.find((child) => isTag(child) && localName(child.name).endsWith("Preference"));
+		return [{
+			id,
+			name: attribute(element, "Name") ?? id,
+			type: attribute(element, "VariableType") ?? "unknown",
+			appliedCharacterStyle: preference ? attribute(preference, "AppliedCharacterStyle") : void 0,
+			searchStrategy: preference ? attribute(preference, "SearchStrategy") : void 0,
+			location: `designmap.xml#${id}`
+		}];
+	});
+}
 function spreadSources(document, kind) {
 	return document.all.filter((element) => localName(element.name) === kind).map((element) => attribute(element, "src")).filter((source) => source !== void 0);
 }
@@ -238,7 +298,6 @@ function idmlModel(entries, limits = IDML_LIMITS) {
 	const spreadResult = spreads(parts, "Spread", spreadSources(designmap, "Spread"), report, framePreferences);
 	const masterResult = spreads(parts, "MasterSpread", spreadSources(designmap, "MasterSpread"), report, new FramePreferenceIndex());
 	const masterStoryIds = [...masterResult.frameStories].filter((story) => !spreadResult.frameStories.has(story));
-	for (const story of masterStoryIds) report.add(report.unsupportedElements, "master story", story);
 	return {
 		id: attribute(document, "Self") ?? "IDML document",
 		preferences: {
@@ -246,17 +305,13 @@ function idmlModel(entries, limits = IDML_LIMITS) {
 			pageHeight: numberAttribute(preference, "PageHeight"),
 			facingPages: boolAttribute(preference, "FacingPages", true),
 			binding: binding === "RightToLeft" ? "right-to-left" : "left-to-right",
-			margin: {
-				top: numberAttribute(margin, "Top", 0),
-				bottom: numberAttribute(margin, "Bottom", 0),
-				left: numberAttribute(margin, "Left", 0),
-				right: numberAttribute(margin, "Right", 0)
-			}
+			margin: readMargin(margin)
 		},
 		spreads: spreadResult.values,
 		masterSpreads: masterResult.values,
 		stories: parseStories(parts, framePreferences, report),
 		bodyFramePreferences: framePreferences.values(),
+		textVariables: textVariables(designmap),
 		masterStoryIds,
 		partsRead: parts.map((part) => part.name),
 		styles: parts.flatMap((part) => part.name.endsWith("/Styles.xml") || part.name === "Resources/Styles.xml" ? parseStyles(part.all, part.name) : []),

package/dist/parse-parts.js

@@ -0,0 +1,61 @@
+import { refusal } from "./refusal.js";
+import { isTag } from "domhandler";
+import { Parser, parseDocument } from "htmlparser2";
+//#region src/parse-parts.ts
+function allElements(root) {
+	const found = [];
+	const pending = [root];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (!node) continue;
+		if (isTag(node)) found.push(node);
+		if ("children" in node) for (const child of [...node.children].reverse()) pending.push(child);
+	}
+	return found;
+}
+function checkDepth(source, part, limit) {
+	let depth = 0;
+	new Parser({
+		onopentag() {
+			depth += 1;
+			if (depth > limit) throw refusal(`IDML XML part ${part} exceeds the ${limit} level XML depth limit`, `reduce its nesting to ${limit} levels or fewer`);
+		},
+		onclosetag() {
+			depth -= 1;
+		}
+	}, {
+		xmlMode: true,
+		recognizeSelfClosing: true
+	}).end(source);
+}
+function parseParts(entries, limits) {
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	return entries.filter((entry) => entry.name.toLowerCase().endsWith(".xml")).map((entry) => {
+		let source;
+		try {
+			source = decoder.decode(entry.bytes);
+		} catch {
+			throw refusal(`IDML XML part ${entry.name} is not valid UTF-8`, "export that XML part as UTF-8");
+		}
+		let document;
+		try {
+			checkDepth(source, entry.name, limits.xmlDepth);
+			document = parseDocument(source, {
+				xmlMode: true,
+				recognizeSelfClosing: true
+			});
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("XML depth limit")) throw error;
+			throw refusal(`IDML XML part ${entry.name} could not be parsed: ${String(error)}`, "export well-formed XML");
+		}
+		const all = allElements(document);
+		if (all.length === 0) throw refusal(`IDML XML part ${entry.name} has no root element`, "export a non-empty well-formed XML part");
+		return {
+			name: entry.name,
+			document,
+			all
+		};
+	});
+}
+//#endregion
+export { parseParts };

package/dist/report.d.ts

@@ -4,6 +4,12 @@ export interface IdmlFontUse {
   fontStyle?: string;
   locations: string[];
 }
+export interface IdmlMixedMasterChapter {
+  chapter: string;
+  side: 'recto' | 'verso';
+  masters: string[];
+  chosen: string;
+}
 export interface IdmlReportData {
   unsupportedElements: Record<string, number>;
   unsupportedStyleProperties: Record<string, number>;
@@ -13,5 +19,6 @@ export interface IdmlReportData {
   spotColors: Record<string, number>;
   locations: Record<string, string[]>;
   fonts: IdmlFontUse[];
+  mixedMasterChapters: IdmlMixedMasterChapter[];
 }
 //#endregion

package/dist/report.js

@@ -10,6 +10,7 @@ const BUCKET_NAMES = {
 var ReportCollector = class {
 	locations = /* @__PURE__ */ new Map();
 	fonts = /* @__PURE__ */ new Map();
+	mixedMasterChapters;
 	buckets = Object.fromEntries(Object.keys(BUCKET_NAMES).map((name) => [name, /* @__PURE__ */ new Map()]));
 	get unsupportedElements() {
 		return this.buckets.unsupportedElements;
@@ -30,6 +31,7 @@ var ReportCollector = class {
 		return this.buckets.spotColors;
 	}
 	constructor(seed) {
+		this.mixedMasterChapters = [...seed?.mixedMasterChapters ?? []];
 		for (const name of Object.keys(BUCKET_NAMES)) for (const [key, count] of Object.entries(seed?.[name] ?? {})) this.buckets[name].set(key, count);
 		for (const [key, locations] of Object.entries(seed?.locations ?? {})) this.locations.set(key, [...locations]);
 		for (const font of seed?.fonts ?? []) this.font(font.appliedFont, font.fontStyle, font.locations[0] ?? "Resources/Styles.xml");
@@ -62,7 +64,8 @@ var ReportCollector = class {
 		return {
 			...Object.fromEntries(Object.keys(BUCKET_NAMES).map((name) => [name, record(this.buckets[name])])),
 			locations: Object.fromEntries([...this.locations].sort(([a], [b]) => a.localeCompare(b))),
-			fonts: [...this.fonts.values()]
+			fonts: [...this.fonts.values()],
+			mixedMasterChapters: [...this.mixedMasterChapters]
 		};
 	}
 	bucketName(bucket) {

package/dist/stories.js

@@ -1,4 +1,4 @@
-import { resolveDirection } from "@segnavia/format";
+import { BOOK_FURNITURE, MOTIF_ATTRIBUTE, motifFieldAttribute, resolveDirection } from "@segnavia/format";
 import { BOOK_COLUMN_MAX, BOOK_COLUMN_MIN } from "@segnavia/html";
 import serialize from "dom-serializer";
 import { Element, Text } from "domhandler";
@@ -10,8 +10,7 @@ const OMITTED = /* @__PURE__ */ new Set([
 	"Polygon",
 	"Table",
 	"Footnote",
-	"Note",
-	"TextVariableInstance"
+	"Note"
 ]);
 const WRAPPERS = /* @__PURE__ */ new Set([
 	"HyperlinkTextSource",
@@ -41,7 +40,18 @@ function tokens(root, report) {
 			kind: "paragraph",
 			location: node.location
 		});
-		else if (node.name === "#processing-instruction") report.add(report.unsupportedSpecialCharacters, node.text ?? "processing instruction", node.location);
+		else if (node.name === "#processing-instruction") result.push({
+			kind: "processing-instruction",
+			text: node.text ?? "",
+			character,
+			location: node.location
+		});
+		else if (node.name === "TextVariableInstance") result.push({
+			kind: "variable",
+			variable: node.attributes.AssociatedTextVariable,
+			character,
+			location: node.location
+		});
 		else if (OMITTED.has(node.name)) report.add(report.unsupportedElements, node.name, node.location);
 		else if (node.name === "Properties") return true;
 		else if (node.name === "Change" && node.attributes.ChangeType !== void 0 && !node.attributes.ChangeType.includes("Inserted")) report.add(report.unsupportedElements, "Change", node.location);
@@ -73,6 +83,71 @@ function contentNodes(token, styles, direction) {
 	const classValue = classes(styleClass, localClass);
 	return classValue ? [new Element("span", { class: classValue }, nodes)] : nodes;
 }
+function matchedVariable(character, variables) {
+	const style = character ? rangeAttributes(character).AppliedCharacterStyle : void 0;
+	return variables.find((variable) => variable.appliedCharacterStyle === style);
+}
+const folioFurniture = BOOK_FURNITURE.find((item) => item.key.endsWith(":folio"));
+const markFurniture = BOOK_FURNITURE.find((item) => item.key.endsWith(":mark"));
+const markWhich = markFurniture?.fields.find((field) => field.key === "which");
+function furnitureClass(token, styles, direction) {
+	const characterAttributes = rangeAttributes(token.character);
+	const characterStyle = characterAttributes.AppliedCharacterStyle;
+	return classes(styles.styleClass(characterStyle, "character"), styles.overrideClass(characterAttributes, styles.flattened(characterStyle, "character"), direction, token.character?.location ?? token.location));
+}
+function markNode(variable, className) {
+	if (!markFurniture) return void 0;
+	const last = markWhich && "choices" in markWhich ? markWhich.choices.find((choice) => choice === "last") : void 0;
+	const fallback = markWhich && "default" in markWhich ? markWhich.default : void 0;
+	return new Element("span", {
+		[MOTIF_ATTRIBUTE]: markFurniture.key,
+		[motifFieldAttribute("name")]: variable.name,
+		[motifFieldAttribute("which")]: variable.searchStrategy === "LastOnPage" ? last ?? fallback ?? "" : fallback ?? "",
+		...className ? { class: className } : {}
+	}, []);
+}
+function furnitureNode(token, variables, master, styles, direction, report) {
+	const className = furnitureClass(token, styles, direction);
+	if (token.kind === "processing-instruction") {
+		if (master && /\bACE\s+18\b/.test(token.text ?? "") && folioFurniture) return new Element("span", {
+			[MOTIF_ATTRIBUTE]: folioFurniture.key,
+			...className ? { class: className } : {}
+		}, []);
+		report.add(report.unsupportedSpecialCharacters, token.text ?? "processing instruction", token.location);
+		return;
+	}
+	if (token.kind !== "variable") return void 0;
+	const variable = variables.find((candidate) => candidate.id === token.variable);
+	if (master && variable) return markNode(variable, className);
+	report.add(report.unsupportedElements, variable ? `TextVariable:${variable.name}` : `TextVariableInstance:${token.variable ?? "unknown"}`, token.location);
+}
+function paragraphChildren(paragraphTokens, styles, report, direction, variables, master) {
+	const children = [];
+	let marked;
+	for (const token of paragraphTokens) {
+		if (token.kind === "text") {
+			const variable = master ? void 0 : matchedVariable(token.character, variables);
+			if (variable) {
+				if (marked?.variable.id !== variable.id) {
+					marked = {
+						variable,
+						node: new Element("span", { "data-mark": variable.name }, [])
+					};
+					children.push(marked.node);
+				}
+				marked.node.children.push(...contentNodes(token, styles, direction));
+			} else {
+				marked = void 0;
+				children.push(...contentNodes(token, styles, direction));
+			}
+			continue;
+		}
+		marked = void 0;
+		const furniture = furnitureNode(token, variables, master, styles, direction, report);
+		if (furniture) children.push(furniture);
+	}
+	return children;
+}
 function textNodes(value) {
 	const pieces = value.split("\u2028");
 	const result = [];
@@ -82,7 +157,7 @@ function textNodes(value) {
 	}
 	return result;
 }
-function paragraphNode(paragraph, paragraphTokens, styles, report, bookDirection, bookLanguage, storyDirection, frame) {
+function paragraphNode(paragraph, paragraphTokens, styles, report, bookDirection, bookLanguage, storyDirection, frame, variables, master) {
 	const attributes = rangeAttributes(paragraph);
 	const styleId = attributes.AppliedParagraphStyle;
 	const flattened = styles.flattened(styleId, "paragraph");
@@ -97,17 +172,13 @@ function paragraphNode(paragraph, paragraphTokens, styles, report, bookDirection
 	if (className) htmlAttributes.class = className;
 	if (resolvedDirection !== bookDirection) htmlAttributes.dir = resolvedDirection;
 	if (language && language !== bookLanguage) htmlAttributes.lang = language;
-	const span = attributes.SpanColumnType ?? flattened.SpanColumnType;
+	const span = attributes.SpanColumnType ?? flattened.SpanColumnType ?? "SingleColumn";
 	if (frame && frame.columns >= 2 && span === "SingleColumn") {
 		if (Number.isInteger(frame.columns) && frame.columns >= BOOK_COLUMN_MIN && frame.columns <= BOOK_COLUMN_MAX) htmlAttributes["data-columns"] = String(frame.columns);
 		else report.addOnce(report.unsupportedElements, `TextColumnCount:${frame.columns}`, frame.location ?? paragraph.location);
 	}
 	if (span === "SplitColumns") report.add(report.unsupportedStyleProperties, "SpanColumnType:SplitColumns", paragraph.location);
-	const children = [];
-	for (const token of paragraphTokens) {
-		if (token.kind !== "text") continue;
-		children.push(...contentNodes(token, styles, resolvedDirection));
-	}
+	const children = paragraphChildren(paragraphTokens, styles, report, resolvedDirection, variables, master);
 	if (children.length === 0) children.push(new Element("br", {}, []));
 	return new Element("p", htmlAttributes, children);
 }
@@ -117,11 +188,17 @@ function storyHtml(story, styles, report, bookDirection, bookLanguage) {
 		encodeEntities: "utf8"
 	}) };
 	const paragraphs = [];
-	for (const paragraph of story.root.children.filter((node) => node.name === "ParagraphStyleRange")) {
+	const paragraphRanges = [];
+	const collectParagraphs = (node) => {
+		if (node.name === "ParagraphStyleRange") paragraphRanges.push(node);
+		else if (node.name === "Story" || node.name === "XMLElement") for (const child of node.children) collectParagraphs(child);
+	};
+	collectParagraphs(story.root);
+	for (const paragraph of paragraphRanges) {
 		const all = tokens(paragraph, report);
 		let current = [];
 		const flush = () => {
-			paragraphs.push(paragraphNode(paragraph, current, styles, report, bookDirection, bookLanguage, story.direction, story.frame));
+			paragraphs.push(paragraphNode(paragraph, current, styles, report, bookDirection, bookLanguage, story.direction, story.frame, story.textVariables ?? [], story.master ?? false));
 			current = [];
 		};
 		for (const token of all) if (token.kind === "paragraph") flush();

package/dist/story-model.js

@@ -1,5 +1,5 @@
-import { activeIdmlValue } from "./style-property-report.js";
 import { idmlDirection, localName } from "./xml.js";
+import { activeIdmlValue } from "./style-property-report.js";
 import { isTag } from "domhandler";
 //#region src/story-model.ts
 function textNode(node, part, path) {

package/dist/styles.js

@@ -1,6 +1,6 @@
+import { idmlDirection, localName } from "./xml.js";
 import { stylePropertyMapping } from "./style-mappings.js";
 import { reportableStyleProperties } from "./style-property-report.js";
-import { idmlDirection, localName } from "./xml.js";
 import { isTag } from "domhandler";
 //#region src/styles.ts
 const PARAGRAPH_ROOT = "$ID/[No paragraph style]";

package/dist/types.d.ts

@@ -32,4 +32,59 @@ export interface IdmlStory {
   root?: IdmlTextNode;
   frame?: IdmlFramePreference;
 }
+export interface IdmlTextVariable {
+  id: string;
+  name: string;
+  type: string;
+  appliedCharacterStyle?: string;
+  searchStrategy?: string;
+  location: string;
+}
+export interface IdmlMargin {
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+}
+export interface IdmlDocumentPreferences {
+  pageWidth: number;
+  pageHeight: number;
+  facingPages: boolean;
+  binding: 'left-to-right' | 'right-to-left';
+  margin: IdmlMargin;
+}
+export interface IdmlPage {
+  id: string;
+  appliedMaster?: string;
+  stories: string[];
+  side?: 'left' | 'right' | 'single';
+}
+export interface IdmlSpread {
+  id: string;
+  pages: IdmlPage[];
+}
+export interface IdmlMasterFrame {
+  id: string;
+  story: string;
+  bounds: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+  };
+}
+export interface IdmlMasterPage extends IdmlPage {
+  margin: IdmlMargin;
+  frames: IdmlMasterFrame[];
+}
+export interface IdmlMasterSpread {
+  id: string;
+  name: string;
+  basedOn?: string;
+  pages: IdmlMasterPage[];
+  unmappedItems: {
+    type: string;
+    id: string;
+  }[];
+}
 //#endregion

package/dist/unsupported-elements.js

@@ -24,6 +24,8 @@ const MAPPED_ELEMENTS = /* @__PURE__ */ new Set([
 	"ParagraphStyle",
 	"CharacterStyle",
 	"Color",
+	"TextVariable",
+	"MatchCharacterStylePreference",
 	"Properties"
 ]);
 function insideMappedResource(element) {

package/dist/variables.js

@@ -0,0 +1,21 @@
+//#region src/variables.ts
+const MATCH_CHARACTER_STYLE = "MatchCharacterStyleType";
+function matchVariables(variables, report) {
+	const result = [];
+	const matchedStyles = /* @__PURE__ */ new Set();
+	for (const variable of variables) {
+		if (variable.type !== MATCH_CHARACTER_STYLE || !variable.appliedCharacterStyle) {
+			report.add(report.unsupportedElements, `TextVariable:${variable.name}`, variable.location);
+			continue;
+		}
+		if (matchedStyles.has(variable.appliedCharacterStyle)) {
+			report.add(report.unsupportedElements, `TextVariable duplicate style:${variable.name}`, variable.location);
+			continue;
+		}
+		matchedStyles.add(variable.appliedCharacterStyle);
+		result.push(variable);
+	}
+	return result;
+}
+//#endregion
+export { matchVariables };

package/package.json

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