@stll/folio-core 0.37.5 → 0.38.0

package/dist/compare/section-boundary-properties.js

@@ -0,0 +1,235 @@
+import { sectionReferenceHistory } from "../docx/sectionReferenceHistory.js";
+import { expectParagraphAttrs } from "../prosemirror/attrs/index.js";
+import { resolveAllChangesInHeadlessStateWithMapping } from "../prosemirror/commands/comments.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
+//#region src/compare/section-boundary-properties.ts
+const withoutChangeHistory = (properties) => {
+	const { propertyChanges: _propertyChanges, ...result } = properties;
+	return result;
+};
+const boundaryChildrenOf = (document) => {
+	const children = [];
+	let hasChangeHistory = false;
+	document.forEach((node, position) => {
+		if (node.type.name !== "paragraph") {
+			children.push({
+				type: "other",
+				nodeType: node.type.name
+			});
+			return;
+		}
+		const sectionProperties = expectParagraphAttrs(node)._sectionProperties;
+		if (sectionProperties?.propertyChanges !== void 0) {
+			hasChangeHistory = true;
+			return;
+		}
+		children.push({
+			type: "paragraph",
+			paragraph: {
+				position,
+				text: node.textContent,
+				sectionProperties
+			}
+		});
+	});
+	return hasChangeHistory ? null : children;
+};
+/**
+* Compare section properties attached to retained top-level paragraph endpoints.
+* A section endpoint cannot be added to or removed from a retained paragraph
+* with `sectPrChange`: its previous payload is still a section endpoint.
+*/
+const compareSectionBoundaryProperties = ({ current, target, mapTargetProperties }) => {
+	const currentChildren = boundaryChildrenOf(current);
+	const targetChildren = boundaryChildrenOf(target);
+	if (!currentChildren || !targetChildren) return {
+		status: "unalignable",
+		detail: "section boundary revision history is unsupported"
+	};
+	if (currentChildren.length !== targetChildren.length) return {
+		status: "unalignable",
+		detail: "section boundary topology differs"
+	};
+	const changes = [];
+	for (const [index, currentChild] of currentChildren.entries()) {
+		const targetChild = targetChildren[index];
+		if (!targetChild || currentChild.type !== targetChild.type) return {
+			status: "unalignable",
+			detail: "section boundary topology differs"
+		};
+		if (currentChild.type === "other" && targetChild.type === "other") {
+			if (currentChild.nodeType !== targetChild.nodeType) return {
+				status: "unalignable",
+				detail: "section boundary topology differs"
+			};
+			continue;
+		}
+		if (currentChild.type !== "paragraph" || targetChild.type !== "paragraph") return {
+			status: "unalignable",
+			detail: "section boundary topology differs"
+		};
+		const currentParagraph = currentChild.paragraph;
+		const targetParagraph = targetChild.paragraph;
+		if (currentParagraph.text !== targetParagraph.text) return {
+			status: "unalignable",
+			detail: "retained paragraph text differs"
+		};
+		const currentProperties = currentParagraph.sectionProperties;
+		const targetProperties = targetParagraph.sectionProperties;
+		if (currentProperties === void 0 || targetProperties === void 0) {
+			if (currentProperties !== targetProperties) return {
+				status: "unalignable",
+				detail: "section endpoint presence differs"
+			};
+			continue;
+		}
+		const currentWithoutHistory = withoutChangeHistory(currentProperties);
+		const mappedTarget = mapTargetProperties ? mapTargetProperties(targetProperties) : targetProperties;
+		if (mappedTarget === null) return {
+			status: "unalignable",
+			detail: "section references cannot be mapped"
+		};
+		const targetWithoutHistory = withoutChangeHistory(mappedTarget);
+		if (canonicalJson(currentWithoutHistory) === canonicalJson(targetWithoutHistory)) continue;
+		changes.push({
+			position: currentParagraph.position,
+			current: currentWithoutHistory,
+			target: targetWithoutHistory
+		});
+	}
+	return {
+		status: "matched",
+		changes
+	};
+};
+const boundaryParagraphEntriesOf = (document) => {
+	const children = boundaryChildrenOf(document);
+	if (!children) return null;
+	return children.flatMap((child) => child.type === "paragraph" ? [child.paragraph] : []);
+};
+/** Stage section deltas after document operations, against the accepted projection. */
+const stageSectionBoundaryProperties = ({ state, target, originalRevisionIdSeed, revisionStamp, author, maxRanges, mapTargetProperties }) => {
+	if (!Number.isSafeInteger(maxRanges) || maxRanges < 0) return { status: "budget-exceeded" };
+	const reviewedState = resolveAllChangesInHeadlessStateWithMapping(state, "accept");
+	const reviewed = boundaryParagraphEntriesOf(reviewedState.state.doc);
+	const targets = boundaryParagraphEntriesOf(target);
+	if (!reviewed || !targets) return {
+		status: "unalignable",
+		detail: "section boundary revision history is unsupported"
+	};
+	if (reviewed.length !== targets.length) return {
+		status: "unalignable",
+		detail: "retained paragraph count differs"
+	};
+	const updates = [];
+	const inverse = reviewedState.mapping.invert();
+	for (const [index, reviewedParagraph] of reviewed.entries()) {
+		const targetParagraph = targets[index];
+		if (!targetParagraph || reviewedParagraph.text !== targetParagraph.text) return {
+			status: "unalignable",
+			detail: `retained paragraph text differs at ${index}`
+		};
+		if (targetParagraph.sectionProperties === void 0) {
+			if (reviewedParagraph.sectionProperties !== void 0) return {
+				status: "unalignable",
+				detail: "section endpoint presence differs"
+			};
+			continue;
+		}
+		const targetProperties = withoutChangeHistory(targetParagraph.sectionProperties);
+		if (reviewedParagraph.sectionProperties !== void 0 && canonicalJson(withoutChangeHistory(reviewedParagraph.sectionProperties)) === canonicalJson(targetProperties)) continue;
+		const mapped = inverse.mapResult(reviewedParagraph.position, 1);
+		if (mapped.deleted) return {
+			status: "unalignable",
+			detail: "boundary has no source position"
+		};
+		const current = state.doc.nodeAt(mapped.pos);
+		if (!current || current.type.name !== "paragraph") return {
+			status: "unalignable",
+			detail: "mapped boundary is not a paragraph"
+		};
+		const attrs = expectParagraphAttrs(current);
+		const currentProperties = attrs._sectionProperties;
+		const marker = attrs.pPrMark;
+		if (marker?.kind === "ins" && marker.info.id >= originalRevisionIdSeed) {
+			if (currentProperties !== void 0) return {
+				status: "unalignable",
+				detail: "inserted endpoint already has section properties"
+			};
+			const staged = mapTargetProperties({
+				kind: "inserted",
+				current: void 0,
+				target: targetProperties
+			});
+			if (!staged || staged.kind !== "inserted") return {
+				status: "unalignable",
+				detail: "inserted section references cannot be mapped"
+			};
+			updates.push({
+				position: mapped.pos,
+				target: staged.target
+			});
+			continue;
+		}
+		if (currentProperties === void 0 || currentProperties.propertyChanges !== void 0) return {
+			status: "unalignable",
+			detail: "retained endpoint cannot carry a section change"
+		};
+		const staged = mapTargetProperties({
+			kind: "retained",
+			current: withoutChangeHistory(currentProperties),
+			target: targetProperties
+		});
+		if (!staged || staged.kind !== "retained") return {
+			status: "unalignable",
+			detail: "retained section references cannot be mapped"
+		};
+		updates.push({
+			position: mapped.pos,
+			previous: staged.previous,
+			target: staged.target
+		});
+	}
+	if (updates.length > maxRanges) return { status: "budget-exceeded" };
+	let nextRevisionId = revisionStamp.idSeed;
+	let transaction = state.tr;
+	for (const update of updates.toSorted((left, right) => right.position - left.position)) {
+		const position = transaction.mapping.map(update.position, 1);
+		const node = transaction.doc.nodeAt(position);
+		if (!node || node.type.name !== "paragraph") return {
+			status: "unalignable",
+			detail: "boundary moved while staging"
+		};
+		const previousReferences = update.previous === void 0 ? void 0 : sectionReferenceHistory({
+			previous: update.previous,
+			target: update.target
+		});
+		const propertyChanges = update.previous === void 0 ? void 0 : [{
+			type: "sectionPropertyChange",
+			info: {
+				id: nextRevisionId++,
+				author,
+				date: revisionStamp.date
+			},
+			previousProperties: update.previous,
+			...previousReferences !== void 0 && { previousReferences },
+			currentProperties: update.target
+		}];
+		transaction = transaction.setNodeMarkup(position, void 0, {
+			...node.attrs,
+			_sectionProperties: {
+				...update.target,
+				...propertyChanges === void 0 ? {} : { propertyChanges }
+			},
+			sectionBreakType: update.target.sectionStart ?? null
+		});
+	}
+	return {
+		status: "matched",
+		transaction,
+		nextRevisionId,
+		rangeCount: updates.length
+	};
+};
+//#endregion
+export { compareSectionBoundaryProperties, stageSectionBoundaryProperties };

package/dist/compare/style-resources.d.ts

@@ -0,0 +1,30 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/compare/style-resources.d.ts
+type ImportReferencedStyleDefinitionsOptions = {
+  sourceStyles: document_d_exports.StyleDefinitions | undefined;
+  destinationStyles: document_d_exports.StyleDefinitions | undefined;
+  sourceTheme: document_d_exports.Theme | undefined;
+  destinationTheme: document_d_exports.Theme | undefined;
+  referencedStyleIds: readonly string[];
+  reservedStyleIds?: readonly string[];
+  materializeDefaultParagraphStyle?: boolean;
+};
+type ImportReferencedStyleDefinitionsResult = {
+  status: "unchanged" | "imported";
+  styles: document_d_exports.StyleDefinitions | undefined;
+  styleIdMap: ReadonlyMap<string, string>;
+  importedStyleIds: readonly string[];
+  defaultParagraphStyleId?: string;
+} | {
+  status: "unalignable";
+  detail: string;
+};
+/**
+ * Add the target style definitions required by a comparison without changing
+ * existing package resources. A referenced style is only portable when both
+ * packages have the same document defaults and theme: those resources take
+ * part in OOXML style resolution even when a style definition itself is new.
+ */
+declare const importReferencedStyleDefinitions: ({ sourceStyles, destinationStyles, sourceTheme, destinationTheme, referencedStyleIds, reservedStyleIds, materializeDefaultParagraphStyle }: ImportReferencedStyleDefinitionsOptions) => ImportReferencedStyleDefinitionsResult;
+//#endregion
+export { ImportReferencedStyleDefinitionsOptions, ImportReferencedStyleDefinitionsResult, importReferencedStyleDefinitions };

package/dist/compare/style-resources.js

@@ -0,0 +1,404 @@
+import { createStyleResolver } from "../prosemirror/styles/styleResolver.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
+import { resolveColorToHex } from "../utils/colorResolver.js";
+import { resolveThemeFont } from "../utils/fontResolver.js";
+//#region src/compare/style-resources.ts
+const styleDependencies = ({ basedOn, link, next }) => [
+	basedOn,
+	link,
+	next
+].filter((styleId) => styleId !== void 0);
+const themesMatch = (sourceTheme, destinationTheme) => canonicalJson(sourceTheme) === canonicalJson(destinationTheme);
+const hasThemeReference = (value) => {
+	if (Array.isArray(value)) return value.some(hasThemeReference);
+	if (typeof value !== "object" || value === null) return false;
+	return Object.entries(value).some(([key, nested]) => key.toLowerCase().includes("theme") || hasThemeReference(nested));
+};
+const materializeThemeColor = (color, theme) => {
+	if (!color || !color.themeColor) return color;
+	const rgb = resolveColorToHex(color, theme);
+	if (!rgb) return void 0;
+	const { themeColor: _themeColor, themeTint: _themeTint, themeShade: _themeShade, ...plain } = color;
+	return {
+		...plain,
+		rgb
+	};
+};
+const languageForThemeFontSlot = ({ formatting, slot }) => {
+	if (slot === "eastAsia") return formatting.language?.eastAsia ?? formatting.language?.val;
+	if (slot === "cs") return formatting.language?.bidi ?? formatting.language?.val;
+	return formatting.language?.val;
+};
+const scriptForLanguage = (language) => {
+	if (!language || typeof Intl.Locale !== "function") return void 0;
+	try {
+		return new Intl.Locale(language).maximize().script;
+	} catch {
+		return;
+	}
+};
+const resolveThemeFontForFormatting = ({ formatting, slot, theme, themeRef }) => {
+	const script = scriptForLanguage(languageForThemeFontSlot({
+		formatting,
+		slot
+	}));
+	const themeFont = themeRef.toLowerCase().startsWith("major") ? theme?.fontScheme?.majorFont : theme?.fontScheme?.minorFont;
+	return (script ? themeFont?.fonts?.[script] : void 0) || resolveThemeFont(themeRef, theme?.fontScheme);
+};
+const materializeThemeTextFormatting = (formatting, theme, materializeThemeReferences) => {
+	if (!formatting) return {
+		status: "ok",
+		formatting
+	};
+	if (!materializeThemeReferences) return {
+		status: "ok",
+		formatting
+	};
+	if (hasThemeReference(formatting.shading)) return { status: "unalignable" };
+	const color = materializeThemeColor(formatting.color, theme);
+	if (formatting.color?.themeColor && !color) return { status: "unalignable" };
+	const underlineColor = materializeThemeColor(formatting.underline?.color, theme);
+	if (formatting.underline?.color?.themeColor && !underlineColor) return { status: "unalignable" };
+	const { asciiTheme: _asciiTheme, hAnsiTheme: _hAnsiTheme, eastAsiaTheme: _eastAsiaTheme, csTheme: _csTheme, ...fontFamily } = formatting.fontFamily ?? {};
+	const themeFonts = formatting.fontFamily;
+	const resolvedAscii = themeFonts?.asciiTheme ? resolveThemeFontForFormatting({
+		formatting,
+		slot: "ascii",
+		theme,
+		themeRef: themeFonts.asciiTheme
+	}) : null;
+	const resolvedHAnsi = themeFonts?.hAnsiTheme ? resolveThemeFontForFormatting({
+		formatting,
+		slot: "hAnsi",
+		theme,
+		themeRef: themeFonts.hAnsiTheme
+	}) : null;
+	const resolvedEastAsia = themeFonts?.eastAsiaTheme ? resolveThemeFontForFormatting({
+		formatting,
+		slot: "eastAsia",
+		theme,
+		themeRef: themeFonts.eastAsiaTheme
+	}) : null;
+	const resolvedCs = themeFonts?.csTheme ? resolveThemeFontForFormatting({
+		formatting,
+		slot: "cs",
+		theme,
+		themeRef: themeFonts.csTheme
+	}) : null;
+	if (themeFonts?.asciiTheme && !resolvedAscii || themeFonts?.hAnsiTheme && !resolvedHAnsi || themeFonts?.eastAsiaTheme && !resolvedEastAsia || themeFonts?.csTheme && !resolvedCs) return { status: "unalignable" };
+	return {
+		status: "ok",
+		formatting: {
+			...formatting,
+			...formatting.color && color && { color },
+			...formatting.underline && { underline: {
+				...formatting.underline,
+				...underlineColor && { color: underlineColor }
+			} },
+			...formatting.fontFamily && { fontFamily: {
+				...fontFamily,
+				...resolvedAscii && { ascii: resolvedAscii },
+				...resolvedHAnsi && { hAnsi: resolvedHAnsi },
+				...resolvedEastAsia && { eastAsia: resolvedEastAsia },
+				...resolvedCs && { cs: resolvedCs }
+			} }
+		}
+	};
+};
+const materializeEffectiveStyle = ({ style, styles, theme, materializeThemeReferences }) => {
+	if (style.type === "numbering") return { status: "unalignable" };
+	const resolver = createStyleResolver(styles);
+	const resolved = style.type === "character" ? {
+		paragraphFormatting: void 0,
+		runFormatting: resolver.resolveRunStyle(style.styleId)
+	} : resolver.resolveParagraphStyle(style.styleId);
+	if (materializeThemeReferences && hasThemeReference(resolved.paragraphFormatting)) return { status: "unalignable" };
+	const runFormatting = materializeThemeTextFormatting(resolved.runFormatting, theme, materializeThemeReferences);
+	if (runFormatting.status === "unalignable") return runFormatting;
+	const conditionalStyles = [];
+	for (const conditional of style.tblStylePr ?? []) {
+		if (materializeThemeReferences && hasThemeReference(conditional.pPr)) return { status: "unalignable" };
+		const conditionalRunFormatting = materializeThemeTextFormatting(conditional.rPr, theme, materializeThemeReferences);
+		if (conditionalRunFormatting.status === "unalignable") return { status: "unalignable" };
+		conditionalStyles.push({
+			...conditional,
+			...conditionalRunFormatting.formatting && { rPr: conditionalRunFormatting.formatting }
+		});
+	}
+	const { basedOn: _basedOn, ...independent } = style;
+	return {
+		status: "ok",
+		style: {
+			...independent,
+			...(style.type === "paragraph" || style.type === "table") && resolved.paragraphFormatting && { pPr: resolved.paragraphFormatting },
+			...runFormatting.formatting && { rPr: runFormatting.formatting },
+			...style.tblStylePr && { tblStylePr: conditionalStyles }
+		}
+	};
+};
+const materializeEffectiveDefaultParagraphStyle = ({ styles, destinationStyles, theme, styleId, materializeThemeReferences }) => {
+	const resolved = createStyleResolver(styles).resolveParagraphStyle(void 0);
+	const destinationResolved = createStyleResolver(destinationStyles).resolveParagraphStyle(void 0);
+	if (materializeThemeReferences && hasThemeReference(resolved.paragraphFormatting)) return { status: "unalignable" };
+	const runFormatting = materializeThemeTextFormatting(resolved.runFormatting, theme, materializeThemeReferences);
+	if (runFormatting.status === "unalignable") return runFormatting;
+	const sourceParagraphFormatting = resolved.paragraphFormatting;
+	const destinationParagraphFormatting = destinationResolved.paragraphFormatting;
+	const materializedSpacing = {
+		...sourceParagraphFormatting?.spaceBefore === void 0 && destinationParagraphFormatting?.spaceBefore !== void 0 && { spaceBefore: 0 },
+		...sourceParagraphFormatting?.spaceAfter === void 0 && destinationParagraphFormatting?.spaceAfter !== void 0 && { spaceAfter: 0 },
+		...sourceParagraphFormatting?.lineSpacing === void 0 && destinationParagraphFormatting?.lineSpacing !== void 0 && { lineSpacing: 240 },
+		...sourceParagraphFormatting?.lineSpacingRule === void 0 && destinationParagraphFormatting?.lineSpacingRule !== void 0 && { lineSpacingRule: "auto" },
+		...sourceParagraphFormatting?.beforeAutospacing === void 0 && destinationParagraphFormatting?.beforeAutospacing !== void 0 && { beforeAutospacing: false },
+		...sourceParagraphFormatting?.afterAutospacing === void 0 && destinationParagraphFormatting?.afterAutospacing !== void 0 && { afterAutospacing: false }
+	};
+	const paragraphFormatting = sourceParagraphFormatting || Object.keys(materializedSpacing).length > 0 ? {
+		...sourceParagraphFormatting,
+		...materializedSpacing
+	} : void 0;
+	return {
+		status: "ok",
+		style: {
+			styleId,
+			type: "paragraph",
+			...paragraphFormatting && { pPr: paragraphFormatting },
+			...runFormatting.formatting && { rPr: runFormatting.formatting }
+		}
+	};
+};
+const effectiveDefaultParagraphFormattingMatches = ({ sourceStyles, destinationStyles, sourceTheme, destinationTheme, materializeThemeReferences }) => {
+	const sourceResolved = createStyleResolver(sourceStyles).resolveParagraphStyle(void 0);
+	const destinationResolved = createStyleResolver(destinationStyles).resolveParagraphStyle(void 0);
+	const sourceRunFormatting = materializeThemeTextFormatting(sourceResolved.runFormatting, sourceTheme, materializeThemeReferences);
+	const destinationRunFormatting = materializeThemeTextFormatting(destinationResolved.runFormatting, destinationTheme, materializeThemeReferences);
+	if (sourceRunFormatting.status === "unalignable" || destinationRunFormatting.status === "unalignable" || materializeThemeReferences && hasThemeReference(sourceResolved.paragraphFormatting) || materializeThemeReferences && hasThemeReference(destinationResolved.paragraphFormatting)) return false;
+	return canonicalJson({
+		pPr: sourceResolved.paragraphFormatting,
+		rPr: sourceRunFormatting.formatting
+	}) === canonicalJson({
+		pPr: destinationResolved.paragraphFormatting,
+		rPr: destinationRunFormatting.formatting
+	});
+};
+const nextAvailableStyleAlias = ({ taken, sequence }) => {
+	let candidate = `FolioImportedStyle${sequence}`;
+	let suffix = sequence;
+	while (taken.has(candidate)) {
+		suffix += 1;
+		candidate = `FolioImportedStyle${suffix}`;
+	}
+	return candidate;
+};
+const remapImportedStyle = ({ style, styleIdMap, isolatedDefaultStyleIds }) => {
+	const { default: _default, ...withoutDefault } = style;
+	return {
+		...isolatedDefaultStyleIds.has(style.styleId) ? withoutDefault : style,
+		styleId: styleIdMap.get(style.styleId) ?? style.styleId,
+		...style.basedOn !== void 0 && { basedOn: styleIdMap.get(style.basedOn) ?? style.basedOn },
+		...style.link !== void 0 && { link: styleIdMap.get(style.link) ?? style.link },
+		...style.next !== void 0 && { next: styleIdMap.get(style.next) ?? style.next }
+	};
+};
+/**
+* Add the target style definitions required by a comparison without changing
+* existing package resources. A referenced style is only portable when both
+* packages have the same document defaults and theme: those resources take
+* part in OOXML style resolution even when a style definition itself is new.
+*/
+const importReferencedStyleDefinitions = ({ sourceStyles, destinationStyles, sourceTheme, destinationTheme, referencedStyleIds, reservedStyleIds = [], materializeDefaultParagraphStyle = false }) => {
+	const requested = [...new Set(referencedStyleIds)].toSorted();
+	if (requested.length === 0 && !materializeDefaultParagraphStyle) return {
+		status: "unchanged",
+		styles: destinationStyles,
+		styleIdMap: /* @__PURE__ */ new Map(),
+		importedStyleIds: []
+	};
+	if (!sourceStyles) return {
+		status: "unalignable",
+		detail: "the target has no style definitions"
+	};
+	if (!destinationStyles) return {
+		status: "unalignable",
+		detail: "the base has no style definitions"
+	};
+	const sourceById = new Map(sourceStyles.styles.map((style) => [style.styleId, style]));
+	const destinationById = new Map(destinationStyles.styles.map((style) => [style.styleId, style]));
+	const reserved = new Set(reservedStyleIds);
+	const required = /* @__PURE__ */ new Set();
+	const pending = [...requested];
+	while (pending.length > 0) {
+		const styleId = pending.pop();
+		if (!styleId || required.has(styleId)) continue;
+		const source = sourceById.get(styleId);
+		if (!source) return {
+			status: "unalignable",
+			detail: "a referenced target style is missing"
+		};
+		required.add(styleId);
+		pending.push(...styleDependencies(source));
+	}
+	const imported = [...required].toSorted();
+	const taken = /* @__PURE__ */ new Set([
+		...sourceById.keys(),
+		...destinationById.keys(),
+		...reserved
+	]);
+	const styleIdMap = /* @__PURE__ */ new Map();
+	const isolatedDefaultStyleIds = /* @__PURE__ */ new Set();
+	let aliasSequence = 1;
+	for (const styleId of imported) {
+		const source = sourceById.get(styleId);
+		const destination = destinationById.get(styleId);
+		if (!source) return {
+			status: "unalignable",
+			detail: "a referenced target style is missing"
+		};
+		if (destination !== void 0 && canonicalJson(source) !== canonicalJson(destination) || !destination && (reserved.has(styleId) || source.default)) {
+			const alias = nextAvailableStyleAlias({
+				taken,
+				sequence: aliasSequence
+			});
+			aliasSequence += 1;
+			taken.add(alias);
+			styleIdMap.set(styleId, alias);
+			if (source.default) isolatedDefaultStyleIds.add(styleId);
+			continue;
+		}
+		styleIdMap.set(styleId, styleId);
+	}
+	const contextMatches = canonicalJson(sourceStyles.docDefaults) === canonicalJson(destinationStyles.docDefaults) && themesMatch(sourceTheme, destinationTheme);
+	const materializeThemeReferences = !themesMatch(sourceTheme, destinationTheme);
+	const additions = sourceStyles.styles.filter(({ styleId }) => required.has(styleId) && (!destinationById.has(styleId) || styleIdMap.get(styleId) !== styleId));
+	if (contextMatches) {
+		if (additions.length === 0) return {
+			status: "unchanged",
+			styles: destinationStyles,
+			styleIdMap,
+			importedStyleIds: []
+		};
+		return {
+			status: "imported",
+			styles: {
+				...destinationStyles,
+				styles: [...destinationStyles.styles, ...additions.map((style) => remapImportedStyle({
+					style,
+					styleIdMap,
+					isolatedDefaultStyleIds
+				}))]
+			},
+			styleIdMap,
+			importedStyleIds: additions.map(({ styleId }) => styleId)
+		};
+	}
+	const materializedStyles = [];
+	for (const style of additions) {
+		const result = materializeEffectiveStyle({
+			style,
+			styles: sourceStyles,
+			theme: sourceTheme,
+			materializeThemeReferences
+		});
+		if (result.status === "unalignable") return {
+			status: "unalignable",
+			detail: "a referenced style has formatting that cannot be materialized"
+		};
+		materializedStyles.push(remapImportedStyle({
+			style: result.style,
+			styleIdMap,
+			isolatedDefaultStyleIds
+		}));
+	}
+	let defaultParagraphStyleId;
+	let materializedDefaultParagraphStyle;
+	if (materializeDefaultParagraphStyle && !effectiveDefaultParagraphFormattingMatches({
+		sourceStyles,
+		destinationStyles,
+		sourceTheme,
+		destinationTheme,
+		materializeThemeReferences
+	})) {
+		defaultParagraphStyleId = nextAvailableStyleAlias({
+			taken,
+			sequence: aliasSequence
+		});
+		const result = materializeEffectiveDefaultParagraphStyle({
+			styles: sourceStyles,
+			destinationStyles,
+			theme: sourceTheme,
+			styleId: defaultParagraphStyleId,
+			materializeThemeReferences
+		});
+		if (result.status === "unalignable") return {
+			status: "unalignable",
+			detail: "default paragraph formatting cannot be isolated from the base formatting context"
+		};
+		materializedDefaultParagraphStyle = result.style;
+		materializedStyles.push(result.style);
+	}
+	if (materializedStyles.length === 0) return {
+		status: "unchanged",
+		styles: destinationStyles,
+		styleIdMap,
+		importedStyleIds: []
+	};
+	const candidateStyles = {
+		...destinationStyles,
+		styles: [...destinationStyles.styles, ...materializedStyles]
+	};
+	const sourceResolver = createStyleResolver(sourceStyles);
+	const candidateResolver = createStyleResolver(candidateStyles);
+	for (const style of additions) {
+		const candidateStyleId = styleIdMap.get(style.styleId) ?? style.styleId;
+		const sourceResolved = style.type === "character" ? {
+			paragraphFormatting: void 0,
+			runFormatting: sourceResolver.resolveRunStyle(style.styleId)
+		} : sourceResolver.resolveParagraphStyle(style.styleId);
+		const candidateResolved = style.type === "character" ? {
+			paragraphFormatting: void 0,
+			runFormatting: candidateResolver.resolveRunStyle(candidateStyleId)
+		} : candidateResolver.resolveParagraphStyle(candidateStyleId);
+		const sourceRunFormatting = materializeThemeTextFormatting(sourceResolved.runFormatting, sourceTheme, materializeThemeReferences);
+		const candidateRunFormatting = materializeThemeTextFormatting(candidateResolved.runFormatting, destinationTheme, materializeThemeReferences);
+		if (sourceRunFormatting.status === "unalignable" || candidateRunFormatting.status === "unalignable" || materializeThemeReferences && hasThemeReference(sourceResolved.paragraphFormatting) || materializeThemeReferences && hasThemeReference(candidateResolved.paragraphFormatting) || canonicalJson({
+			pPr: sourceResolved.paragraphFormatting,
+			rPr: sourceRunFormatting.formatting
+		}) !== canonicalJson({
+			pPr: candidateResolved.paragraphFormatting,
+			rPr: candidateRunFormatting.formatting
+		})) return {
+			status: "unalignable",
+			detail: "a referenced style differs after materializing its formatting"
+		};
+	}
+	if (defaultParagraphStyleId !== void 0) {
+		const sourceResolved = {
+			paragraphFormatting: materializedDefaultParagraphStyle?.pPr,
+			runFormatting: materializedDefaultParagraphStyle?.rPr
+		};
+		const candidateResolved = candidateResolver.resolveParagraphStyle(defaultParagraphStyleId);
+		const sourceRunFormatting = {
+			status: "ok",
+			formatting: sourceResolved.runFormatting
+		};
+		const candidateRunFormatting = materializeThemeTextFormatting(candidateResolved.runFormatting, destinationTheme, materializeThemeReferences);
+		if (candidateRunFormatting.status === "unalignable" || materializeThemeReferences && hasThemeReference(candidateResolved.paragraphFormatting) || canonicalJson({
+			pPr: sourceResolved.paragraphFormatting,
+			rPr: sourceRunFormatting.formatting
+		}) !== canonicalJson({
+			pPr: candidateResolved.paragraphFormatting,
+			rPr: candidateRunFormatting.formatting
+		})) return {
+			status: "unalignable",
+			detail: "default paragraph formatting cannot be isolated from the base formatting context"
+		};
+	}
+	return {
+		status: "imported",
+		styles: candidateStyles,
+		styleIdMap,
+		importedStyleIds: materializedStyles.map(({ styleId }) => styleId),
+		...defaultParagraphStyleId !== void 0 && { defaultParagraphStyleId }
+	};
+};
+//#endregion
+export { importReferencedStyleDefinitions };