@stll/folio-core 0.9.0 → 0.11.0

package/dist/controller/headerFooterEditorManager.js

@@ -0,0 +1,182 @@
+import { clearHeaderFooterVerbatimXml } from "../docx/headerFooterVerbatim.js";
+import { proseDocToBlocks } from "../prosemirror/conversion/fromProseDoc.js";
+import { ExtensionManager } from "../prosemirror/extensions/ExtensionManager.js";
+import { ensureBaseDirectionInState } from "../prosemirror/extensions/features/AutoBidiDetectionExtension.js";
+import { createDocumentStylesPlugin } from "../prosemirror/plugins/documentStyles.js";
+import { ensureParaIdsInState } from "../prosemirror/extensions/features/ParaIdAllocatorExtension.js";
+import { createStarterKit } from "../prosemirror/extensions/StarterKit.js";
+import { schema } from "../prosemirror/schema/index.js";
+import { headerFooterToProseDoc } from "../prosemirror/conversion/toProseDoc.js";
+import { EditorState } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+//#region src/controller/headerFooterEditorManager.ts
+/**
+* Framework-neutral lifecycle owner for persistent header/footer EditorViews.
+*
+* Each distinct relationship id owns one off-screen ProseMirror view. Painted
+* header/footer instances that share that relationship therefore share live
+* editor state, and adapters only decide when to synchronize or destroy the
+* manager.
+*/
+const buildInitialState = (headerFooter, styles, theme, manager) => {
+	const proseDocOptions = {};
+	if (styles) proseDocOptions.styles = styles;
+	if (theme !== void 0) proseDocOptions.theme = theme;
+	const document = headerFooterToProseDoc(headerFooter.content, proseDocOptions);
+	return ensureBaseDirectionInState(ensureParaIdsInState(EditorState.create({
+		doc: document,
+		schema,
+		plugins: [...manager.getPlugins(), createDocumentStylesPlugin(styles)]
+	})));
+};
+const enumerateHeaderFooterParts = ({ headers, footers }) => {
+	const parts = [];
+	if (headers) for (const rId of headers.keys()) parts.push({
+		kind: "header",
+		rId
+	});
+	if (footers) {
+		for (const rId of footers.keys()) if (!headers?.has(rId)) parts.push({
+			kind: "footer",
+			rId
+		});
+	}
+	return parts;
+};
+const enumerateDocumentHeaderFooterParts = (document) => {
+	if (!document?.package) return [];
+	return enumerateHeaderFooterParts({
+		headers: document.package.headers,
+		footers: document.package.footers
+	});
+};
+const resolveHeaderFooter = (document, { kind, rId }) => {
+	return (kind === "header" ? document?.package.headers : document?.package.footers)?.get(rId) ?? null;
+};
+const createHeaderFooterEditorManager = (deps) => {
+	const mounted = /* @__PURE__ */ new Map();
+	const destroyMounted = (part) => {
+		part.view.destroy();
+		part.manager.destroy();
+		part.mountNode.remove();
+	};
+	const destroy = () => {
+		for (const part of mounted.values()) destroyMounted(part);
+		mounted.clear();
+	};
+	const sync = () => {
+		const host = deps.getHost();
+		if (!host) return;
+		const document = deps.getDocument();
+		const styles = deps.getStyles();
+		const theme = deps.getTheme();
+		const wanted = new Map(enumerateDocumentHeaderFooterParts(document).map((part) => [part.rId, part]));
+		for (const [rId, part] of mounted) {
+			if (wanted.has(rId)) continue;
+			destroyMounted(part);
+			mounted.delete(rId);
+		}
+		for (const part of wanted.values()) {
+			const headerFooter = resolveHeaderFooter(document, part);
+			if (!headerFooter) continue;
+			const existing = mounted.get(part.rId);
+			if (existing) {
+				if (existing.mountNode.parentElement !== host) host.append(existing.mountNode);
+				const contentIsCurrent = existing.appliedHeaderFooter === headerFooter && existing.appliedContent === headerFooter.content;
+				const contextIsCurrent = existing.appliedStyles === styles && existing.appliedTheme === theme;
+				if (contentIsCurrent && contextIsCurrent) continue;
+				existing.view.updateState(buildInitialState(headerFooter, styles, theme, existing.manager));
+				existing.appliedHeaderFooter = headerFooter;
+				existing.appliedContent = headerFooter.content;
+				existing.appliedStyles = styles;
+				existing.appliedTheme = theme;
+				existing.dirty = false;
+				continue;
+			}
+			const manager = new ExtensionManager(createStarterKit());
+			manager.buildSchema();
+			manager.initializeRuntime();
+			const mountNode = host.ownerDocument.createElement("div");
+			mountNode.dataset["hfRId"] = part.rId;
+			mountNode.dataset["hfKind"] = part.kind;
+			host.append(mountNode);
+			const view = new EditorView(mountNode, {
+				state: buildInitialState(headerFooter, styles, theme, manager),
+				dispatchTransaction(transaction) {
+					const nextState = view.state.apply(transaction);
+					view.updateState(nextState);
+					const mountedPart = mounted.get(part.rId);
+					if (mountedPart && transaction.docChanged) mountedPart.dirty = true;
+					deps.onTransaction?.({
+						docChanged: transaction.docChanged,
+						kind: part.kind,
+						rId: part.rId,
+						selectionChanged: transaction.selectionSet,
+						view
+					});
+				}
+			});
+			mounted.set(part.rId, {
+				appliedContent: headerFooter.content,
+				appliedHeaderFooter: headerFooter,
+				appliedStyles: styles,
+				appliedTheme: theme,
+				dirty: false,
+				kind: part.kind,
+				manager,
+				mountNode,
+				rId: part.rId,
+				view
+			});
+		}
+	};
+	return {
+		destroy,
+		getView: (rId) => mounted.get(rId)?.view ?? null,
+		listSlots: () => [...mounted.values()].map(({ kind, rId }) => ({
+			kind,
+			rId
+		})),
+		snapshotDocument: (document) => {
+			let headers = document.package.headers;
+			let footers = document.package.footers;
+			let headersChanged = false;
+			let footersChanged = false;
+			for (const { dirty, kind, rId, view } of mounted.values()) {
+				if (!dirty) continue;
+				const source = kind === "header" ? headers : footers;
+				const existing = source?.get(rId);
+				if (!source || !existing) continue;
+				const updated = {
+					...existing,
+					content: proseDocToBlocks(view.state.doc)
+				};
+				clearHeaderFooterVerbatimXml(updated);
+				if (kind === "header") {
+					if (!headersChanged) {
+						headers = new Map(headers);
+						headersChanged = true;
+					}
+					headers?.set(rId, updated);
+				} else {
+					if (!footersChanged) {
+						footers = new Map(footers);
+						footersChanged = true;
+					}
+					footers?.set(rId, updated);
+				}
+			}
+			if (!headersChanged && !footersChanged) return document;
+			const packageWithSnapshots = { ...document.package };
+			if (headersChanged && headers) packageWithSnapshots.headers = headers;
+			if (footersChanged && footers) packageWithSnapshots.footers = footers;
+			return {
+				...document,
+				package: packageWithSnapshots
+			};
+		},
+		sync
+	};
+};
+//#endregion
+export { createHeaderFooterEditorManager, enumerateDocumentHeaderFooterParts, enumerateHeaderFooterParts };

package/dist/controller/hiddenEditorManager.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
-import { HiddenEditorApi } from "./hiddenEditorApi.js";
 import { HiddenEditorStateReason } from "../layout-engine/layoutInstrumentation.js";
 import { ExtensionManager } from "../prosemirror/extensions/ExtensionManager.js";
+import { HiddenEditorApi } from "./hiddenEditorApi.js";
 import { EditorState, Plugin, Transaction } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 import * as YProseMirror from "y-prosemirror";

package/dist/controller/layoutPipeline.js

@@ -78,7 +78,8 @@ function runLayoutPipeline(deps, state, options = {}) {
 		if (documentSettings?.autoHyphenation === true) flowOpts.automaticHyphenation = {
 			enabled: true,
 			...documentSettings.doNotHyphenateCaps !== void 0 ? { doNotHyphenateCaps: documentSettings.doNotHyphenateCaps } : {},
-			...documentSettings.consecutiveHyphenLimit !== void 0 ? { consecutiveLineLimit: documentSettings.consecutiveHyphenLimit } : {}
+			...documentSettings.consecutiveHyphenLimit !== void 0 ? { consecutiveLineLimit: documentSettings.consecutiveHyphenLimit } : {},
+			...documentSettings.hyphenationZoneTwips !== void 0 ? { hyphenationZoneTwips: documentSettings.hyphenationZoneTwips } : {}
 		};
 		let newBlocks = toFlowBlocks(state.doc, flowOpts);
 		const previewState = templatePreviewValuesKey.getState(state);

package/dist/document-operations.d.ts

@@ -5,7 +5,7 @@ import { FolioAIEditView } from "./ai-edits/apply.js";
 declare const FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION: 1;
 declare const FOLIO_DOCUMENT_OPERATION_TYPES: readonly ["replaceInBlock", "replaceRange", "commentOnRange", "formatRange", "insertAfterBlock", "insertBeforeBlock", "replaceBlock", "deleteBlock", "commentOnBlock", "insertSignatureTable"];
 declare const FOLIO_DOCUMENT_OPERATION_MODES: readonly ["direct", "tracked-changes"];
-declare const FOLIO_DOCUMENT_OPERATION_STORIES: readonly ["main"];
+declare const FOLIO_DOCUMENT_OPERATION_STORIES: readonly ["main", "header", "footer", "footnote", "endnote"];
 declare const FOLIO_DOCUMENT_OPERATION_PRECONDITIONS: readonly ["blockTextHash"];
 declare const FOLIO_DOCUMENT_OPERATION_BATCH_MODES: readonly ["best-effort", "atomic"];
 type FolioDocumentOperation = FolioAIEditOperation;
@@ -68,8 +68,17 @@ type FolioDocumentOperationIssue = {
   recovery: FolioDocumentOperationRecovery;
 };
 type FolioDocumentOperationStory = "main" | {
-  type: "header" | "footer";
+  type: "header";
   relationshipId: string;
+} | {
+  type: "footer";
+  relationshipId: string;
+} | {
+  type: "footnote";
+  noteId: number;
+} | {
+  type: "endnote";
+  noteId: number;
 };
 /** One typed target affected by a successfully applied document operation. */
 type FolioDocumentOperationAffectedTarget = {

package/dist/document-operations.js

@@ -15,7 +15,13 @@ const FOLIO_DOCUMENT_OPERATION_TYPES = Object.freeze([
 	"insertSignatureTable"
 ]);
 const FOLIO_DOCUMENT_OPERATION_MODES = Object.freeze(["direct", "tracked-changes"]);
-const FOLIO_DOCUMENT_OPERATION_STORIES = Object.freeze(["main"]);
+const FOLIO_DOCUMENT_OPERATION_STORIES = Object.freeze([
+	"main",
+	"header",
+	"footer",
+	"footnote",
+	"endnote"
+]);
 const FOLIO_DOCUMENT_OPERATION_PRECONDITIONS = Object.freeze(["blockTextHash"]);
 const FOLIO_DOCUMENT_OPERATION_BATCH_MODES = Object.freeze(["best-effort", "atomic"]);
 const DIRECT_AND_TRACKED_MODES = FOLIO_DOCUMENT_OPERATION_MODES;

package/dist/document-stories.d.ts

@@ -0,0 +1,10 @@
+import { FolioDocumentStoryHandle } from "./ai-edits/headless.js";
+
+//#region src/document-stories.d.ts
+type FolioDocumentStoryPair = {
+  baseStory: FolioDocumentStoryHandle | null;
+  revisedStory: FolioDocumentStoryHandle | null;
+};
+declare const pairFolioDocumentStories: (baseStories: readonly FolioDocumentStoryHandle[], revisedStories: readonly FolioDocumentStoryHandle[]) => FolioDocumentStoryPair[];
+//#endregion
+export { FolioDocumentStoryPair, pairFolioDocumentStories };

package/dist/document-stories.js

@@ -0,0 +1,27 @@
+//#region src/document-stories.ts
+const documentStoryKey = (story) => {
+	if (story.type === "main") return story.type;
+	if (story.type === "header" || story.type === "footer") return `${story.type}:${story.relationshipId}`;
+	return `${story.type}:${String(story.noteId)}`;
+};
+const pairFolioDocumentStories = (baseStories, revisedStories) => {
+	const revisedByKey = new Map(revisedStories.map((story) => [documentStoryKey(story), story]));
+	const pairedKeys = /* @__PURE__ */ new Set();
+	const pairs = [];
+	for (const baseStory of baseStories) {
+		const key = documentStoryKey(baseStory);
+		const revisedStory = revisedByKey.get(key) ?? null;
+		pairs.push({
+			baseStory,
+			revisedStory
+		});
+		if (revisedStory) pairedKeys.add(key);
+	}
+	for (const revisedStory of revisedStories) if (!pairedKeys.has(documentStoryKey(revisedStory))) pairs.push({
+		baseStory: null,
+		revisedStory
+	});
+	return pairs;
+};
+//#endregion
+export { pairFolioDocumentStories };

package/dist/docx/corePropertiesParser.d.ts

@@ -0,0 +1,8 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/corePropertiesParser.d.ts
+type DocumentProperties = NonNullable<document_d_exports.DocxPackage["properties"]>;
+/** Parse recognized package metadata from `docProps/core.xml`. */
+declare const parseCoreProperties: (xml: string | null) => DocumentProperties | undefined;
+//#endregion
+export { parseCoreProperties };

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 ?? ""}` : "";