@stll/folio-core 0.8.0 → 0.9.0

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
@@ -1169,7 +1173,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 +1188,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":

package/dist/docx/selectiveSave.js

@@ -1,14 +1,14 @@
-import { hasUnsynthesizedReplyRanges } from "./commentReplyMarkers.js";
 import { RELATIONSHIP_TYPES } from "./relsParser.js";
-import { validateFolioDocumentModel } from "./modelValidation.js";
+import { parseCommentsExtended } from "./commentParser.js";
 import { parseNumbering } from "./numberingParser.js";
+import { validateFolioDocumentModel } from "./modelValidation.js";
+import { hasUnsynthesizedReplyRanges } from "./commentReplyMarkers.js";
 import { buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds } from "./selectiveXmlPatch.js";
 import { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeEndnotes, serializeFootnotes } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
 import { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_PART_LOWER, addCommentsExtendedOverride, addCommentsExtendedRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, updateCoreProperties } from "./rezip.js";
-import { parseCommentsExtended } from "./commentParser.js";
 import "./selectiveSaveFlags.js";
 //#region src/docx/selectiveSave.ts
 const SYNTHETIC_IMAGE_RID_PREFIX = "rId_img_";

package/dist/docx/serializer/fontTableSerializer.d.ts

@@ -0,0 +1,6 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/fontTableSerializer.d.ts
+declare const serializeFontTableXml: (fontTable: document_d_exports.FontTable) => string;
+//#endregion
+export { serializeFontTableXml };

package/dist/docx/serializer/fontTableSerializer.js

@@ -0,0 +1,26 @@
+import { escapeXml } from "./xmlUtils.js";
+//#region src/docx/serializer/fontTableSerializer.ts
+const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+const serializeFontTableXml = (fontTable) => {
+	const fonts = fontTable.fonts.map(serializeFont).join("");
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:fonts xmlns:w="${W_NS}">${fonts}</w:fonts>`;
+};
+const serializeFont = (font) => {
+	const parts = [];
+	if (font.altName) parts.push(`<w:altName w:val="${escapeXml(font.altName)}"/>`);
+	if (font.panose1) parts.push(`<w:panose1 w:val="${escapeXml(font.panose1)}"/>`);
+	if (font.charset) parts.push(`<w:charset w:val="${escapeXml(font.charset)}"/>`);
+	if (font.family) parts.push(`<w:family w:val="${font.family}"/>`);
+	if (font.pitch) parts.push(`<w:pitch w:val="${font.pitch}"/>`);
+	if (font.sig) {
+		const attrs = [];
+		for (const [key, value] of Object.entries(font.sig)) {
+			if (value === void 0) continue;
+			attrs.push(`w:${key}="${escapeXml(value)}"`);
+		}
+		if (attrs.length > 0) parts.push(`<w:sig ${attrs.join(" ")}/>`);
+	}
+	return `<w:font w:name="${escapeXml(font.name)}">${parts.join("")}</w:font>`;
+};
+//#endregion
+export { serializeFontTableXml };

package/dist/docx/serializer/headerFooterSerializer.js

@@ -1,8 +1,8 @@
+import { canReplayHeaderFooterVerbatim, getHeaderFooterVerbatimXml } from "../headerFooterVerbatim.js";
 import { escapeXml } from "./xmlUtils.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializeTable } from "./tableSerializer.js";
-import { canReplayHeaderFooterVerbatim, getHeaderFooterVerbatimXml } from "../headerFooterVerbatim.js";
 //#region src/docx/serializer/headerFooterSerializer.ts
 const NAMESPACES = {
 	wpc: "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",

package/dist/docx/serializer/paragraphSerializer.js

@@ -165,6 +165,8 @@ function serializeParagraphFormatting(formatting, propertyChanges, pPrMark) {
 		if (tabsXml) parts.push(tabsXml);
 		pushToggle("suppressLineNumbers", formatting.suppressLineNumbers);
 		pushToggle("suppressAutoHyphens", formatting.suppressAutoHyphens);
+		pushToggle("kinsoku", formatting.kinsoku);
+		pushToggle("overflowPunct", formatting.overflowPunctuation);
 		const spacingXml = serializeSpacing(formatting);
 		if (spacingXml) parts.push(spacingXml);
 		const indXml = serializeIndentation(formatting);
@@ -350,6 +352,8 @@ function serializeInlineSdt(sdt) {
 			case "simpleField": return serializeSimpleField(item);
 			case "complexField": return serializeComplexField(item);
 			case "inlineSdt": return serializeInlineSdt(item);
+			case "insertion": return serializeTrackedChange("ins", item);
+			case "deletion": return serializeTrackedChange("del", item);
 			case "mathEquation": return item.ommlXml || "";
 			default: return item;
 		}

package/dist/docx/serializer/runSerializer.js

@@ -85,6 +85,13 @@ function serializeTextFormatting(formatting) {
 		if (formatting.fontFamily.csTheme) fontAttrs.push(`w:cstheme="${formatting.fontFamily.csTheme}"`);
 		if (fontAttrs.length > 0) parts.push(`<w:rFonts ${fontAttrs.join(" ")}/>`);
 	}
+	if (formatting.language) {
+		const languageAttrs = [];
+		if (formatting.language.val) languageAttrs.push(`w:val="${escapeXml(formatting.language.val)}"`);
+		if (formatting.language.eastAsia) languageAttrs.push(`w:eastAsia="${escapeXml(formatting.language.eastAsia)}"`);
+		if (formatting.language.bidi) languageAttrs.push(`w:bidi="${escapeXml(formatting.language.bidi)}"`);
+		if (languageAttrs.length > 0) parts.push(`<w:lang ${languageAttrs.join(" ")}/>`);
+	}
 	if (formatting.bold === true) parts.push("<w:b/>");
 	else if (formatting.bold === false) parts.push("<w:b w:val=\"0\"/>");
 	if (formatting.boldCs === true) parts.push("<w:bCs/>");

package/dist/docx/serializer/settingsSerializer.d.ts

@@ -0,0 +1,6 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/settingsSerializer.d.ts
+declare const serializeSettingsXml: (settings: document_d_exports.DocumentSettings) => string;
+//#endregion
+export { serializeSettingsXml };

package/dist/docx/serializer/settingsSerializer.js

@@ -0,0 +1,16 @@
+import { escapeXml, intAttr } from "./xmlUtils.js";
+//#region src/docx/serializer/settingsSerializer.ts
+const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+const serializeSettingsXml = (settings) => {
+	const parts = [`<w:defaultTabStop w:val="${intAttr(settings.defaultTabStop)}"/>`];
+	if (settings.evenAndOddHeaders) parts.push("<w:evenAndOddHeaders/>");
+	if (settings.themeFontLang) {
+		const attrs = [];
+		if (settings.themeFontLang.eastAsia) attrs.push(`w:eastAsia="${escapeXml(settings.themeFontLang.eastAsia)}"`);
+		if (settings.themeFontLang.bidi) attrs.push(`w:bidi="${escapeXml(settings.themeFontLang.bidi)}"`);
+		if (attrs.length > 0) parts.push(`<w:themeFontLang ${attrs.join(" ")}/>`);
+	}
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:settings xmlns:w="${W_NS}">${parts.join("")}</w:settings>`;
+};
+//#endregion
+export { serializeSettingsXml };

package/dist/docx/serializer/stylesSerializer.d.ts

@@ -0,0 +1,6 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/stylesSerializer.d.ts
+declare const serializeStylesXml: (definitions: document_d_exports.StyleDefinitions) => string;
+//#endregion
+export { serializeStylesXml };

package/dist/docx/serializer/stylesSerializer.js

@@ -0,0 +1,56 @@
+import { escapeXml } from "./xmlUtils.js";
+import { serializeTextFormatting } from "./runSerializer.js";
+import { serializeParagraphFormatting } from "./paragraphSerializer.js";
+import { serializeTableCellFormatting, serializeTableFormatting, serializeTableRowFormatting } from "./tableSerializer.js";
+//#region src/docx/serializer/stylesSerializer.ts
+const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+const serializeStylesXml = (definitions) => {
+	const docDefaults = serializeDocumentDefaults(definitions);
+	const latentStyles = serializeLatentStyles(definitions);
+	const styles = definitions.styles.map(serializeStyle).join("");
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:styles xmlns:w="${W_NS}">${docDefaults}${latentStyles}${styles}</w:styles>`;
+};
+const serializeDocumentDefaults = (definitions) => {
+	return `<w:docDefaults><w:rPrDefault>${serializeTextFormatting(definitions.docDefaults?.rPr) || "<w:rPr/>"}</w:rPrDefault><w:pPrDefault>${serializeParagraphFormatting(definitions.docDefaults?.pPr) || "<w:pPr/>"}</w:pPrDefault></w:docDefaults>`;
+};
+const serializeLatentStyles = (definitions) => {
+	const latent = definitions.latentStyles;
+	if (!latent) return "";
+	const attrs = [];
+	pushBooleanAttr(attrs, "w:defLockedState", latent.defLockedState);
+	if (latent.defUIPriority !== void 0) attrs.push(`w:defUIPriority="${latent.defUIPriority}"`);
+	pushBooleanAttr(attrs, "w:defSemiHidden", latent.defSemiHidden);
+	pushBooleanAttr(attrs, "w:defUnhideWhenUsed", latent.defUnhideWhenUsed);
+	pushBooleanAttr(attrs, "w:defQFormat", latent.defQFormat);
+	return `<w:latentStyles${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}/>`;
+};
+const serializeStyle = (style) => {
+	const attrs = [`w:type="${style.type}"`, `w:styleId="${escapeXml(style.styleId)}"`];
+	if (style.default) attrs.push("w:default=\"1\"");
+	const parts = [`<w:name w:val="${escapeXml(style.name ?? style.styleId)}"/>`];
+	if (style.basedOn) parts.push(`<w:basedOn w:val="${escapeXml(style.basedOn)}"/>`);
+	if (style.next) parts.push(`<w:next w:val="${escapeXml(style.next)}"/>`);
+	if (style.link) parts.push(`<w:link w:val="${escapeXml(style.link)}"/>`);
+	if (style.uiPriority !== void 0) parts.push(`<w:uiPriority w:val="${style.uiPriority}"/>`);
+	pushBooleanElement(parts, "hidden", style.hidden);
+	pushBooleanElement(parts, "semiHidden", style.semiHidden);
+	pushBooleanElement(parts, "unhideWhenUsed", style.unhideWhenUsed);
+	pushBooleanElement(parts, "qFormat", style.qFormat);
+	pushBooleanElement(parts, "personal", style.personal);
+	parts.push(serializeParagraphFormatting(style.pPr));
+	parts.push(serializeTextFormatting(style.rPr));
+	parts.push(serializeTableFormatting(style.tblPr));
+	parts.push(serializeTableRowFormatting(style.trPr));
+	parts.push(serializeTableCellFormatting(style.tcPr));
+	for (const conditional of style.tblStylePr ?? []) parts.push(`<w:tblStylePr w:type="${conditional.type}">${serializeParagraphFormatting(conditional.pPr)}${serializeTextFormatting(conditional.rPr)}${serializeTableFormatting(conditional.tblPr)}${serializeTableRowFormatting(conditional.trPr)}${serializeTableCellFormatting(conditional.tcPr)}</w:tblStylePr>`);
+	return `<w:style ${attrs.join(" ")}>${parts.join("")}</w:style>`;
+};
+const pushBooleanElement = (parts, name, value) => {
+	if (value === true) parts.push(`<w:${name}/>`);
+	else if (value === false) parts.push(`<w:${name} w:val="0"/>`);
+};
+const pushBooleanAttr = (attrs, name, value) => {
+	if (value !== void 0) attrs.push(`${name}="${value ? 1 : 0}"`);
+};
+//#endregion
+export { serializeStylesXml };

package/dist/docx/serializer/tableSerializer.js

@@ -30,36 +30,35 @@ function serializeMeasurement(measurement, elementName) {
 /**
 * Serialize table borders (w:tblBorders or w:tcBorders)
 */
+function serializeTableBorderParts(borders) {
+	const parts = [];
+	const appendBorder = (border, name) => {
+		const xml = serializeBorder(border, name);
+		if (xml) parts.push(xml);
+	};
+	appendBorder(borders.top, "top");
+	appendBorder(borders.left, "left");
+	appendBorder(borders.bottom, "bottom");
+	appendBorder(borders.right, "right");
+	appendBorder(borders.insideH, "insideH");
+	appendBorder(borders.insideV, "insideV");
+	return parts;
+}
 function serializeTableBorders(borders, elementName) {
 	if (!borders) return "";
-	const parts = [];
-	if (borders.top) {
-		const topXml = serializeBorder(borders.top, "top");
-		if (topXml) parts.push(topXml);
-	}
-	if (borders.left) {
-		const leftXml = serializeBorder(borders.left, "left");
-		if (leftXml) parts.push(leftXml);
-	}
-	if (borders.bottom) {
-		const bottomXml = serializeBorder(borders.bottom, "bottom");
-		if (bottomXml) parts.push(bottomXml);
-	}
-	if (borders.right) {
-		const rightXml = serializeBorder(borders.right, "right");
-		if (rightXml) parts.push(rightXml);
-	}
-	if (borders.insideH) {
-		const insideHXml = serializeBorder(borders.insideH, "insideH");
-		if (insideHXml) parts.push(insideHXml);
-	}
-	if (borders.insideV) {
-		const insideVXml = serializeBorder(borders.insideV, "insideV");
-		if (insideVXml) parts.push(insideVXml);
-	}
+	const parts = serializeTableBorderParts(borders);
 	if (parts.length === 0) return "";
 	return `<w:${elementName}>${parts.join("")}</w:${elementName}>`;
 }
+function serializeTableCellBorders(borders) {
+	if (!borders) return "";
+	const parts = serializeTableBorderParts(borders);
+	const topLeftToBottomRight = serializeBorder(borders.topLeftToBottomRight, "tl2br");
+	if (topLeftToBottomRight) parts.push(topLeftToBottomRight);
+	const topRightToBottomLeft = serializeBorder(borders.topRightToBottomLeft, "tr2bl");
+	if (topRightToBottomLeft) parts.push(topRightToBottomLeft);
+	return parts.length > 0 ? `<w:tcBorders>${parts.join("")}</w:tcBorders>` : "";
+}
 /**
 * Serialize cell margins (w:tblCellMar or w:tcMar)
 */
@@ -238,7 +237,7 @@ function serializeTableCellFormatting(formatting, propertyChanges, structuralCha
 		if (formatting.gridSpan && formatting.gridSpan > 1) parts.push(`<w:gridSpan w:val="${intAttr(formatting.gridSpan)}"/>`);
 		if (formatting.vMerge) if (formatting.vMerge === "restart") parts.push("<w:vMerge w:val=\"restart\"/>");
 		else parts.push("<w:vMerge/>");
-		const bordersXml = serializeTableBorders(formatting.borders, "tcBorders");
+		const bordersXml = serializeTableCellBorders(formatting.borders);
 		if (bordersXml) parts.push(bordersXml);
 		const shadingXml = serializeShading(formatting.shading);
 		if (shadingXml) parts.push(shadingXml);

package/dist/docx/serializer/themeSerializer.d.ts

@@ -0,0 +1,6 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/docx/serializer/themeSerializer.d.ts
+declare const serializeThemeXml: (theme: document_d_exports.Theme) => string;
+//#endregion
+export { serializeThemeXml };

package/dist/docx/serializer/themeSerializer.js

@@ -0,0 +1,36 @@
+import { escapeXml } from "./xmlUtils.js";
+//#region src/docx/serializer/themeSerializer.ts
+const A_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
+const serializeThemeXml = (theme) => {
+	const name = escapeXml(theme.name ?? "Folio Theme");
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<a:theme xmlns:a="${A_NS}" name="${name}"><a:themeElements>${serializeColorScheme(theme.colorScheme)}${serializeFontScheme(theme)}${serializeFormatScheme(theme)}</a:themeElements></a:theme>`;
+};
+const serializeColorScheme = (colors) => {
+	const values = {
+		dk1: colors?.dk1 ?? "000000",
+		lt1: colors?.lt1 ?? "FFFFFF",
+		dk2: colors?.dk2 ?? "44546A",
+		lt2: colors?.lt2 ?? "E7E6E6",
+		accent1: colors?.accent1 ?? "4472C4",
+		accent2: colors?.accent2 ?? "ED7D31",
+		accent3: colors?.accent3 ?? "A5A5A5",
+		accent4: colors?.accent4 ?? "FFC000",
+		accent5: colors?.accent5 ?? "5B9BD5",
+		accent6: colors?.accent6 ?? "70AD47",
+		hlink: colors?.hlink ?? "0563C1",
+		folHlink: colors?.folHlink ?? "954F72"
+	};
+	return `<a:clrScheme name="Folio">${Object.entries(values).map(([slot, value]) => `<a:${slot}><a:srgbClr val="${escapeXml(value)}"/></a:${slot}>`).join("")}</a:clrScheme>`;
+};
+const serializeFontScheme = (theme) => {
+	return `<a:fontScheme name="Folio">${serializeThemeFont(theme.fontScheme?.majorFont, "majorFont", "Arial")}${serializeThemeFont(theme.fontScheme?.minorFont, "minorFont", "Arial")}</a:fontScheme>`;
+};
+const serializeThemeFont = (font, element, fallback) => {
+	const scriptFonts = Object.entries(font?.fonts ?? {}).map(([script, typeface]) => `<a:font script="${escapeXml(script)}" typeface="${escapeXml(typeface)}"/>`).join("");
+	return `<a:${element}><a:latin typeface="${escapeXml(font?.latin ?? fallback)}"/><a:ea typeface="${escapeXml(font?.ea ?? "")}"/><a:cs typeface="${escapeXml(font?.cs ?? "")}"/>${scriptFonts}</a:${element}>`;
+};
+const serializeFormatScheme = (theme) => {
+	return `<a:fmtScheme name="${escapeXml(theme.formatScheme?.name ?? "Folio")}"><a:fillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:fillStyleLst><a:lnStyleLst><a:ln w="6350" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:prstDash val="solid"/></a:ln></a:lnStyleLst><a:effectStyleLst><a:effectStyle><a:effectLst/></a:effectStyle></a:effectStyleLst><a:bgFillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:bgFillStyleLst></a:fmtScheme>`;
+};
+//#endregion
+export { serializeThemeXml };

package/dist/docx/settingsParser.js

@@ -8,6 +8,8 @@ const DEFAULT_TAB_STOP_TWIPS = 720;
 * we substitute the OOXML default instead.
 */
 const MAX_TAB_STOP_TWIPS = 31680;
+const MAX_HYPHENATION_ZONE_TWIPS = 31680;
+const MAX_CONSECUTIVE_HYPHEN_LIMIT = 255;
 function parseSettings(xml) {
 	const root = xml ? parseXmlDocument(xml) : null;
 	const settings = { defaultTabStop: parseDefaultTabStop(root) };
@@ -22,8 +24,52 @@ function parseSettings(xml) {
 		...eastAsiaLang ? { eastAsia: eastAsiaLang } : {},
 		...bidiLang ? { bidi: bidiLang } : {}
 	};
+	const autoHyphenation = parseOnOffSetting(root, "autoHyphenation");
+	if (autoHyphenation !== void 0) settings.autoHyphenation = autoHyphenation;
+	const doNotHyphenateCaps = parseOnOffSetting(root, "doNotHyphenateCaps");
+	if (doNotHyphenateCaps !== void 0) settings.doNotHyphenateCaps = doNotHyphenateCaps;
+	const consecutiveHyphenLimit = parseIntegerSetting(root, "consecutiveHyphenLimit", MAX_CONSECUTIVE_HYPHEN_LIMIT);
+	if (consecutiveHyphenLimit !== void 0) settings.consecutiveHyphenLimit = consecutiveHyphenLimit;
+	const hyphenationZoneTwips = parseIntegerSetting(root, "hyphenationZone", MAX_HYPHENATION_ZONE_TWIPS);
+	if (hyphenationZoneTwips !== void 0) settings.hyphenationZoneTwips = hyphenationZoneTwips;
+	const noLineBreaksBefore = parseKinsokuOverride(root, "noLineBreaksBefore");
+	const noLineBreaksAfter = parseKinsokuOverride(root, "noLineBreaksAfter");
+	const compat = root ? findChild(root, "w", "compat") : null;
+	const splitPageBreakAndParagraphMark = compat ? findChild(compat, "w", "splitPgBreakAndParaMark") : null;
+	if (splitPageBreakAndParagraphMark && parseBooleanElement(splitPageBreakAndParagraphMark)) settings.splitPageBreakAndParagraphMark = true;
+	const applyBreakingRules = compat ? findChild(compat, "w", "applyBreakingRules") : null;
+	const useLegacyEthiopicAmharicRules = applyBreakingRules !== null && parseBooleanElement(applyBreakingRules);
+	if (noLineBreaksBefore || noLineBreaksAfter || useLegacyEthiopicAmharicRules) settings.lineBreakRules = {
+		...noLineBreaksBefore ? { noLineBreaksBefore } : {},
+		...noLineBreaksAfter ? { noLineBreaksAfter } : {},
+		...useLegacyEthiopicAmharicRules ? { useLegacyEthiopicAmharicRules: true } : {}
+	};
 	return settings;
 }
+function parseOnOffSetting(root, name) {
+	if (!root) return;
+	const element = findChild(root, "w", name);
+	return element ? parseBooleanElement(element) : void 0;
+}
+function parseIntegerSetting(root, name, maximum) {
+	if (!root) return;
+	const element = findChild(root, "w", name);
+	const raw = element ? getAttribute(element, "w", "val") : null;
+	if (raw === null || !/^\d+$/u.test(raw)) return;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isSafeInteger(parsed) && parsed <= maximum ? parsed : void 0;
+}
+function parseKinsokuOverride(root, name) {
+	if (!root) return;
+	const element = findChild(root, "w", name);
+	const characters = element ? getAttribute(element, "w", "val") : null;
+	if (!characters) return;
+	const language = getAttribute(element, "w", "lang") || void 0;
+	return {
+		characters,
+		...language ? { language } : {}
+	};
+}
 function parseDefaultTabStop(root) {
 	if (!root) return 720;
 	const el = findChild(root, "w", "defaultTabStop");

package/dist/docx/styleParser.js

@@ -110,6 +110,17 @@ function parseRunProperties(rPr, theme) {
 		}
 		formatting.fontFamily = fontFamily;
 	}
+	const lang = findChild(rPr, "w", "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 = findChild(rPr, "w", "spacing");
 	if (spacing) {
 		const val = parseNumericAttribute(spacing, "w", "val");
@@ -348,6 +359,10 @@ function parseParagraphProperties(pPr, theme) {
 	if (suppressLineNumbers) formatting.suppressLineNumbers = parseBooleanElement(suppressLineNumbers);
 	const suppressAutoHyphens = findChild(pPr, "w", "suppressAutoHyphens");
 	if (suppressAutoHyphens) formatting.suppressAutoHyphens = parseBooleanElement(suppressAutoHyphens);
+	const kinsoku = findChild(pPr, "w", "kinsoku");
+	if (kinsoku) formatting.kinsoku = parseBooleanElement(kinsoku);
+	const overflowPunct = findChild(pPr, "w", "overflowPunct");
+	if (overflowPunct) formatting.overflowPunctuation = parseBooleanElement(overflowPunct);
 	const rPr = findChild(pPr, "w", "rPr");
 	if (rPr) {
 		const runProps = parseRunProperties(rPr, theme);
@@ -388,6 +403,16 @@ function parseTableBorders(tblBorders) {
 	if (insideV) borders.insideV = insideV;
 	return Object.keys(borders).length > 0 ? borders : void 0;
 }
+/** Parse cell-only diagonal borders in addition to the shared table sides. */
+function parseTableCellBorders(tcBorders) {
+	if (!tcBorders) return;
+	const borders = { ...parseTableBorders(tcBorders) };
+	const topLeftToBottomRight = parseBorderSpec(findChild(tcBorders, "w", "tl2br"));
+	if (topLeftToBottomRight) borders.topLeftToBottomRight = topLeftToBottomRight;
+	const topRightToBottomLeft = parseBorderSpec(findChild(tcBorders, "w", "tr2bl"));
+	if (topRightToBottomLeft) borders.topRightToBottomLeft = topRightToBottomLeft;
+	return Object.keys(borders).length > 0 ? borders : void 0;
+}
 /**
 * Parse cell margins
 */
@@ -535,7 +560,7 @@ function parseTableCellProperties(tcPr, _theme) {
 	}
 	const tcBorders = findChild(tcPr, "w", "tcBorders");
 	if (tcBorders) {
-		const bordersResult = parseTableBorders(tcBorders);
+		const bordersResult = parseTableCellBorders(tcBorders);
 		if (bordersResult) formatting.borders = bordersResult;
 	}
 	const tcMar = findChild(tcPr, "w", "tcMar");

package/dist/docx/tableParser.js

@@ -105,6 +105,16 @@ function parseTableBorders(bordersElement) {
 	if (Object.keys(borders).length === 0) return;
 	return borders;
 }
+/** Parse cell-only diagonal borders in addition to the shared table sides. */
+function parseTableCellBorders(bordersElement) {
+	if (!bordersElement) return;
+	const borders = { ...parseTableBorders(bordersElement) };
+	const topLeftToBottomRight = parseBorderSpec(findChild(bordersElement, "w", "tl2br"));
+	if (topLeftToBottomRight) borders.topLeftToBottomRight = topLeftToBottomRight;
+	const topRightToBottomLeft = parseBorderSpec(findChild(bordersElement, "w", "tr2bl"));
+	if (topRightToBottomLeft) borders.topRightToBottomLeft = topRightToBottomLeft;
+	return Object.keys(borders).length > 0 ? borders : void 0;
+}
 /**
 * Parse cell margins (w:tblCellMar or w:tcMar)
 *
@@ -446,7 +456,7 @@ function parseTableCellProperties(tcPrElement) {
 	const formatting = {};
 	const width = parseWidth(findChild(tcPrElement, "w", "tcW"));
 	if (width) formatting.width = width;
-	const borders = parseTableBorders(findChild(tcPrElement, "w", "tcBorders"));
+	const borders = parseTableCellBorders(findChild(tcPrElement, "w", "tcBorders"));
 	if (borders) formatting.borders = borders;
 	const margins = parseCellMargins(findChild(tcPrElement, "w", "tcMar"));
 	if (margins) formatting.margins = margins;

package/dist/docx/vmlImageParser.js

@@ -206,6 +206,7 @@ function parseVmlImageContent(pictElement, rels, media, rootXmlns = {}) {
 		const shapeStyle = parseStyleAttr(getAttribute(shape, null, "style"));
 		const widthPx = cssLengthToPx(shapeStyle["width"]);
 		const heightPx = cssLengthToPx(shapeStyle["height"]);
+		if (getLocalName(pictElement.name ?? "") === "object" && (widthPx !== void 0 && !validPreviewDimension(widthPx) || heightPx !== void 0 && !validPreviewDimension(heightPx))) continue;
 		const image = {
 			type: "image",
 			rId,