@segnavia/idml 0.31.0 → 0.32.0

package/dist/placement-report.js

@@ -0,0 +1,15 @@
+//#region src/placement-report.ts
+function reportPage(page, consumed, report) {
+	for (const link of page.links ?? []) {
+		report.link(link.uri, link.location);
+		if (!consumed) report.add(report.unsupportedElements, "link", link.location);
+	}
+	for (const item of page.unmapped ?? []) report.add(report.unsupportedElements, item.name, item.location);
+	if (!consumed) for (const art of page.art ?? []) report.add(report.unsupportedElements, "polygon art group", art.location);
+}
+function reportPlacements(model, consumedPages, report) {
+	for (const spread of model.spreads) for (const page of spread.pages) reportPage(page, consumedPages.has(page), report);
+	for (const master of model.masterSpreads) for (const page of master.pages) reportPage(page, false, report);
+}
+//#endregion
+export { reportPlacements };

package/dist/placements.js

@@ -0,0 +1,300 @@
+import { attribute, elements, localName } from "./xml.js";
+import { framePreference } from "./frame-preferences.js";
+import { GRAPHIC_ELEMENTS, SHAPE_ELEMENTS } from "./unsupported-elements.js";
+import { isTag } from "domhandler";
+//#region src/placements.ts
+const IDENTITY = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function transform(element) {
+	const values = (attribute(element, "ItemTransform") ?? "").trim().split(/\s+/).map(Number);
+	return values.length === 6 && values.every(Number.isFinite) ? values : IDENTITY;
+}
+function compose(parent, child) {
+	const [a, b, c, d, x, y] = parent;
+	const [e, f, g, h, u, v] = child;
+	return [
+		a * e + c * f,
+		b * e + d * f,
+		a * g + c * h,
+		b * g + d * h,
+		a * u + c * v + x,
+		b * u + d * v + y
+	];
+}
+function apply(value, point) {
+	return [value[0] * point[0] + value[2] * point[1] + value[4], value[1] * point[0] + value[3] * point[1] + value[5]];
+}
+function pageArea(element) {
+	const value = (attribute(element, "GeometricBounds") ?? "").trim().split(/\s+/).map(Number);
+	if (value.length !== 4 || !value.every(Number.isFinite)) return void 0;
+	const [top, left, bottom, right] = value;
+	const matrix = transform(element);
+	return [
+		apply(matrix, [left, top]),
+		apply(matrix, [right, top]),
+		apply(matrix, [right, bottom]),
+		apply(matrix, [left, bottom])
+	];
+}
+function placementBounds(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 placementBounds(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;
+	for (let index = 0, previous = area.length - 1; index < area.length; previous = index, index += 1) {
+		const [xi, yi] = area[index];
+		const [xj, yj] = area[previous];
+		if (yi === yj && y === yi && x >= Math.min(xi, xj) && x <= Math.max(xi, xj)) return true;
+		if (yi > y !== yj > y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+	}
+	return inside;
+}
+function centered(box) {
+	return [(box.left + box.right) / 2, (box.top + box.bottom) / 2];
+}
+function framePlacement(element, matrix, location) {
+	const story = attribute(element, "ParentStory");
+	if (!story) return void 0;
+	const box = frameBounds(element, matrix);
+	const preference = framePreference(element, location);
+	return {
+		id: attribute(element, "Self") ?? story,
+		story,
+		...box ? {
+			bounds: box,
+			center: centered(box)
+		} : {},
+		...preference ? { preference } : {},
+		location
+	};
+}
+function pointAttribute(element, name, fallback) {
+	const values = (attribute(element, name) ?? "").trim().split(/\s+/).map(Number);
+	return values.length === 2 && values.every(Number.isFinite) ? values : fallback;
+}
+function polygonPlacement(element, matrix, location, group) {
+	const paths = elements(element, "GeometryPathType").flatMap((path) => {
+		const points = elements(path, "PathPointType").flatMap((candidate) => {
+			const anchor = pointAttribute(candidate, "Anchor");
+			return anchor ? [{
+				anchor: apply(matrix, anchor),
+				left: apply(matrix, pointAttribute(candidate, "LeftDirection", anchor)),
+				right: apply(matrix, pointAttribute(candidate, "RightDirection", anchor))
+			}] : [];
+		});
+		return points.length > 0 ? [{
+			open: attribute(path, "PathOpen") === "true",
+			points
+		}] : [];
+	});
+	const box = placementBounds(paths.flatMap((path) => path.points.flatMap((point) => [
+		point.anchor,
+		point.left,
+		point.right
+	])));
+	if (!box) return void 0;
+	const weight = Number(attribute(element, "StrokeWeight"));
+	const color = attribute(element, "StrokeColor");
+	return {
+		polygon: {
+			paths,
+			fill: attribute(element, "FillColor") ?? "Swatch/None",
+			...Number.isFinite(weight) && weight > 0 && color && !color.endsWith("/None") ? { stroke: {
+				color,
+				weight
+			} } : {},
+			location
+		},
+		bounds: box,
+		center: centered(box),
+		group
+	};
+}
+function linkedUri(element) {
+	const graphic = elements(element).find((candidate) => GRAPHIC_ELEMENTS.includes(localName(candidate.name)));
+	return graphic ? elements(graphic, "Link").map((link) => attribute(link, "LinkResourceURI")).find((uri) => Boolean(uri)) : void 0;
+}
+function collectShape(result, element, name, matrix, location, group) {
+	const box = frameBounds(element, matrix);
+	const uri = linkedUri(element);
+	if (uri) result.links.push({
+		...box ? {
+			bounds: box,
+			center: centered(box)
+		} : {},
+		uri,
+		location
+	});
+	else if (name === "Polygon") {
+		const polygon = polygonPlacement(element, matrix, location, group ?? attribute(element, "Self") ?? location);
+		if (polygon) result.polygons.push(polygon);
+		else result.unmapped.push({
+			name,
+			location,
+			...box ? { center: centered(box) } : {}
+		});
+	} else result.unmapped.push({
+		name,
+		location,
+		...box ? { center: centered(box) } : {}
+	});
+}
+function collectTerminal(result, element, name, matrix, location, group) {
+	if (name === "TextFrame") {
+		const frame = framePlacement(element, matrix, location);
+		if (frame) result.frames.push(frame);
+		return true;
+	}
+	if (SHAPE_ELEMENTS.includes(name)) {
+		collectShape(result, element, name, matrix, location, group);
+		return true;
+	}
+	return false;
+}
+function spreadPlacements(spread, location) {
+	const result = {
+		frames: [],
+		polygons: [],
+		links: [],
+		unmapped: []
+	};
+	let sequence = 0;
+	const pending = [...spread.children].reverse().map((node) => ({
+		node,
+		matrix: IDENTITY,
+		group: void 0
+	}));
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (!current || !isTag(current.node)) continue;
+		const name = localName(current.node.name);
+		if (name === "Page" || name === "Spread" || name === "MasterSpread") continue;
+		const matrix = [
+			"Group",
+			"TextFrame",
+			...SHAPE_ELEMENTS
+		].includes(name) ? compose(current.matrix, transform(current.node)) : current.matrix;
+		const itemLocation = `${location}#${name}[${++sequence}]`;
+		const group = name === "Group" ? current.group ?? attribute(current.node, "Self") ?? itemLocation : current.group;
+		if (collectTerminal(result, current.node, name, matrix, itemLocation, group)) continue;
+		for (let index = current.node.children.length - 1; index >= 0; index -= 1) pending.push({
+			node: current.node.children[index],
+			matrix,
+			group
+		});
+	}
+	return result;
+}
+const relativeBounds = (value, area) => ({
+	left: value.left - area.left,
+	top: value.top - area.top,
+	right: value.right - area.left,
+	bottom: value.bottom - area.top
+});
+function relativePolygon(polygon, area) {
+	const relative = ([x, y]) => [x - area.left, y - area.top];
+	return {
+		...polygon,
+		paths: polygon.paths.map((path) => ({
+			...path,
+			points: path.points.map((point) => ({
+				anchor: relative(point.anchor),
+				left: relative(point.left),
+				right: relative(point.right)
+			}))
+		}))
+	};
+}
+function placeFrames(frames, pageIndex, areas, pages) {
+	for (const frame of frames) {
+		const index = pageIndex(frame.center);
+		const area = areas[index];
+		const page = pages[index];
+		if (!area || !page || !frame.bounds) continue;
+		page.bodyFrames = [...page.bodyFrames ?? [], {
+			story: frame.story,
+			bounds: relativeBounds(frame.bounds, area),
+			location: frame.location
+		}];
+	}
+}
+function placeArt(polygons, pageIndex, areas, pages) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of polygons) {
+		const index = pageIndex(item.center);
+		const area = areas[index];
+		if (!area || !pages[index]) continue;
+		const group = groups.get(`${index}:${item.group}`) ?? {
+			index,
+			polygons: [],
+			boxes: [],
+			location: item.polygon.location
+		};
+		group.polygons.push(relativePolygon(item.polygon, area));
+		group.boxes.push(relativeBounds(item.bounds, area));
+		groups.set(`${index}:${item.group}`, group);
+	}
+	for (const group of groups.values()) {
+		const page = pages[group.index];
+		if (!page) continue;
+		const box = {
+			left: Math.min(...group.boxes.map((item) => item.left)),
+			top: Math.min(...group.boxes.map((item) => item.top)),
+			right: Math.max(...group.boxes.map((item) => item.right)),
+			bottom: Math.max(...group.boxes.map((item) => item.bottom))
+		};
+		page.art = [...page.art ?? [], {
+			bounds: box,
+			polygons: group.polygons,
+			location: group.location
+		}];
+	}
+}
+function attachPlacements(placements, pageElements, pages, report) {
+	const pageAreas = pageElements.map(pageArea);
+	const areas = pageAreas.map((points) => points ? placementBounds(points) : void 0);
+	const pageIndex = (center) => center ? pageAreas.findIndex((area) => area !== void 0 && contains(area, center)) : -1;
+	placeFrames(placements.frames, pageIndex, areas, pages);
+	placeArt(placements.polygons, pageIndex, areas, pages);
+	for (const link of placements.links) {
+		const index = pageIndex(link.center);
+		const area = areas[index];
+		const page = pages[index];
+		if (area && page && link.bounds) page.links = [...page.links ?? [], {
+			...link,
+			bounds: relativeBounds(link.bounds, area)
+		}];
+		else {
+			report.link(link.uri, link.location);
+			report.add(report.unsupportedElements, "link", link.location);
+		}
+	}
+	for (const item of placements.unmapped) {
+		const page = pages[pageIndex(item.center)];
+		if (page) page.unmapped = [...page.unmapped ?? [], {
+			name: item.name,
+			location: item.location
+		}];
+		else report.add(report.unsupportedElements, item.name, item.location);
+	}
+	for (const item of placements.polygons) if (pageIndex(item.center) < 0) report.add(report.unsupportedElements, "polygon art group", item.polygon.location);
+}
+//#endregion
+export { attachPlacements, contains, pageArea, placementBounds, spreadPlacements };

package/dist/positioned-box.js

@@ -0,0 +1,14 @@
+import { MM_PER_PT } from "@segnavia/format";
+//#region src/positioned-box.ts
+function formatRoundedNumber(value, digits = 2) {
+	const rounded = Number(value.toFixed(digits));
+	return String(Object.is(rounded, -0) ? 0 : rounded);
+}
+function positionedBoxStyle(bounds, options) {
+	const scale = options.unit === "mm" ? MM_PER_PT : 1;
+	const digits = options.unit === "mm" ? 6 : 2;
+	const value = (points) => `${formatRoundedNumber(points * scale, digits)}${options.unit}`;
+	return `position:absolute;inset-inline-start:${value(options.rtl ? options.pageWidth - options.margin.right - bounds.right : bounds.left - options.margin.left)};inline-size:${value(bounds.right - bounds.left)};inset-block-start:${value(bounds.top - options.blockOrigin)};block-size:${value(bounds.bottom - bounds.top)}`;
+}
+//#endregion
+export { formatRoundedNumber, positionedBoxStyle };

package/dist/report.d.ts

@@ -10,6 +10,10 @@ export interface IdmlMixedMasterChapter {
   masters: string[];
   chosen: string;
 }
+export interface IdmlLinkUse {
+  uri: string;
+  locations: string[];
+}
 export interface IdmlReportData {
   unsupportedElements: Record<string, number>;
   unsupportedStyleProperties: Record<string, number>;
@@ -19,6 +23,9 @@ export interface IdmlReportData {
   spotColors: Record<string, number>;
   locations: Record<string, string[]>;
   fonts: IdmlFontUse[];
+  unmappedFonts: IdmlFontUse[];
+  links: IdmlLinkUse[];
+  strippedAssetContent: Record<string, string[]>;
   mixedMasterChapters: IdmlMixedMasterChapter[];
 }
 //#endregion

package/dist/report.js

@@ -7,9 +7,15 @@ const BUCKET_NAMES = {
 	unsupportedLanguages: "language",
 	spotColors: "spot"
 };
+function fontUseKey(appliedFont, fontStyle) {
+	return `${appliedFont}\u0000${fontStyle ?? ""}`;
+}
 var ReportCollector = class {
 	locations = /* @__PURE__ */ new Map();
 	fonts = /* @__PURE__ */ new Map();
+	unmappedFonts = /* @__PURE__ */ new Map();
+	links = /* @__PURE__ */ new Map();
+	strippedAssetContent = /* @__PURE__ */ new Map();
 	mixedMasterChapters;
 	buckets = Object.fromEntries(Object.keys(BUCKET_NAMES).map((name) => [name, /* @__PURE__ */ new Map()]));
 	get unsupportedElements() {
@@ -34,7 +40,13 @@ var ReportCollector = class {
 		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]);
+		this.seedKeyedRecords(seed);
+	}
+	seedKeyedRecords(seed) {
 		for (const font of seed?.fonts ?? []) this.font(font.appliedFont, font.fontStyle, font.locations[0] ?? "Resources/Styles.xml");
+		for (const font of seed?.unmappedFonts ?? []) for (const location of font.locations) this.unmappedFont(font.appliedFont, font.fontStyle, location);
+		for (const link of seed?.links ?? []) for (const location of link.locations) this.link(link.uri, location);
+		for (const [uri, findings] of Object.entries(seed?.strippedAssetContent ?? {})) for (const finding of findings) this.strippedAsset(uri, finding);
 	}
 	add(bucket, name, location, count = 1) {
 		bucket.set(name, (bucket.get(name) ?? 0) + count);
@@ -50,14 +62,36 @@ var ReportCollector = class {
 	}
 	font(appliedFont, fontStyle, location) {
 		if (!appliedFont) return;
-		const key = `${appliedFont}\u0000${fontStyle ?? ""}`;
-		const found = this.fonts.get(key) ?? {
+		this.record(this.fonts, appliedFont, fontStyle, location);
+	}
+	unmappedFont(appliedFont, fontStyle, location) {
+		this.record(this.unmappedFonts, appliedFont, fontStyle, location);
+	}
+	link(uri, location) {
+		const found = this.links.get(uri) ?? {
+			uri,
+			locations: []
+		};
+		this.recordLocation(found.locations, location);
+		this.links.set(uri, found);
+	}
+	strippedAsset(uri, finding) {
+		const found = this.strippedAssetContent.get(uri) ?? [];
+		this.recordLocation(found, finding);
+		this.strippedAssetContent.set(uri, found);
+	}
+	record(target, appliedFont, fontStyle, location) {
+		const key = fontUseKey(appliedFont, fontStyle);
+		const found = target.get(key) ?? {
 			appliedFont,
 			...fontStyle ? { fontStyle } : {},
 			locations: []
 		};
-		if (found.locations.length < 5 && !found.locations.includes(location)) found.locations.push(location);
-		this.fonts.set(key, found);
+		this.recordLocation(found.locations, location);
+		target.set(key, found);
+	}
+	recordLocation(target, location) {
+		if (target.length < 5 && !target.includes(location)) target.push(location);
 	}
 	data() {
 		const record = (values) => Object.fromEntries([...values].sort(([a], [b]) => a.localeCompare(b)));
@@ -65,6 +99,9 @@ var ReportCollector = class {
 			...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()],
+			unmappedFonts: [...this.unmappedFonts.values()],
+			links: [...this.links.values()],
+			strippedAssetContent: Object.fromEntries([...this.strippedAssetContent].sort(([a], [b]) => a.localeCompare(b))),
 			mixedMasterChapters: [...this.mixedMasterChapters]
 		};
 	}
@@ -75,4 +112,4 @@ var ReportCollector = class {
 	}
 };
 //#endregion
-export { ReportCollector };
+export { ReportCollector, fontUseKey };

package/dist/stories.js

@@ -1,7 +1,7 @@
 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 { Element, Text } from "domhandler";
 //#region src/stories.ts
 const OMITTED = /* @__PURE__ */ new Set([
 	"TextFrame",

package/dist/styles.js

@@ -1,4 +1,5 @@
 import { idmlDirection, localName } from "./xml.js";
+import { resolveSwatchColor } from "./swatch-color.js";
 import { stylePropertyMapping } from "./style-mappings.js";
 import { reportableStyleProperties } from "./style-property-report.js";
 import { isTag } from "domhandler";
@@ -84,19 +85,28 @@ function textDeclarations(values, mapped, output) {
 	if (mapped.has("Capitalization") && values.Capitalization === "AllCaps") output.push("text-transform:uppercase");
 	if (mapped.has("Underline") && (values.Underline === "true" || values.Underline === "Underline")) output.push("text-decoration-line:underline");
 }
+function resolvedFontProperties(changed, resolved) {
+	if (changed.AppliedFont === void 0 && changed.FontStyle === void 0) return {};
+	return {
+		...resolved.AppliedFont === void 0 ? {} : { AppliedFont: resolved.AppliedFont },
+		...resolved.FontStyle === void 0 ? {} : { FontStyle: resolved.FontStyle }
+	};
+}
 var StyleMapper = class {
 	swatches;
 	report;
 	bookDirection;
+	fonts;
 	byId;
 	classes = /* @__PURE__ */ new Map();
 	used = /* @__PURE__ */ new Set();
 	overrides = /* @__PURE__ */ new Map();
 	reportedStyleProperties = /* @__PURE__ */ new Set();
-	constructor(styles, swatches, report, bookDirection) {
+	constructor(styles, swatches, report, bookDirection, fonts) {
 		this.swatches = swatches;
 		this.report = report;
 		this.bookDirection = bookDirection;
+		this.fonts = fonts;
 		this.byId = new Map(styles.map((style) => [style.id, style]));
 		const taken = /* @__PURE__ */ new Set();
 		for (const style of styles) {
@@ -140,6 +150,7 @@ var StyleMapper = class {
 		for (const name of reportableStyleProperties(changed, resolved)) this.report.add(this.report.unsupportedOverrideProperties, name, location);
 		if (changed.AppliedFont !== void 0 || changed.FontStyle !== void 0) this.report.font(resolved.AppliedFont, resolved.FontStyle, location);
 		const cssProperties = Object.fromEntries(Object.entries(changed).filter(([name]) => stylePropertyMapping(name)?.kind === "css"));
+		Object.assign(cssProperties, resolvedFontProperties(changed, resolved));
 		if (styleDirection && styleDirection !== directionValue) {
 			for (const name of ["LeftIndent", "RightIndent"]) cssProperties[name] = base[name] ?? "0";
 			for (const name of ["Justification"]) if (base[name] !== void 0 && cssProperties[name] === void 0) cssProperties[name] = base[name];
@@ -152,7 +163,8 @@ var StyleMapper = class {
 		this.overrides.set(key, {
 			name,
 			properties: cssProperties,
-			direction: directionValue
+			direction: directionValue,
+			location
 		});
 		return name;
 	}
@@ -186,13 +198,14 @@ var StyleMapper = class {
 			rules.push(`.${name}{${declarations}}`);
 		}
 		for (const value of this.overrides.values()) {
-			const declarations = this.declarations(value.properties, value.direction, value.name, this.report.unsupportedOverrideProperties);
+			const declarations = this.declarations(value.properties, value.direction, value.location, this.report.unsupportedOverrideProperties);
 			if (declarations) rules.push(`.${value.name}{${declarations}}`);
 		}
 		return rules.join("");
 	}
 	declarations(values, dir, location, unsupported = this.report.unsupportedStyleProperties) {
 		const output = [];
+		output.push(...this.fonts?.declarations(values.AppliedFont, values.FontStyle, location) ?? []);
 		const mapped = new Set(Object.keys(values).filter((name) => stylePropertyMapping(name)?.kind === "css"));
 		const pt = (name, property) => {
 			if (!mapped.has(name)) return;
@@ -215,7 +228,7 @@ var StyleMapper = class {
 		if (mapped.has("Justification")) this.justification(values.Justification, dir, output, location, unsupported);
 		if (hasCssMapping(mapped, "keeps")) this.keeps(values, output);
 		if (mapped.has("StartParagraph") && values.StartParagraph && values.StartParagraph !== "Anywhere") this.report.add(unsupported, `StartParagraph:${values.StartParagraph}`, location);
-		const color = mapped.has("FillColor") ? this.color(values.FillColor, location) : void 0;
+		const color = mapped.has("FillColor") ? resolveSwatchColor(values.FillColor, this.swatches, this.report, location, "text") : void 0;
 		if (color) output.push(`color:${color}`);
 		return output.join(";");
 	}
@@ -264,22 +277,6 @@ var StyleMapper = class {
 			if (Number.isInteger(last) && last > 0) output.push(`widows:${last}`);
 		}
 	}
-	color(id, location) {
-		if (!id || id.endsWith("/None")) return void 0;
-		if (id.endsWith("/Black")) return "#000";
-		if (id.endsWith("/Paper")) return "#fff";
-		const swatch = this.swatches.find((value) => value.id === id || value.name === id);
-		if (!swatch) return void 0;
-		if (swatch.model === "spot") {
-			this.report.add(this.report.spotColors, swatch.name, location);
-			return;
-		}
-		if (swatch.model === "rgb" && swatch.values?.length === 3) return `rgb(${swatch.values.join(" ")})`;
-		if (swatch.model === "cmyk" && swatch.values?.length === 4) {
-			const [c, m, y, k] = swatch.values.map((value) => value / 100);
-			return `rgb(${Math.round(255 * (1 - c) * (1 - k))} ${Math.round(255 * (1 - m) * (1 - k))} ${Math.round(255 * (1 - y) * (1 - k))})`;
-		}
-	}
 };
 //#endregion
 export { StyleMapper, parseStyles, parseSwatches };

package/dist/svg-path.js

@@ -0,0 +1,33 @@
+import { formatRoundedNumber } from "./positioned-box.js";
+import { resolveSwatchColor } from "./swatch-color.js";
+//#region src/svg-path.ts
+const escapeAttribute = (value) => value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+function point(value, origin) {
+	return `${formatRoundedNumber(value[0] - origin[0])} ${formatRoundedNumber(value[1] - origin[1])}`;
+}
+function pathData(path, origin) {
+	const first = path.points[0];
+	if (!first) return "";
+	const output = [`M${point(first.anchor, origin)}`];
+	for (let index = 1; index < path.points.length; index += 1) {
+		const previous = path.points[index - 1];
+		const current = path.points[index];
+		if (previous && current) output.push(`C${point(previous.right, origin)} ${point(current.left, origin)} ${point(current.anchor, origin)}`);
+	}
+	const last = path.points.at(-1);
+	if (!path.open && last && path.points.length > 1) output.push(`C${point(last.right, origin)} ${point(first.left, origin)} ${point(first.anchor, origin)}Z`);
+	return output.join("");
+}
+function artSvg(art, swatches, positionStyle, report) {
+	const width = art.bounds.right - art.bounds.left;
+	const height = art.bounds.bottom - art.bounds.top;
+	const origin = [art.bounds.left, art.bounds.top];
+	const paths = art.polygons.flatMap((polygon) => {
+		if (polygon.stroke) report.add(report.unsupportedStyleProperties, `StrokeColor:${polygon.stroke.color}`, polygon.location);
+		const fill = resolveSwatchColor(polygon.fill, swatches, report, polygon.location, "fill") ?? "currentColor";
+		return polygon.paths.map((path) => `<path d="${escapeAttribute(pathData(path, origin))}" fill="${escapeAttribute(fill)}"/>`);
+	});
+	return `<svg style="${escapeAttribute(positionStyle)}" viewBox="0 0 ${formatRoundedNumber(width)} ${formatRoundedNumber(height)}" width="${formatRoundedNumber(width)}pt" height="${formatRoundedNumber(height)}pt" xmlns="http://www.w3.org/2000/svg">${paths.join("")}</svg>`;
+}
+//#endregion
+export { artSvg };

package/dist/swatch-color.js

@@ -0,0 +1,25 @@
+//#region src/swatch-color.ts
+const colorComponent = (value) => Math.round(value + 1e-9);
+function unresolved(id, location, use, report) {
+	report.add(report.unsupportedStyleProperties, `FillColor:${id}`, location);
+	return use === "fill" ? "currentColor" : void 0;
+}
+function resolveSwatchColor(id, swatches, report, location, use) {
+	if (!id || id.endsWith("/None") || id === "None") return use === "fill" ? "none" : void 0;
+	if (id.endsWith("/Black") || id === "Black") return "#000";
+	if (id.endsWith("/Paper") || id === "Paper") return "#fff";
+	const swatch = swatches.find((value) => value.id === id || value.name === id);
+	if (!swatch) return unresolved(id, location, use, report);
+	if (swatch.model === "spot") {
+		report.add(report.spotColors, swatch.name, location);
+		return use === "fill" ? "currentColor" : void 0;
+	}
+	if (swatch.model === "rgb" && swatch.values?.length === 3) return `rgb(${swatch.values.map(colorComponent).join(" ")})`;
+	if (swatch.model === "cmyk" && swatch.values?.length === 4) {
+		const [c, m, y, k] = swatch.values.map((value) => value / 100);
+		return `rgb(${colorComponent(255 * (1 - c) * (1 - k))} ${colorComponent(255 * (1 - m) * (1 - k))} ${colorComponent(255 * (1 - y) * (1 - k))})`;
+	}
+	return unresolved(id, location, use, report);
+}
+//#endregion
+export { resolveSwatchColor };

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { FontReferenceInput } from "@segnavia/format";
 //#region src/types.d.ts
 export interface IdmlTextNode {
   name: string;
@@ -14,6 +15,60 @@ export interface IdmlStyle {
   properties: Record<string, string>;
   location: string;
 }
+export interface IdmlFont {
+  family: string;
+  style?: string;
+  postscriptName?: string;
+}
+export type IdmlFontMap = (font: IdmlFont) => FontReferenceInput | undefined;
+export type IdmlAssetMap = (uri: string) => string | undefined;
+export interface IdmlImportOptions {
+  font?: IdmlFontMap;
+  asset?: IdmlAssetMap;
+}
+export type IdmlPoint = [number, number];
+export interface IdmlBounds {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}
+export interface IdmlPathPoint {
+  anchor: IdmlPoint;
+  left: IdmlPoint;
+  right: IdmlPoint;
+}
+export interface IdmlPolygon {
+  paths: {
+    open: boolean;
+    points: IdmlPathPoint[];
+  }[];
+  fill: string;
+  stroke?: {
+    color: string;
+    weight: number;
+  };
+  location: string;
+}
+export interface IdmlArtPlacement {
+  bounds: IdmlBounds;
+  polygons: IdmlPolygon[];
+  location: string;
+}
+export interface IdmlFramePlacement {
+  bounds: IdmlBounds;
+  story: string;
+  location: string;
+}
+export interface IdmlLinkPlacement {
+  bounds: IdmlBounds;
+  uri: string;
+  location: string;
+}
+export interface IdmlUnmappedPlacement {
+  name: string;
+  location: string;
+}
 export interface IdmlSwatch {
   id: string;
   name: string;
@@ -58,6 +113,10 @@ export interface IdmlPage {
   appliedMaster?: string;
   stories: string[];
   side?: 'left' | 'right' | 'single';
+  bodyFrames?: IdmlFramePlacement[];
+  art?: IdmlArtPlacement[];
+  links?: IdmlLinkPlacement[];
+  unmapped?: IdmlUnmappedPlacement[];
 }
 export interface IdmlSpread {
   id: string;