@stll/folio-core 0.62.0 → 0.63.0

package/dist/docx/rezip.js

@@ -5,7 +5,7 @@ import { canonicalJson } from "../utils/canonicalJson.js";
 import { base64ToBytes, decodeText, encodeUtf8 } from "../utils/textEncoding.js";
 import { isAllowedExternalWatermarkImageUrl } from "../watermark/index.js";
 import { appVersionInSchemaForm, normalizeAppVersionInExtendedProperties } from "./appVersionNormalization.js";
-import { withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
+import { withoutExhaustedComments, withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
 import { applyReplyThreadMarkers } from "./commentReplyMarkers.js";
 import { registerContentTypeParts } from "./contentTypeRegistry.js";
 import { readDocumentSectionFacts } from "./documentSectionFacts.js";
@@ -44,40 +44,10 @@ import { hasCanonicalWordprocessingPrefixes } from "./wordprocessingPrefixes.js"
 import { OFFICE_RELATIONSHIP_NAMESPACE_URIS, OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, findAttributeByNamespaceUri, findChild, findChildByNamespaceUri, findChildrenByNamespaceUri, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri, matchesName, parseXml, parseXmlDocument } from "./xmlParser.js";
 import { Result, TaggedError, panic } from "better-result";
 import { assertValidOoxmlNumericIds, escapeXmlAttribute, escapeXmlText, validateDocxPackage } from "@stll/docx-core";
-import { mintRelationshipId } from "@stll/docx-core/model";
-import { writeZipPart } from "@stll/docx-core/zip";
+import { mintRelationshipId, numberingInstanceResolves } from "@stll/docx-core/model";
 import JSZip from "jszip";
+import { writeZipPart } from "@stll/docx-core/zip";
 //#region src/docx/rezip.ts
-/**
-* DOCX Repacker - Repack modified document into valid DOCX
-*
-* Takes a Document with modified content and creates a new DOCX file
-* by updating document.xml while preserving all other files from
-* the original ZIP archive.
-*
-* This ensures round-trip fidelity:
-* - styles.xml, theme1.xml, fontTable.xml remain untouched
-* - Media files preserved
-* - Relationships preserved
-* - Only document.xml is updated with new content
-*
-* OOXML Package Structure:
-* - [Content_Types].xml - Content type declarations
-* - _rels/.rels - Package relationships
-* - word/document.xml - Main document (modified)
-* - word/styles.xml - Styles (preserved)
-* - word/theme/theme1.xml - Theme (preserved)
-* - word/numbering.xml - Numbering (preserved)
-* - word/fontTable.xml - Font table (preserved)
-* - word/settings.xml - Settings (preserved)
-* - word/header*.xml - Headers (preserved)
-* - word/footer*.xml - Footers (preserved)
-* - word/footnotes.xml - Footnotes (preserved)
-* - word/endnotes.xml - Endnotes (preserved)
-* - word/media/* - Media files (preserved)
-* - word/_rels/document.xml.rels - Document relationships (preserved)
-* - docProps/* - Document properties (preserved)
-*/
 var DocxPackageFidelityError = class extends TaggedError("DocxPackageFidelityError") {
 	constructor(message) {
 		super({ message });
@@ -224,7 +194,8 @@ async function serializeCommentsToZip(doc, zip, compressionLevel) {
 }
 const hasCommentEntries = (xml) => {
 	const root = parseXml(xml);
-	return getChildElements(findChild(root, "w", "comments") ?? root).some((element) => matchesName(element, "w", "comment"));
+	const comments = findChild(root, "w", "comments") ?? root;
+	return getChildElements(comments).some((element) => matchesName(element, "w", "comment"));
 };
 /**
 * Bring `word/commentsExtended.xml` and its packaging (content-type override +
@@ -471,15 +442,18 @@ async function processNewImages(parts, zip, compressionLevel) {
 			}) ?? panic("A detached drawing lost its embedded image relationship");
 			image.rId = newRId;
 		}
-		if (relEntries.length > 0) writeZipPart({
-			zip,
-			path: relsPath,
-			data: encodeUtf8(relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`)),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions: { level: compressionLevel }
-			}
-		});
+		if (relEntries.length > 0) {
+			const updatedRelsXml = relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`);
+			writeZipPart({
+				zip,
+				path: relsPath,
+				data: encodeUtf8(updatedRelsXml),
+				options: {
+					compression: "DEFLATE",
+					compressionOptions: { level: compressionLevel }
+				}
+			});
+		}
 	}
 	await registerImageExtensions(zip, extensionsAdded, compressionLevel);
 }
@@ -953,24 +927,27 @@ const finishRepack = async ({ document: sourceDocument, originalZip, outputZip,
 	await serializeHeaderFooterSettingsIntoZip(document, outputZip, compressionLevel);
 	await serializeCommentsToZip(document, outputZip, compressionLevel);
 	await dropAttachedTemplateReference(outputZip, compressionLevel);
-	if (updateModifiedDate && originalCorePropertiesXml) writeZipPart({
-		zip: outputZip,
-		path: "docProps/core.xml",
-		data: encodeUtf8(updateCoreProperties(originalCorePropertiesXml, {
+	if (updateModifiedDate && originalCorePropertiesXml) {
+		const updatedCoreProperties = updateCoreProperties(originalCorePropertiesXml, {
 			updateModifiedDate,
 			...modifiedBy !== void 0 ? { modifiedBy } : {}
-		})),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+		});
+		writeZipPart({
+			zip: outputZip,
+			path: "docProps/core.xml",
+			data: encodeUtf8(updatedCoreProperties),
+			options: {
+				compression: "DEFLATE",
+				compressionOptions: { level: compressionLevel }
+			}
+		});
+	}
 	return generateDocxZip(outputZip, compressionLevel);
 };
 async function repackDocxWithSectionEndpointRemoval({ document: doc, options, sectionEndpointRemoval, sectionReferenceRemovals }) {
 	if (!doc.originalBuffer) panic("Cannot repack document: no original buffer for round-trip. Use createDocx() for new documents.");
 	const { compressionLevel = 6, updateModifiedDate = true, modifiedBy, changedNoteParaIds } = options;
-	const exportDocument = withoutOrphanCommentRanges(doc);
+	const exportDocument = withoutExhaustedComments(withoutOrphanCommentRanges(doc));
 	const originalZip = await JSZip.loadAsync(doc.originalBuffer);
 	const [originalDocumentXml, originalCorePropertiesXml] = await Promise.all([originalZip.file("word/document.xml")?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })), originalZip.file("docProps/core.xml")?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))]);
 	removeUnsafeEntries(originalZip);
@@ -1011,7 +988,7 @@ function repackDocx(doc, options = {}) {
 */
 async function repackDocxFromRaw(doc, rawContent, options = {}) {
 	const { compressionLevel = 6, updateModifiedDate = true, modifiedBy, changedNoteParaIds } = options;
-	let exportDocument = withoutOrphanCommentRanges(cloneExportDocument(doc));
+	let exportDocument = withoutExhaustedComments(withoutOrphanCommentRanges(cloneExportDocument(doc)));
 	const newZip = new JSZip();
 	for (const [path, file] of Object.entries(rawContent.originalZip.files)) {
 		if (file.dir) {
@@ -1098,18 +1075,21 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 	await serializeAddedStylesIntoZip(exportDocument, rawContent.originalZip, newZip, compressionLevel);
 	await serializeCommentsToZip(exportDocument, newZip, compressionLevel);
 	await dropAttachedTemplateReference(newZip, compressionLevel);
-	if (updateModifiedDate && rawContent.corePropsXml) writeZipPart({
-		zip: newZip,
-		path: "docProps/core.xml",
-		data: encodeUtf8(updateCoreProperties(rawContent.corePropsXml, {
+	if (updateModifiedDate && rawContent.corePropsXml) {
+		const updatedCoreProps = updateCoreProperties(rawContent.corePropsXml, {
 			updateModifiedDate,
 			...modifiedBy !== void 0 ? { modifiedBy } : {}
-		})),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+		});
+		writeZipPart({
+			zip: newZip,
+			path: "docProps/core.xml",
+			data: encodeUtf8(updatedCoreProps),
+			options: {
+				compression: "DEFLATE",
+				compressionOptions: { level: compressionLevel }
+			}
+		});
+	}
 	return generateDocxZip(newZip, compressionLevel);
 }
 const COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
@@ -1369,10 +1349,11 @@ async function addRelationship(originalBuffer, relationship) {
 	const newRId = `rId${findMaxRId(relsXml) + 1}`;
 	const targetModeAttr = relationship.targetMode === "External" ? " TargetMode=\"External\"" : "";
 	const newRelElement = `<Relationship Id="${newRId}" Type="${relationship.type}" Target="${escapeXmlAttribute(relationship.target)}"${targetModeAttr}/>`;
+	const updatedRelsXml = relsXml.replace("</Relationships>", `${newRelElement}</Relationships>`);
 	writeZipPart({
 		zip,
 		path: relsPath,
-		data: encodeUtf8(relsXml.replace("</Relationships>", `${newRelElement}</Relationships>`))
+		data: encodeUtf8(updatedRelsXml)
 	});
 	return {
 		buffer: await zip.generateAsync({
@@ -1673,17 +1654,18 @@ async function rebindWatermarkRelIds({ document: doc, zip, compressionLevel, bod
 	const changedPaths = /* @__PURE__ */ new Set();
 	for (const { watermark, header, relsPath, partPath } of pending) {
 		let canonical;
-		if (watermark.imageTarget !== void 0) if (watermark.imageTargetExternal) {
-			if (bodyAuthority === "canonical" && !isAllowedExternalWatermarkImageUrl(watermark.imageTarget)) throw new DocxPackageFidelityError("A canonical picture watermark has an unsafe external target");
-			canonical = isAllowedExternalWatermarkImageUrl(watermark.imageTarget) ? {
-				mode: "external",
-				url: watermark.imageTarget
-			} : resolveCanonical(watermark.imageRId);
-		} else canonical = {
-			mode: "internal",
-			absolute: watermark.imageTarget
-		};
-		else canonical = resolveCanonical(watermark.imageRId);
+		if (watermark.imageTarget !== void 0) {
+			if (watermark.imageTargetExternal) {
+				if (bodyAuthority === "canonical" && !isAllowedExternalWatermarkImageUrl(watermark.imageTarget)) throw new DocxPackageFidelityError("A canonical picture watermark has an unsafe external target");
+				canonical = isAllowedExternalWatermarkImageUrl(watermark.imageTarget) ? {
+					mode: "external",
+					url: watermark.imageTarget
+				} : resolveCanonical(watermark.imageRId);
+			} else canonical = {
+				mode: "internal",
+				absolute: watermark.imageTarget
+			};
+		} else canonical = resolveCanonical(watermark.imageRId);
 		if (!canonical) {
 			if (bodyAuthority === "canonical") throw new DocxPackageFidelityError("A canonical picture watermark image cannot be resolved");
 			continue;
@@ -1788,46 +1770,50 @@ async function serializeHeadersFootersToZip({ doc, zip, compressionLevel, onDiag
 async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel, changedNoteParaIds }) {
 	const footnotes = doc.package.footnotes ?? [];
 	const originalFootnotes = doc.package.footnotes === void 0 ? null : findNotePartEntry(originalZip, "word/footnotes.xml");
-	if (footnotes.length > 0 || originalFootnotes) if (originalFootnotes) await patchNotePartIntoZip({
-		conventionalLowerPath: "word/footnotes.xml",
-		currentXml: serializeFootnotes(footnotes),
-		replacementXml: serializeNewFootnotesPart(footnotes, doc),
-		baselineFrom: (xml) => serializeFootnotes(parseFootnotes(xml).getNormalFootnotes()),
-		elementName: "footnote",
-		changedNoteParaIds,
-		originalZip,
-		newZip,
-		compressionLevel
-	});
-	else await materializeNewNotePart({
-		contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
-		newZip,
-		partPath: "word/footnotes.xml",
-		relationshipType: RELATIONSHIP_TYPES.footnotes,
-		serializedPart: serializeNewFootnotesPart(footnotes, doc),
-		compressionLevel
-	});
+	if (footnotes.length > 0 || originalFootnotes) {
+		if (originalFootnotes) await patchNotePartIntoZip({
+			conventionalLowerPath: "word/footnotes.xml",
+			currentXml: serializeFootnotes(footnotes),
+			replacementXml: serializeNewFootnotesPart(footnotes, doc),
+			baselineFrom: (xml) => serializeFootnotes(parseFootnotes(xml).getNormalFootnotes()),
+			elementName: "footnote",
+			changedNoteParaIds,
+			originalZip,
+			newZip,
+			compressionLevel
+		});
+		else await materializeNewNotePart({
+			contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
+			newZip,
+			partPath: "word/footnotes.xml",
+			relationshipType: RELATIONSHIP_TYPES.footnotes,
+			serializedPart: serializeNewFootnotesPart(footnotes, doc),
+			compressionLevel
+		});
+	}
 	const endnotes = doc.package.endnotes ?? [];
 	const originalEndnotes = doc.package.endnotes === void 0 ? null : findNotePartEntry(originalZip, "word/endnotes.xml");
-	if (endnotes.length > 0 || originalEndnotes) if (originalEndnotes) await patchNotePartIntoZip({
-		conventionalLowerPath: "word/endnotes.xml",
-		currentXml: serializeEndnotes(endnotes),
-		replacementXml: serializeNewEndnotesPart(endnotes, doc),
-		baselineFrom: (xml) => serializeEndnotes(parseEndnotes(xml).getNormalEndnotes()),
-		elementName: "endnote",
-		changedNoteParaIds,
-		originalZip,
-		newZip,
-		compressionLevel
-	});
-	else await materializeNewNotePart({
-		contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml",
-		newZip,
-		partPath: "word/endnotes.xml",
-		relationshipType: RELATIONSHIP_TYPES.endnotes,
-		serializedPart: serializeNewEndnotesPart(endnotes, doc),
-		compressionLevel
-	});
+	if (endnotes.length > 0 || originalEndnotes) {
+		if (originalEndnotes) await patchNotePartIntoZip({
+			conventionalLowerPath: "word/endnotes.xml",
+			currentXml: serializeEndnotes(endnotes),
+			replacementXml: serializeNewEndnotesPart(endnotes, doc),
+			baselineFrom: (xml) => serializeEndnotes(parseEndnotes(xml).getNormalEndnotes()),
+			elementName: "endnote",
+			changedNoteParaIds,
+			originalZip,
+			newZip,
+			compressionLevel
+		});
+		else await materializeNewNotePart({
+			contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml",
+			newZip,
+			partPath: "word/endnotes.xml",
+			relationshipType: RELATIONSHIP_TYPES.endnotes,
+			serializedPart: serializeNewEndnotesPart(endnotes, doc),
+			compressionLevel
+		});
+	}
 }
 async function materializeNewNotePart({ contentType, newZip, partPath, relationshipType, serializedPart, compressionLevel }) {
 	const contentTypesFile = findNotePartEntry(newZip, "[content_types].xml");
@@ -2317,20 +2303,22 @@ const createEmptyDocxZip = ({ creator, application }) => {
 		data: encodeUtf8(SEED_STYLES_XML)
 	});
 	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const creatorElement = creator === void 0 ? "" : `\n  <dc:creator>${escapeXmlText(creator)}</dc:creator>`;
 	writeZipPart({
 		zip,
 		path: "docProps/core.xml",
 		data: encodeUtf8(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">${creator === void 0 ? "" : `\n  <dc:creator>${escapeXmlText(creator)}</dc:creator>`}
+<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">${creatorElement}
   <dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created>
   <dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>
 </cp:coreProperties>`)
 	});
+	const applicationElements = application === void 0 ? "" : `\n  <Application>${escapeXmlText(application)}</Application>\n  <AppVersion>${CREATED_APP_VERSION}</AppVersion>`;
 	writeZipPart({
 		zip,
 		path: "docProps/app.xml",
 		data: encodeUtf8(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">${application === void 0 ? "" : `\n  <Application>${escapeXmlText(application)}</Application>\n  <AppVersion>${CREATED_APP_VERSION}</AppVersion>`}
+<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">${applicationElements}
 </Properties>`)
 	});
 	return zip;
@@ -2437,10 +2425,11 @@ const createDocumentSeedZip = async (doc, properties) => {
 	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("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 		writeZipPart({
 			zip,
 			path: "[Content_Types].xml",
-			data: encodeUtf8((await contentTypesFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))).replace("</Types>", `${overrides.join("")}\n</Types>`))
+			data: encodeUtf8(contentTypes.replace("</Types>", `${overrides.join("")}\n</Types>`))
 		});
 	}
 	return zip;
@@ -2466,12 +2455,13 @@ const assertStyleNumberingReferences = (doc) => {
 		if (numId !== void 0) referenced.add(numId);
 	}
 	if (referenced.size === 0) return;
-	const available = new Map(doc.package.numbering?.nums.map((numbering) => [numbering.numId, numbering]) ?? []);
-	const availableAbstract = new Set(doc.package.numbering?.abstractNums.map((numbering) => numbering.abstractNumId) ?? []);
+	const definitions = doc.package.numbering ?? {
+		abstractNums: [],
+		nums: []
+	};
 	for (const numId of referenced) {
-		const numbering = available.get(numId);
-		if (!numbering) panic(`Style references missing numbering definition ${numId}`);
-		if (!availableAbstract.has(numbering.abstractNumId)) panic(`Numbering definition ${numbering.numId} references missing abstract numbering`);
+		if (!definitions.nums.some((instance) => instance.numId === numId)) panic(`Style references missing numbering definition ${numId}`);
+		if (!numberingInstanceResolves(definitions, numId)) panic(`Numbering definition ${numId} defines no level`);
 	}
 };
 //#endregion

package/dist/docx/runConsolidator.d.ts

@@ -7,34 +7,34 @@ import { formattingEquals, isTextOnlyRun, runsMergeable } from "@stll/docx-core/
  * @param runs - Array of runs to consolidate
  * @returns Consolidated array with fewer, larger runs
  */
-declare function consolidateRuns(runs: document_d_exports.Run[]): document_d_exports.Run[];
+export declare function consolidateRuns(runs: document_d_exports.Run[]): document_d_exports.Run[];
 /**
  * Consolidate runs within a paragraph content array
  *
  * This handles the full paragraph structure, consolidating runs while
  * preserving hyperlinks, bookmarks, and fields as merge boundaries.
  */
-declare function consolidateParagraphContent(content: document_d_exports.Hyperlink["children"]): document_d_exports.Hyperlink["children"];
-declare function consolidateParagraphContent(content: document_d_exports.ParagraphContent[]): document_d_exports.ParagraphContent[];
+export declare function consolidateParagraphContent(content: document_d_exports.Hyperlink["children"]): document_d_exports.Hyperlink["children"];
+export declare function consolidateParagraphContent(content: document_d_exports.ParagraphContent[]): document_d_exports.ParagraphContent[];
 /**
  * Consolidate all runs within a paragraph
  *
  * @param paragraph - Paragraph to consolidate
  * @returns New paragraph with consolidated runs
  */
-declare function consolidateParagraph(paragraph: document_d_exports.Paragraph): document_d_exports.Paragraph;
+export declare function consolidateParagraph(paragraph: document_d_exports.Paragraph): document_d_exports.Paragraph;
 /**
  * Get the number of runs in a paragraph (for debugging/metrics)
  */
-declare function countRuns(paragraph: document_d_exports.Paragraph): number;
+export declare function countRuns(paragraph: document_d_exports.Paragraph): number;
 /**
  * Calculate the consolidation ratio (reduction in number of runs)
  * Useful for debugging and metrics
  */
-declare function getConsolidationStats(originalParagraphs: document_d_exports.Paragraph[], consolidatedParagraphs: document_d_exports.Paragraph[]): {
+export declare function getConsolidationStats(originalParagraphs: document_d_exports.Paragraph[], consolidatedParagraphs: document_d_exports.Paragraph[]): {
   originalRunCount: number;
   consolidatedRunCount: number;
   reductionPercentage: number;
 };
 //#endregion
-export { consolidateParagraph, consolidateParagraphContent, consolidateRuns, countRuns, formattingEquals, getConsolidationStats, isTextOnlyRun, runsMergeable };
+export { formattingEquals, isTextOnlyRun, runsMergeable };

package/dist/docx/runConsolidator.js

@@ -3,6 +3,19 @@ import { runHoldsPayload } from "./runPayload.js";
 import { formattingEquals, isTextOnlyRun, mergeRunContent, runsMergeable, runsMergeable as runsMergeable$1 } from "@stll/docx-core/ops";
 //#region src/docx/runConsolidator.ts
 /**
+* Run Consolidator - Merge consecutive runs with identical formatting
+*
+* DOCX files often contain many small runs with the same formatting,
+* created by Word for various reasons (spell checking, revision tracking,
+* cursor positioning, etc.). This causes:
+* - 252+ tiny <span> elements instead of a few
+* - Poor editing UX (cursor jumps between spans)
+* - Performance issues
+*
+* This module provides utilities to consolidate runs with identical
+* formatting into single runs, reducing fragmentation.
+*/
+/**
 * Consolidate an array of runs by merging consecutive runs with identical formatting
 *
 * @param runs - Array of runs to consolidate

package/dist/docx/runParser.d.ts

@@ -13,7 +13,7 @@ import { StyleMap } from "./styleParser.js";
  * twice is written twice. Naming the owner states that once, at the call site
  * that knows it, instead of leaving it to whichever reader ran first.
  */
-declare const RUN_PROPERTY_OWNERS: {
+export declare const RUN_PROPERTY_OWNERS: {
   /** A `w:r`'s own properties: `Run.propertyChanges` reads the `w:rPrChange`. */
   readonly run: "run";
   /**
@@ -28,14 +28,14 @@ declare const RUN_PROPERTY_OWNERS: {
    */
   readonly standalone: "standalone";
 };
-type RunPropertyOwner = (typeof RUN_PROPERTY_OWNERS)[keyof typeof RUN_PROPERTY_OWNERS];
+export type RunPropertyOwner = (typeof RUN_PROPERTY_OWNERS)[keyof typeof RUN_PROPERTY_OWNERS];
 /**
  * `w:vertAlign` `baseline` is the reserved value that means "no vertical
  * offset", not a third offset beside `superscript` and `subscript`. It is
  * answered here because this module reads the slot, so a consumer deciding
  * whether a run sits on the baseline cannot drift from how it was parsed.
  */
-declare const isBaselineVertAlign: (vertAlign: document_d_exports.TextFormatting["vertAlign"]) => boolean;
+export declare const isBaselineVertAlign: (vertAlign: document_d_exports.TextFormatting["vertAlign"]) => boolean;
 /**
  * The one reader of a run property set (`w:rPr`).
  *
@@ -63,7 +63,7 @@ declare const isBaselineVertAlign: (vertAlign: document_d_exports.TextFormatting
  * means the owner carried no `w:rPr`, or a paragraph-mark carrier contained
  * only metadata owned by the paragraph. An authored empty set remains {}.
  */
-declare function parseRunProperties(rPr: XmlElement | null, theme: document_d_exports.Theme | null, owner: RunPropertyOwner): document_d_exports.TextFormatting | undefined;
+export declare function parseRunProperties(rPr: XmlElement | null, theme: document_d_exports.Theme | null, owner: RunPropertyOwner): document_d_exports.TextFormatting | undefined;
 /**
  * Parse a run element (w:r)
  *
@@ -77,48 +77,47 @@ declare function parseRunProperties(rPr: XmlElement | null, theme: document_d_ex
  *   on its own charges its previews to no package
  * @returns Parsed Run object
  */
-declare function parseRun(node: XmlElement, _styles: StyleMap | null, theme: document_d_exports.Theme | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null, rootXmlns?: Record<string, string>, previews?: PreviewLedger): document_d_exports.Run;
+export declare function parseRun(node: XmlElement, _styles: StyleMap | null, theme: document_d_exports.Theme | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null, rootXmlns?: Record<string, string>, previews?: PreviewLedger): document_d_exports.Run;
 /**
  * Get plain text from a run
  *
  * @param run - Parsed Run object
  * @returns Concatenated text content
  */
-declare function getRunText(run: document_d_exports.Run): string;
+export declare function getRunText(run: document_d_exports.Run): string;
 /**
  * Check if a run contains any actual content
  *
  * @param run - Parsed Run object
  * @returns true if run has visible content
  */
-declare function hasContent(run: document_d_exports.Run): boolean;
+export declare function hasContent(run: document_d_exports.Run): boolean;
 /**
  * Check if a run contains a drawing/image
  *
  * @param run - Parsed Run object
  * @returns true if run contains an image
  */
-declare function hasImage(run: document_d_exports.Run): boolean;
+export declare function hasImage(run: document_d_exports.Run): boolean;
 /**
  * Get all images from a run
  *
  * @param run - Parsed Run object
  * @returns Array of Image objects
  */
-declare function getImages(run: document_d_exports.Run): document_d_exports.Image[];
+export declare function getImages(run: document_d_exports.Run): document_d_exports.Image[];
 /**
  * Check if a run is part of a complex field
  *
  * @param run - Parsed Run object
  * @returns true if run contains field characters
  */
-declare function hasFieldChar(run: document_d_exports.Run): boolean;
+export declare function hasFieldChar(run: document_d_exports.Run): boolean;
 /**
  * Get field character type if present
  *
  * @param run - Parsed Run object
  * @returns Field character type or null
  */
-declare function getFieldCharType(run: document_d_exports.Run): "begin" | "separate" | "end" | null;
-//#endregion
-export { RUN_PROPERTY_OWNERS, RunPropertyOwner, getFieldCharType, getImages, getRunText, hasContent, hasFieldChar, hasImage, isBaselineVertAlign, parseRun, parseRunProperties };
+export declare function getFieldCharType(run: document_d_exports.Run): "begin" | "separate" | "end" | null;
+//#endregion

package/dist/docx/runParser.js

@@ -1,6 +1,7 @@
 import { parseHorizontalScalePercent } from "../utils/horizontalScale.js";
 import { sliceText } from "../utils/sliceText.js";
 import { NO_MODELLED_ATTRIBUTES, attributeRemainder } from "./attributeRemainder.js";
+import { parseChartPreview } from "./chartPreview.js";
 import { CAPTURE, dispatchChildrenWithContext, keptUnless, ownedElsewhere, sequencePositions } from "./containerChildren.js";
 import { parseDiagramPreview } from "./diagramPreview.js";
 import { parseFieldState } from "./fieldState.js";
@@ -21,7 +22,7 @@ import { resolveThemeFontRef } from "./themeParser.js";
 import { parsePropertyChangeInfo } from "./trackedChangeInfo.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { parseVmlImageContent, shouldPreserveRawVmlPict } from "./vmlImageParser.js";
-import { WORDPROCESSINGML_NAMESPACE_URIS, cloneWithXmlnsDeclarations, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getLocalName, getNamespaceUri, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseOnOffAttribute, selectAlternateContentBranch } from "./xmlParser.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, cloneWithXmlnsDeclarations, findAllDeep, findChild, findChildren, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseOnOffAttribute, selectAlternateContentBranch } from "./xmlParser.js";
 import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 //#region src/docx/runParser.ts
 /**
@@ -257,9 +258,9 @@ const readUnderline = (u, formatting) => {
 };
 /** @returns whether `w:lang` named a tag for any of the three scripts. */
 const readLanguage = (lang, formatting) => {
-	const val = truncateLanguageTag(getAttribute(lang, "w", "val") || void 0);
-	const eastAsia = truncateLanguageTag(getAttribute(lang, "w", "eastAsia") || void 0);
-	const bidi = truncateLanguageTag(getAttribute(lang, "w", "bidi") || void 0);
+	const val = truncateLanguageTag(getAttributeByNamespaceUri(lang, WORDPROCESSINGML_NAMESPACE_URIS, "val") || void 0);
+	const eastAsia = truncateLanguageTag(getAttributeByNamespaceUri(lang, WORDPROCESSINGML_NAMESPACE_URIS, "eastAsia") || void 0);
+	const bidi = truncateLanguageTag(getAttributeByNamespaceUri(lang, WORDPROCESSINGML_NAMESPACE_URIS, "bidi") || void 0);
 	if (!val && !eastAsia && !bidi) return false;
 	formatting.language = {
 		...val ? { val } : {},
@@ -609,6 +610,13 @@ function parseDrawingContent(element, rels, media, previews) {
 		rawXml: captureVerbatimXml(element),
 		rawXmlMode: DRAWING_RAW_XML_MODES.PRESERVE_ONLY
 	};
+	const chartImage = parseChartPreview(element, rels ?? void 0, media ?? void 0);
+	if (chartImage) return {
+		type: "drawing",
+		image: chartImage,
+		rawXml: captureVerbatimXml(element),
+		rawXmlMode: DRAWING_RAW_XML_MODES.PRESERVE_ONLY
+	};
 	if (shouldPreserveRawShapeDrawing(element)) return preserveOnlyDrawing(captureVerbatimXml(element));
 	const shape = parseShapeFromDrawing(element);
 	if (shape) return {
@@ -728,6 +736,20 @@ function parseRunContents(runElement, rels, media, previews, rootXmlns = {}) {
 						break;
 					}
 				}
+				const fallbackDrawing = fallbackEl ? getChildElements(fallbackEl).find((el) => getLocalName(el.name) === "drawing") : void 0;
+				const fallbackImage = fallbackDrawing ? parseImage(fallbackDrawing, rels ?? void 0, media ?? void 0) : null;
+				if (fallbackImage?.src && choiceEl) {
+					const choiceDrawing = getChildElements(choiceEl).find((el) => getLocalName(el.name) === "drawing");
+					const choiceImage = choiceDrawing ? parseImage(choiceDrawing, rels ?? void 0, media ?? void 0) : null;
+					if (choiceImage) fallbackImage.size = choiceImage.size;
+					contents.push({
+						type: "drawing",
+						image: fallbackImage,
+						rawXml: captureVerbatimXml(child),
+						rawXmlMode: DRAWING_RAW_XML_MODES.PRESERVE_ONLY
+					});
+					break;
+				}
 				const fallbackPict = fallbackEl ? getChildElements(fallbackEl).find((el) => getLocalName(el.name) === "pict") : void 0;
 				const fallbackVml = fallbackPict && !choiceTextBoxDrawing ? parseVmlImageContent(fallbackPict, rels, media, previews, rootXmlns) : null;
 				if (fallbackVml?.image.src) {
@@ -768,9 +790,7 @@ function parseRunContents(runElement, rels, media, previews, rootXmlns = {}) {
 				if (contents.length === contentsBeforeAlternate && !hasTextBoxBranch) contents.push(preserveOnlyDrawing(captureVerbatimXml(cloneWithXmlnsDeclarations(child, rootXmlns))));
 				break;
 			}
-			default:
-				contents.push(preserveRunChild(child));
-				break;
+			default: contents.push(preserveRunChild(child));
 		}
 	}
 	return contents;
@@ -818,9 +838,10 @@ function getRunText(run) {
 	let text = "";
 	for (const content of run.content) if (content.type === "text") text += content.text;
 	else if (content.type === "tab") text += "	";
-	else if (content.type === "break") if (content.breakType === "page") text += "\f";
-	else text += "\n";
-	else if (content.type === "softHyphen") text += "­";
+	else if (content.type === "break") {
+		if (content.breakType === "page") text += "\f";
+		else text += "\n";
+	} else if (content.type === "softHyphen") text += "­";
 	else if (content.type === "noBreakHyphen") text += "‑";
 	return text;
 }

package/dist/docx/runPayload.d.ts

@@ -1,5 +1,4 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/runPayload.d.ts
-declare const runHoldsPayload: (run: document_d_exports.Run) => boolean;
-//#endregion
-export { runHoldsPayload };
+export declare const runHoldsPayload: (run: document_d_exports.Run) => boolean;
+//#endregion

package/dist/docx/runPropertyPresence.d.ts

@@ -1,11 +1,10 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
 //#region src/docx/runPropertyPresence.d.ts
-declare const EMPTY_RUN_PROPERTIES_ATTRIBUTE = "emptyRunProperties";
-declare const retainsEmptyRunProperties: (element: XmlElement) => boolean;
-declare const omitsPreviousRunProperties: (element: XmlElement) => boolean;
-declare const serializePreviousRunProperties: (properties: document_d_exports.TextFormatting | undefined) => string;
-declare const serializeEmptyRunProperties: (run: document_d_exports.Run) => string[];
-declare const isEmptyRunPropertiesAttribute: ({ namespace, name }: Pick<document_d_exports.PreservedAttribute, "namespace" | "name">) => boolean;
-//#endregion
-export { EMPTY_RUN_PROPERTIES_ATTRIBUTE, isEmptyRunPropertiesAttribute, omitsPreviousRunProperties, retainsEmptyRunProperties, serializeEmptyRunProperties, serializePreviousRunProperties };
+export declare const EMPTY_RUN_PROPERTIES_ATTRIBUTE = "emptyRunProperties";
+export declare const retainsEmptyRunProperties: (element: XmlElement) => boolean;
+export declare const omitsPreviousRunProperties: (element: XmlElement) => boolean;
+export declare const serializePreviousRunProperties: (properties: document_d_exports.TextFormatting | undefined) => string;
+export declare const serializeEmptyRunProperties: (run: document_d_exports.Run) => string[];
+export declare const isEmptyRunPropertiesAttribute: ({ namespace, name }: Pick<document_d_exports.PreservedAttribute, "namespace" | "name">) => boolean;
+//#endregion