@segnavia/idml 0.28.0 → 0.29.0

package/dist/style-mappings.js

@@ -0,0 +1,52 @@
+//#region src/style-mappings.ts
+const css = (name) => ({
+	kind: "css",
+	css: name
+});
+const nonFormatting = { kind: "non-formatting" };
+const STYLE_PROPERTY_MAPPINGS = {
+	PointSize: css("font-size"),
+	Leading: css("line-height"),
+	AutoLeading: css("line-height"),
+	Tracking: css("letter-spacing"),
+	SpaceBefore: css("margin-block-start"),
+	SpaceAfter: css("margin-block-end"),
+	FirstLineIndent: css("text-indent"),
+	Capitalization: css("capitalization"),
+	Underline: css("text-decoration-line"),
+	FillColor: css("color"),
+	LeftIndent: css("padding-inline"),
+	RightIndent: css("padding-inline"),
+	Justification: css("text-align"),
+	KeepWithNext: css("keeps"),
+	KeepLinesTogether: css("keeps"),
+	KeepAllLinesTogether: css("keeps"),
+	KeepFirstLines: css("keeps"),
+	KeepLastLines: css("keeps"),
+	StartParagraph: css("starts"),
+	ParagraphDirection: { kind: "direction" },
+	AppliedLanguage: { kind: "language" },
+	AppliedFont: { kind: "font" },
+	FontStyle: { kind: "font" },
+	SpanColumnType: { kind: "columns" },
+	Self: nonFormatting,
+	Name: nonFormatting,
+	BasedOn: nonFormatting,
+	AppliedParagraphStyle: nonFormatting,
+	AppliedCharacterStyle: nonFormatting,
+	EmitCss: nonFormatting,
+	StyleUniqueId: nonFormatting,
+	KeyboardShortcut: nonFormatting,
+	ExtendedKeyboardShortcut: nonFormatting,
+	Imported: nonFormatting,
+	PreviewColor: nonFormatting,
+	IncludeClass: nonFormatting,
+	EpubAriaRole: nonFormatting,
+	SplitDocument: nonFormatting,
+	NextStyle: nonFormatting
+};
+function stylePropertyMapping(name) {
+	return STYLE_PROPERTY_MAPPINGS[name];
+}
+//#endregion
+export { STYLE_PROPERTY_MAPPINGS, stylePropertyMapping };

package/dist/style-property-report.js

@@ -0,0 +1,236 @@
+import { stylePropertyMapping } from "./style-mappings.js";
+//#region src/style-property-report.ts
+const INDESIGN_PROPERTY_DEFAULTS = {
+	HorizontalScale: [100],
+	VerticalScale: [100],
+	Skew: [0],
+	BaselineShift: [0],
+	DesiredWordSpacing: [100],
+	MinimumWordSpacing: [80],
+	MaximumWordSpacing: [133],
+	DesiredLetterSpacing: [0],
+	MinimumLetterSpacing: [0],
+	MaximumLetterSpacing: [0],
+	DesiredGlyphScaling: [100],
+	MinimumGlyphScaling: [100],
+	MaximumGlyphScaling: [100],
+	FillTint: [-1, 100],
+	KerningMethod: ["$ID/Metrics"],
+	Ligatures: [true],
+	OTFContextualAlternate: [true],
+	OTFMark: [true],
+	OTFFigureStyle: ["Default"],
+	OTFLocale: [true],
+	PositionalForm: ["None"],
+	CharacterAlignment: ["AlignEmCenter"],
+	DigitsType: ["DefaultDigits"],
+	CharacterDirection: ["DefaultDirection"],
+	DiacriticPosition: ["OpentypePositionFromBaseline"],
+	XOffsetDiacritic: [0],
+	YOffsetDiacritic: [0],
+	Kashidas: ["DefaultKashidas"],
+	ParagraphKashidaWidth: [2],
+	ParagraphJustification: ["DefaultJustification"],
+	GlyphForm: ["None"],
+	MiterLimit: [4],
+	EndJoin: ["MiterEndJoin"],
+	NoBreak: [false],
+	SingleWordJustification: ["LeftAlign"],
+	"OTF*": [false]
+};
+const JUSTIFICATION_SETTINGS = /* @__PURE__ */ new Set([
+	"DesiredWordSpacing",
+	"MinimumWordSpacing",
+	"MaximumWordSpacing",
+	"DesiredLetterSpacing",
+	"MinimumLetterSpacing",
+	"MaximumLetterSpacing",
+	"DesiredGlyphScaling",
+	"MinimumGlyphScaling",
+	"MaximumGlyphScaling",
+	"SingleWordJustification"
+]);
+const CJK_PREFIXES = [
+	"Kinsoku",
+	"Shatai",
+	"CjkGrid",
+	"Grid",
+	"AutoTcy"
+];
+const CJK_PROPERTIES = /* @__PURE__ */ new Set([
+	"Mojikumi",
+	"Jidori",
+	"Rensuuji",
+	"BunriKinshi",
+	"Tsume",
+	"LeadingAki",
+	"TrailingAki",
+	"Gyoudori",
+	"ParagraphGyoudori",
+	"KeyboardDirection",
+	"TreatIdeographicSpaceAsSpace",
+	"CharacterRotation",
+	"RotateSingleByteCharacters"
+]);
+function truthy(value) {
+	return value?.trim().toLowerCase() === "true";
+}
+function notNone(value) {
+	const normalized = value?.trim().toLowerCase();
+	return Boolean(normalized && ![
+		"none",
+		"$id/none",
+		"nolist"
+	].includes(normalized));
+}
+const SWITCHED_GROUPS = [
+	{
+		matches: (name) => name.startsWith("RuleAbove"),
+		enabled: (values) => truthy(values.RuleAbove),
+		reportAs: "RuleAbove"
+	},
+	{
+		matches: (name) => name.startsWith("RuleBelow"),
+		enabled: (values) => truthy(values.RuleBelow),
+		reportAs: "RuleBelow"
+	},
+	{
+		matches: (name) => name.startsWith("ParagraphBorder"),
+		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",
+		reportAs: "Underline"
+	},
+	{
+		matches: (name) => name.startsWith("StrikeThrough") || name.startsWith("StrikeThru"),
+		enabled: (values) => truthy(values.StrikeThru ?? values.StrikeThrough),
+		reportAs: "StrikeThru"
+	},
+	{
+		matches: (name) => name.startsWith("Bullets") || name.startsWith("Numbering"),
+		enabled: (values) => notNone(values.BulletsAndNumberingListType),
+		reportAs: "BulletsAndNumberingListType"
+	},
+	{
+		matches: (name) => name.startsWith("DropCap") || name === "DropcapDetail",
+		enabled: (values) => Number(values.DropCapLines) > 0,
+		reportAs: "DropCapLines"
+	},
+	{
+		matches: (name) => name.startsWith("Kenten"),
+		enabled: (values) => notNone(values.KentenKind),
+		reportAs: "KentenKind"
+	},
+	{
+		matches: (name) => name.startsWith("Ruby"),
+		enabled: (values) => truthy(values.RubyFlag),
+		reportAs: "RubyFlag"
+	},
+	{
+		matches: (name) => name.startsWith("Warichu"),
+		enabled: (values) => truthy(values.Warichu),
+		reportAs: "Warichu"
+	},
+	{
+		matches: (name) => name.startsWith("Tatechuyoko"),
+		enabled: (values) => truthy(values.Tatechuyoko),
+		reportAs: "Tatechuyoko"
+	},
+	{
+		matches: (name) => name.startsWith("Gradient"),
+		enabled: (values) => [values.FillColor, values.StrokeColor].some((value) => value?.toLowerCase().includes("gradient")),
+		reportAs: "Gradient"
+	},
+	{
+		matches: (name) => name.startsWith("Stroke"),
+		enabled: (values) => Number(values.StrokeWeight) > 0 && notNone(values.StrokeColor),
+		reportAs: "Stroke"
+	}
+];
+function equalsDefault(name, value) {
+	const defaults = INDESIGN_PROPERTY_DEFAULTS[name] ?? (name.startsWith("OTF") ? INDESIGN_PROPERTY_DEFAULTS["OTF*"] : void 0);
+	if (!defaults) return false;
+	const normalized = value.trim().toLowerCase();
+	return defaults.some((candidate) => String(candidate).toLowerCase() === normalized);
+}
+function hasEntries(value) {
+	const normalized = value?.trim().toLowerCase();
+	return Boolean(normalized && ![
+		"false",
+		"0",
+		"none",
+		"$id/none",
+		"[]"
+	].includes(normalized));
+}
+function isCjkLanguage(value) {
+	return /(?:chinese|japanese|korean|^zh(?:-|$)|^ja(?:-|$)|^ko(?:-|$))/i.test(value ?? "");
+}
+function activeIdmlValue(value) {
+	const normalized = value.trim().toLowerCase();
+	if (!normalized || [
+		"false",
+		"none",
+		"nothing",
+		"$id/none",
+		"$id/nothing",
+		"n",
+		"no",
+		"off"
+	].includes(normalized)) return false;
+	const numbers = normalized.split(/[\s,]+/).map(Number);
+	return numbers.length === 0 || !numbers.every((number) => Number.isFinite(number) && number === 0);
+}
+function isHyphenationProperty(name) {
+	return name.startsWith("Hyphenat") || name === "HyphenWeight" || name === "ProviderHyphenationStyle";
+}
+function groupedProperties(names, resolved) {
+	const output = [];
+	if (names.some(isHyphenationProperty) && truthy(resolved.Hyphenation)) output.push("Hyphenation");
+	const changedJustification = [...JUSTIFICATION_SETTINGS].some((name) => {
+		const value = resolved[name];
+		return value !== void 0 && !equalsDefault(name, value);
+	});
+	if (names.some((name) => JUSTIFICATION_SETTINGS.has(name)) && changedJustification) output.push("JustificationSettings");
+	return output;
+}
+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;
+	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;
+	if (equalsDefault(name, value)) return void 0;
+	return !root || activeIdmlValue(value) ? name : void 0;
+}
+function reportableStyleProperties(source, resolved, root = false) {
+	const names = Object.keys(source);
+	const output = new Set(groupedProperties(names, resolved));
+	for (const name of names) {
+		const value = source[name];
+		if (value === void 0) continue;
+		const reported = reportableProperty(name, value, resolved, root);
+		if (reported) output.add(reported);
+	}
+	return [...output];
+}
+//#endregion
+export { INDESIGN_PROPERTY_DEFAULTS, activeIdmlValue, reportableStyleProperties };

package/dist/styles.js

@@ -0,0 +1,285 @@
+import { stylePropertyMapping } from "./style-mappings.js";
+import { reportableStyleProperties } from "./style-property-report.js";
+import { idmlDirection, localName } from "./xml.js";
+import { isTag } from "domhandler";
+//#region src/styles.ts
+const PARAGRAPH_ROOT = "$ID/[No paragraph style]";
+const CHARACTER_ROOT = "$ID/[No character style]";
+function text(element) {
+	return element.children.map((child) => "data" in child ? child.data : isTag(child) ? text(child) : "").join("").trim();
+}
+function properties(element) {
+	const result = { ...element.attribs };
+	const holder = element.children.find((child) => isTag(child) && localName(child.name) === "Properties");
+	for (const child of holder?.children ?? []) {
+		if (!isTag(child)) continue;
+		const value = text(child);
+		if (value || child.children.some(isTag)) result[localName(child.name)] = value || "[entry]";
+	}
+	return result;
+}
+function parseStyles(roots, part) {
+	const result = [];
+	for (const kind of ["ParagraphStyle", "CharacterStyle"]) for (const element of roots.filter((candidate) => localName(candidate.name) === kind)) {
+		const values = properties(element);
+		const id = values.Self;
+		if (!id) continue;
+		result.push({
+			id,
+			name: values.Name ?? id.split("/").at(-1) ?? id,
+			kind: kind === "ParagraphStyle" ? "paragraph" : "character",
+			...values.BasedOn ? { basedOn: values.BasedOn } : {},
+			properties: Object.fromEntries(Object.entries(values).filter(([name]) => ![
+				"Self",
+				"Name",
+				"BasedOn"
+			].includes(name))),
+			location: `${part}#${id}`
+		});
+	}
+	return result;
+}
+function parseSwatches(roots) {
+	const result = [];
+	for (const element of roots.filter((candidate) => localName(candidate.name) === "Color")) {
+		const id = element.attribs.Self;
+		if (!id) continue;
+		const name = element.attribs.Name ?? id;
+		const space = element.attribs.Space;
+		const values = (element.attribs.ColorValue ?? "").trim().split(/\s+/).map(Number).filter(Number.isFinite);
+		const model = element.attribs.Model === "Spot" ? "spot" : space === "RGB" ? "rgb" : space === "CMYK" ? "cmyk" : "named";
+		result.push({
+			id,
+			name,
+			model,
+			...values.length > 0 ? { values } : {}
+		});
+	}
+	return result;
+}
+function rootName(kind) {
+	return kind === "paragraph" ? PARAGRAPH_ROOT : CHARACTER_ROOT;
+}
+function slug(value) {
+	return value.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "style";
+}
+const LANGUAGES = {
+	"$ID/Hebrew": "he",
+	"$ID/English: USA": "en-US",
+	"$ID/English: UK": "en-GB",
+	"$ID/French": "fr",
+	"$ID/German": "de",
+	"$ID/Spanish": "es",
+	"$ID/Italian": "it",
+	"$ID/Arabic": "ar"
+};
+function hasCssMapping(names, css) {
+	return [...names].some((name) => {
+		const mapping = stylePropertyMapping(name);
+		return mapping?.kind === "css" && mapping.css === css;
+	});
+}
+function textDeclarations(values, mapped, output) {
+	if (mapped.has("Capitalization") && values.Capitalization === "SmallCaps") output.push("font-variant-caps:small-caps");
+	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");
+}
+var StyleMapper = class {
+	swatches;
+	report;
+	bookDirection;
+	byId;
+	classes = /* @__PURE__ */ new Map();
+	used = /* @__PURE__ */ new Set();
+	overrides = /* @__PURE__ */ new Map();
+	reportedStyleProperties = /* @__PURE__ */ new Set();
+	constructor(styles, swatches, report, bookDirection) {
+		this.swatches = swatches;
+		this.report = report;
+		this.bookDirection = bookDirection;
+		this.byId = new Map(styles.map((style) => [style.id, style]));
+		const taken = /* @__PURE__ */ new Set();
+		for (const style of styles) {
+			const base = `${style.kind === "paragraph" ? "idml-p-" : "idml-c-"}${slug(style.name)}`;
+			let candidate = base;
+			let suffix = 2;
+			while (taken.has(candidate)) candidate = `${base}-${suffix++}`;
+			taken.add(candidate);
+			this.classes.set(style.id, candidate);
+		}
+	}
+	flattened(id, kind) {
+		return Object.assign({}, ...this.styleChain(id, kind).map((style) => style.properties));
+	}
+	styleChain(id, kind) {
+		const root = this.rootStyle(kind);
+		const chain = [];
+		const seen = /* @__PURE__ */ new Set();
+		let current = this.findStyle(id, kind);
+		while (current && !seen.has(current.id)) {
+			seen.add(current.id);
+			chain.unshift(current);
+			current = this.findStyle(current.basedOn, kind);
+		}
+		if (root && !chain.includes(root)) chain.unshift(root);
+		return chain;
+	}
+	styleClass(id, _kind) {
+		if (!id || id.includes("[None]") || id.includes("[No character style]")) return void 0;
+		const style = this.findStyle(id, _kind);
+		const value = style ? this.classes.get(style.id) : void 0;
+		if (value && style) this.used.add(style.id);
+		return value;
+	}
+	overrideClass(values, base, directionValue, location, styleDirection) {
+		const changed = Object.fromEntries(Object.entries(values).filter(([name, value]) => stylePropertyMapping(name)?.kind !== "non-formatting" && value !== base[name]));
+		const resolved = {
+			...base,
+			...values
+		};
+		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"));
+		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];
+		}
+		if (Object.keys(cssProperties).length === 0) return void 0;
+		const key = JSON.stringify(Object.entries(cssProperties).sort(([a], [b]) => a.localeCompare(b))) + directionValue;
+		const found = this.overrides.get(key);
+		if (found) return found.name;
+		const name = `idml-o-${this.overrides.size + 1}`;
+		this.overrides.set(key, {
+			name,
+			properties: cssProperties,
+			direction: directionValue
+		});
+		return name;
+	}
+	paragraphDirection(properties) {
+		return idmlDirection(properties.ParagraphDirection);
+	}
+	paragraphStyleDirection(properties) {
+		return this.paragraphDirection(properties) ?? this.bookDirection;
+	}
+	language(value, location) {
+		if (!value) return void 0;
+		const known = LANGUAGES[value];
+		if (!known) this.report.add(this.report.unsupportedLanguages, value, location);
+		return known;
+	}
+	rootLanguage() {
+		const root = this.rootStyle("paragraph");
+		return this.language(root?.properties.AppliedLanguage, root?.location ?? "Resources/Styles.xml");
+	}
+	css() {
+		const rules = [];
+		for (const id of this.used) {
+			const style = this.byId.get(id);
+			const name = this.classes.get(id);
+			if (!style || !name) continue;
+			const values = this.flattened(id, style.kind);
+			this.reportUnmappedStyleProperties(style);
+			this.report.font(values.AppliedFont, values.FontStyle, style.location);
+			const dir = style.kind === "paragraph" ? this.paragraphStyleDirection(values) : this.bookDirection;
+			const declarations = this.declarations(values, dir, style.location);
+			rules.push(`.${name}{${declarations}}`);
+		}
+		for (const value of this.overrides.values()) {
+			const declarations = this.declarations(value.properties, value.direction, value.name, this.report.unsupportedOverrideProperties);
+			if (declarations) rules.push(`.${value.name}{${declarations}}`);
+		}
+		return rules.join("");
+	}
+	declarations(values, dir, location, unsupported = this.report.unsupportedStyleProperties) {
+		const output = [];
+		const mapped = new Set(Object.keys(values).filter((name) => stylePropertyMapping(name)?.kind === "css"));
+		const pt = (name, property) => {
+			if (!mapped.has(name)) return;
+			const value = Number(values[name]);
+			if (Number.isFinite(value)) output.push(`${property}:${value}pt`);
+		};
+		pt("PointSize", "font-size");
+		if (mapped.has("Leading") && values.Leading === "Auto") output.push(`line-height:${(Number(values.AutoLeading) || 120) / 100}`);
+		else pt("Leading", "line-height");
+		const tracking = Number(values.Tracking);
+		if (mapped.has("Tracking") && Number.isFinite(tracking)) output.push(`letter-spacing:${tracking / 1e3}em`);
+		pt("SpaceBefore", "margin-block-start");
+		pt("SpaceAfter", "margin-block-end");
+		pt("FirstLineIndent", "text-indent");
+		const startIndent = dir === "rtl" ? "RightIndent" : "LeftIndent";
+		const endIndent = dir === "rtl" ? "LeftIndent" : "RightIndent";
+		pt(startIndent, "padding-inline-start");
+		pt(endIndent, "padding-inline-end");
+		textDeclarations(values, mapped, output);
+		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;
+		if (color) output.push(`color:${color}`);
+		return output.join(";");
+	}
+	findStyle(id, kind) {
+		if (!id) return void 0;
+		const exact = this.byId.get(id);
+		if (exact?.kind === kind) return exact;
+		return [...this.byId.values()].find((style) => style.kind === kind && (style.name === id || style.id.endsWith(`/${id}`)));
+	}
+	rootStyle(kind) {
+		return [...this.byId.values()].find((style) => style.kind === kind && (style.name === rootName(kind) || style.id.endsWith(`/${rootName(kind)}`)));
+	}
+	reportUnmappedStyleProperties(style) {
+		const root = this.rootStyle(style.kind);
+		const resolved = {};
+		for (const source of this.styleChain(style.id, style.kind)) {
+			Object.assign(resolved, source.properties);
+			for (const name of reportableStyleProperties(source.properties, resolved, source === root)) {
+				const key = `${source.id}\u0000${name}`;
+				if (this.reportedStyleProperties.has(key)) continue;
+				this.reportedStyleProperties.add(key);
+				this.report.add(this.report.unsupportedStyleProperties, name, source.location);
+			}
+		}
+	}
+	justification(value, dir, output, location, bucket) {
+		if (!value) return;
+		const side = (physical) => physical === (dir === "rtl" ? "right" : "left") ? "start" : "end";
+		if (value === "LeftAlign" || value === "RightAlign") output.push(`text-align:${side(value === "LeftAlign" ? "left" : "right")}`);
+		else if (value === "CenterAlign") output.push("text-align:center");
+		else if (value === "FullyJustified") output.push("text-align:justify", "text-align-last:justify");
+		else if (value.endsWith("Justified")) {
+			output.push("text-align:justify");
+			if (value.startsWith("Left")) output.push(`text-align-last:${side("left")}`);
+			else if (value.startsWith("Right")) output.push(`text-align-last:${side("right")}`);
+			else if (value.startsWith("Center")) output.push("text-align-last:center");
+		} else if (value === "ToBindingSide" || value === "AwayFromBindingSide") this.report.add(bucket, `Justification:${value}`, location);
+	}
+	keeps(values, output) {
+		if ((Number(values.KeepWithNext) || 0) > 0) output.push("break-after:avoid");
+		if (values.KeepLinesTogether === "true" && values.KeepAllLinesTogether === "true") output.push("break-inside:avoid");
+		else if (values.KeepLinesTogether === "true") {
+			const first = Number(values.KeepFirstLines);
+			const last = Number(values.KeepLastLines);
+			if (Number.isInteger(first) && first > 0) output.push(`orphans:${first}`);
+			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/types.d.ts

@@ -0,0 +1,35 @@
+//#region src/types.d.ts
+export interface IdmlTextNode {
+  name: string;
+  attributes: Record<string, string>;
+  text?: string;
+  children: IdmlTextNode[];
+  location: string;
+}
+export interface IdmlStyle {
+  id: string;
+  name: string;
+  kind: 'paragraph' | 'character';
+  basedOn?: string;
+  properties: Record<string, string>;
+  location: string;
+}
+export interface IdmlSwatch {
+  id: string;
+  name: string;
+  model: 'rgb' | 'cmyk' | 'spot' | 'named';
+  values?: number[];
+}
+export interface IdmlFramePreference {
+  columns: number;
+  gutter: number;
+  location?: string;
+}
+export interface IdmlStory {
+  id: string;
+  part: string;
+  direction?: 'ltr' | 'rtl';
+  root?: IdmlTextNode;
+  frame?: IdmlFramePreference;
+}
+//#endregion

package/dist/unsupported-elements.js

@@ -0,0 +1,49 @@
+import { localName } from "./xml.js";
+//#region src/unsupported-elements.ts
+const MAPPED_ELEMENTS = /* @__PURE__ */ new Set([
+	"Document",
+	"DocumentPreference",
+	"MarginPreference",
+	"MasterSpread",
+	"Spread",
+	"Page",
+	"Story",
+	"TextFrame",
+	"Group",
+	"TextFramePreference",
+	"PathGeometry",
+	"GeometryPathType",
+	"PathPointArray",
+	"PathPointType",
+	"Styles",
+	"Graphic",
+	"RootParagraphStyleGroup",
+	"ParagraphStyleGroup",
+	"RootCharacterStyleGroup",
+	"CharacterStyleGroup",
+	"ParagraphStyle",
+	"CharacterStyle",
+	"Color",
+	"Properties"
+]);
+function insideMappedResource(element) {
+	let parent = element.parent;
+	while (parent && "name" in parent) {
+		const name = localName(parent.name);
+		if (name === "ParagraphStyle" || name === "CharacterStyle" || name === "Color") return true;
+		parent = parent.parent;
+	}
+	return false;
+}
+function collectUnsupportedElements(parts, report) {
+	for (const part of parts) {
+		if (part.name.startsWith("Stories/")) continue;
+		for (const element of part.all) {
+			const name = localName(element.name);
+			if (!MAPPED_ELEMENTS.has(name) && !insideMappedResource(element)) report.add(report.unsupportedElements, name, part.name);
+		}
+	}
+	return report.unsupportedElements;
+}
+//#endregion
+export { collectUnsupportedElements };

package/dist/xml.js

@@ -0,0 +1,18 @@
+import { refusal } from "./refusal.js";
+//#region src/xml.ts
+function localName(name) {
+	return name.includes(":") ? name.split(":").at(-1) ?? name : name;
+}
+function numberAttribute(element, name, fallback) {
+	const raw = element?.attribs[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 idmlDirection(value) {
+	const normalized = value?.toLowerCase();
+	if (normalized?.includes("righttoleft")) return "rtl";
+	if (normalized?.includes("lefttoright")) return "ltr";
+}
+//#endregion
+export { idmlDirection, localName, numberAttribute };