@segnavia/idml 0.33.0 → 0.35.0

package/dist/paragraph-box.js

@@ -0,0 +1,123 @@
+import { formatRoundedNumber, logicalCornerRadii } from "./positioned-box.js";
+import { resolveSwatchColor } from "./swatch-color.js";
+//#region src/paragraph-box.ts
+function enabled(value) {
+	return value?.trim().toLowerCase() === "true";
+}
+function number(values, mapped, name) {
+	if (!mapped.has(name)) return void 0;
+	const value = Number(values[name]);
+	return Number.isFinite(value) ? value : void 0;
+}
+function points(output, property, value) {
+	output.push(`${property}:${formatRoundedNumber(value)}pt`);
+}
+function optionalPoints(output, property, value, scale = 1) {
+	if (value !== void 0) points(output, property, value * scale);
+}
+function combinedPoints(output, property, base, adjustment, scale = 1) {
+	if (base === void 0 && adjustment === void 0) return;
+	points(output, property, (base ?? 0) + (adjustment ?? 0) * scale);
+}
+function padding(options, output, property, base, offset, offsetName) {
+	if (base === void 0 && offset === void 0) return;
+	const value = (base ?? 0) + (offset ?? 0);
+	if (value < 0) options.report.add(options.unsupported, offsetName, options.location);
+	points(output, property, Math.max(0, value));
+}
+function boxDeclarations(options, shaded, reset, output) {
+	const { values, mapped, direction } = options;
+	const top = shaded ? number(values, mapped, "ParagraphShadingTopOffset") : void 0;
+	const bottom = shaded ? number(values, mapped, "ParagraphShadingBottomOffset") : void 0;
+	const left = shaded ? number(values, mapped, "ParagraphShadingLeftOffset") : void 0;
+	const right = shaded ? number(values, mapped, "ParagraphShadingRightOffset") : void 0;
+	const before = number(values, mapped, "SpaceBefore");
+	const after = number(values, mapped, "SpaceAfter");
+	const startIndent = number(values, mapped, direction === "rtl" ? "RightIndent" : "LeftIndent");
+	const endIndent = number(values, mapped, direction === "rtl" ? "LeftIndent" : "RightIndent");
+	const startOffset = direction === "rtl" ? right : left;
+	const endOffset = direction === "rtl" ? left : right;
+	const startOffsetName = direction === "rtl" ? "ParagraphShadingRightOffset" : "ParagraphShadingLeftOffset";
+	const endOffsetName = direction === "rtl" ? "ParagraphShadingLeftOffset" : "ParagraphShadingRightOffset";
+	if (reset) {
+		points(output, "margin-block-start", before ?? 0);
+		points(output, "margin-block-end", after ?? 0);
+		points(output, "padding-block-start", 0);
+		points(output, "padding-block-end", 0);
+		points(output, "padding-inline-start", Math.max(0, startIndent ?? 0));
+		points(output, "padding-inline-end", Math.max(0, endIndent ?? 0));
+		points(output, "margin-inline-start", 0);
+		points(output, "margin-inline-end", 0);
+		return;
+	}
+	combinedPoints(output, "margin-block-start", before, top, -1);
+	combinedPoints(output, "margin-block-end", after, bottom, -1);
+	padding(options, output, "padding-block-start", void 0, top, "ParagraphShadingTopOffset");
+	padding(options, output, "padding-block-end", void 0, bottom, "ParagraphShadingBottomOffset");
+	padding(options, output, "padding-inline-start", startIndent, startOffset, startOffsetName);
+	padding(options, output, "padding-inline-end", endIndent, endOffset, endOffsetName);
+	optionalPoints(output, "margin-inline-start", startOffset, -1);
+	optionalPoints(output, "margin-inline-end", endOffset, -1);
+}
+const PHYSICAL_CORNERS = [
+	"TopLeft",
+	"TopRight",
+	"BottomLeft",
+	"BottomRight"
+];
+function cornerDeclarations(options, output) {
+	const { values, mapped, direction, report, unsupported, location } = options;
+	const radii = {
+		topLeft: void 0,
+		topRight: void 0,
+		bottomLeft: void 0,
+		bottomRight: void 0
+	};
+	for (const physical of PHYSICAL_CORNERS) {
+		const optionName = `ParagraphShading${physical}CornerOption`;
+		const option = values[optionName];
+		if (!option || option === "None" || option.endsWith("/None")) continue;
+		if (option !== "RoundedCorner" && !option.endsWith("/RoundedCorner")) {
+			report.add(unsupported, optionName, location);
+			continue;
+		}
+		const radius = number(values, mapped, `ParagraphShading${physical}CornerRadius`);
+		if (radius !== void 0) radii[`${physical[0]?.toLowerCase()}${physical.slice(1)}`] = radius;
+	}
+	for (const [property, radius] of Object.entries(logicalCornerRadii(radii, direction))) if (radius !== void 0) points(output, property, radius);
+}
+function reportUnmappedOptions(options) {
+	const { values, report, unsupported, location } = options;
+	if (values.ParagraphShadingWidth && !["ColumnWidth", "Column"].includes(values.ParagraphShadingWidth)) report.add(unsupported, "ParagraphShadingWidth", location);
+	if (values.ParagraphShadingTopOrigin && !["Ascent", "AscentTopOrigin"].includes(values.ParagraphShadingTopOrigin)) report.add(unsupported, "ParagraphShadingTopOrigin", location);
+	if (values.ParagraphShadingBottomOrigin && !["Descent", "DescentBottomOrigin"].includes(values.ParagraphShadingBottomOrigin)) report.add(unsupported, "ParagraphShadingBottomOrigin", location);
+	if (enabled(values.ParagraphShadingClipToFrame)) report.add(unsupported, "ParagraphShadingClipToFrame", location);
+	if (enabled(values.ParagraphShadingSuppressPrinting)) report.add(unsupported, "ParagraphShadingSuppressPrinting", location);
+}
+function paragraphBoxDeclarations(options) {
+	const { values, swatches, report, unsupported, location } = options;
+	const output = [];
+	const shaded = enabled(values.ParagraphShadingOn);
+	boxDeclarations(options, shaded, options.resetShading, output);
+	if (options.resetShading) {
+		output.push("background-color:transparent");
+		for (const property of Object.keys(logicalCornerRadii({
+			topLeft: 0,
+			topRight: 0,
+			bottomLeft: 0,
+			bottomRight: 0
+		}, options.direction))) points(output, property, 0);
+	}
+	if (!shaded) return output;
+	if (!values.ParagraphShadingColor) report.add(unsupported, "ParagraphShadingColor", location);
+	const color = values.ParagraphShadingColor ? resolveSwatchColor(values.ParagraphShadingColor, swatches, report, location, "text", "ParagraphShadingColor") : void 0;
+	if (color) {
+		const tint = Number(values.ParagraphShadingTint);
+		output.push(`background-color:${Number.isFinite(tint) && tint >= 0 && tint < 100 ? `color-mix(in srgb, ${color} ${tint}%, #fff)` : color}`);
+	}
+	cornerDeclarations(options, output);
+	reportUnmappedOptions(options);
+	return output;
+}
+//#endregion
+export { paragraphBoxDeclarations };

package/dist/placements.js

@@ -11,10 +11,13 @@ const IDENTITY = [
 	0,
 	0
 ];
-function transform(element) {
-	const values = (attribute(element, "ItemTransform") ?? "").trim().split(/\s+/).map(Number);
+function itemTransform(value) {
+	const values = (value ?? "").trim().split(/\s+/).map(Number);
 	return values.length === 6 && values.every(Number.isFinite) ? values : IDENTITY;
 }
+function transform(element) {
+	return itemTransform(attribute(element, "ItemTransform"));
+}
 function compose(parent, child) {
 	const [a, b, c, d, x, y] = parent;
 	const [e, f, g, h, u, v] = child;
@@ -27,19 +30,23 @@ function compose(parent, child) {
 		b * u + d * v + y
 	];
 }
-function apply(value, point) {
+function applyTransform(value, point) {
 	return [value[0] * point[0] + value[2] * point[1] + value[4], value[1] * point[0] + value[3] * point[1] + value[5]];
 }
+function pointValue(value, fallback) {
+	const values = (value ?? "").trim().split(/\s+/).map(Number);
+	return values.length === 2 && values.every(Number.isFinite) ? values : fallback;
+}
 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])
+		applyTransform(matrix, [left, top]),
+		applyTransform(matrix, [right, top]),
+		applyTransform(matrix, [right, bottom]),
+		applyTransform(matrix, [left, bottom])
 	];
 }
 function placementBounds(points) {
@@ -54,7 +61,7 @@ function placementBounds(points) {
 	};
 }
 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)));
+	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) => applyTransform(matrix, point)));
 }
 function contains(area, [x, y]) {
 	let inside = false;
@@ -86,17 +93,16 @@ function framePlacement(element, matrix, 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;
+	return pointValue(attribute(element, name), 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))
+				anchor: applyTransform(matrix, anchor),
+				left: applyTransform(matrix, pointAttribute(candidate, "LeftDirection", anchor)),
+				right: applyTransform(matrix, pointAttribute(candidate, "RightDirection", anchor))
 			}] : [];
 		});
 		return points.length > 0 ? [{
@@ -297,4 +303,4 @@ function attachPlacements(placements, pageElements, pages, report) {
 	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 };
+export { applyTransform, attachPlacements, contains, itemTransform, pageArea, placementBounds, pointValue, spreadPlacements };

package/dist/positioned-box.js

@@ -4,6 +4,14 @@ function formatRoundedNumber(value, digits = 2) {
 	const rounded = Number(value.toFixed(digits));
 	return String(Object.is(rounded, -0) ? 0 : rounded);
 }
+function logicalCornerRadii(corners, direction) {
+	return {
+		"border-start-start-radius": direction === "rtl" ? corners.topRight : corners.topLeft,
+		"border-start-end-radius": direction === "rtl" ? corners.topLeft : corners.topRight,
+		"border-end-start-radius": direction === "rtl" ? corners.bottomRight : corners.bottomLeft,
+		"border-end-end-radius": direction === "rtl" ? corners.bottomLeft : corners.bottomRight
+	};
+}
 function positionedBoxStyle(bounds, options) {
 	const scale = options.unit === "mm" ? MM_PER_PT : 1;
 	const digits = options.unit === "mm" ? 6 : 2;
@@ -11,4 +19,4 @@ function positionedBoxStyle(bounds, options) {
 	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 };
+export { formatRoundedNumber, logicalCornerRadii, positionedBoxStyle };

package/dist/report.d.ts

@@ -26,6 +26,7 @@ export interface IdmlReportData {
   unmappedFonts: IdmlFontUse[];
   links: IdmlLinkUse[];
   strippedAssetContent: Record<string, string[]>;
+  versoOpenings: Record<string, string[]>;
   mixedMasterChapters: IdmlMixedMasterChapter[];
 }
 //#endregion

package/dist/report.js

@@ -7,6 +7,7 @@ const BUCKET_NAMES = {
 	unsupportedLanguages: "language",
 	spotColors: "spot"
 };
+const KEYED_RECORD_NAMES = ["strippedAssetContent", "versoOpenings"];
 function fontUseKey(appliedFont, fontStyle) {
 	return `${appliedFont}\u0000${fontStyle ?? ""}`;
 }
@@ -16,6 +17,7 @@ var ReportCollector = class {
 	unmappedFonts = /* @__PURE__ */ new Map();
 	links = /* @__PURE__ */ new Map();
 	strippedAssetContent = /* @__PURE__ */ new Map();
+	versoOpenings = /* @__PURE__ */ new Map();
 	mixedMasterChapters;
 	buckets = Object.fromEntries(Object.keys(BUCKET_NAMES).map((name) => [name, /* @__PURE__ */ new Map()]));
 	get unsupportedElements() {
@@ -46,7 +48,7 @@ var ReportCollector = class {
 		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);
+		for (const name of KEYED_RECORD_NAMES) for (const [key, locations] of Object.entries(seed?.[name] ?? {})) for (const location of locations) this.recordKeyed(this[name], key, location);
 	}
 	add(bucket, name, location, count = 1) {
 		bucket.set(name, (bucket.get(name) ?? 0) + count);
@@ -76,9 +78,15 @@ var ReportCollector = class {
 		this.links.set(uri, found);
 	}
 	strippedAsset(uri, finding) {
-		const found = this.strippedAssetContent.get(uri) ?? [];
-		this.recordLocation(found, finding);
-		this.strippedAssetContent.set(uri, found);
+		this.recordKeyed(this.strippedAssetContent, uri, finding);
+	}
+	versoOpening(story, page) {
+		this.recordKeyed(this.versoOpenings, story, page);
+	}
+	recordKeyed(target, key, location) {
+		const found = target.get(key) ?? [];
+		this.recordLocation(found, location);
+		target.set(key, found);
 	}
 	record(target, appliedFont, fontStyle, location) {
 		const key = fontUseKey(appliedFont, fontStyle);
@@ -95,13 +103,15 @@ var ReportCollector = class {
 	}
 	data() {
 		const record = (values) => Object.fromEntries([...values].sort(([a], [b]) => a.localeCompare(b)));
+		const buckets = Object.fromEntries(Object.keys(BUCKET_NAMES).map((name) => [name, record(this.buckets[name])]));
+		const keyedRecords = Object.fromEntries(KEYED_RECORD_NAMES.map((name) => [name, Object.fromEntries([...this[name]].sort(([a], [b]) => a.localeCompare(b)))]));
 		return {
-			...Object.fromEntries(Object.keys(BUCKET_NAMES).map((name) => [name, record(this.buckets[name])])),
+			...buckets,
+			...keyedRecords,
 			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]
 		};
 	}

package/dist/stories.js

@@ -2,9 +2,9 @@ import { BOOK_FURNITURE, MOTIF_ATTRIBUTE, motifFieldAttribute, resolveDirection
 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
 const OMITTED = /* @__PURE__ */ new Set([
-	"TextFrame",
 	"Rectangle",
 	"Group",
 	"Polygon",
@@ -30,7 +30,7 @@ function rangeAttributes(node) {
 function tokens(root, report) {
 	const result = [];
 	const terminal = (node, character) => {
-		if (node.name === "Content") result.push({
+		if (node.name === "#text") result.push({
 			kind: "text",
 			text: node.text ?? "",
 			character,
@@ -52,6 +52,10 @@ function tokens(root, report) {
 			character,
 			location: node.location
 		});
+		else if (node.name === "TextFrame") result.push({
+			kind: "anchored",
+			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);
@@ -59,6 +63,16 @@ function tokens(root, report) {
 		return true;
 	};
 	const walk = (node, character) => {
+		if (node.name === "Content") {
+			if (node.children.length === 0) result.push({
+				kind: "text",
+				text: node.text ?? "",
+				character,
+				location: node.location
+			});
+			else for (const child of node.children) walk(child, character);
+			return;
+		}
 		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);
@@ -121,7 +135,7 @@ function furnitureNode(token, variables, master, styles, direction, report) {
 	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) {
+function paragraphChildren(paragraphTokens, styles, report, direction, variables, master, options) {
 	const children = [];
 	let marked;
 	for (const token of paragraphTokens) {
@@ -143,6 +157,12 @@ function paragraphChildren(paragraphTokens, styles, report, direction, variables
 			continue;
 		}
 		marked = void 0;
+		if (token.kind === "anchored") {
+			const html = options.anchored?.(token.location, direction);
+			if (html) children.push(...parseDocument(html, { xmlMode: false }).children.filter((child) => child instanceof Text || child instanceof Element));
+			else if (!options.anchored) report.add(report.unsupportedElements, "TextFrame", token.location);
+			continue;
+		}
 		const furniture = furnitureNode(token, variables, master, styles, direction, report);
 		if (furniture) children.push(furniture);
 	}
@@ -157,7 +177,7 @@ function textNodes(value) {
 	}
 	return result;
 }
-function paragraphNode(paragraph, paragraphTokens, styles, report, bookDirection, bookLanguage, storyDirection, frame, variables, master) {
+function paragraphNode(paragraph, paragraphTokens, styles, report, bookDirection, bookLanguage, storyDirection, frame, variables, master, options) {
 	const attributes = rangeAttributes(paragraph);
 	const styleId = attributes.AppliedParagraphStyle;
 	const flattened = styles.flattened(styleId, "paragraph");
@@ -178,15 +198,21 @@ function paragraphNode(paragraph, paragraphTokens, styles, report, bookDirection
 		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 = paragraphChildren(paragraphTokens, styles, report, resolvedDirection, variables, master);
+	const children = paragraphChildren(paragraphTokens, styles, report, resolvedDirection, variables, master, options);
 	if (children.length === 0) children.push(new Element("br", {}, []));
-	return new Element("p", htmlAttributes, children);
+	return new Element(options.inlineParagraphs ? "span" : "p", options.inlineParagraphs ? {
+		...htmlAttributes,
+		style: "display:block"
+	} : 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"
-	}) };
+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", {}, [])]);
+		return { html: serialize(empty, {
+			xmlMode: false,
+			encodeEntities: "utf8"
+		}) };
+	}
 	const paragraphs = [];
 	const paragraphRanges = [];
 	const collectParagraphs = (node) => {
@@ -198,14 +224,14 @@ function storyHtml(story, styles, report, bookDirection, bookLanguage) {
 		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));
+			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();
 	}
-	if (paragraphs.length === 0) paragraphs.push(new Element("p", {}, [new Element("br", {}, [])]));
+	if (paragraphs.length === 0) paragraphs.push(new Element(options.inlineParagraphs ? "span" : "p", options.inlineParagraphs ? { style: "display:block" } : {}, [new Element("br", {}, [])]));
 	return {
 		html: serialize(paragraphs, {
 			xmlMode: false,

package/dist/story-model.js

@@ -5,9 +5,17 @@ import { isTag } from "domhandler";
 function textNode(node, part, path) {
 	const children = [];
 	let childIndex = 0;
+	const content = localName(node.name) === "Content";
 	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 === "text" && content && child.data) children.push({
+			name: "#text",
+			attributes: {},
+			text: child.data,
+			children: [],
+			location: `${part}${path}#text${childIndex}`
+		});
 		else if (child.type === "directive") children.push({
 			name: "#processing-instruction",
 			attributes: {},
@@ -16,7 +24,7 @@ function textNode(node, part, path) {
 			location: `${part}${path}#pi${childIndex}`
 		});
 	}
-	const directText = node.children.filter((child) => child.type === "text").map((child) => child.data).join("");
+	const directText = content ? "" : node.children.filter((child) => child.type === "text").map((child) => child.data).join("");
 	return {
 		name: localName(node.name),
 		attributes: { ...node.attribs },

package/dist/style-mappings.js

@@ -24,6 +24,26 @@ const STYLE_PROPERTY_MAPPINGS = {
 	KeepFirstLines: css("keeps"),
 	KeepLastLines: css("keeps"),
 	StartParagraph: css("starts"),
+	ParagraphShadingOn: css("paragraph-shading"),
+	ParagraphShadingColor: css("paragraph-shading"),
+	ParagraphShadingTint: css("paragraph-shading"),
+	ParagraphShadingTopOffset: css("paragraph-shading"),
+	ParagraphShadingBottomOffset: css("paragraph-shading"),
+	ParagraphShadingLeftOffset: css("paragraph-shading"),
+	ParagraphShadingRightOffset: css("paragraph-shading"),
+	ParagraphShadingTopLeftCornerOption: css("paragraph-shading"),
+	ParagraphShadingTopLeftCornerRadius: css("paragraph-shading"),
+	ParagraphShadingTopRightCornerOption: css("paragraph-shading"),
+	ParagraphShadingTopRightCornerRadius: css("paragraph-shading"),
+	ParagraphShadingBottomLeftCornerOption: css("paragraph-shading"),
+	ParagraphShadingBottomLeftCornerRadius: css("paragraph-shading"),
+	ParagraphShadingBottomRightCornerOption: css("paragraph-shading"),
+	ParagraphShadingBottomRightCornerRadius: css("paragraph-shading"),
+	ParagraphShadingWidth: css("paragraph-shading"),
+	ParagraphShadingTopOrigin: css("paragraph-shading"),
+	ParagraphShadingBottomOrigin: css("paragraph-shading"),
+	ParagraphShadingClipToFrame: css("paragraph-shading"),
+	ParagraphShadingSuppressPrinting: css("paragraph-shading"),
 	ParagraphDirection: { kind: "direction" },
 	AppliedLanguage: { kind: "language" },
 	AppliedFont: { kind: "font" },

package/dist/style-property-report.js

@@ -99,11 +99,6 @@ const SWITCHED_GROUPS = [
 		enabled: (values) => truthy(values.ParagraphBorderOn),
 		reportAs: "ParagraphBorderOn"
 	},
-	{
-		matches: (name) => name.startsWith("ParagraphShading"),
-		enabled: (values) => truthy(values.ParagraphShadingOn),
-		reportAs: "ParagraphShadingOn"
-	},
 	{
 		matches: (name) => name.startsWith("Underline"),
 		enabled: (values) => truthy(values.Underline) || values.Underline === "Underline",
@@ -192,6 +187,22 @@ function activeIdmlValue(value) {
 function isHyphenationProperty(name) {
 	return name.startsWith("Hyphenat") || name === "HyphenWeight" || name === "ProviderHyphenationStyle";
 }
+function alwaysHandledElsewhere(name) {
+	return isHyphenationProperty(name) || JUSTIFICATION_SETTINGS.has(name) || [
+		"EmptyGrepStyles",
+		"EmptyNestedStyles",
+		"EmptyLineStyles"
+	].includes(name);
+}
+const COLLECTION_PROPERTIES = /* @__PURE__ */ new Set([
+	"AllGREPStyles",
+	"AllNestedStyles",
+	"AllLineStyles",
+	"TabList"
+]);
+function isCollectionProperty(name) {
+	return COLLECTION_PROPERTIES.has(name);
+}
 function groupedProperties(names, resolved) {
 	const output = [];
 	if (names.some(isHyphenationProperty) && truthy(resolved.Hyphenation)) output.push("Hyphenation");
@@ -204,17 +215,9 @@ function groupedProperties(names, resolved) {
 }
 function reportableProperty(name, value, resolved, root) {
 	if (stylePropertyMapping(name)) return void 0;
-	if (isHyphenationProperty(name) || JUSTIFICATION_SETTINGS.has(name)) return void 0;
-	if ([
-		"EmptyGrepStyles",
-		"EmptyNestedStyles",
-		"EmptyLineStyles"
-	].includes(name)) return void 0;
-	if ([
-		"AllGREPStyles",
-		"AllNestedStyles",
-		"AllLineStyles"
-	].includes(name) || name === "TabList") return hasEntries(value) ? name : void 0;
+	if (alwaysHandledElsewhere(name)) return void 0;
+	if (isCollectionProperty(name)) return hasEntries(value) ? name : void 0;
+	if (name.startsWith("ParagraphShading")) return truthy(resolved.ParagraphShadingOn) && activeIdmlValue(value) ? name : void 0;
 	const switched = SWITCHED_GROUPS.find((group) => group.matches(name));
 	if (switched) return switched.enabled(resolved) ? switched.reportAs : void 0;
 	if ((CJK_PREFIXES.some((prefix) => name.startsWith(prefix)) || CJK_PROPERTIES.has(name)) && !isCjkLanguage(resolved.AppliedLanguage)) return void 0;