@segnavia/idml 0.28.0 → 0.29.0

package/dist/frame-preferences.js

@@ -0,0 +1,45 @@
+import { localName, numberAttribute } from "./xml.js";
+import { isTag } from "domhandler";
+//#region src/frame-preferences.ts
+function preferenceElement(frame) {
+	const pending = [...frame.children];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (!node || !isTag(node)) continue;
+		if (localName(node.name) === "TextFramePreference") return node;
+		pending.push(...node.children);
+	}
+}
+function framePreference(frame, location) {
+	const element = preferenceElement(frame);
+	if (!element) return void 0;
+	return {
+		columns: numberAttribute(element, "TextColumnCount", 1),
+		gutter: numberAttribute(element, "TextColumnGutter", 0),
+		location
+	};
+}
+var FramePreferenceIndex = class {
+	byStory = /* @__PURE__ */ new Map();
+	add(story, preference) {
+		if (!preference || preference.columns < 2) return;
+		const values = this.byStory.get(story) ?? [];
+		values.push(preference);
+		this.byStory.set(story, values);
+	}
+	preferred(story) {
+		const values = this.byStory.get(story) ?? [];
+		const counts = /* @__PURE__ */ new Map();
+		for (const value of values) {
+			const key = `${value.columns}\u0000${value.gutter}`;
+			counts.set(key, (counts.get(key) ?? 0) + 1);
+		}
+		const selected = [...counts].sort((left, right) => right[1] - left[1])[0]?.[0];
+		return values.find((value) => `${value.columns}\u0000${value.gutter}` === selected);
+	}
+	values() {
+		return [...this.byStory.values()].flat();
+	}
+};
+//#endregion
+export { FramePreferenceIndex, framePreference };

package/dist/import.d.ts

@@ -1,9 +1,9 @@
+import { IdmlReportData } from "./report.js";
 import { Book } from "@segnavia/format";
 //#region src/import.d.ts
 export type IdmlImportOptions = Record<never, never>;
-export interface IdmlImportReport {
+export interface IdmlImportReport extends IdmlReportData {
   partsRead: string[];
-  unsupportedElements: Record<string, number>;
 }
 export interface IdmlImportResult {
   book: Book;

package/dist/import.js

@@ -1,4 +1,5 @@
 import { refusal } from "./refusal.js";
+import { ReportCollector } from "./report.js";
 import { modelToBook } from "./map-book.js";
 import { idmlModel } from "./model.js";
 import { readZip } from "./zip.js";
@@ -13,11 +14,12 @@ async function importIdml(bytes, _options = {}) {
 	if (value !== IDML_MIMETYPE) throw refusal(`the IDML mimetype entry is ${JSON.stringify(value)}, not ${IDML_MIMETYPE}`, "use the IDML package mimetype");
 	if (!byName.has("designmap.xml")) throw refusal("the IDML designmap.xml entry is missing", "add the required designmap.xml entry");
 	const model = idmlModel(entries);
+	const collector = new ReportCollector(model.report);
 	return {
-		book: modelToBook(model),
+		book: modelToBook(model, collector),
 		report: {
 			partsRead: model.partsRead,
-			unsupportedElements: model.unsupportedElements
+			...collector.data()
 		}
 	};
 }

package/dist/index.d.ts

@@ -1,4 +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 { IdmlDocumentPreferences, IdmlMargin, IdmlMasterSpread, IdmlModel, IdmlPage, IdmlSpread, IdmlStory } from "./model.js";
-export { IDML_LIMITS, type IdmlDocumentPreferences, type IdmlImportOptions, type IdmlImportReport, type IdmlImportResult, type IdmlMargin, type IdmlMasterSpread, type IdmlModel, type IdmlPage, 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 };
+import { IdmlStory } from "./types.js";
+import { IdmlDocumentPreferences, IdmlMargin, IdmlMasterSpread, IdmlModel, IdmlPage, IdmlSpread } 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,27 +1,50 @@
 import { refusal } from "./refusal.js";
+import { ReportCollector } from "./report.js";
+import { storyHtml } from "./stories.js";
+import { StyleMapper } from "./styles.js";
 import { Book, MM_PER_PT } from "@segnavia/format";
 import { findActiveContent } from "@segnavia/html";
-import serialize from "dom-serializer";
-import { Element } from "domhandler";
 //#region src/map-book.ts
-const emptyParagraph = () => serialize(new Element("p", {}, []), { xmlMode: false });
 function orderedStories(model) {
 	const order = /* @__PURE__ */ new Map();
 	for (const spread of model.spreads) for (const page of spread.pages) for (const story of page.stories) if (!order.has(story)) order.set(story, order.size);
 	const masterStories = new Set(model.masterStoryIds);
 	return model.stories.filter((story) => !masterStories.has(story.id)).sort((left, right) => (order.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (order.get(right.id) ?? Number.MAX_SAFE_INTEGER));
 }
-function modelToBook(model) {
+function bodyColumnGap(model, stories, report) {
+	const storyFrames = stories.flatMap((story) => story.frame?.columns && story.frame.columns >= 2 ? [story.frame] : []);
+	const frames = (model.bodyFramePreferences ?? storyFrames).filter((frame) => frame.columns >= 2);
+	const representativeFrames = storyFrames.length > 0 ? storyFrames : frames;
+	const counts = /* @__PURE__ */ new Map();
+	for (const frame of representativeFrames) counts.set(frame.gutter, (counts.get(frame.gutter) ?? 0) + 1);
+	const selected = [...counts].sort((left, right) => right[1] - left[1])[0]?.[0];
+	if (selected === void 0) return void 0;
+	for (const gutter of new Set(frames.map((frame) => frame.gutter).filter((gutter) => gutter !== selected))) {
+		const frame = frames.find((candidate) => candidate.gutter === gutter);
+		report.add(report.unsupportedElements, "differing body frame gutters", frame?.location ?? model.id);
+	}
+	return selected;
+}
+function modelToBook(model, report = new ReportCollector(model.report)) {
 	const preferences = model.preferences;
 	const rightBinding = preferences.binding === "right-to-left";
-	const chapters = orderedStories(model).map((story) => ({
+	const bookDirection = rightBinding ? "rtl" : "ltr";
+	const styles = new StyleMapper(model.styles ?? [], model.swatches ?? [], report, bookDirection);
+	const bookLanguage = styles.rootLanguage();
+	const stories = orderedStories(model);
+	const chapters = stories.map((story) => ({
+		story,
+		mapped: storyHtml(story, styles, report, bookDirection, bookLanguage)
+	})).map(({ story, mapped: value }) => ({
 		title: story.id,
-		html: emptyParagraph()
+		html: value.html
 	}));
 	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");
+	const columnGap = bodyColumnGap(model, stories, report);
+	const css = styles.css();
 	return Book.parse({
 		title: model.id,
 		mode: "paginated",
@@ -36,9 +59,12 @@ function modelToBook(model) {
 				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
-			}
+			},
+			...columnGap === void 0 ? {} : { columnGap: columnGap * MM_PER_PT }
 		},
-		dir: rightBinding ? "rtl" : "ltr",
+		dir: bookDirection,
+		...bookLanguage ? { lang: bookLanguage } : {},
+		...css ? { css } : {},
 		rectoOpenings: preferences.facingPages,
 		chapters
 	});

package/dist/model.d.ts

@@ -1,3 +1,5 @@
+import { IdmlReportData } from "./report.js";
+import { IdmlFramePreference, IdmlStory, IdmlStyle, IdmlSwatch } from "./types.js";
 //#region src/model.d.ts
 export interface IdmlMargin {
   top: number;
@@ -25,10 +27,6 @@ export interface IdmlMasterSpread {
   id: string;
   pages: IdmlPage[];
 }
-export interface IdmlStory {
-  id: string;
-  part: string;
-}
 export interface IdmlModel {
   id: string;
   preferences: IdmlDocumentPreferences;
@@ -37,6 +35,10 @@ export interface IdmlModel {
   stories: IdmlStory[];
   masterStoryIds: string[];
   partsRead: string[];
-  unsupportedElements: Record<string, number>;
+  styles?: IdmlStyle[];
+  swatches?: IdmlSwatch[];
+  bodyFramePreferences?: IdmlFramePreference[];
+  report?: IdmlReportData;
 }
-//#endregion
+//#endregion
+export type { IdmlStory };

package/dist/model.js

@@ -1,21 +1,14 @@
 import { refusal } from "./refusal.js";
+import { ReportCollector } from "./report.js";
+import { localName, numberAttribute } from "./xml.js";
+import { parseStyles, parseSwatches } from "./styles.js";
+import { FramePreferenceIndex, framePreference } from "./frame-preferences.js";
 import { IDML_LIMITS } from "./limits.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
-const MAPPED_ELEMENTS = /* @__PURE__ */ new Set([
-	"Document",
-	"DocumentPreference",
-	"MarginPreference",
-	"MasterSpread",
-	"Spread",
-	"Page",
-	"Story",
-	"TextFrame"
-]);
-function localName(name) {
-	return name.includes(":") ? name.split(":").at(-1) ?? name : name;
-}
 function elements(root, name) {
 	const found = [];
 	const pending = [root];
@@ -35,12 +28,6 @@ function attribute(element, ...names) {
 		if (value !== void 0) return value;
 	}
 }
-function numberAttribute(element, name, fallback) {
-	const raw = element && attribute(element, name);
-	const value = raw === void 0 ? fallback : Number(raw);
-	if (value === void 0 || !Number.isFinite(value) || value < 0) throw refusal(`IDML ${name} must be a non-negative number`, `set ${name} to a non-negative numeric value`);
-	return value;
-}
 function boolAttribute(element, name, fallback) {
 	const raw = attribute(element, name);
 	if (raw === void 0) return fallback;
@@ -157,7 +144,17 @@ function contains(area, [x, y]) {
 	}
 	return inside;
 }
-function spreadFrames(spread) {
+function framePlacement(element, matrix, location) {
+	const story = attribute(element, "ParentStory");
+	if (!story) return void 0;
+	const preference = framePreference(element, location);
+	return {
+		story,
+		center: frameCenter(element, matrix),
+		...preference ? { preference } : {}
+	};
+}
+function spreadFrames(spread, location) {
 	const result = [];
 	const pending = [...spread.children].reverse().map((node) => ({
 		node,
@@ -170,11 +167,8 @@ function spreadFrames(spread) {
 		if (name === "Page" || name === "Spread" || name === "MasterSpread") continue;
 		const matrix = name === "Group" || name === "TextFrame" ? compose(current.matrix, transform(current.node)) : current.matrix;
 		if (name === "TextFrame") {
-			const story = attribute(current.node, "ParentStory");
-			if (story) result.push({
-				story,
-				center: frameCenter(current.node, matrix)
-			});
+			const placement = framePlacement(current.node, matrix, `${location}#TextFrame[${result.length + 1}]`);
+			if (placement) result.push(placement);
 			continue;
 		}
 		for (let index = current.node.children.length - 1; index >= 0; index -= 1) pending.push({
@@ -184,25 +178,26 @@ function spreadFrames(spread) {
 	}
 	return result;
 }
-function placeStories(element, pageElements, pages, unsupportedCounts) {
+function placeStories(element, pageElements, pages, report, framePreferences, location) {
 	const areas = pageElements.map(pageArea);
 	const frameStories = /* @__PURE__ */ new Set();
-	for (const frame of spreadFrames(element)) {
+	for (const frame of spreadFrames(element, location)) {
 		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;
 		const target = pages[pageIndex];
 		if (target && !target.stories.includes(frame.story)) target.stories.push(frame.story);
-		else if (pageIndex < 0) unsupportedCounts.set("TextFrame off page", (unsupportedCounts.get("TextFrame off page") ?? 0) + 1);
+		else if (pageIndex < 0) report.add(report.unsupportedElements, "TextFrame off page", frame.story);
 	}
 	return frameStories;
 }
-function spreads(parts, kind, orderedNames, unsupportedCounts) {
+function spreads(parts, kind, orderedNames, report, framePreferences) {
 	const result = [];
 	const frameStories = /* @__PURE__ */ new Set();
 	const byName = new Map(parts.map((part) => [part.name, part]));
 	const named = new Set(orderedNames);
 	const unlisted = parts.filter((part) => !named.has(part.name) && part.all.some((element) => localName(element.name) === kind && attribute(element, "Self"))).length;
-	if (unlisted > 0) unsupportedCounts.set("unlisted spread part", (unsupportedCounts.get("unlisted spread part") ?? 0) + unlisted);
+	if (unlisted > 0) report.add(report.unsupportedElements, "unlisted spread part", kind, unlisted);
 	for (const name of orderedNames) {
 		const part = byName.get(name);
 		if (!part) throw refusal(`designmap.xml ${kind} src ${name} has no matching ZIP entry`, `add the named ${kind} part to the package`);
@@ -211,7 +206,7 @@ function spreads(parts, kind, orderedNames, unsupportedCounts) {
 			if (!id) continue;
 			const pageElements = elements(element, "Page");
 			const pages = pageElements.map(page);
-			for (const story of placeStories(element, pageElements, pages, unsupportedCounts)) frameStories.add(story);
+			for (const story of placeStories(element, pageElements, pages, report, framePreferences, name)) frameStories.add(story);
 			result.push({
 				id,
 				pages
@@ -226,29 +221,6 @@ function spreads(parts, kind, orderedNames, unsupportedCounts) {
 function spreadSources(document, kind) {
 	return document.all.filter((element) => localName(element.name) === kind).map((element) => attribute(element, "src")).filter((source) => source !== void 0);
 }
-function stories(parts) {
-	const result = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const part of parts) for (const element of part.all.filter((candidate) => localName(candidate.name) === "Story")) {
-		const id = attribute(element, "Self");
-		if (!id || seen.has(id)) continue;
-		seen.add(id);
-		result.push({
-			id,
-			part: part.name
-		});
-	}
-	return result;
-}
-function unsupported(parts) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const part of parts) for (const element of part.all) {
-		const name = localName(element.name);
-		if (MAPPED_ELEMENTS.has(name)) continue;
-		counts.set(name, (counts.get(name) ?? 0) + 1);
-	}
-	return counts;
-}
 function idmlModel(entries, limits = IDML_LIMITS) {
 	const parts = parseParts(entries, limits);
 	const designmap = parts.find((part) => part.name === "designmap.xml");
@@ -260,11 +232,13 @@ function idmlModel(entries, limits = IDML_LIMITS) {
 	const margin = parts.flatMap((part) => part.all).find((element) => localName(element.name) === "MarginPreference");
 	const binding = attribute(preference, "PageBinding") ?? attribute(document, "PageBinding") ?? "LeftToRight";
 	if (binding !== "LeftToRight" && binding !== "RightToLeft") throw refusal(`IDML PageBinding ${binding} is not supported`, "use LeftToRight or RightToLeft page binding");
-	const unsupportedCounts = unsupported(parts);
-	const spreadResult = spreads(parts, "Spread", spreadSources(designmap, "Spread"), unsupportedCounts);
-	const masterResult = spreads(parts, "MasterSpread", spreadSources(designmap, "MasterSpread"), unsupportedCounts);
+	const report = new ReportCollector();
+	collectUnsupportedElements(parts, report);
+	const framePreferences = new FramePreferenceIndex();
+	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));
-	if (masterStoryIds.length > 0) unsupportedCounts.set("master story", masterStoryIds.length);
+	for (const story of masterStoryIds) report.add(report.unsupportedElements, "master story", story);
 	return {
 		id: attribute(document, "Self") ?? "IDML document",
 		preferences: {
@@ -281,10 +255,13 @@ function idmlModel(entries, limits = IDML_LIMITS) {
 		},
 		spreads: spreadResult.values,
 		masterSpreads: masterResult.values,
-		stories: stories(parts),
+		stories: parseStories(parts, framePreferences, report),
+		bodyFramePreferences: framePreferences.values(),
 		masterStoryIds,
 		partsRead: parts.map((part) => part.name),
-		unsupportedElements: Object.fromEntries([...unsupportedCounts].sort(([left], [right]) => left.localeCompare(right)))
+		styles: parts.flatMap((part) => part.name.endsWith("/Styles.xml") || part.name === "Resources/Styles.xml" ? parseStyles(part.all, part.name) : []),
+		swatches: parts.flatMap((part) => part.name.endsWith("/Graphic.xml") || part.name === "Resources/Graphic.xml" ? parseSwatches(part.all) : []),
+		report: report.data()
 	};
 }
 //#endregion

package/dist/report.d.ts

@@ -0,0 +1,17 @@
+//#region src/report.d.ts
+export interface IdmlFontUse {
+  appliedFont: string;
+  fontStyle?: string;
+  locations: string[];
+}
+export interface IdmlReportData {
+  unsupportedElements: Record<string, number>;
+  unsupportedStyleProperties: Record<string, number>;
+  unsupportedOverrideProperties: Record<string, number>;
+  unsupportedSpecialCharacters: Record<string, number>;
+  unsupportedLanguages: Record<string, number>;
+  spotColors: Record<string, number>;
+  locations: Record<string, string[]>;
+  fonts: IdmlFontUse[];
+}
+//#endregion

package/dist/report.js

@@ -0,0 +1,75 @@
+//#region src/report.ts
+const BUCKET_NAMES = {
+	unsupportedElements: "element",
+	unsupportedStyleProperties: "style",
+	unsupportedOverrideProperties: "override",
+	unsupportedSpecialCharacters: "special",
+	unsupportedLanguages: "language",
+	spotColors: "spot"
+};
+var ReportCollector = class {
+	locations = /* @__PURE__ */ new Map();
+	fonts = /* @__PURE__ */ new Map();
+	buckets = Object.fromEntries(Object.keys(BUCKET_NAMES).map((name) => [name, /* @__PURE__ */ new Map()]));
+	get unsupportedElements() {
+		return this.buckets.unsupportedElements;
+	}
+	get unsupportedStyleProperties() {
+		return this.buckets.unsupportedStyleProperties;
+	}
+	get unsupportedOverrideProperties() {
+		return this.buckets.unsupportedOverrideProperties;
+	}
+	get unsupportedSpecialCharacters() {
+		return this.buckets.unsupportedSpecialCharacters;
+	}
+	get unsupportedLanguages() {
+		return this.buckets.unsupportedLanguages;
+	}
+	get spotColors() {
+		return this.buckets.spotColors;
+	}
+	constructor(seed) {
+		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");
+	}
+	add(bucket, name, location, count = 1) {
+		bucket.set(name, (bucket.get(name) ?? 0) + count);
+		const key = `${this.bucketName(bucket)}:${name}`;
+		const values = this.locations.get(key) ?? [];
+		if (values.length < 5 && !values.includes(location)) values.push(location);
+		this.locations.set(key, values);
+	}
+	addOnce(bucket, name, location) {
+		const key = `${this.bucketName(bucket)}:${name}`;
+		if (this.locations.get(key)?.includes(location)) return;
+		this.add(bucket, name, location);
+	}
+	font(appliedFont, fontStyle, location) {
+		if (!appliedFont) return;
+		const key = `${appliedFont}\u0000${fontStyle ?? ""}`;
+		const found = this.fonts.get(key) ?? {
+			appliedFont,
+			...fontStyle ? { fontStyle } : {},
+			locations: []
+		};
+		if (found.locations.length < 5 && !found.locations.includes(location)) found.locations.push(location);
+		this.fonts.set(key, found);
+	}
+	data() {
+		const record = (values) => Object.fromEntries([...values].sort(([a], [b]) => a.localeCompare(b)));
+		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()]
+		};
+	}
+	bucketName(bucket) {
+		const found = Object.keys(BUCKET_NAMES).find((name) => this.buckets[name] === bucket);
+		if (!found) throw new Error("Report bucket is not registered.");
+		return BUCKET_NAMES[found];
+	}
+};
+//#endregion
+export { ReportCollector };

package/dist/stories.js

@@ -0,0 +1,141 @@
+import { resolveDirection } from "@segnavia/format";
+import { BOOK_COLUMN_MAX, BOOK_COLUMN_MIN } from "@segnavia/html";
+import serialize from "dom-serializer";
+import { Element, Text } from "domhandler";
+//#region src/stories.ts
+const OMITTED = /* @__PURE__ */ new Set([
+	"TextFrame",
+	"Rectangle",
+	"Group",
+	"Polygon",
+	"Table",
+	"Footnote",
+	"Note",
+	"TextVariableInstance"
+]);
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"HyperlinkTextSource",
+	"XMLElement",
+	"Change"
+]);
+function classes(...values) {
+	return values.filter(Boolean).join(" ") || void 0;
+}
+function rangeAttributes(node) {
+	if (!node) return {};
+	const result = { ...node.attributes };
+	const holder = node.children.find((child) => child.name === "Properties");
+	for (const child of holder?.children ?? []) if (child.text) result[child.name] = child.text.trim();
+	return result;
+}
+function tokens(root, report) {
+	const result = [];
+	const terminal = (node, character) => {
+		if (node.name === "Content") result.push({
+			kind: "text",
+			text: node.text ?? "",
+			character,
+			location: node.location
+		});
+		else if (node.name === "Br") result.push({
+			kind: "paragraph",
+			location: node.location
+		});
+		else if (node.name === "#processing-instruction") report.add(report.unsupportedSpecialCharacters, node.text ?? "processing instruction", 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);
+		else return false;
+		return true;
+	};
+	const walk = (node, character) => {
+		if (terminal(node, character)) return;
+		const nextCharacter = node.name === "CharacterStyleRange" ? node : character;
+		if (WRAPPERS.has(node.name)) report.add(report.unsupportedElements, node.name, node.location);
+		else if (![
+			"Story",
+			"ParagraphStyleRange",
+			"CharacterStyleRange"
+		].includes(node.name)) report.add(report.unsupportedElements, node.name, node.location);
+		for (const child of node.children) walk(child, nextCharacter);
+	};
+	walk(root);
+	return result;
+}
+function contentNodes(token, styles, direction) {
+	const character = token.character;
+	const characterAttributes = rangeAttributes(character);
+	const characterStyle = characterAttributes.AppliedCharacterStyle;
+	const characterBase = styles.flattened(characterStyle, "character");
+	const styleClass = styles.styleClass(characterStyle, "character");
+	const localClass = styles.overrideClass(characterAttributes, characterBase, direction, character?.location ?? token.location);
+	const nodes = textNodes(token.text ?? "");
+	const classValue = classes(styleClass, localClass);
+	return classValue ? [new Element("span", { class: classValue }, nodes)] : nodes;
+}
+function textNodes(value) {
+	const pieces = value.split("\u2028");
+	const result = [];
+	for (const [index, piece] of pieces.entries()) {
+		if (piece) result.push(new Text(piece));
+		if (index < pieces.length - 1) result.push(new Element("br", {}, []));
+	}
+	return result;
+}
+function paragraphNode(paragraph, paragraphTokens, styles, report, bookDirection, bookLanguage, storyDirection, frame) {
+	const attributes = rangeAttributes(paragraph);
+	const styleId = attributes.AppliedParagraphStyle;
+	const flattened = styles.flattened(styleId, "paragraph");
+	const rawText = paragraphTokens.filter((token) => token.kind === "text").map((token) => token.text ?? "").join("");
+	const resolvedDirection = styles.paragraphDirection(attributes) ?? styles.paragraphDirection(flattened) ?? storyDirection ?? resolveDirection(void 0, void 0, rawText);
+	const languageName = attributes.AppliedLanguage ?? flattened.AppliedLanguage;
+	const language = styles.language(languageName, paragraph.location);
+	const paragraphClass = styles.styleClass(styleId, "paragraph");
+	const overrideClass = styles.overrideClass(attributes, flattened, resolvedDirection, paragraph.location, styles.paragraphStyleDirection(flattened));
+	const htmlAttributes = {};
+	const className = classes(paragraphClass, overrideClass);
+	if (className) htmlAttributes.class = className;
+	if (resolvedDirection !== bookDirection) htmlAttributes.dir = resolvedDirection;
+	if (language && language !== bookLanguage) htmlAttributes.lang = language;
+	const span = attributes.SpanColumnType ?? flattened.SpanColumnType;
+	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));
+	}
+	if (children.length === 0) children.push(new Element("br", {}, []));
+	return new Element("p", htmlAttributes, children);
+}
+function storyHtml(story, styles, report, bookDirection, bookLanguage) {
+	if (!story.root) return { html: serialize(new Element("p", {}, [new Element("br", {}, [])]), {
+		xmlMode: false,
+		encodeEntities: "utf8"
+	}) };
+	const paragraphs = [];
+	for (const paragraph of story.root.children.filter((node) => node.name === "ParagraphStyleRange")) {
+		const all = tokens(paragraph, report);
+		let current = [];
+		const flush = () => {
+			paragraphs.push(paragraphNode(paragraph, current, styles, report, bookDirection, bookLanguage, story.direction, story.frame));
+			current = [];
+		};
+		for (const token of all) if (token.kind === "paragraph") flush();
+		else current.push(token);
+		if (current.length > 0 || all.length === 0 || all.at(-1)?.kind !== "paragraph") flush();
+	}
+	if (paragraphs.length === 0) paragraphs.push(new Element("p", {}, [new Element("br", {}, [])]));
+	return {
+		html: serialize(paragraphs, {
+			xmlMode: false,
+			encodeEntities: "utf8"
+		}),
+		...story.frame ? { gutter: story.frame.gutter } : {}
+	};
+}
+//#endregion
+export { storyHtml };

package/dist/story-model.js

@@ -0,0 +1,53 @@
+import { activeIdmlValue } from "./style-property-report.js";
+import { idmlDirection, localName } from "./xml.js";
+import { isTag } from "domhandler";
+//#region src/story-model.ts
+function textNode(node, part, path) {
+	const children = [];
+	let childIndex = 0;
+	for (const child of node.children) {
+		childIndex += 1;
+		if (isTag(child)) children.push(textNode(child, part, `${path}/${localName(child.name)}[${childIndex}]`));
+		else if (child.type === "directive") children.push({
+			name: "#processing-instruction",
+			attributes: {},
+			text: child.data,
+			children: [],
+			location: `${part}${path}#pi${childIndex}`
+		});
+	}
+	const directText = node.children.filter((child) => child.type === "text").map((child) => child.data).join("");
+	return {
+		name: localName(node.name),
+		attributes: { ...node.attribs },
+		...directText ? { text: directText } : {},
+		children,
+		location: `${part}${path}`
+	};
+}
+function storyDirection(element, part, id, report) {
+	const preference = element.children.find((child) => isTag(child) && localName(child.name) === "StoryPreference");
+	for (const [name, value] of Object.entries(preference?.attribs ?? {})) if (name !== "StoryDirection" && activeIdmlValue(value)) report.add(report.unsupportedElements, `StoryPreference:${name}`, `${part}#${id}`);
+	return idmlDirection(preference?.attribs.StoryDirection ?? element.attribs.StoryDirection);
+}
+function parseStories(parts, framePreferences, report) {
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const part of parts) for (const element of part.all.filter((candidate) => localName(candidate.name) === "Story")) {
+		const id = element.attribs.Self;
+		if (!id || seen.has(id)) continue;
+		seen.add(id);
+		const direction = storyDirection(element, part.name, id, report);
+		const frame = framePreferences.preferred(id);
+		result.push({
+			id,
+			part: part.name,
+			root: textNode(element, part.name, `/Story[@Self=${id}]`),
+			...direction ? { direction } : {},
+			...frame ? { frame } : {}
+		});
+	}
+	return result;
+}
+//#endregion
+export { parseStories };