@stll/folio-core 0.8.0 → 0.10.0

package/dist/docx/fontTableParser.js

@@ -0,0 +1,72 @@
+import { findChild, findChildren, getAttribute, parseXmlDocument } from "./xmlParser.js";
+//#region src/docx/fontTableParser.ts
+const FONT_FAMILIES = [
+	"decorative",
+	"modern",
+	"roman",
+	"script",
+	"swiss",
+	"auto"
+];
+const FONT_PITCHES = [
+	"default",
+	"fixed",
+	"variable"
+];
+const parseFontTable = (xml) => {
+	if (!xml) return;
+	const root = parseXmlDocument(xml);
+	if (!root) return;
+	const fonts = [];
+	for (const element of findChildren(root, "w", "font")) {
+		const font = parseFont(element);
+		if (font) fonts.push(font);
+	}
+	return fonts.length > 0 ? { fonts } : void 0;
+};
+const parseFont = (element) => {
+	const name = getAttribute(element, "w", "name");
+	if (!name) return;
+	const font = { name };
+	assignValue(font, "altName", childValue(element, "altName"));
+	assignValue(font, "panose1", childValue(element, "panose1"));
+	assignValue(font, "charset", childValue(element, "charset"));
+	const family = childValue(element, "family");
+	if (family && isFontFamily(family)) font.family = family;
+	const pitch = childValue(element, "pitch");
+	if (pitch && isFontPitch(pitch)) font.pitch = pitch;
+	const sig = findChild(element, "w", "sig");
+	if (sig) {
+		const parsed = {};
+		assignSignatureValue(parsed, "usb0", getAttribute(sig, "w", "usb0") ?? void 0);
+		assignSignatureValue(parsed, "usb1", getAttribute(sig, "w", "usb1") ?? void 0);
+		assignSignatureValue(parsed, "usb2", getAttribute(sig, "w", "usb2") ?? void 0);
+		assignSignatureValue(parsed, "usb3", getAttribute(sig, "w", "usb3") ?? void 0);
+		assignSignatureValue(parsed, "csb0", getAttribute(sig, "w", "csb0") ?? void 0);
+		assignSignatureValue(parsed, "csb1", getAttribute(sig, "w", "csb1") ?? void 0);
+		if (Object.values(parsed).some((value) => value !== void 0)) font.sig = parsed;
+	}
+	assignValue(font, "embedRegular", relationshipId(element, "embedRegular"));
+	assignValue(font, "embedBold", relationshipId(element, "embedBold"));
+	assignValue(font, "embedItalic", relationshipId(element, "embedItalic"));
+	assignValue(font, "embedBoldItalic", relationshipId(element, "embedBoldItalic"));
+	return font;
+};
+const childValue = (element, name) => {
+	const child = findChild(element, "w", name);
+	return child ? getAttribute(child, "w", "val") ?? void 0 : void 0;
+};
+const relationshipId = (element, name) => {
+	const child = findChild(element, "w", name);
+	return child ? getAttribute(child, "r", "id") ?? void 0 : void 0;
+};
+const assignValue = (font, key, value) => {
+	if (value !== void 0) font[key] = value;
+};
+const assignSignatureValue = (signature, key, value) => {
+	if (value !== void 0) signature[key] = value;
+};
+const isFontFamily = (value) => FONT_FAMILIES.some((family) => family === value);
+const isFontPitch = (value) => FONT_PITCHES.some((pitch) => pitch === value);
+//#endregion
+export { parseFontTable };

package/dist/docx/groupDrawingParser.js

@@ -37,7 +37,10 @@ const colorFrom = (parent, fallback) => {
 		const value = getAttribute(parent, "w", "val");
 		if (value && HEX_COLOR.test(value)) return value.toUpperCase();
 	}
-	const value = getAttribute(findChildByLocalName(findChildByLocalName(parent, "solidFill"), "srgbClr"), null, "val");
+	if (findChildByLocalName(parent, "noFill")) return "none";
+	const srgb = findChildByLocalName(findChildByLocalName(parent, "solidFill"), "srgbClr");
+	const referencedSrgb = findChildByLocalName(parent, "srgbClr");
+	const value = getAttribute(srgb ?? referencedSrgb, null, "val");
 	if (value && HEX_COLOR.test(value)) return value.toUpperCase();
 	return fallback;
 };
@@ -80,9 +83,11 @@ const renderGeometry = (wsp) => {
 	const { x, y, width, height } = childTransform(wsp);
 	if (width <= 0 || height <= 0) return "";
 	const spPr = findChildByLocalName(wsp, "spPr");
+	const style = findChildByLocalName(wsp, "style");
+	const styleStroke = colorFrom(findChildByLocalName(style, "lnRef"), "none");
 	const fill = colorFrom(spPr, "none");
 	const line = findChildByLocalName(spPr, "ln");
-	const stroke = colorFrom(line, "none");
+	const stroke = colorFrom(line, styleStroke);
 	const strokeWidth = line ? parseNumericAttribute(line, null, "w") ?? DEFAULT_LINE_WIDTH_EMU : 0;
 	const paths = findAllDeep(findChildByLocalName(spPr, "custGeom"), "a", "path");
 	if (paths.length === 0) return `<rect x="${x}" y="${y}" width="${width}" height="${height}" fill="${fill === "none" ? "none" : `#${fill}`}" stroke="${stroke === "none" ? "none" : `#${stroke}`}" stroke-width="${strokeWidth}"/>`;

package/dist/docx/headerFooterParser.js

@@ -1,8 +1,8 @@
 import { collectXmlnsDeclarations, parseXml } from "./xmlParser.js";
 import { parseWatermark } from "./watermarkParser.js";
 import { parseFooterReference, parseFooterReferences, parseHeaderReference, parseHeaderReferences } from "./headerFooterRefParser.js";
-import { assignHeaderFooterVerbatimXml } from "./headerFooterVerbatim.js";
 import { parseBlockContent } from "./blockContentParser.js";
+import { assignHeaderFooterVerbatimXml } from "./headerFooterVerbatim.js";
 //#region src/docx/headerFooterParser.ts
 /**
 * Parse a header XML file (word/header*.xml)

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/normalizeBaseDirection.js

@@ -1,5 +1,5 @@
-import { detectBaseDirection } from "../utils/baseDirection.js";
 import { createStyleResolver } from "../prosemirror/styles/styleResolver.js";
+import { detectBaseDirection } from "../utils/baseDirection.js";
 //#region src/docx/normalizeBaseDirection.ts
 const runText = (run) => {
 	let text = "";

package/dist/docx/numberingParser.js

@@ -603,6 +603,7 @@ function computeListRendering(numPr, numbering) {
 	const markerFont = level.rPr?.fontFamily?.ascii || level.rPr?.fontFamily?.hAnsi;
 	if (markerFont) rendering.markerFontFamily = markerFont;
 	if (level.rPr?.fontSize) rendering.markerFontSize = level.rPr.fontSize / 2;
+	if (level.rPr?.bold !== void 0) rendering.markerBold = level.rPr.bold;
 	if (level.rPr?.allCaps) rendering.markerAllCaps = true;
 	if (level.lvlJc) rendering.markerAlignment = level.lvlJc;
 	if (level.suffix) rendering.markerSuffix = level.suffix;

package/dist/docx/paragraphParser.js

@@ -164,12 +164,18 @@ function collectFirstParagraphPropertyChildren(pPr) {
 			case "keepNext":
 				children.keepNext ??= child;
 				break;
+			case "kinsoku":
+				children.kinsoku ??= child;
+				break;
 			case "numPr":
 				children.numPr ??= child;
 				break;
 			case "outlineLvl":
 				children.outlineLvl ??= child;
 				break;
+			case "overflowPunct":
+				children.overflowPunct ??= child;
+				break;
 			case "pageBreakBefore":
 				children.pageBreakBefore ??= child;
 				break;
@@ -226,6 +232,10 @@ function parseParagraphProperties(pPr, theme, styles) {
 	if (!pPr) return;
 	const formatting = {};
 	const propertyChildren = collectFirstParagraphPropertyChildren(pPr);
+	const kinsoku = propertyChildren.kinsoku;
+	if (kinsoku) formatting.kinsoku = parseBooleanElement(kinsoku);
+	const overflowPunct = propertyChildren.overflowPunct;
+	if (overflowPunct) formatting.overflowPunctuation = parseBooleanElement(overflowPunct);
 	const jc = propertyChildren.jc;
 	if (jc) {
 		const val = narrowEnum(getAttribute(jc, "w", "val"), ParagraphAlignmentSchema);
@@ -525,7 +535,7 @@ function isTrackedChangeWrapperChild(content) {
 	return content.type === "run" || content.type === "hyperlink";
 }
 function isInlineSdtContent(content) {
-	return content.type === "run" || content.type === "hyperlink" || content.type === "simpleField" || content.type === "complexField" || content.type === "inlineSdt" || content.type === "mathEquation";
+	return content.type === "run" || content.type === "hyperlink" || content.type === "simpleField" || content.type === "complexField" || content.type === "inlineSdt" || content.type === "insertion" || content.type === "deletion" || content.type === "mathEquation";
 }
 function pushTrackedChangeWrapper({ contents, type, info, content, preserveEmpty = false }) {
 	if (content.length === 0 && !preserveEmpty) return;
@@ -981,6 +991,7 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 				const markerFont = level.rPr?.fontFamily?.ascii || level.rPr?.fontFamily?.hAnsi;
 				if (markerFont) listRendering.markerFontFamily = markerFont;
 				if (level.rPr?.fontSize) listRendering.markerFontSize = level.rPr.fontSize / 2;
+				if (level.rPr?.bold !== void 0) listRendering.markerBold = level.rPr.bold;
 				if (level.rPr?.allCaps) listRendering.markerAllCaps = true;
 				if (level.lvlJc) listRendering.markerAlignment = level.lvlJc;
 				if (level.suffix) listRendering.markerSuffix = level.suffix;

package/dist/docx/parser.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../types/document.js";
-import { DocxUnzipOptions } from "./unzip.js";
 import { DocxInput } from "../utils/docxInput.js";
+import { DocxUnzipOptions } from "./unzip.js";
 
 //#region src/docx/parser.d.ts
 /**

package/dist/docx/parser.js

@@ -1,24 +1,26 @@
-import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
-import { applyThemeFontLang, parseTheme } from "./themeParser.js";
-import { parseEndnotes, parseFootnotes } from "./footnoteParser.js";
-import { DocxModelValidationError, formatDocumentModelIssues, validateFolioDocumentModel } from "./modelValidation.js";
-import { parseNumbering } from "./numberingParser.js";
-import { DocxEncryptionError } from "./encryption/errors.js";
-import { getMediaMimeType, mediaToDataUrl, unzipDocx } from "./unzip.js";
-import { parseComments } from "./commentParser.js";
-import { parseFooter, parseHeader } from "./headerFooterParser.js";
 import { toArrayBuffer } from "../utils/docxInput.js";
 import { loadFontsWithMapping } from "../utils/fontLoader.js";
 import { convertTiffToPngDataUrl, isTiffMimeType } from "../utils/tiffConverter.js";
+import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
+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";
+import { parseFooter, parseHeader } from "./headerFooterParser.js";
 import { normalizeHeaderFooterReferences } from "./headerFooterReferenceNormalization.js";
+import { DocxModelValidationError, formatDocumentModelIssues, validateFolioDocumentModel } from "./modelValidation.js";
 import { extractMetafileRaster, isMetafileMimeType } from "./metafileRaster.js";
+import { parseFontTable } from "./fontTableParser.js";
 import { normalizeNumberingReferences } from "./numberingReferenceNormalization.js";
 import { parseSettings } from "./settingsParser.js";
 import { parseStylesPackage } from "./styleParser.js";
 import { normalizeTrackedMoveRanges } from "./trackedMoveRangeNormalization.js";
+import { DocxEncryptionError } from "./encryption/errors.js";
+import { getMediaMimeType, mediaToDataUrl, unzipDocx } from "./unzip.js";
 import { TaggedError } from "better-result";
 //#region src/docx/parser.ts
 /**
@@ -84,6 +86,7 @@ async function parseDocx(input, options = {}) {
 		onProgress("Parsed styles", 30);
 		onProgress("Parsing numbering...", 30);
 		const numbering = timeStage("numbering", () => parseNumbering(raw.numberingXml));
+		const fontTable = timeStage("fontTable", () => parseFontTable(raw.fontTableXml));
 		onProgress("Parsed numbering", 35);
 		onProgress("Processing media files...", 35);
 		const media = await timeStageAsync("media", () => buildMediaMap(raw, rels));
@@ -166,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),
@@ -174,12 +178,14 @@ async function parseDocx(input, options = {}) {
 				...styleDefinitions !== void 0 ? { styles: styleDefinitions } : {},
 				theme,
 				numbering: numbering.definitions,
+				...fontTable ? { fontTable } : {},
 				...headers !== void 0 ? { headers } : {},
 				...footers !== void 0 ? { footers } : {},
 				...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

@@ -1,8 +1,9 @@
-import { applyReplyThreadMarkers } from "./commentReplyMarkers.js";
 import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
+import { parseNumbering } from "./numberingParser.js";
 import { parseEndnotes, parseFootnotes } from "./footnoteParser.js";
 import { assertValidFolioDocumentModel } from "./modelValidation.js";
-import { parseNumbering } from "./numberingParser.js";
+import { isPreservableDocxEntry } from "./unzip.js";
+import { applyReplyThreadMarkers } from "./commentReplyMarkers.js";
 import { buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds, extractParagraphXml } from "./selectiveXmlPatch.js";
 import { escapeXml } from "./serializer/xmlUtils.js";
 import { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
@@ -10,7 +11,10 @@ import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeHeaderFooter } from "./serializer/headerFooterSerializer.js";
 import { serializeEndnotes, serializeFootnotes } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
-import { isPreservableDocxEntry } from "./unzip.js";
+import { serializeFontTableXml } from "./serializer/fontTableSerializer.js";
+import { serializeSettingsXml } from "./serializer/settingsSerializer.js";
+import { serializeStylesXml } from "./serializer/stylesSerializer.js";
+import { serializeThemeXml } from "./serializer/themeSerializer.js";
 import { panic } from "better-result";
 import JSZip from "jszip";
 //#region src/docx/rezip.ts
@@ -1018,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;
 }
 /**
@@ -1169,7 +1171,7 @@ function createEmptyDocx() {
 	zip.file("docProps/app.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">
   <Application>EigenPal DOCX Editor</Application>
-  <AppVersion>1.0.0</AppVersion>
+  <AppVersion>1.0000</AppVersion>
 </Properties>`);
 	return zip.generateAsync({
 		type: "arraybuffer",
@@ -1184,11 +1186,72 @@ function createEmptyDocx() {
 * @returns Promise resolving to DOCX as ArrayBuffer
 */
 async function createDocx(doc) {
-	const emptyBuffer = await createEmptyDocx();
+	const emptyBuffer = await createDocumentSeedDocx(doc);
 	return repackDocx({
 		...doc,
 		originalBuffer: emptyBuffer
 	});
 }
+const createDocumentSeedDocx = async (doc) => {
+	const buffer = await createEmptyDocx();
+	const zip = await JSZip.loadAsync(buffer);
+	const relationships = ["<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles\" Target=\"styles.xml\"/>"];
+	const overrides = [];
+	let nextRelationshipId = 2;
+	if (doc.package.styles) {
+		assertStyleNumberingReferences(doc);
+		zip.file("word/styles.xml", serializeStylesXml(doc.package.styles));
+	}
+	const numbering = doc.package.numbering;
+	if (numbering && (numbering.abstractNums.length > 0 || numbering.nums.length > 0)) {
+		zip.file("word/numbering.xml", serializeNumberingXml(numbering));
+		relationships.push(relationshipXml(nextRelationshipId, "numbering", "numbering.xml"));
+		overrides.push(overrideXml("/word/numbering.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"));
+		nextRelationshipId += 1;
+	}
+	if (doc.package.theme) {
+		zip.file("word/theme/theme1.xml", serializeThemeXml(doc.package.theme));
+		relationships.push(relationshipXml(nextRelationshipId, "theme", "theme/theme1.xml"));
+		overrides.push(overrideXml("/word/theme/theme1.xml", "application/vnd.openxmlformats-officedocument.theme+xml"));
+		nextRelationshipId += 1;
+	}
+	if (doc.package.fontTable && doc.package.fontTable.fonts.length > 0) {
+		zip.file("word/fontTable.xml", serializeFontTableXml(doc.package.fontTable));
+		relationships.push(relationshipXml(nextRelationshipId, "fontTable", "fontTable.xml"));
+		overrides.push(overrideXml("/word/fontTable.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"));
+		nextRelationshipId += 1;
+	}
+	if (doc.package.settings) {
+		zip.file("word/settings.xml", serializeSettingsXml(doc.package.settings));
+		relationships.push(relationshipXml(nextRelationshipId, "settings", "settings.xml"));
+		overrides.push(overrideXml("/word/settings.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"));
+	}
+	zip.file("word/_rels/document.xml.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${relationships.join("")}</Relationships>`);
+	if (overrides.length > 0) {
+		const contentTypesFile = zip.file("[Content_Types].xml");
+		if (!contentTypesFile) panic("Fresh DOCX seed is missing [Content_Types].xml");
+		const contentTypes = await contentTypesFile.async("string");
+		zip.file("[Content_Types].xml", contentTypes.replace("</Types>", `${overrides.join("")}\n</Types>`));
+	}
+	return zip.generateAsync({
+		type: "arraybuffer",
+		compression: "DEFLATE",
+		compressionOptions: { level: 6 }
+	});
+};
+const relationshipXml = (id, type, target) => `<Relationship Id="rId${id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/${type}" Target="${target}"/>`;
+const overrideXml = (partName, contentType) => `<Override PartName="${partName}" ContentType="${contentType}"/>`;
+const assertStyleNumberingReferences = (doc) => {
+	const referenced = /* @__PURE__ */ new Set();
+	for (const style of doc.package.styles?.styles ?? []) {
+		const numId = style.pPr?.numPr?.numId;
+		if (numId !== void 0) referenced.add(numId);
+	}
+	if (referenced.size === 0) return;
+	const available = new Set(doc.package.numbering?.nums.map((numbering) => numbering.numId) ?? []);
+	for (const numId of referenced) if (!available.has(numId)) panic(`Style references missing numbering definition ${numId}`);
+	const availableAbstract = new Set(doc.package.numbering?.abstractNums.map((numbering) => numbering.abstractNumId) ?? []);
+	for (const numbering of doc.package.numbering?.nums ?? []) if (!availableAbstract.has(numbering.abstractNumId)) panic(`Numbering definition ${numbering.numId} references missing abstract numbering`);
+};
 //#endregion
 export { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_CONTENT_TYPE, COMMENTS_EXTENDED_PART, COMMENTS_EXTENDED_PART_LOWER, DocxPackageFidelityError, addCommentsExtendedOverride, addCommentsExtendedRelationship, addMedia, addRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, createDocx, createEmptyDocx, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, isDocxBuffer, removeCommentsExtendedOverride, removeCommentsExtendedRelationship, repackDocx, repackDocxFromRaw, updateCoreProperties, updateDocumentXml, updateMultipleFiles, updateXmlFile, validateDocx };

package/dist/docx/runConsolidator.js

@@ -38,8 +38,12 @@ function formattingEquals(a, b) {
 	if (!colorEquals(a.color, b.color)) return false;
 	if (!shadingEquals(a.shading, b.shading)) return false;
 	if (!fontFamilyEquals(a.fontFamily, b.fontFamily)) return false;
+	if (!languageEquals(a.language, b.language)) return false;
 	return true;
 }
+function languageEquals(a, b) {
+	return a?.val === b?.val && a?.eastAsia === b?.eastAsia && a?.bidi === b?.bidi;
+}
 /**
 * Compare underline settings
 */

package/dist/docx/runParser.js

@@ -89,6 +89,9 @@ function collectFirstRunPropertyChildren(rPr) {
 			case "kern":
 				children.kern ??= child;
 				break;
+			case "lang":
+				children.lang ??= child;
+				break;
 			case "outline":
 				children.outline ??= child;
 				break;
@@ -262,6 +265,17 @@ function parseRunProperties(rPr, theme, _styles) {
 		}
 		formatting.fontFamily = fontFamily;
 	}
+	const lang = propertyChildren.lang;
+	if (lang) {
+		const val = getAttribute(lang, "w", "val") || void 0;
+		const eastAsia = getAttribute(lang, "w", "eastAsia") || void 0;
+		const bidi = getAttribute(lang, "w", "bidi") || void 0;
+		if (val || eastAsia || bidi) formatting.language = {
+			...val ? { val } : {},
+			...eastAsia ? { eastAsia } : {},
+			...bidi ? { bidi } : {}
+		};
+	}
 	const spacing = propertyChildren.spacing;
 	if (spacing) {
 		const val = parseNumericAttribute(spacing, "w", "val");
@@ -531,7 +545,11 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 			if (vmlDrawing) contents.push(vmlDrawing);
 			break;
 		}
-		case "object": break;
+		case "object": {
+			const objectPreview = parseVmlImageContent(child, rels, media, rootXmlns);
+			if (objectPreview) contents.push(objectPreview);
+			break;
+		}
 		case "rPr": break;
 		case "lastRenderedPageBreak": break;
 		case "cr":