@stll/folio-core 0.44.0 → 0.46.0

package/dist/docx/containerChildren.gen.js

@@ -0,0 +1,246 @@
+//#region src/docx/containerChildren.gen.ts
+/**
+* GENERATED FILE — do not edit.
+*
+* Every child the Transitional content model declares for a container folio
+* dispatches, derived from the committed schema graph by
+* `scripts/generate-container-children.ts`. The shared child dispatcher makes
+* a handler map total over these names, so a container cannot gain a declared
+* child without somebody deciding whether it is modelled or captured.
+* Regenerate with:
+*
+*   bun run generate:container-children
+*/
+const CONTAINER_CHILDREN = {
+	"w:comment": [
+		"altChunk",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"p",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"sdt",
+		"tbl"
+	],
+	"run-level-content": [
+		"bdo",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"dir",
+		"fldSimple",
+		"hyperlink",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"pPr",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"r",
+		"sdt",
+		"smartTag",
+		"smartTagPr",
+		"subDoc"
+	],
+	"table-content": [
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"customXmlPr",
+		"del",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"sdt",
+		"tblGrid",
+		"tblPr",
+		"tr"
+	],
+	"row-content": [
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"sdt",
+		"tblPrEx",
+		"tc",
+		"tr",
+		"trPr"
+	],
+	"w:hyperlink": [
+		"bdo",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"dir",
+		"fldSimple",
+		"hyperlink",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"r",
+		"sdt",
+		"smartTag",
+		"subDoc"
+	],
+	"w:fldSimple": [
+		"bdo",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"dir",
+		"fldData",
+		"fldSimple",
+		"hyperlink",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"r",
+		"sdt",
+		"smartTag",
+		"subDoc"
+	],
+	"block-content": [
+		"altChunk",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"p",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"sdt",
+		"sectPr",
+		"tbl",
+		"tcPr"
+	]
+};
+//#endregion
+export { CONTAINER_CHILDREN };

package/dist/docx/containerChildren.js

@@ -0,0 +1,103 @@
+import { TRANSITIONAL_NAMESPACE_BY_STRICT_URI } from "./strictValueEncodings.gen.js";
+import { captureVerbatimXml } from "./verbatimCapture.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, getChildElements, getLocalName, getNamespaceUri } from "./xmlParser.js";
+//#region src/docx/containerChildren.ts
+/** Keep this child's markup verbatim, in place. */
+const CAPTURE = "capture";
+/**
+* Another reader owns this child, and re-emits it.
+*
+* `w:rPr` under a run, read by `parseRunProperties`; `w:commentReference`
+* under a run, lifted out by the paragraph parser. Capturing one of these as
+* well would write it twice, so the disposition has to be stated rather than
+* left to a bare `break`.
+*/
+const OWNED_ELSEWHERE = "owned-elsewhere";
+/**
+* This child goes with the wrapper folio does not keep.
+*
+* `w:smartTagPr` is the case: folio unwraps `w:smartTag` and splices its
+* content into the paragraph, so the properties describing the wrapper have
+* nothing left to describe and capturing them would put a `w:smartTagPr`
+* where the schema does not admit one. The drop is stated here and recorded
+* in `specifications/container-contract/contract.json`, which is the whole
+* difference between this and a `default` that says nothing.
+*/
+const DROPPED_WITH_ITS_WRAPPER = "dropped-with-its-wrapper";
+/**
+* The Transitional spelling of a namespace, so one disposition covers both.
+*
+* ISO Strict writes the same content model under its own URIs: maths is
+* `purl.oclc.org/ooxml/officeDocument/math` rather than
+* `schemas.openxmlformats.org/officeDocument/2006/math`. A namespace-keyed
+* disposition written in Transitional would otherwise send a Strict
+* document's maths to the sink, which models it as bytes instead of an
+* equation. The pairs come from the generated table rather than a second list
+* here, so a namespace cannot be paired in one place and forgotten in the
+* other.
+*/
+const transitionalNamespaceOf = (namespace) => TRANSITIONAL_NAMESPACE_BY_STRICT_URI.get(namespace) ?? namespace;
+/**
+* Walk a container's children, handing each to its handler and the rest to the
+* sink.
+*
+* @returns the container's unmodelled markup, or `undefined` when it held
+*   none — an empty record is never written, so a fully modelled container
+*   stays byte-identical in the model.
+*/
+const dispatchChildren = ({ element, handlers, modelledCount, undeclared, undeclaredNamespaces }) => {
+	const children = [];
+	const capture = (child) => {
+		children.push({
+			index: modelledCount(),
+			xml: captureVerbatimXml(child)
+		});
+	};
+	const declared = new Map(Object.entries(handlers));
+	const byName = new Map(Object.entries(undeclared ?? {}));
+	const byNamespace = new Map(Object.entries(undeclaredNamespaces ?? {}));
+	for (const child of getChildElements(element)) {
+		const localName = getLocalName(child.name);
+		const namespace = getNamespaceUri(child);
+		const disposition = namespace === void 0 || WORDPROCESSINGML_NAMESPACE_URIS.has(namespace) ? declared.get(localName) ?? byName.get(localName) : byName.get(localName) ?? byNamespace.get(transitionalNamespaceOf(namespace));
+		if (disposition === void 0 || disposition === "capture") {
+			capture(child);
+			continue;
+		}
+		if (disposition === "dropped-with-its-wrapper" || disposition === "owned-elsewhere") continue;
+		disposition(child);
+	}
+	return children.length === 0 ? void 0 : { children };
+};
+/**
+* Put a container's modelled children back with its preserved ones between
+* them, in source position.
+*
+* Where the content model demands schema order the caller has already put its
+* modelled children in that order; the sink's `index` then places each capture
+* between the same two siblings it sat between when it was read.
+*
+* @param wrap turns one capture's markup into whatever the caller's list holds
+*/
+const withPreservedChildren = (modelled, preserved, wrap) => {
+	const captures = preserved?.children;
+	if (captures === void 0 || captures.length === 0) return [...modelled];
+	const byIndex = /* @__PURE__ */ new Map();
+	for (const { index, xml } of captures) {
+		const slot = Math.min(Math.max(index, 0), modelled.length);
+		const bucket = byIndex.get(slot);
+		if (bucket) {
+			bucket.push(wrap(xml));
+			continue;
+		}
+		byIndex.set(slot, [wrap(xml)]);
+	}
+	const items = [];
+	for (const [index, item] of modelled.entries()) items.push(...byIndex.get(index) ?? [], item);
+	items.push(...byIndex.get(modelled.length) ?? []);
+	return items;
+};
+/** {@link withPreservedChildren} for a caller that already holds markup. */
+const serializeWithPreservedChildren = (modelled, preserved) => withPreservedChildren(modelled, preserved, (xml) => xml).join("");
+//#endregion
+export { CAPTURE, DROPPED_WITH_ITS_WRAPPER, OWNED_ELSEWHERE, dispatchChildren, serializeWithPreservedChildren, transitionalNamespaceOf, withPreservedChildren };

package/dist/docx/diagramPreview.js

@@ -1,5 +1,7 @@
-import { resolveRelativePath } from "./relsParser.js";
-import { findChildByNamespaceUri, getAttribute, getLocalName, parseNumericAttribute, parseXmlDocument } from "./xmlParser.js";
+import { bytesToDataUrl } from "../utils/base64.js";
+import { PREVIEW_KINDS } from "./previewBudget.js";
+import { resolveRelationshipIdOfType, resolveRelativePath } from "./relsParser.js";
+import { OFFICE_RELATIONSHIP_NAMESPACE_URIS, findChildByNamespaceUri, getAttribute, getAttributeByNamespaceUri, getLocalName, parseNumericAttribute, parseXmlDocument } from "./xmlParser.js";
 //#region src/docx/diagramPreview.ts
 const MAX_PREVIEW_SHAPES = 128;
 const MAX_PREVIEW_PIXELS = 144e4;
@@ -7,21 +9,47 @@ const MAX_PREVIEW_PAINT_PIXELS = MAX_PREVIEW_PIXELS * 4;
 const DRAWINGML_NAMESPACE_URIS = /* @__PURE__ */ new Set(["http://schemas.openxmlformats.org/drawingml/2006/main", "http://purl.oclc.org/ooxml/drawingml/main"]);
 const DIAGRAM_NAMESPACE_URIS = /* @__PURE__ */ new Set(["http://schemas.openxmlformats.org/drawingml/2006/diagram", "http://purl.oclc.org/ooxml/drawingml/diagram"]);
 const DIAGRAM_DRAWING_NAMESPACE_URIS = /* @__PURE__ */ new Set(["http://schemas.microsoft.com/office/drawing/2008/diagram"]);
+const DIAGRAM_DATA_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramData";
+const DIAGRAM_DRAWING_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing";
+const DOCUMENT_PART_PATH = "word/document.xml";
 const WORD_DRAWING_NAMESPACE_URIS = /* @__PURE__ */ new Set(["http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing", "http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing"]);
+/**
+* The preview is a megapixel raster, so both checksums run over megabytes.
+* `for (const byte of bytes)` drives the array iterator protocol once per
+* byte, which profiles as the dominant cost of parsing a SmartArt document;
+* indexed loops and a table-driven CRC produce the same numbers without it.
+*/
+const CRC32_TABLE = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	for (let index = 0; index < 256; index += 1) {
+		let value = index;
+		for (let bit = 0; bit < 8; bit += 1) value = value >>> 1 ^ (value & 1 ? 3988292384 : 0);
+		table[index] = value >>> 0;
+	}
+	return table;
+})();
 const crc32 = (bytes) => {
 	let crc = 4294967295;
-	for (const byte of bytes) {
-		crc ^= byte;
-		for (let bit = 0; bit < 8; bit += 1) crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
-	}
+	for (let index = 0; index < bytes.length; index += 1) crc = crc >>> 8 ^ CRC32_TABLE[(crc ^ bytes[index]) & 255];
 	return (crc ^ 4294967295) >>> 0;
 };
+/**
+* `a` and `b` stay below 2^31 for 5552 iterations from any legal state, so the
+* modulo runs per block rather than per byte.
+*/
+const ADLER32_BLOCK = 5552;
 const adler32 = (bytes) => {
 	let a = 1;
 	let b = 0;
-	for (const byte of bytes) {
-		a = (a + byte) % 65521;
-		b = (b + a) % 65521;
+	let index = 0;
+	while (index < bytes.length) {
+		const end = Math.min(index + ADLER32_BLOCK, bytes.length);
+		for (; index < end; index += 1) {
+			a += bytes[index];
+			b += a;
+		}
+		a %= 65521;
+		b %= 65521;
 	}
 	return b << 16 | a;
 };
@@ -88,9 +116,8 @@ const previewPng = (width, height, shapes) => {
 		cursor += length;
 		offset += length;
 	}
-	const output = new Uint8Array(cursor + 4);
-	output.set(compressed.subarray(0, cursor));
-	new DataView(output.buffer).setUint32(cursor, adler32(pixels));
+	new DataView(compressed.buffer).setUint32(cursor, adler32(pixels));
+	const output = compressed;
 	const signature = new Uint8Array([
 		137,
 		80,
@@ -127,13 +154,38 @@ const extent = (drawing) => {
 		height: parseNumericAttribute(value, null, "cy") ?? 0
 	};
 };
-const cachedDiagramShapes = (rels, media) => {
-	const matches = [...rels.values()].filter((relationship) => relationship.type === "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing");
-	if (matches.length !== 1 || !matches[0]?.target) return [];
-	const path = resolveRelativePath("word/document.xml", matches[0].target);
-	const file = media.get(path);
-	if (!file?.data) return [];
-	const root = parseXmlDocument(new TextDecoder().decode(file.data));
+/** Parse the part a relationship of the given type names, by that relationship's id. */
+const partByRelationshipId = ({ rels, media, rId, type }) => {
+	const resolved = resolveRelationshipIdOfType(rels, rId ?? void 0, type);
+	if (resolved.status !== "resolved" || !resolved.relationship.target) return null;
+	const file = media.get(resolveRelativePath(DOCUMENT_PART_PATH, resolved.relationship.target));
+	return file?.data ? parseXmlDocument(new TextDecoder().decode(file.data)) : null;
+};
+/**
+* The drawing cache this diagram points at, reached through its own ids.
+*
+* `dgm:relIds/@r:dm` names the data part, and that part's `dsp:dataModelExt`
+* extension names the cached drawing. Scanning the relationship map for a type
+* instead of following the ids reads the wrong diagram whenever a document has
+* more than one, which is why the scan refused outright on a second match:
+* both diagrams in a two-diagram document then got no preview at all.
+*/
+const cachedDiagramShapes = (graphicData, rels, media) => {
+	const relIds = findChildByNamespaceUri(graphicData, DIAGRAM_NAMESPACE_URIS, "relIds");
+	const data = partByRelationshipId({
+		rels,
+		media,
+		rId: getAttributeByNamespaceUri(relIds, OFFICE_RELATIONSHIP_NAMESPACE_URIS, "dm"),
+		type: DIAGRAM_DATA_RELATIONSHIP_TYPE
+	});
+	if (!data) return [];
+	const dataModelExt = descendantsByNamespace(data, DIAGRAM_DRAWING_NAMESPACE_URIS, "dataModelExt").at(0);
+	const root = partByRelationshipId({
+		rels,
+		media,
+		rId: getAttribute(dataModelExt, null, "relId"),
+		type: DIAGRAM_DRAWING_RELATIONSHIP_TYPE
+	});
 	if (!root) return [];
 	const shapes = [];
 	for (const shape of descendantsByNamespace(root, DIAGRAM_DRAWING_NAMESPACE_URIS, "sp").slice(0, MAX_PREVIEW_SHAPES)) {
@@ -155,31 +207,39 @@ const cachedDiagramShapes = (rels, media) => {
 	}
 	return shapes;
 };
+const matchesNamespace = (element, namespaceUris, localName) => element.namespaceUri !== void 0 && namespaceUris.has(element.namespaceUri) && getLocalName(element.name ?? "") === localName;
 const descendantsByNamespace = (root, namespaceUris, localName) => {
 	const result = [];
 	const visit = (element) => {
-		if (element.namespaceUri && namespaceUris.has(element.namespaceUri) && getLocalName(element.name ?? "") === localName) result.push(element);
+		if (matchesNamespace(element, namespaceUris, localName)) result.push(element);
 		for (const child of element.elements ?? []) if (child.type === "element") visit(child);
 	};
 	visit(root);
 	return result;
 };
+/** The first match in document order, without walking the rest of the subtree. */
+const firstDescendantByNamespace = (root, namespaceUris, localName) => {
+	if (matchesNamespace(root, namespaceUris, localName)) return root;
+	for (const child of root.elements ?? []) {
+		if (child.type !== "element") continue;
+		const found = firstDescendantByNamespace(child, namespaceUris, localName);
+		if (found) return found;
+	}
+	return null;
+};
 /** Create a deliberately simple, bounded preview; it is never an editable diagram projection. */
 const parseDiagramPreview = (drawing, rels, media) => {
 	if (!rels || !media) return null;
-	const graphicData = descendantsByNamespace(drawing, DRAWINGML_NAMESPACE_URIS, "graphicData").at(0);
+	const graphicData = firstDescendantByNamespace(drawing, DRAWINGML_NAMESPACE_URIS, "graphicData");
 	if (!graphicData || !DIAGRAM_NAMESPACE_URIS.has(getAttribute(graphicData, null, "uri") ?? "")) return null;
 	const { width, height } = extent(drawing);
 	if (width <= 0 || height <= 0) return null;
-	const png = previewPng(width, height, cachedDiagramShapes(rels, media));
-	let binary = "";
-	for (let offset = 0; offset < png.length; offset += 32768) binary += String.fromCodePoint(...png.subarray(offset, offset + 32768));
 	return {
 		type: "image",
 		rId: "",
-		src: `data:image/png;base64,${btoa(binary)}`,
-		mimeType: "image/png",
-		filename: "smartart-preview.png",
+		src: bytesToDataUrl(previewPng(width, height, cachedDiagramShapes(graphicData, rels, media)), PREVIEW_KINDS.smartArt.mimeType),
+		mimeType: PREVIEW_KINDS.smartArt.mimeType,
+		filename: PREVIEW_KINDS.smartArt.filename,
 		size: {
 			width,
 			height

package/dist/docx/documentParser.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
-import { StyleMap } from "./styleParser.js";
 import { ParseContext } from "./parseContext.js";
+import { StyleMap } from "./styleParser.js";
 //#region src/docx/documentParser.d.ts
 /**
  * Extract template variables from text

package/dist/docx/documentParser.js

@@ -49,7 +49,7 @@ function extractTableVariables(table) {
 	for (const row of table.rows) for (const cell of row.cells) for (const cellContent of cell.content) if (cellContent.type === "paragraph") {
 		const vars = extractTemplateVariables(getParagraphText(cellContent));
 		for (const v of vars) if (!variables.includes(v)) variables.push(v);
-	} else {
+	} else if (cellContent.type === "table") {
 		const nestedVars = extractTableVariables(cellContent);
 		for (const v of nestedVars) if (!variables.includes(v)) variables.push(v);
 	}
@@ -149,7 +149,7 @@ function getAllParagraphs(body) {
 function getTableParagraphs(table) {
 	const paragraphs = [];
 	for (const row of table.rows) for (const cell of row.cells) for (const content of cell.content) if (content.type === "paragraph") paragraphs.push(content);
-	else paragraphs.push(...getTableParagraphs(content));
+	else if (content.type === "table") paragraphs.push(...getTableParagraphs(content));
 	return paragraphs;
 }
 /**
@@ -193,7 +193,7 @@ function getTableText(table) {
 		for (const cell of row.cells) {
 			const cellTexts = [];
 			for (const content of cell.content) if (content.type === "paragraph") cellTexts.push(getParagraphText(content));
-			else cellTexts.push(getTableText(content));
+			else if (content.type === "table") cellTexts.push(getTableText(content));
 			rowTexts.push(cellTexts.join("\n"));
 		}
 		lines.push(rowTexts.join("	"));

package/dist/docx/ensureParaIds.js

@@ -1,5 +1,5 @@
 import { deterministicHexId } from "../utils/hexId.js";
-import { isXmlNameBoundary } from "./selectiveXmlPatch.js";
+import { isXmlNameBoundary, spliceXml } from "./selectiveXmlPatch.js";
 import { loadDocxArchive } from "./server/boundedArchive.js";
 import { TaggedError } from "better-result";
 import JSZip from "jszip";
@@ -97,11 +97,21 @@ const OPEN_TAG_TEXT_ID_PATTERN = /\sw(?:14)?:textId=(?<quote>["'])(?<id>[\s\S]*?
 const XMLNS_W14_PATTERN = /\sxmlns:w14=(?<quote>["'])(?<value>[\s\S]*?)\k<quote>/u;
 const XMLNS_MC_PATTERN = /\sxmlns:mc=(?<quote>["'])(?<value>[\s\S]*?)\k<quote>/u;
 const MC_IGNORABLE_PATTERN = /\smc:Ignorable=(?<quote>["'])(?<value>[\s\S]*?)\k<quote>/u;
-const applySplices = (xml, edits) => {
-	const ordered = [...edits].sort((a, b) => b.start - a.start);
-	let result = xml;
-	for (const { start, end, text } of ordered) result = result.slice(0, start) + text + result.slice(end);
-	return result;
+/**
+* Stamp the edits into the part through the splice owner, which refuses a
+* result that would leave a comment range with only one half. These edits
+* rewrite `<w:p …>` open tags and the root element's attributes, so they
+* should never cut across a range marker; the owner is what makes that
+* structural rather than a reading of the scanner.
+*/
+const applySplices = (xml, edits, partPath) => {
+	const patched = spliceXml(xml, edits.map(({ start, end, text }) => ({
+		start,
+		end,
+		newXml: text
+	})));
+	if (patched === null) throw createEnsureParaIdsError(`Stamping paragraph ids into ${partPath} broke a comment range`);
+	return patched;
 };
 const createEnsureParaIdsError = (message, cause) => new EnsureParaIdsError({
 	message,
@@ -382,7 +392,7 @@ const ensureParaIdsInternal = async (docx, options) => {
 		if (scan.edits.length === 0) continue;
 		assigned += scan.assigned;
 		deduplicated += scan.deduplicated;
-		updates.set(partPath, applySplices(xml, [...scan.edits, ...ensureRootNamespaces(xml, partPath)]));
+		updates.set(partPath, applySplices(xml, [...scan.edits, ...ensureRootNamespaces(xml, partPath)], partPath));
 	}
 	if (updates.size === 0) return {
 		docx: toUint8Array(docx),

package/dist/docx/fieldParser.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../types/document.js";
-import { StyleMap } from "./styleParser.js";
 import { XmlElement } from "./xmlParser.js";
+import { StyleMap } from "./styleParser.js";
 //#region src/docx/fieldParser.d.ts
 /**
  * All known field types from OOXML specification

package/dist/docx/fieldParser.js

@@ -1,7 +1,8 @@
+import { parseFieldState } from "./fieldState.js";
 import { formatOoxmlCounter } from "./ooxmlCounterFormatter.js";
 import { FieldTypeSchema, narrowEnum } from "./parserEnums.js";
 import { parseRun } from "./runParser.js";
-import { findChildren, getAttribute, parseOnOffAttribute } from "./xmlParser.js";
+import { findChildren, getAttribute } from "./xmlParser.js";
 //#region src/docx/fieldParser.ts
 /**
 * All known field types from OOXML specification
@@ -162,10 +163,9 @@ function parseSimpleField(node, styles, theme) {
 		type: "simpleField",
 		instruction,
 		fieldType: parseFieldType(instruction),
-		content: []
+		content: [],
+		...parseFieldState(node)
 	};
-	if (parseOnOffAttribute(node, "w", "fldLock") === true) field.fldLock = true;
-	if (parseOnOffAttribute(node, "w", "dirty") === true) field.dirty = true;
 	const children = findChildren(node, "w", "r");
 	for (const child of children) {
 		const run = parseRun(child, styles, theme);

package/dist/docx/fieldState.d.ts

@@ -0,0 +1,26 @@
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/fieldState.d.ts
+/** What a field element states about its lock and dirty flags. */
+type FieldState = {
+  fldLock?: boolean;
+  dirty?: boolean;
+};
+/** Read both attributes off a `w:fldSimple` or `w:fldChar`, keeping an explicit off. */
+declare const parseFieldState: (element: XmlElement) => FieldState;
+/**
+ * The stated flags of a field, without the rest of it.
+ *
+ * The complex-field assembly carries the begin `w:fldChar`'s state across the
+ * runs between `begin` and `end`, and this is the one place that knows which
+ * fields that state is made of.
+ */
+declare const fieldStateOf: ({ fldLock, dirty }: FieldState) => FieldState;
+/**
+ * The attributes to write for a field's stated flags, in schema order.
+ *
+ * `1`/`0` is what Word writes and what the table, section and border
+ * serializers write.
+ */
+declare const fieldStateAttributes: ({ fldLock, dirty }: FieldState) => string[];
+//#endregion
+export { FieldState, fieldStateAttributes, fieldStateOf, parseFieldState };