@stll/folio-core 0.9.0 → 0.10.0

package/dist/docx/corePropertiesParser.js

@@ -0,0 +1,53 @@
+import { findChildByLocalName, getTextContent, parseXmlDocument } from "./xmlParser.js";
+//#region src/docx/corePropertiesParser.ts
+const STRING_PROPERTIES = [
+	"title",
+	"subject",
+	"creator",
+	"keywords",
+	"description",
+	"lastModifiedBy"
+];
+const parseRevision = (value) => {
+	if (!/^\d+$/u.test(value)) return;
+	const revision = Number(value);
+	return Number.isSafeInteger(revision) ? revision : void 0;
+};
+const parseDate = (value) => {
+	const timestamp = Date.parse(value);
+	return Number.isNaN(timestamp) ? void 0 : new Date(timestamp);
+};
+/** Parse recognized package metadata from `docProps/core.xml`. */
+const parseCoreProperties = (xml) => {
+	if (!xml) return;
+	const root = parseXmlDocument(xml);
+	if (!root) return;
+	const properties = {};
+	let recognizedPropertyCount = 0;
+	for (const property of STRING_PROPERTIES) {
+		const element = findChildByLocalName(root, property);
+		if (!element) continue;
+		properties[property] = getTextContent(element);
+		recognizedPropertyCount++;
+	}
+	const revisionElement = findChildByLocalName(root, "revision");
+	if (revisionElement) {
+		const revision = parseRevision(getTextContent(revisionElement));
+		if (revision !== void 0) {
+			properties.revision = revision;
+			recognizedPropertyCount++;
+		}
+	}
+	for (const property of ["created", "modified"]) {
+		const element = findChildByLocalName(root, property);
+		if (!element) continue;
+		const date = parseDate(getTextContent(element));
+		if (date !== void 0) {
+			properties[property] = date;
+			recognizedPropertyCount++;
+		}
+	}
+	return recognizedPropertyCount > 0 ? properties : void 0;
+};
+//#endregion
+export { parseCoreProperties };

package/dist/docx/index.d.ts

@@ -1,4 +1,5 @@
 import { getCachedNumberingMap } from "./numberingParser.js";
 import { DOCX_ENCRYPTION_ERROR_CODES, DocxEncryptionError, DocxEncryptionErrorCode, isDocxEncryptionError } from "./encryption/errors.js";
 import { DecryptDocxOptions, DecryptDocxResult, decryptDocxIfNeeded, openDocxBuffer } from "./encryption/openEncryptedDocx.js";
-export { DOCX_ENCRYPTION_ERROR_CODES, type DecryptDocxOptions, type DecryptDocxResult, DocxEncryptionError, type DocxEncryptionErrorCode, decryptDocxIfNeeded, getCachedNumberingMap, isDocxEncryptionError, openDocxBuffer };
+import { FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, FolioDocumentMetadataProperty, FolioDocumentPrivacyArchiveError, FolioDocumentPrivacyOptions, FolioDocumentPrivacyReport, FolioDocumentPrivacyTransform, InvalidFolioDocumentPrivacyOptionsError, RewriteDocxMetadataPrivacyResult, isFolioDocumentPrivacyTransform, rewriteDocxMetadataPrivacy } from "./metadataPrivacy.js";
+export { DOCX_ENCRYPTION_ERROR_CODES, type DecryptDocxOptions, type DecryptDocxResult, DocxEncryptionError, type DocxEncryptionErrorCode, FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, type FolioDocumentMetadataProperty, FolioDocumentPrivacyArchiveError, type FolioDocumentPrivacyOptions, type FolioDocumentPrivacyReport, type FolioDocumentPrivacyTransform, InvalidFolioDocumentPrivacyOptionsError, type RewriteDocxMetadataPrivacyResult, decryptDocxIfNeeded, getCachedNumberingMap, isDocxEncryptionError, isFolioDocumentPrivacyTransform, openDocxBuffer, rewriteDocxMetadataPrivacy };

package/dist/docx/index.js

@@ -1,4 +1,5 @@
 import { getCachedNumberingMap } from "./numberingParser.js";
 import { DOCX_ENCRYPTION_ERROR_CODES, DocxEncryptionError, isDocxEncryptionError } from "./encryption/errors.js";
 import { decryptDocxIfNeeded, openDocxBuffer } from "./encryption/openEncryptedDocx.js";
-export { DOCX_ENCRYPTION_ERROR_CODES, DocxEncryptionError, decryptDocxIfNeeded, getCachedNumberingMap, isDocxEncryptionError, openDocxBuffer };
+import { FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, FolioDocumentPrivacyArchiveError, InvalidFolioDocumentPrivacyOptionsError, isFolioDocumentPrivacyTransform, rewriteDocxMetadataPrivacy } from "./metadataPrivacy.js";
+export { DOCX_ENCRYPTION_ERROR_CODES, DocxEncryptionError, FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, FolioDocumentPrivacyArchiveError, InvalidFolioDocumentPrivacyOptionsError, decryptDocxIfNeeded, getCachedNumberingMap, isDocxEncryptionError, isFolioDocumentPrivacyTransform, openDocxBuffer, rewriteDocxMetadataPrivacy };

package/dist/docx/metadataPrivacy.d.ts

@@ -0,0 +1,40 @@
+//#region src/docx/metadataPrivacy.d.ts
+declare const FOLIO_DOCUMENT_METADATA_PROPERTIES: readonly ["title", "subject", "creator", "keywords", "description", "lastModifiedBy", "revision", "created", "modified"];
+type FolioDocumentMetadataProperty = (typeof FOLIO_DOCUMENT_METADATA_PROPERTIES)[number];
+declare const FOLIO_DOCUMENT_PRIVACY_TRANSFORMS: readonly ["remove-attribution", "remove-timestamps", "remove-descriptive-metadata"];
+type FolioDocumentPrivacyTransform = (typeof FOLIO_DOCUMENT_PRIVACY_TRANSFORMS)[number];
+declare const isFolioDocumentPrivacyTransform: (value: unknown) => value is FolioDocumentPrivacyTransform;
+type FolioDocumentPrivacyOptions = {
+  transforms: readonly FolioDocumentPrivacyTransform[];
+};
+type FolioDocumentPrivacyReport = {
+  appliedTransforms: FolioDocumentPrivacyTransform[];
+  removedMetadataProperties: FolioDocumentMetadataProperty[];
+};
+type RewriteDocxMetadataPrivacyResult = {
+  buffer: ArrayBuffer;
+  privacyReport: FolioDocumentPrivacyReport;
+};
+declare const InvalidFolioDocumentPrivacyOptionsError_base: import("better-result").TaggedErrorClass<"InvalidFolioDocumentPrivacyOptionsError", {
+  message: string;
+  receivedValue: unknown;
+}>;
+declare class InvalidFolioDocumentPrivacyOptionsError extends InvalidFolioDocumentPrivacyOptionsError_base {}
+declare const FolioDocumentPrivacyArchiveError_base: import("better-result").TaggedErrorClass<"FolioDocumentPrivacyArchiveError", {
+  message: string;
+  reason: "input-too-large" | "load-failed" | "too-many-entries" | "core-properties-too-large";
+  cause?: unknown;
+}>;
+declare class FolioDocumentPrivacyArchiveError extends FolioDocumentPrivacyArchiveError_base {}
+declare const PRIVATE_METADATA_PROPERTIES_BY_TRANSFORM: {
+  readonly "remove-attribution": readonly ["creator", "lastModifiedBy"];
+  readonly "remove-timestamps": readonly ["created", "modified"];
+  readonly "remove-descriptive-metadata": readonly ["title", "subject", "keywords", "description"];
+};
+declare const resolveFolioDocumentPrivacyTransforms: (transforms: unknown) => FolioDocumentPrivacyTransform[];
+/** Rewrite selected package metadata fields without changing other package parts. */
+declare const rewriteDocxMetadataPrivacy: (buffer: ArrayBuffer, {
+  transforms
+}: FolioDocumentPrivacyOptions) => Promise<RewriteDocxMetadataPrivacyResult>;
+//#endregion
+export { FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, FolioDocumentMetadataProperty, FolioDocumentPrivacyArchiveError, FolioDocumentPrivacyOptions, FolioDocumentPrivacyReport, FolioDocumentPrivacyTransform, InvalidFolioDocumentPrivacyOptionsError, PRIVATE_METADATA_PROPERTIES_BY_TRANSFORM, RewriteDocxMetadataPrivacyResult, isFolioDocumentPrivacyTransform, resolveFolioDocumentPrivacyTransforms, rewriteDocxMetadataPrivacy };

package/dist/docx/metadataPrivacy.js

@@ -0,0 +1,131 @@
+import { elementToXml, getLocalName, parseXmlDocument } from "./xmlParser.js";
+import { TaggedError } from "better-result";
+import JSZip from "jszip";
+//#region src/docx/metadataPrivacy.ts
+const FOLIO_DOCUMENT_METADATA_PROPERTIES = Object.freeze([
+	"title",
+	"subject",
+	"creator",
+	"keywords",
+	"description",
+	"lastModifiedBy",
+	"revision",
+	"created",
+	"modified"
+]);
+const isFolioDocumentMetadataProperty = (value) => FOLIO_DOCUMENT_METADATA_PROPERTIES.some((property) => property === value);
+const FOLIO_DOCUMENT_PRIVACY_TRANSFORMS = Object.freeze([
+	"remove-attribution",
+	"remove-timestamps",
+	"remove-descriptive-metadata"
+]);
+const isFolioDocumentPrivacyTransform = (value) => FOLIO_DOCUMENT_PRIVACY_TRANSFORMS.some((transform) => transform === value);
+var InvalidFolioDocumentPrivacyOptionsError = class extends TaggedError("InvalidFolioDocumentPrivacyOptionsError")() {};
+var FolioDocumentPrivacyArchiveError = class extends TaggedError("FolioDocumentPrivacyArchiveError")() {};
+const PRIVATE_METADATA_PROPERTIES_BY_TRANSFORM = {
+	"remove-attribution": ["creator", "lastModifiedBy"],
+	"remove-timestamps": ["created", "modified"],
+	"remove-descriptive-metadata": [
+		"title",
+		"subject",
+		"keywords",
+		"description"
+	]
+};
+const resolveFolioDocumentPrivacyTransforms = (transforms) => {
+	if (!Array.isArray(transforms) || transforms.some((transform) => !isFolioDocumentPrivacyTransform(transform))) throw new InvalidFolioDocumentPrivacyOptionsError({
+		message: "Document privacy received an unrecognized transform",
+		receivedValue: transforms
+	});
+	const requested = new Set(transforms);
+	return FOLIO_DOCUMENT_PRIVACY_TRANSFORMS.filter((transform) => requested.has(transform));
+};
+const XML_DECLARATION_PATTERN = /^\s*<\?xml[^?]*\?>/u;
+const MAX_INPUT_BYTES = 50 * 1024 * 1024;
+const MAX_ARCHIVE_ENTRIES = 5e3;
+const MAX_CORE_PROPERTIES_BYTES = 1024 * 1024;
+const loadPrivacyArchive = async (buffer) => {
+	if (buffer.byteLength > MAX_INPUT_BYTES) throw new FolioDocumentPrivacyArchiveError({
+		message: "Document privacy input exceeded the compressed-size limit",
+		reason: "input-too-large"
+	});
+	let zip;
+	try {
+		zip = await JSZip.loadAsync(buffer);
+	} catch (cause) {
+		throw new FolioDocumentPrivacyArchiveError({
+			message: "Document privacy input is not a readable package",
+			reason: "load-failed",
+			cause
+		});
+	}
+	if (Object.values(zip.files).length > MAX_ARCHIVE_ENTRIES) throw new FolioDocumentPrivacyArchiveError({
+		message: "Document privacy input exceeded the package-entry limit",
+		reason: "too-many-entries"
+	});
+	const coreProperties = zip.file("docProps/core.xml");
+	if (!coreProperties) return zip;
+	const data = "_data" in coreProperties ? coreProperties._data : void 0;
+	const declaredBytes = typeof data === "object" && data !== null && "uncompressedSize" in data ? data.uncompressedSize : void 0;
+	if (typeof declaredBytes !== "number" || declaredBytes > MAX_CORE_PROPERTIES_BYTES) throw new FolioDocumentPrivacyArchiveError({
+		message: "Document privacy core properties exceeded the part-size limit",
+		reason: "core-properties-too-large"
+	});
+	return zip;
+};
+const rewriteCorePropertiesPrivacy = (xml, transforms) => {
+	const root = parseXmlDocument(xml);
+	if (!root?.elements) return {
+		xml,
+		removedMetadataProperties: []
+	};
+	const propertiesToRemove = /* @__PURE__ */ new Set();
+	for (const transform of transforms) for (const property of PRIVATE_METADATA_PROPERTIES_BY_TRANSFORM[transform]) propertiesToRemove.add(property);
+	const removedPropertySet = /* @__PURE__ */ new Set();
+	root.elements = root.elements.filter((element) => {
+		if (element.type !== "element") return true;
+		const property = getLocalName(element.name ?? "");
+		if (!isFolioDocumentMetadataProperty(property)) return true;
+		if (!propertiesToRemove.has(property)) return true;
+		removedPropertySet.add(property);
+		return false;
+	});
+	return {
+		xml: `${xml.match(XML_DECLARATION_PATTERN)?.at(0) ?? ""}${elementToXml(root)}`,
+		removedMetadataProperties: FOLIO_DOCUMENT_METADATA_PROPERTIES.filter((property) => removedPropertySet.has(property))
+	};
+};
+/** Rewrite selected package metadata fields without changing other package parts. */
+const rewriteDocxMetadataPrivacy = async (buffer, { transforms }) => {
+	const appliedTransforms = resolveFolioDocumentPrivacyTransforms(transforms);
+	const zip = await loadPrivacyArchive(buffer);
+	const coreProperties = zip.file("docProps/core.xml");
+	if (!coreProperties) return {
+		buffer,
+		privacyReport: {
+			appliedTransforms,
+			removedMetadataProperties: []
+		}
+	};
+	const rewritten = rewriteCorePropertiesPrivacy(await coreProperties.async("text"), appliedTransforms);
+	if (rewritten.removedMetadataProperties.length === 0) return {
+		buffer,
+		privacyReport: {
+			appliedTransforms,
+			removedMetadataProperties: []
+		}
+	};
+	zip.file("docProps/core.xml", rewritten.xml);
+	return {
+		buffer: await zip.generateAsync({
+			type: "arraybuffer",
+			compression: "DEFLATE"
+		}),
+		privacyReport: {
+			appliedTransforms,
+			removedMetadataProperties: rewritten.removedMetadataProperties
+		}
+	};
+};
+//#endregion
+export { FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, FolioDocumentPrivacyArchiveError, InvalidFolioDocumentPrivacyOptionsError, PRIVATE_METADATA_PROPERTIES_BY_TRANSFORM, isFolioDocumentPrivacyTransform, resolveFolioDocumentPrivacyTransforms, rewriteDocxMetadataPrivacy };

package/dist/docx/parser.js

@@ -6,6 +6,7 @@ import { applyThemeFontLang, parseTheme } from "./themeParser.js";
 import { parseComments } from "./commentParser.js";
 import { normalizeCommentReferences } from "./commentReferenceNormalization.js";
 import { detectDocxConformanceClass } from "./conformance.js";
+import { parseCoreProperties } from "./corePropertiesParser.js";
 import { parseNumbering } from "./numberingParser.js";
 import { extractAllTemplateVariables, parseDocumentBody } from "./documentParser.js";
 import { parseEndnotes, parseFootnotes } from "./footnoteParser.js";
@@ -168,6 +169,7 @@ async function parseDocx(input, options = {}) {
 			onProgress("Loaded fonts", 95);
 		} else onProgress("Skipping font loading", 95);
 		onProgress("Assembling document...", 95);
+		const properties = timeStage("coreProperties", () => parseCoreProperties(raw.corePropsXml));
 		const document = {
 			package: {
 				conformanceClass: detectDocxConformanceClass(raw.documentXml),
@@ -182,7 +184,8 @@ async function parseDocx(input, options = {}) {
 				...footnotes !== void 0 ? { footnotes } : {},
 				...endnotes !== void 0 ? { endnotes } : {},
 				relationships: rels,
-				media
+				media,
+				...properties !== void 0 ? { properties } : {}
 			},
 			originalBuffer: raw.originalBuffer,
 			...templateVariables !== void 0 ? { templateVariables } : {},

package/dist/docx/rezip.d.ts

@@ -124,10 +124,11 @@ declare function hasUnmaterializedHeaderFooter(doc: document_d_exports.Document)
  */
 declare function hasModelDrivenPictureWatermark(doc: document_d_exports.Document): boolean;
 declare function collectHeaderFooterUpdates(doc: document_d_exports.Document): Map<string, string>;
-/**
- * Update core properties XML with new modification date
- */
-declare function updateCoreProperties(corePropsXml: string, options: {
+/** Update existing core-property values without synthesizing absent metadata. */
+declare function updateCoreProperties(corePropsXml: string, {
+  updateModifiedDate,
+  modifiedBy
+}: {
   updateModifiedDate?: boolean;
   modifiedBy?: string;
 }): string;

package/dist/docx/rezip.js

@@ -1022,18 +1022,16 @@ function findNotePartEntry(zip, conventionalLowerPath) {
 	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.toLowerCase() === conventionalLowerPath) return file;
 	return null;
 }
-/**
-* Update core properties XML with new modification date
-*/
-function updateCoreProperties(corePropsXml, options) {
+/** Update existing core-property values without synthesizing absent metadata. */
+function updateCoreProperties(corePropsXml, { updateModifiedDate, modifiedBy }) {
 	let result = corePropsXml;
-	if (options.updateModifiedDate) {
+	if (updateModifiedDate) {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		if (result.includes("<dcterms:modified")) result = result.replace(/<dcterms:modified[^<>]*>[^<]*<\/dcterms:modified>/u, `<dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>`);
-		else result = result.replace("</cp:coreProperties>", `<dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified></cp:coreProperties>`);
 	}
-	if (options.modifiedBy) if (result.includes("<cp:lastModifiedBy")) result = result.replace(/<cp:lastModifiedBy>[^<]*<\/cp:lastModifiedBy>/u, `<cp:lastModifiedBy>${escapeXml(options.modifiedBy)}</cp:lastModifiedBy>`);
-	else result = result.replace("</cp:coreProperties>", `<cp:lastModifiedBy>${escapeXml(options.modifiedBy)}</cp:lastModifiedBy></cp:coreProperties>`);
+	if (modifiedBy) {
+		if (result.includes("<cp:lastModifiedBy")) result = result.replace(/<cp:lastModifiedBy>[^<]*<\/cp:lastModifiedBy>/u, `<cp:lastModifiedBy>${escapeXml(modifiedBy)}</cp:lastModifiedBy>`);
+	}
 	return result;
 }
 /**

package/dist/layout-bridge/convert/toFlowBlocks.js

@@ -445,6 +445,7 @@ function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange) {
 	if (attrs.cropBottom != null) run.cropBottom = attrs.cropBottom;
 	if (attrs.cropLeft != null) run.cropLeft = attrs.cropLeft;
 	if (attrs.position !== void 0) run.position = attrs.position;
+	if (attrs.layoutInCell !== void 0) run.layoutInCell = attrs.layoutInCell;
 	if (trackedChange?.isInsertion) run.isInsertion = true;
 	if (trackedChange?.isDeletion) run.isDeletion = true;
 	if (trackedChange?.changeAuthor !== void 0) run.changeAuthor = trackedChange.changeAuthor;

package/dist/layout-engine/measure/cache.js

@@ -1,4 +1,5 @@
 import { getLineBreakProviderGeneration } from "./lineBreakProvider.js";
+import { lineBreakPolicyCacheParts } from "./effectiveLineBreakPolicy.js";
 //#region src/layout-engine/measure/cache.ts
 /**
 * Current max size for text width cache
@@ -168,13 +169,7 @@ function hashParagraphBlock(block) {
 		if (attrs.defaultFontFamily != null) parts.push(`dff:${attrs.defaultFontFamily}`);
 		if (attrs.suppressEmptyParagraphHeight) parts.push("sup");
 		if (attrs.reserveEmptyOutlineHeight) parts.push("outline-empty-reserve");
-		if (attrs.kinsoku !== void 0) parts.push(`kinsoku:${attrs.kinsoku}`);
-		if (attrs.overflowPunctuation !== void 0) parts.push(`overflow-punct:${attrs.overflowPunctuation}`);
-		if (attrs.suppressAutoHyphens !== void 0) parts.push(`suppress-auto-hyphens:${attrs.suppressAutoHyphens}`);
-		const automaticHyphenation = attrs.automaticHyphenation;
-		if (automaticHyphenation) parts.push(`auto-hyphens:${automaticHyphenation.doNotHyphenateCaps}|${automaticHyphenation.consecutiveLineLimit}`);
-		const lineBreakRules = attrs.lineBreakRules;
-		if (lineBreakRules) parts.push(`line-break-rules:${lineBreakRules.noLineBreaksBefore?.language}|${lineBreakRules.noLineBreaksBefore?.characters}|${lineBreakRules.noLineBreaksAfter?.language}|${lineBreakRules.noLineBreaksAfter?.characters}|${lineBreakRules.useLegacyEthiopicAmharicRules}`);
+		parts.push(...lineBreakPolicyCacheParts(attrs));
 		const borders = attrs.borders;
 		if (borders) {
 			const signature = (border) => border ? `${border.width ?? ""},${border.style ?? ""},${border.color ?? ""}` : "";

package/dist/layout-engine/measure/effectiveLineBreakPolicy.d.ts

@@ -0,0 +1,29 @@
+import { ParagraphAttrs, TextRun } from "../types.js";
+import { LineBreakPolicy } from "./lineBreakProvider.js";
+
+//#region src/layout-engine/measure/effectiveLineBreakPolicy.d.ts
+type EffectiveAutomaticHyphenation = Readonly<{
+  type: "disabled";
+}> | Readonly<{
+  type: "enabled";
+  consecutiveLineLimit: number;
+  hyphenationZoneTwips: number;
+}>;
+type EffectiveLineBreakPolicy = Readonly<{
+  /** Exact provider inputs; omitted OOXML values stay omitted for custom providers. */provider: Readonly<LineBreakPolicy>; /** `w:overflowPunct` defaults to enabled when omitted. */
+  hangingPunctuation: boolean; /** Effective document and paragraph automatic-hyphenation state. */
+  automaticHyphenation: EffectiveAutomaticHyphenation;
+}>;
+type ResolveEffectiveLineBreakPolicyOptions = {
+  attrs: ParagraphAttrs | undefined;
+  run: TextRun;
+};
+/** Resolve all authored line-breaking inputs used while measuring one text run. */
+declare const resolveEffectiveLineBreakPolicy: ({
+  attrs,
+  run
+}: ResolveEffectiveLineBreakPolicyOptions) => EffectiveLineBreakPolicy;
+/** Cache fragments for every paragraph attribute consumed by the resolver. */
+declare const lineBreakPolicyCacheParts: (attrs: ParagraphAttrs) => readonly string[];
+//#endregion
+export { lineBreakPolicyCacheParts, resolveEffectiveLineBreakPolicy };

package/dist/layout-engine/measure/effectiveLineBreakPolicy.js

@@ -0,0 +1,60 @@
+import { hasCjk } from "../../utils/scriptSegments.js";
+//#region src/layout-engine/measure/effectiveLineBreakPolicy.ts
+const DEFAULT_HYPHENATION_ZONE_TWIPS = 360;
+/** Resolve all authored line-breaking inputs used while measuring one text run. */
+const resolveEffectiveLineBreakPolicy = ({ attrs, run }) => {
+	const locale = resolveRunLocale(run);
+	const rules = attrs?.lineBreakRules;
+	const before = rules?.noLineBreaksBefore;
+	const after = rules?.noLineBreaksAfter;
+	const automaticHyphenation = attrs?.automaticHyphenation;
+	return {
+		provider: {
+			...locale ? { locale } : {},
+			...attrs?.kinsoku !== void 0 ? { kinsoku: attrs.kinsoku } : {},
+			...before && languageMatches(before.language, locale) ? { noLineBreaksBefore: before.characters } : {},
+			...after && languageMatches(after.language, locale) ? { noLineBreaksAfter: after.characters } : {},
+			...rules?.useLegacyEthiopicAmharicRules ? { useLegacyEthiopicAmharicRules: true } : {},
+			...automaticHyphenation?.doNotHyphenateCaps !== void 0 ? { doNotHyphenateCaps: automaticHyphenation.doNotHyphenateCaps } : {},
+			...run.allCaps === true ? { renderedAllCaps: true } : {}
+		},
+		hangingPunctuation: attrs?.overflowPunctuation !== false,
+		automaticHyphenation: resolveAutomaticHyphenation(attrs)
+	};
+};
+/** Cache fragments for every paragraph attribute consumed by the resolver. */
+const lineBreakPolicyCacheParts = (attrs) => {
+	const parts = [];
+	if (attrs.kinsoku !== void 0) parts.push(`kinsoku:${attrs.kinsoku}`);
+	if (attrs.overflowPunctuation !== void 0) parts.push(`overflow-punct:${attrs.overflowPunctuation}`);
+	if (attrs.suppressAutoHyphens !== void 0) parts.push(`suppress-auto-hyphens:${attrs.suppressAutoHyphens}`);
+	const automaticHyphenation = attrs.automaticHyphenation;
+	if (automaticHyphenation) parts.push(`auto-hyphens:${automaticHyphenation.doNotHyphenateCaps}|${automaticHyphenation.consecutiveLineLimit}|${automaticHyphenation.hyphenationZoneTwips}`);
+	const rules = attrs.lineBreakRules;
+	if (rules) parts.push(`line-break-rules:${rules.noLineBreaksBefore?.language}|${rules.noLineBreaksBefore?.characters}|${rules.noLineBreaksAfter?.language}|${rules.noLineBreaksAfter?.characters}|${rules.useLegacyEthiopicAmharicRules}`);
+	return parts;
+};
+const resolveAutomaticHyphenation = (attrs) => {
+	const automaticHyphenation = attrs?.automaticHyphenation;
+	if (automaticHyphenation?.enabled !== true || attrs?.suppressAutoHyphens === true) return { type: "disabled" };
+	return {
+		type: "enabled",
+		consecutiveLineLimit: automaticHyphenation.consecutiveLineLimit ?? 0,
+		hyphenationZoneTwips: automaticHyphenation.hyphenationZoneTwips ?? DEFAULT_HYPHENATION_ZONE_TWIPS
+	};
+};
+const resolveRunLocale = (run) => {
+	const language = run.language;
+	if (hasCjk(run.text)) return language?.eastAsia ?? language?.val;
+	if (run.rtl) return language?.bidi ?? language?.val;
+	return language?.val;
+};
+const languageMatches = (ruleLanguage, locale) => {
+	if (!ruleLanguage) return true;
+	if (!locale) return false;
+	const rule = ruleLanguage.toLowerCase();
+	const active = locale.toLowerCase();
+	return active === rule || active.startsWith(`${rule}-`) || rule.startsWith(`${active}-`);
+};
+//#endregion
+export { lineBreakPolicyCacheParts, resolveEffectiveLineBreakPolicy };

package/dist/layout-engine/measure/measureParagraph.js

@@ -1,13 +1,14 @@
 import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
 import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
 import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
-import { buildRunFontStyle, ptToPx } from "./measureHelpers.js";
+import { buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
 import "./lineBreakProvider.js";
 import { calculateTabWidth, pixelsToTwips } from "../../prosemirror/utils/tabCalculator.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
 import { hasCjk } from "../../utils/scriptSegments.js";
 import { measuredLineAdvance } from "../lineFlow.js";
 import { isFloatingImageRun } from "../types.js";
+import { resolveEffectiveLineBreakPolicy } from "./effectiveLineBreakPolicy.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
 import { getFloatingAvailableWidth, getFloatingMargins } from "./floatingZones.js";
 import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
@@ -24,7 +25,7 @@ const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
-const JUSTIFY_SPACE_CONTRACTION_RATIO = .1;
+const JUSTIFY_SPACE_CONTRACTION_RATIO = .075;
 const JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO = .195;
 const JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO = .23;
 const JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO = .015;
@@ -51,6 +52,11 @@ function findMaxFittingLength(text, style, maxWidth, forceMin = false, policy) {
 	}
 	return forceMin && best === 0 ? boundaries.at(0) ?? 0 : best;
 }
+function exceedsHyphenationZone(line, zoneTwips) {
+	if (line.width <= 0) return true;
+	const visibleWidth = Math.max(0, line.width - line.trailingWhitespaceWidth);
+	return Math.max(0, line.availableWidth - visibleWidth) > twipsToPx(zoneTwips) + WIDTH_TOLERANCE;
+}
 /**
 * Extract FontStyle from a run that carries RunFormatting (text, tab, or
 * field). All three share the same formatting shape, so they measure the
@@ -60,31 +66,6 @@ function findMaxFittingLength(text, style, maxWidth, forceMin = false, policy) {
 function runToFontStyle(run) {
 	return buildRunFontStyle(run, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE);
 }
-function languageMatches(ruleLanguage, locale) {
-	if (!ruleLanguage) return true;
-	if (!locale) return false;
-	const rule = ruleLanguage.toLowerCase();
-	const active = locale.toLowerCase();
-	return active === rule || active.startsWith(`${rule}-`) || rule.startsWith(`${active}-`);
-}
-function lineBreakPolicy(block, run) {
-	const language = run.language;
-	let locale = language?.val;
-	if (hasCjk(run.text)) locale = language?.eastAsia ?? language?.val;
-	else if (run.rtl) locale = language?.bidi ?? language?.val;
-	const rules = block.attrs?.lineBreakRules;
-	const before = rules?.noLineBreaksBefore;
-	const after = rules?.noLineBreaksAfter;
-	return {
-		...locale ? { locale } : {},
-		...block.attrs?.kinsoku !== void 0 ? { kinsoku: block.attrs.kinsoku } : {},
-		...before && languageMatches(before.language, locale) ? { noLineBreaksBefore: before.characters } : {},
-		...after && languageMatches(after.language, locale) ? { noLineBreaksAfter: after.characters } : {},
-		...rules?.useLegacyEthiopicAmharicRules ? { useLegacyEthiopicAmharicRules: true } : {},
-		...block.attrs?.automaticHyphenation?.doNotHyphenateCaps !== void 0 ? { doNotHyphenateCaps: block.attrs.automaticHyphenation.doNotHyphenateCaps } : {},
-		...run.allCaps === true ? { renderedAllCaps: true } : {}
-	};
-}
 /**
 * Line-HEIGHT style for a text run. Word derives a CJK line's height from an
 * East-Asian face, not the run's ascii font: real documents routinely put CJK
@@ -454,7 +435,10 @@ function computeTrailingGlueWidths(block) {
 		}
 		if (isSpaceOrTab(text.at(0))) continue;
 		const style = runToFontStyle(nextRun);
-		const firstBreak = findWordBreaks(text, lineBreakPolicy(block, nextRun)).at(0);
+		const firstBreak = findWordBreaks(text, resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run: nextRun
+		}).provider).at(0);
 		widths[index] = measureTextWidth(firstBreak === void 0 ? text : trimTrailingSpacesAndTabs(text.slice(0, firstBreak)), style) + (firstBreak === void 0 ? widths[index + 1] ?? 0 : 0);
 	}
 	return widths;
@@ -466,7 +450,10 @@ function computeProtectedCrossRunGlueWidths(block) {
 		if (!run || !isTextRun(run)) continue;
 		const trailing = /(\S+)(\s*)$/u.exec(run.text ?? "");
 		const token = trailing?.[1];
-		const policy = lineBreakPolicy(block, run);
+		const policy = resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run
+		}).provider;
 		if (!token || token.length !== 1 || !policy.locale?.toLocaleLowerCase().startsWith("cs")) continue;
 		let separator = trailing[2] ?? "";
 		let glueWidth = separator.length > 0 ? measureTextWidth(separator, runToFontStyle(run)) : 0;
@@ -512,7 +499,10 @@ function collectCrossRunWord({ block, startRunIndex, startChar }) {
 		if (runIndex !== startRunIndex && isSpaceOrTab(remainder[0])) break;
 		const remainingBudget = 256 - text.length;
 		const boundedRemainder = remainder.slice(0, remainingBudget + 1);
-		const firstBreak = findWordBreaks(boundedRemainder, lineBreakPolicy(block, run)).at(0);
+		const firstBreak = findWordBreaks(boundedRemainder, resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run
+		}).provider).at(0);
 		const segmentText = trimTrailingSpacesAndTabs(firstBreak === void 0 ? boundedRemainder : boundedRemainder.slice(0, firstBreak));
 		if (segmentText.length === 0) break;
 		if (segmentText.length > remainingBudget) return;
@@ -534,7 +524,10 @@ function collectCrossRunWord({ block, startRunIndex, startChar }) {
 	return {
 		text,
 		width,
-		breaks: findHyphenationBreaks(text, lineBreakPolicy(block, firstRun)),
+		breaks: findHyphenationBreaks(text, resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run: firstRun
+		}).provider),
 		segments
 	};
 }
@@ -944,7 +937,11 @@ function measureParagraph(block, maxWidth, options) {
 			const textRun = run;
 			const text = textRun.text;
 			const style = runToFontStyle(textRun);
-			const breakPolicy = lineBreakPolicy(block, textRun);
+			const effectiveLineBreakPolicy = resolveEffectiveLineBreakPolicy({
+				attrs: block.attrs,
+				run: textRun
+			});
+			const breakPolicy = effectiveLineBreakPolicy.provider;
 			const lineHeightStyle = cjkLineHeightStyle(textRun, style);
 			updateMaxFont(lineHeightStyle);
 			if (!text || text.length === 0) {
@@ -966,13 +963,12 @@ function measureParagraph(block, maxWidth, options) {
 				const measuredWord = trimTrailingSpacesAndTabs(word);
 				const wordWidth = measureTextWidth(measuredWord, style);
 				const fullWordWidth = measureTextWidth(word, style);
-				const hangingPunctuationWidth = trailingHangingPunctuationWidth(measuredWord, style, breakPolicy, block.attrs?.overflowPunctuation);
+				const hangingPunctuationWidth = trailingHangingPunctuationWidth(measuredWord, style, breakPolicy, effectiveLineBreakPolicy.hangingPunctuation);
 				const isFirstLine = lines.length === 0;
 				const regularSpaceWidth = compressibleSpaceWidth(measuredWord, style);
 				const widthTolerance = isJustifiedParagraph ? justifyFitTolerance(currentLine, isFirstLine ? firstLineJustifyFitStrategy : continuationJustifyFitStrategy, regularSpaceWidth) : WIDTH_TOLERANCE;
-				const automaticHyphenation = block.attrs?.automaticHyphenation;
-				const consecutiveLineLimit = automaticHyphenation?.consecutiveLineLimit ?? 0;
-				const mayHyphenateLine = automaticHyphenation?.enabled === true && block.attrs?.suppressAutoHyphens !== true && (consecutiveLineLimit === 0 || consecutiveHyphenatedLines < consecutiveLineLimit);
+				const automaticHyphenation = effectiveLineBreakPolicy.automaticHyphenation;
+				const mayHyphenateLine = automaticHyphenation.type === "enabled" && (automaticHyphenation.consecutiveLineLimit === 0 || consecutiveHyphenatedLines < automaticHyphenation.consecutiveLineLimit) && exceedsHyphenationZone(currentLine, automaticHyphenation.hyphenationZoneTwips);
 				const isRunTail = nextBreak === text.length;
 				const crossRunWord = mayHyphenateLine && isRunTail && word.length > 0 && !isBreakChar(word.at(-1)) ? collectCrossRunWord({
 					block,