@segnavia/idml 0.38.0 → 0.40.0

package/dist/asset-from-placement.d.ts

@@ -0,0 +1,7 @@
+import { IdmlAssetMap } from "./types.js";
+import { ResolvePlacement } from "@segnavia/html";
+//#region src/asset-from-placement.d.ts
+export declare function idmlAssetFrom<R extends {
+  kind: string;
+}>(resolve: ResolvePlacement<R>, uris: Iterable<string>, context: Parameters<ResolvePlacement<R>>[1]): Promise<IdmlAssetMap>;
+//#endregion

package/dist/asset-from-placement.js

@@ -0,0 +1,21 @@
+import { classifyMediaAnswer } from "@segnavia/html";
+//#region src/asset-from-placement.ts
+function escapeAttribute(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+async function idmlAssetFrom(resolve, uris, context) {
+	const entries = await Promise.all([...new Set(uris)].map(async (uri) => {
+		const answer = await resolve({
+			kind: "media",
+			address: uri
+		}, context);
+		const classified = classifyMediaAnswer({ answer });
+		if (classified.status !== "ok") return [uri, void 0];
+		const alt = classified.value.media.alt?.text ?? "";
+		return [uri, `<img src="${escapeAttribute(classified.value.src)}" alt="${escapeAttribute(alt)}">`];
+	}));
+	const resolved = new Map(entries);
+	return (uri) => resolved.get(uri);
+}
+//#endregion
+export { idmlAssetFrom };

package/dist/import.d.ts

@@ -1,5 +1,5 @@
-import { IdmlReportData } from "./report.js";
 import { IdmlImportOptions } from "./types.js";
+import { IdmlReportData } from "./report.js";
 import { Book } from "@segnavia/format";
 //#region src/import.d.ts
 export interface IdmlImportReport extends IdmlReportData {

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { IdmlFontUse, IdmlLinkUse, IdmlReportData } from "./report.js";
 import { IdmlAssetMap, IdmlDocumentPreferences, IdmlFont, IdmlFontMap, IdmlImportOptions, IdmlMargin, IdmlMasterSpread, IdmlPage, IdmlSpread, IdmlStory } from "./types.js";
+import { idmlAssetFrom } from "./asset-from-placement.js";
+import { IdmlFontUse, IdmlLinkUse, IdmlReportData } from "./report.js";
 import { IDML_FONT_WEIGHTS, idmlFontStyle } from "./fonts.js";
 import { 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 { IdmlModel } from "./model.js";
-export { IDML_FONT_WEIGHTS, IDML_LIMITS, type IdmlAssetMap, type IdmlDocumentPreferences, type IdmlFont, type IdmlFontMap, type IdmlFontUse, type IdmlImportOptions, type IdmlImportReport, type IdmlImportResult, type IdmlLinkUse, 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, idmlFontStyle, importIdml };
+export { IDML_FONT_WEIGHTS, IDML_LIMITS, type IdmlAssetMap, type IdmlDocumentPreferences, type IdmlFont, type IdmlFontMap, type IdmlFontUse, type IdmlImportOptions, type IdmlImportReport, type IdmlImportResult, type IdmlLinkUse, 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, idmlAssetFrom, idmlFontStyle, importIdml };

package/dist/index.js

@@ -1,4 +1,5 @@
+import { idmlAssetFrom } from "./asset-from-placement.js";
 import { IDML_FONT_WEIGHTS, idmlFontStyle } from "./fonts.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 { importIdml } from "./import.js";
-export { IDML_FONT_WEIGHTS, IDML_LIMITS, MAX_IDML_ENTRIES, MAX_IDML_PACKAGE_BYTES, MAX_IDML_PART_BYTES, MAX_IDML_TOTAL_INFLATED_BYTES, MAX_IDML_XML_DEPTH, idmlFontStyle, importIdml };
+export { IDML_FONT_WEIGHTS, IDML_LIMITS, MAX_IDML_ENTRIES, MAX_IDML_PACKAGE_BYTES, MAX_IDML_PART_BYTES, MAX_IDML_TOTAL_INFLATED_BYTES, MAX_IDML_XML_DEPTH, idmlAssetFrom, idmlFontStyle, importIdml };

package/dist/map-book.js

@@ -10,9 +10,10 @@ import { storyHtml } from "./stories.js";
 import { chapterParents, mapMasters, openingPage, storyPageUses } from "./masters.js";
 import { mapOpeners } from "./openers.js";
 import { reportPlacements } from "./placement-report.js";
+import { TableStyleMapper } from "./table-styles.js";
 import { matchVariables } from "./variables.js";
-import { Book, MM_PER_PT } from "@segnavia/format";
 import { findActiveContent } from "@segnavia/html";
+import { Book, MM_PER_PT } from "@segnavia/format";
 //#region src/map-book.ts
 function orderedStories(model, anchoredOnly = /* @__PURE__ */ new Set()) {
 	const order = /* @__PURE__ */ new Map();
@@ -52,6 +53,7 @@ function modelToBook(model, report = new ReportCollector(model.report), options
 	const bookDirection = rightBinding ? "rtl" : "ltr";
 	const fonts = new FontMapper(model.fonts ?? [], options.font, report);
 	const styles = new StyleMapper(model.styles ?? [], model.swatches ?? [], report, bookDirection, fonts);
+	const tableStyles = new TableStyleMapper(model.styles ?? [], model.swatches ?? [], report, (css) => styles.cssOverrideClass(css));
 	const matchedVariables = matchVariables(model.textVariables ?? [], report);
 	const bookLanguage = styles.rootLanguage();
 	const storyPages = storyPageUses(model);
@@ -64,6 +66,7 @@ function modelToBook(model, report = new ReportCollector(model.report), options
 		textVariables: matchedVariables,
 		master
 	}, styles, report, bookDirection, bookLanguage, {
+		tableStyles,
 		inlineParagraphs: depth > 0,
 		anchored: (location, direction) => {
 			const frame = frameByLocation.get(location);
@@ -117,7 +120,7 @@ function modelToBook(model, report = new ReportCollector(model.report), options
 	if (chapters.length === 0) throw refusal("the IDML has no stories", "add at least one Story");
 	refuseActiveBookHtml(chapters, masters.parents);
 	const columnGap = bodyColumnGap(model, stories, report);
-	const css = `${styles.css()}${masters.css}`;
+	const css = `${tableStyles.css()}${styles.css()}${masters.css}`;
 	const bookFonts = fonts.bookFonts();
 	return Book.parse({
 		title: model.id,

package/dist/model.d.ts

@@ -1,5 +1,5 @@
-import { IdmlReportData } from "./report.js";
 import { IdmlAnchoredFrame, IdmlDocumentPreferences, IdmlFont, IdmlFramePreference, IdmlMargin, IdmlMasterPage, IdmlMasterSpread, IdmlPage, IdmlSpread, IdmlStory, IdmlStyle, IdmlSwatch, IdmlTextVariable } from "./types.js";
+import { IdmlReportData } from "./report.js";
 //#region src/model.d.ts
 export interface IdmlModel {
   id: string;

package/dist/stories.js

@@ -1,6 +1,7 @@
+import { tableNode } from "./table-html.js";
+import { BOOK_COLUMN_MAX, BOOK_COLUMN_MIN } from "@segnavia/html";
 import { BOOK_FURNITURE, MOTIF_ATTRIBUTE, motifFieldAttribute, resolveDirection } from "@segnavia/format";
 import { Element, Text } from "domhandler";
-import { BOOK_COLUMN_MAX, BOOK_COLUMN_MIN } from "@segnavia/html";
 import serialize from "dom-serializer";
 import { parseDocument } from "htmlparser2";
 //#region src/stories.ts
@@ -8,7 +9,6 @@ const OMITTED = /* @__PURE__ */ new Set([
 	"Rectangle",
 	"Group",
 	"Polygon",
-	"Table",
 	"Footnote",
 	"Note"
 ]);
@@ -46,6 +46,11 @@ function tokens(root, report) {
 			character,
 			location: node.location
 		});
+		else if (node.name === "Table") result.push({
+			kind: "table",
+			node,
+			location: node.location
+		});
 		else if (node.name === "TextVariableInstance") result.push({
 			kind: "variable",
 			variable: node.attributes.AssociatedTextVariable,
@@ -58,8 +63,7 @@ function tokens(root, report) {
 		});
 		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;
+		else return reportedChange(node, report);
 		return true;
 	};
 	const walk = (node, character) => {
@@ -86,6 +90,11 @@ function tokens(root, report) {
 	walk(root);
 	return result;
 }
+function reportedChange(node, report) {
+	if (node.name !== "Change" || node.attributes.ChangeType === void 0 || node.attributes.ChangeType.includes("Inserted")) return false;
+	report.add(report.unsupportedElements, "Change", node.location);
+	return true;
+}
 function contentNodes(token, styles, direction) {
 	const character = token.character;
 	const characterAttributes = rangeAttributes(character);
@@ -205,6 +214,45 @@ function paragraphNode(paragraph, paragraphTokens, styles, report, bookDirection
 		style: "display:block"
 	} : htmlAttributes, children);
 }
+function mappedParagraph(paragraph, paragraphTokens, context, frame = context.story.frame) {
+	return paragraphNode(paragraph, paragraphTokens, context.styles, context.report, context.bookDirection, context.bookLanguage, context.story.direction, frame, context.story.textVariables ?? [], context.story.master ?? false, context.options);
+}
+function tableContent(cell, context) {
+	const output = [];
+	for (const paragraph of cell.children.filter((child) => child.name === "ParagraphStyleRange")) {
+		let current = [];
+		const flush = () => {
+			output.push(mappedParagraph(paragraph, current, context, void 0));
+			current = [];
+		};
+		for (const token of tokens(paragraph, context.report)) if (token.kind === "paragraph") flush();
+		else if (token.kind === "table") context.report.add(context.report.unsupportedElements, "Table", token.location);
+		else current.push(token);
+		flush();
+	}
+	return output;
+}
+function renderParagraphRange(paragraph, context) {
+	const output = [];
+	const all = tokens(paragraph, context.report);
+	let current = [];
+	let wroteTable = false;
+	const visible = () => current.some((token) => token.kind !== "text" || Boolean(token.text));
+	const flush = (empty = true) => {
+		if (empty || visible()) output.push(mappedParagraph(paragraph, current, context));
+		current = [];
+	};
+	for (const token of all) if (token.kind === "paragraph") flush();
+	else if (token.kind !== "table" || !token.node) current.push(token);
+	else {
+		flush(false);
+		if (!context.options.tableStyles) context.report.add(context.report.unsupportedElements, "Table", token.location);
+		else output.push(tableNode(token.node, context.options.tableStyles, (cell) => tableContent(cell, context)));
+		wroteTable = true;
+	}
+	if (visible() || !wroteTable && (all.length === 0 || all.at(-1)?.kind !== "paragraph")) flush();
+	return output;
+}
 function storyHtml(story, styles, report, bookDirection, bookLanguage, options = {}) {
 	if (!story.root) {
 		const empty = new Element(options.inlineParagraphs ? "span" : "p", options.inlineParagraphs ? { style: "display:block" } : {}, [new Element("br", {}, [])]);
@@ -220,17 +268,15 @@ function storyHtml(story, styles, report, bookDirection, bookLanguage, options =
 		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, story.textVariables ?? [], story.master ?? false, options));
-			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();
-	}
+	const context = {
+		story,
+		styles,
+		report,
+		bookDirection,
+		bookLanguage,
+		options
+	};
+	for (const paragraph of paragraphRanges) paragraphs.push(...renderParagraphRange(paragraph, context));
 	if (paragraphs.length === 0) paragraphs.push(new Element(options.inlineParagraphs ? "span" : "p", options.inlineParagraphs ? { style: "display:block" } : {}, [new Element("br", {}, [])]));
 	return {
 		html: serialize(paragraphs, {

package/dist/styles.js

@@ -26,7 +26,9 @@ function parseStyles(roots, part) {
 	for (const kind of [
 		"ParagraphStyle",
 		"CharacterStyle",
-		"ObjectStyle"
+		"ObjectStyle",
+		"TableStyle",
+		"CellStyle"
 	]) for (const element of roots.filter((candidate) => localName(candidate.name) === kind)) {
 		const values = properties(element);
 		const id = values.Self;
@@ -34,7 +36,7 @@ function parseStyles(roots, part) {
 		result.push({
 			id,
 			name: values.Name ?? id.split("/").at(-1) ?? id,
-			kind: kind === "ParagraphStyle" ? "paragraph" : kind === "CharacterStyle" ? "character" : "object",
+			kind: STYLE_KINDS[kind],
 			...values.BasedOn ? { basedOn: values.BasedOn } : {},
 			properties: Object.fromEntries(Object.entries(values).filter(([name]) => ![
 				"Self",
@@ -46,6 +48,13 @@ function parseStyles(roots, part) {
 	}
 	return result;
 }
+const STYLE_KINDS = {
+	ParagraphStyle: "paragraph",
+	CharacterStyle: "character",
+	ObjectStyle: "object",
+	TableStyle: "table",
+	CellStyle: "cell"
+};
 function parseSwatches(roots) {
 	const result = [];
 	for (const element of roots.filter((candidate) => localName(candidate.name) === "Color")) {
@@ -65,7 +74,11 @@ function parseSwatches(roots) {
 	return result;
 }
 function rootName(kind) {
-	return kind === "paragraph" ? PARAGRAPH_ROOT : kind === "character" ? CHARACTER_ROOT : OBJECT_ROOT;
+	if (kind === "paragraph") return PARAGRAPH_ROOT;
+	if (kind === "character") return CHARACTER_ROOT;
+	if (kind === "table") return "$ID/[No table style]";
+	if (kind === "cell") return "$ID/[None]";
+	return OBJECT_ROOT;
 }
 function findStyle(styles, id, kind) {
 	if (!id) return void 0;
@@ -147,6 +160,8 @@ var StyleMapper = class {
 	classes = /* @__PURE__ */ new Map();
 	used = /* @__PURE__ */ new Set();
 	overrides = /* @__PURE__ */ new Map();
+	rawOverrides = /* @__PURE__ */ new Map();
+	nextOverride = 1;
 	reportedStyleProperties = /* @__PURE__ */ new Set();
 	constructor(styles, swatches, report, bookDirection, fonts) {
 		this.swatches = swatches;
@@ -156,7 +171,7 @@ var StyleMapper = class {
 		this.byId = new Map(styles.map((style) => [style.id, style]));
 		const taken = /* @__PURE__ */ new Set();
 		for (const style of styles) {
-			if (style.kind === "object") continue;
+			if (style.kind === "object" || style.kind === "table" || style.kind === "cell") continue;
 			const base = `${style.kind === "paragraph" ? "idml-p-" : "idml-c-"}${slug(style.name)}`;
 			let candidate = base;
 			let suffix = 2;
@@ -198,7 +213,7 @@ var StyleMapper = class {
 		const key = JSON.stringify(Object.entries(cssProperties).sort(([a], [b]) => a.localeCompare(b))) + directionValue + resetShading;
 		const found = this.overrides.get(key);
 		if (found) return found.name;
-		const name = `idml-o-${this.overrides.size + 1}`;
+		const name = `idml-o-${this.nextOverride++}`;
 		this.overrides.set(key, {
 			name,
 			properties: cssProperties,
@@ -208,6 +223,17 @@ var StyleMapper = class {
 		});
 		return name;
 	}
+	cssOverrideClass(declarations) {
+		if (!declarations) return void 0;
+		const found = this.rawOverrides.get(declarations);
+		if (found) return found.name;
+		const name = `idml-o-${this.nextOverride++}`;
+		this.rawOverrides.set(declarations, {
+			name,
+			declarations
+		});
+		return name;
+	}
 	paragraphDirection(properties) {
 		return idmlDirection(properties.ParagraphDirection);
 	}
@@ -241,6 +267,7 @@ var StyleMapper = class {
 			const declarations = this.declarations(value.properties, value.direction, value.location, this.report.unsupportedOverrideProperties, value.resetShading);
 			if (declarations) rules.push(`.${value.name}{${declarations}}`);
 		}
+		for (const value of this.rawOverrides.values()) rules.push(`.${value.name}{${value.declarations}}`);
 		return rules.join("");
 	}
 	declarations(values, dir, location, unsupported, resetShading) {
@@ -320,4 +347,4 @@ var StyleMapper = class {
 	}
 };
 //#endregion
-export { StyleMapper, flattenedStyle, parseStyles, parseSwatches };
+export { StyleMapper, flattenedStyle, parseStyles, parseSwatches, slug, styleChain };

package/dist/table-html.js

@@ -0,0 +1,49 @@
+import { tableGrid } from "./table-model.js";
+import { Element } from "domhandler";
+import "dom-serializer";
+//#region src/table-html.ts
+function regionElement(region) {
+	return region === "header" ? "thead" : region === "footer" ? "tfoot" : "tbody";
+}
+function tableNode(node, styles, content) {
+	const grid = tableGrid(node);
+	const tableStyle = node.attributes.AppliedTableStyle;
+	const className = styles.tableClass(tableStyle);
+	const columns = new Element("colgroup", {}, grid.columns.map((width) => new Element("col", { style: `width:${width}pt` }, [])));
+	const groups = [];
+	let currentRegion;
+	let currentRows = [];
+	const flush = () => {
+		if (currentRegion && currentRows.length > 0) groups.push(new Element(regionElement(currentRegion), {}, currentRows));
+		currentRows = [];
+	};
+	for (const [rowIndex, row] of grid.rows.entries()) {
+		if (row.region !== currentRegion) {
+			flush();
+			currentRegion = row.region;
+		}
+		const cells = grid.cells.filter((cell) => cell.row === rowIndex);
+		currentRows.push(new Element("tr", row.fixed && row.height !== void 0 ? { style: `height:${row.height}pt` } : {}, cells.map((cell) => {
+			const classes = styles.cellClasses({
+				tableStyle,
+				region: row.region,
+				column: cell.column,
+				columnCount: grid.columns.length,
+				node: cell.node,
+				direction: grid.direction
+			});
+			return new Element("td", {
+				...cell.rowSpan > 1 ? { rowspan: String(cell.rowSpan) } : {},
+				...cell.columnSpan > 1 ? { colspan: String(cell.columnSpan) } : {},
+				...classes.length > 0 ? { class: classes.join(" ") } : {}
+			}, content(cell.node));
+		})));
+	}
+	flush();
+	return new Element("table", {
+		...className ? { class: className } : {},
+		dir: grid.direction
+	}, [columns, ...groups]);
+}
+//#endregion
+export { tableNode };

package/dist/table-model.js

@@ -0,0 +1,71 @@
+import { refusal } from "./refusal.js";
+//#region src/table-model.ts
+function integer(value, fallback) {
+	const parsed = Number(value);
+	return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function children(node, name) {
+	return node.children.filter((child) => child.name === name);
+}
+function cellLabel(node) {
+	return node.attributes.Name ?? node.location;
+}
+function placeCell(table, cell, occupied, rowCount, columnCount) {
+	const match = /^(\d+):(\d+)$/.exec(cell.attributes.Name ?? "");
+	const column = match ? Number(match[1]) : -1;
+	const row = match ? Number(match[2]) : -1;
+	const rowSpan = Math.max(1, integer(cell.attributes.RowSpan, 1));
+	const columnSpan = Math.max(1, integer(cell.attributes.ColumnSpan, 1));
+	if (row < 0 || column < 0 || row + rowSpan > rowCount || column + columnSpan > columnCount) throw refusal(`table at ${table.location} has cell ${cellLabel(cell)} outside the grid`, "give every Cell a Name inside the declared rows and columns");
+	for (let y = row; y < row + rowSpan; y += 1) {
+		const rowCells = occupied[y];
+		if (!rowCells) throw refusal(`table at ${table.location} has cell ${cellLabel(cell)} outside the grid`, "give every Cell a Name inside the declared rows");
+		for (let x = column; x < column + columnSpan; x += 1) {
+			const found = rowCells[x];
+			if (found) throw refusal(`table at ${table.location} has overlapping cells ${cellLabel(found)} and ${cellLabel(cell)}`, "remove the overlapping cell spans");
+			rowCells[x] = cell;
+		}
+	}
+	return {
+		row,
+		column,
+		rowSpan,
+		columnSpan,
+		node: cell
+	};
+}
+function requireAnchors(table, occupied) {
+	for (const [row, columns] of occupied.entries()) for (const [column, cell] of columns.entries()) if (!cell) throw refusal(`table at ${table.location} has a missing anchor at ${column}:${row}`, "add a Cell that covers that grid position");
+}
+function tableGrid(node) {
+	const columns = children(node, "Column").map((column) => Number(column.attributes.SingleColumnWidth ?? column.attributes.Width));
+	const rowNodes = children(node, "Row");
+	const header = integer(node.attributes.HeaderRowCount, 0);
+	const footer = integer(node.attributes.FooterRowCount, 0);
+	const declaredBody = integer(node.attributes.BodyRowCount, rowNodes.length - header - footer);
+	const rowCount = header + declaredBody + footer;
+	const rows = rowNodes.map((row, index) => {
+		const height = Number(row.attributes.SingleRowHeight ?? row.attributes.Height);
+		return {
+			region: index < header ? "header" : index >= header + declaredBody ? "footer" : "body",
+			...Number.isFinite(height) ? { height } : {},
+			fixed: row.attributes.AutoGrow === "false"
+		};
+	});
+	const widthCount = columns.length || integer(node.attributes.ColumnCount, 0);
+	if (columns.some((width) => !Number.isFinite(width))) throw refusal(`table at ${node.location} has a column without a finite width`, "give every Column a numeric SingleColumnWidth or Width");
+	if (widthCount === 0) throw refusal(`table at ${node.location} has no columns`, "export at least one Column or declare a positive ColumnCount");
+	if (rowCount !== rows.length) throw refusal(`table at ${node.location} declares ${rowCount} rows but contains ${rows.length} Row elements`, "make HeaderRowCount, BodyRowCount, and FooterRowCount add up to the number of Row elements");
+	const occupied = Array.from({ length: rowCount }, () => Array.from({ length: widthCount }));
+	const cells = children(node, "Cell").map((cell) => placeCell(node, cell, occupied, rowCount, widthCount));
+	requireAnchors(node, occupied);
+	cells.sort((a, b) => a.row - b.row || a.column - b.column);
+	return {
+		direction: node.attributes.TableDirection === "RightToLeft" ? "rtl" : "ltr",
+		columns,
+		rows,
+		cells
+	};
+}
+//#endregion
+export { tableGrid };

package/dist/table-styles.js

@@ -0,0 +1,246 @@
+import { resolveSwatchColor } from "./swatch-color.js";
+import { reportableStyleProperties } from "./style-property-report.js";
+import { flattenedStyle, slug, styleChain } from "./styles.js";
+//#region src/table-styles.ts
+const TABLE_HANDLED = /* @__PURE__ */ new Set([
+	"SpaceBefore",
+	"SpaceAfter",
+	"HeaderRegionCellStyle",
+	"BodyRegionCellStyle",
+	"FooterRegionCellStyle",
+	"LeftColumnRegionCellStyle",
+	"RightColumnRegionCellStyle",
+	"AlternatingFills",
+	"StartRowFillColor",
+	"StartRowFillCount",
+	"EndRowFillColor",
+	"EndRowFillCount",
+	"SkipFirstAlternatingFillRows",
+	"SkipLastAlternatingFillRows",
+	"StartColumnFillColor",
+	"StartColumnFillCount",
+	"EndColumnFillColor",
+	"EndColumnFillCount",
+	"SkipFirstAlternatingFillColumns",
+	"SkipLastAlternatingFillColumns"
+]);
+const CELL_HANDLED = /* @__PURE__ */ new Set([
+	"AppliedCellStyle",
+	"FillColor",
+	"FillTint",
+	"VerticalJustification",
+	"TopInset",
+	"BottomInset",
+	"LeftInset",
+	"RightInset",
+	"TopEdgeStrokeWeight",
+	"BottomEdgeStrokeWeight",
+	"LeftEdgeStrokeWeight",
+	"RightEdgeStrokeWeight",
+	"TopEdgeStrokeColor",
+	"BottomEdgeStrokeColor",
+	"LeftEdgeStrokeColor",
+	"RightEdgeStrokeColor",
+	"TopEdgeStrokeType",
+	"BottomEdgeStrokeType",
+	"LeftEdgeStrokeType",
+	"RightEdgeStrokeType",
+	"CellType",
+	"TextRotation",
+	"DiagonalLineInFront",
+	"TopLeftDiagonalLine",
+	"TopRightDiagonalLine"
+]);
+function uniqueClasses(styles, kind, prefix) {
+	const result = /* @__PURE__ */ new Map();
+	const taken = /* @__PURE__ */ new Set();
+	for (const style of styles.filter((candidate) => candidate.kind === kind)) {
+		const base = `${prefix}${slug(style.name)}`;
+		let value = base;
+		let suffix = 2;
+		while (taken.has(value)) value = `${base}-${suffix++}`;
+		taken.add(value);
+		result.set(style.id, value);
+	}
+	return result;
+}
+function tint(color, raw) {
+	const value = Number(raw);
+	return Number.isFinite(value) && value >= 0 && value < 100 ? `color-mix(in srgb, ${color} ${value}%, #fff)` : color;
+}
+function active(value) {
+	return value !== void 0 && ![
+		"",
+		"false",
+		"0",
+		"None",
+		"$ID/None"
+	].includes(value);
+}
+var TableStyleMapper = class {
+	styles;
+	swatches;
+	report;
+	overrideClass;
+	tableClasses;
+	cellClassesById;
+	usedTables = /* @__PURE__ */ new Set();
+	usedRegionCells = /* @__PURE__ */ new Set();
+	usedOwnCells = /* @__PURE__ */ new Set();
+	reported = /* @__PURE__ */ new Set();
+	constructor(styles, swatches, report, overrideClass) {
+		this.styles = styles;
+		this.swatches = swatches;
+		this.report = report;
+		this.overrideClass = overrideClass;
+		this.tableClasses = uniqueClasses(styles, "table", "idml-t-");
+		this.cellClassesById = uniqueClasses(styles, "cell", "idml-cell-");
+	}
+	tableClass(id) {
+		const style = this.find(id, "table");
+		if (!style) return void 0;
+		this.usedTables.add(style.id);
+		return this.tableClasses.get(style.id);
+	}
+	cellClasses(input) {
+		const table = flattenedStyle(this.styles, input.tableStyle, "table");
+		const regionProperty = `${input.region[0]?.toUpperCase()}${input.region.slice(1)}RegionCellStyle`;
+		const physicalFirst = input.direction === "rtl" ? input.columnCount - 1 : 0;
+		const physicalLast = input.direction === "rtl" ? 0 : input.columnCount - 1;
+		const regionIds = [
+			table[regionProperty],
+			input.column === physicalFirst ? table.LeftColumnRegionCellStyle : void 0,
+			input.column === physicalLast ? table.RightColumnRegionCellStyle : void 0
+		].filter((value) => Boolean(value));
+		const ownId = input.node.attributes.AppliedCellStyle;
+		const output = [];
+		for (const id of regionIds) {
+			const style = this.find(id, "cell");
+			if (!style) continue;
+			this.usedRegionCells.add(style.id);
+			const className = this.cellClassesById.get(style.id);
+			if (className) output.push(className);
+		}
+		if (ownId) {
+			const style = this.find(ownId, "cell");
+			if (style) {
+				this.usedOwnCells.add(style.id);
+				const className = this.cellClassesById.get(style.id);
+				if (className) output.push(className);
+			}
+		}
+		const ids = [...regionIds, ownId].filter((value) => Boolean(value));
+		const base = Object.assign({}, ...ids.map((id) => flattenedStyle(this.styles, id, "cell")));
+		const local = Object.fromEntries(Object.entries(input.node.attributes).filter(([name, value]) => CELL_HANDLED.has(name) && name !== "AppliedCellStyle" && value !== base[name]));
+		const override = this.overrideClass(this.cellDeclarations(local, input.node.location));
+		if (override) output.push(override);
+		this.reportFeatures(input.node);
+		return output;
+	}
+	css() {
+		const rules = [];
+		for (const id of this.usedTables) {
+			const style = this.find(id, "table");
+			const className = style && this.tableClasses.get(style.id);
+			if (!style || !className) continue;
+			const values = flattenedStyle(this.styles, id, "table");
+			const declarations = [`border-collapse:collapse`];
+			const before = Number(values.SpaceBefore);
+			const after = Number(values.SpaceAfter);
+			if (Number.isFinite(before)) declarations.push(`margin-block-start:${before}pt`);
+			if (Number.isFinite(after)) declarations.push(`margin-block-end:${after}pt`);
+			rules.push(`.${className}{${declarations.join(";")}}`, ...this.alternatingRules(className, values, style.location));
+			this.reportUnmapped(style, TABLE_HANDLED);
+		}
+		for (const id of [...this.usedRegionCells, ...this.usedOwnCells]) {
+			const style = this.find(id, "cell");
+			const className = style && this.cellClassesById.get(style.id);
+			if (!style || !className) continue;
+			rules.push(`.${className}{${this.cellDeclarations(flattenedStyle(this.styles, id, "cell"), style.location)}}`);
+			this.reportUnmapped(style, CELL_HANDLED);
+		}
+		return rules.join("");
+	}
+	find(id, kind) {
+		if (!id) return void 0;
+		return this.styles.find((style) => style.kind === kind && (style.id === id || style.name === id || style.id.endsWith(`/${id}`)));
+	}
+	reportUnmapped(style, handled) {
+		const resolved = {};
+		for (const source of styleChain(this.styles, style.id, style.kind)) {
+			Object.assign(resolved, source.properties);
+			for (const property of reportableStyleProperties(source.properties, resolved).filter((name) => !handled.has(name))) {
+				const key = `${source.id}\0${property}`;
+				if (this.reported.has(key)) continue;
+				this.reported.add(key);
+				this.report.add(this.report.unsupportedStyleProperties, property, source.location);
+			}
+		}
+	}
+	reportFeatures(node) {
+		if (node.attributes.CellType === "GraphicTypeCell") this.report.add(this.report.unsupportedElements, "Table:GraphicCell", node.location);
+		if (active(node.attributes.TextRotation)) this.report.add(this.report.unsupportedElements, "Table:RotatedCell", node.location);
+		if (active(node.attributes.DiagonalLineInFront) || active(node.attributes.TopLeftDiagonalLine) || active(node.attributes.TopRightDiagonalLine)) this.report.add(this.report.unsupportedElements, "Table:DiagonalLine", node.location);
+	}
+	cellDeclarations(values, location) {
+		const output = [];
+		const edge = (name) => {
+			const logical = name === "Top" ? "block-start" : name === "Bottom" ? "block-end" : name === "Left" ? "inline-start" : "inline-end";
+			const weight = Number(values[`${name}EdgeStrokeWeight`]);
+			if (Number.isFinite(weight)) output.push(`border-${logical}-width:${weight}pt`);
+			const type = values[`${name}EdgeStrokeType`];
+			if (type) {
+				const normalized = type.replace(/^\$ID\//, "").toLowerCase();
+				if ([
+					"solid",
+					"dashed",
+					"dotted"
+				].includes(normalized)) output.push(`border-${logical}-style:${normalized}`);
+				else this.report.add(this.report.unsupportedElements, `Table:StrokeType:${type}`, location);
+			}
+			const color = resolveSwatchColor(values[`${name}EdgeStrokeColor`], this.swatches, this.report, location, "fill", `${name}EdgeStrokeColor`);
+			if (color && color !== "none") output.push(`border-${logical}-color:${color}`);
+		};
+		for (const name of [
+			"Top",
+			"Bottom",
+			"Left",
+			"Right"
+		]) edge(name);
+		for (const [name, property] of [
+			["TopInset", "block-start"],
+			["BottomInset", "block-end"],
+			["LeftInset", "inline-start"],
+			["RightInset", "inline-end"]
+		]) {
+			const value = Number(values[name]);
+			if (Number.isFinite(value)) output.push(`padding-${property}:${value}pt`);
+		}
+		const fill = resolveSwatchColor(values.FillColor, this.swatches, this.report, location, "fill");
+		if (fill && fill !== "none") output.push(`background-color:${tint(fill, values.FillTint)}`);
+		const vertical = values.VerticalJustification?.replace(/^\$ID\//, "").toLowerCase();
+		if (vertical === "topalign" || vertical === "top") output.push("vertical-align:top");
+		else if (vertical === "centeralign" || vertical === "center") output.push("vertical-align:middle");
+		else if (vertical === "bottomalign" || vertical === "bottom") output.push("vertical-align:bottom");
+		else if (vertical && vertical !== "none") this.report.add(this.report.unsupportedElements, "Table:VerticalJustify", location);
+		return output.join(";");
+	}
+	alternatingRules(className, values, location) {
+		const axis = values.AlternatingFills?.includes("Column") ? "Column" : values.AlternatingFills?.includes("Row") ? "Row" : void 0;
+		if (!axis) return [];
+		const a = Math.max(0, Number(values[`Start${axis}FillCount`]) || 0);
+		const period = a + Math.max(0, Number(values[`End${axis}FillCount`]) || 0);
+		if (period === 0) return [];
+		const selector = axis === "Row" ? "tr" : "td";
+		const skip = Math.max(0, Number(values[`SkipFirstAlternatingFill${axis}s`]) || 0);
+		const colors = [values[`Start${axis}FillColor`], values[`End${axis}FillColor`]];
+		const rules = [];
+		for (let index = 0; index < period; index += 1) {
+			const color = resolveSwatchColor(colors[index < a ? 0 : 1], this.swatches, this.report, location, "fill");
+			if (color && color !== "none") rules.push(`.${className} ${selector}:nth-child(${period}n+${skip + index + 1}){background-color:${color}}`);
+		}
+		return rules;
+	}
+};
+//#endregion
+export { TableStyleMapper };

package/dist/types.d.ts

@@ -10,7 +10,7 @@ export interface IdmlTextNode {
 export interface IdmlStyle {
   id: string;
   name: string;
-  kind: 'paragraph' | 'character' | 'object';
+  kind: 'paragraph' | 'character' | 'object' | 'table' | 'cell';
   basedOn?: string;
   properties: Record<string, string>;
   location: string;

package/dist/unsupported-elements.js

@@ -37,8 +37,14 @@ const MAPPED_ELEMENTS = /* @__PURE__ */ new Set([
 	"ParagraphStyleGroup",
 	"RootCharacterStyleGroup",
 	"CharacterStyleGroup",
+	"RootTableStyleGroup",
+	"TableStyleGroup",
+	"RootCellStyleGroup",
+	"CellStyleGroup",
 	"ParagraphStyle",
 	"CharacterStyle",
+	"TableStyle",
+	"CellStyle",
 	"AnchoredObjectSetting",
 	"Color",
 	"TextVariable",
@@ -49,7 +55,7 @@ function insideMappedResource(element) {
 	let parent = element.parent;
 	while (parent && "name" in parent) {
 		const name = localName(parent.name);
-		if (name === "ParagraphStyle" || name === "CharacterStyle" || name === "ObjectStyle" || name === "Color") return true;
+		if (name === "ParagraphStyle" || name === "CharacterStyle" || name === "ObjectStyle" || name === "TableStyle" || name === "CellStyle" || name === "Color") return true;
 		parent = parent.parent;
 	}
 	return false;

package/package.json

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