@stll/folio-core 0.45.0 → 0.47.0

package/dist/docx/containerChildren.js

@@ -0,0 +1,153 @@
+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";
+import { SEQUENCE_CHILDREN } from "@stll/docx-core/schema";
+//#region src/docx/containerChildren.ts
+/** Keep this child's markup verbatim, in place. */
+const CAPTURE = "capture";
+/**
+* What a handler answers with: nothing when it took a typed value, and
+* {@link CAPTURE} when it took none, so the child's bytes are kept instead.
+*
+* `<w:tblLayout/>` states no layout and `<w:jc w:val="end"/>` states a value a
+* reader's enumeration does not admit. Both used to fall off the end of the
+* walk, and neither can be decided by name: a map keyed by name cannot list
+* the values a reader will refuse, only the names it has never heard of.
+*/
+const keptUnless = (taken) => taken ? void 0 : CAPTURE;
+const OWNED_ELSEWHERE = "owned-elsewhere";
+const CLAIMS = /* @__PURE__ */ new Map();
+/**
+* Every owner a handler map has claimed so far.
+*
+* A claim is registered when `ownedElsewhere` is called, so a module that is
+* never imported contributes none. The checks that read this therefore load
+* the claiming modules first, by scanning the sources for the call rather than
+* by keeping a list beside them.
+*/
+const ownedElsewhereClaims = () => [...CLAIMS.values()];
+/** State that another reader takes this child, and who. */
+const ownedElsewhere = (claim) => {
+	CLAIMS.set(`${claim.container}/${claim.child}#${claim.reader}`, claim);
+	return {
+		disposition: OWNED_ELSEWHERE,
+		...claim
+	};
+};
+/**
+* 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, capturePosition, undeclared, undeclaredNamespaces }) => {
+	const children = [];
+	const capture = (child) => {
+		children.push({
+			index: capturePosition(child),
+			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 (typeof disposition !== "function") continue;
+		if (disposition(child) === "capture") capture(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 child of captures) {
+		const { index, xml } = child;
+		const slot = Math.min(Math.max(index, 0), modelled.length);
+		const bucket = byIndex.get(slot);
+		if (bucket) {
+			bucket.push(wrap(xml, child));
+			continue;
+		}
+		byIndex.set(slot, [wrap(xml, child)]);
+	}
+	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("");
+/**
+* Where each child sits in a container whose content model is one flat sequence.
+*
+* A property set is that container: `CT_TblPr` and `CT_SectPr` are sequences
+* of optional singletons, so a child's position is a property of its name and
+* the generated list is the order. That is what the sink records for them,
+* rather than a count of modelled siblings: the count is a mirror of whichever
+* properties folio models today, and it moves under the capture the moment one
+* more of them is modelled.
+*
+* An undeclared child — a foreign namespace, an `mc:` construct, a name a
+* later revision of the format adds — has no place in the sequence, so it
+* takes the place of the last declared child before it and comes back beside
+* the same neighbour. One before every declared child takes position `-1`,
+* ahead of the sequence's first slot.
+*/
+const sequencePositions = (container, element) => {
+	const declared = SEQUENCE_CHILDREN[container];
+	const positions = /* @__PURE__ */ new Map();
+	let previous = -1;
+	for (const child of getChildElements(element)) {
+		const namespace = getNamespaceUri(child);
+		const at = namespace === void 0 || WORDPROCESSINGML_NAMESPACE_URIS.has(namespace) ? declared.indexOf(getLocalName(child.name)) : -1;
+		if (at !== -1) previous = at;
+		positions.set(child, at === -1 ? previous : at);
+	}
+	return (child) => positions.get(child) ?? -1;
+};
+//#endregion
+export { CAPTURE, DROPPED_WITH_ITS_WRAPPER, dispatchChildren, keptUnless, ownedElsewhere, ownedElsewhereClaims, sequencePositions, serializeWithPreservedChildren, transitionalNamespaceOf, withPreservedChildren };

package/dist/docx/diagramPreview.d.ts

@@ -1,7 +1,19 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
 //#region src/docx/diagramPreview.d.ts
-/** Create a deliberately simple, bounded preview; it is never an editable diagram projection. */
+/**
+ * How many `dsp:sp` a preview describes at most.
+ *
+ * The bound is on the description rather than on any picture built from it:
+ * the shapes are what a backend draws, and a drawing with ten thousand of them
+ * is a drawing folio summarises rather than reproduces.
+ */
+declare const MAX_PREVIEW_SHAPES = 128;
+/**
+ * Describe a diagram drawing, without drawing it.
+ *
+ * Deliberately simple and bounded; it is never an editable diagram projection.
+ */
 declare const parseDiagramPreview: (drawing: XmlElement, rels: document_d_exports.RelationshipMap | undefined, media: Map<string, document_d_exports.MediaFile> | undefined) => document_d_exports.Image | null;
 //#endregion
-export { parseDiagramPreview };
+export { MAX_PREVIEW_SHAPES, parseDiagramPreview };

package/dist/docx/diagramPreview.js

@@ -1,11 +1,14 @@
-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
+/**
+* How many `dsp:sp` a preview describes at most.
+*
+* The bound is on the description rather than on any picture built from it:
+* the shapes are what a backend draws, and a drawing with ten thousand of them
+* is a drawing folio summarises rather than reproduces.
+*/
 const MAX_PREVIEW_SHAPES = 128;
-const MAX_PREVIEW_PIXELS = 144e4;
-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"]);
@@ -13,140 +16,6 @@ const DIAGRAM_DATA_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/office
 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 (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;
-	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;
-};
-const pngChunk = (type, data) => {
-	const name = new TextEncoder().encode(type);
-	const output = new Uint8Array(12 + data.length);
-	const view = new DataView(output.buffer);
-	view.setUint32(0, data.length);
-	output.set(name, 4);
-	output.set(data, 8);
-	view.setUint32(8 + data.length, crc32(output.subarray(4, 8 + data.length)));
-	return output;
-};
-const previewPng = (width, height, shapes) => {
-	const scale = Math.min(1, Math.sqrt(MAX_PREVIEW_PIXELS / (width * height)));
-	const w = Math.max(1, Math.round(width * scale));
-	const h = Math.max(1, Math.round(height * scale));
-	const pixels = new Uint8Array((w * 4 + 1) * h);
-	for (let y = 0; y < h; y += 1) {
-		const row = y * (w * 4 + 1);
-		pixels[row] = 0;
-		for (let x = 0; x < w; x += 1) {
-			const index = row + 1 + x * 4;
-			pixels[index] = 238;
-			pixels[index + 1] = 242;
-			pixels[index + 2] = 247;
-			pixels[index + 3] = 255;
-		}
-	}
-	let paintedPixels = 0;
-	for (const shape of shapes) {
-		const sx = Math.max(0, Math.round(shape.x / width * w));
-		const sy = Math.max(0, Math.round(shape.y / height * h));
-		const ex = Math.min(w, Math.round((shape.x + shape.width) / width * w));
-		const ey = Math.min(h, Math.round((shape.y + shape.height) / height * h));
-		const red = Number.parseInt(shape.color.slice(0, 2), 16) || 232;
-		const green = Number.parseInt(shape.color.slice(2, 4), 16) || 238;
-		const blue = Number.parseInt(shape.color.slice(4, 6), 16) || 247;
-		const shapePixels = Math.max(0, ex - sx) * Math.max(0, ey - sy);
-		if (paintedPixels + shapePixels > MAX_PREVIEW_PAINT_PIXELS) break;
-		paintedPixels += shapePixels;
-		for (let y = sy; y < ey; y += 1) {
-			const row = y * (w * 4 + 1);
-			for (let x = sx; x < ex; x += 1) {
-				const index = row + 1 + x * 4;
-				pixels[index] = red;
-				pixels[index + 1] = green;
-				pixels[index + 2] = blue;
-			}
-		}
-	}
-	const compressed = new Uint8Array(2 + pixels.length + Math.ceil(pixels.length / 65535) * 5 + 4);
-	compressed[0] = 120;
-	compressed[1] = 1;
-	let cursor = 2;
-	for (let offset = 0; offset < pixels.length;) {
-		const length = Math.min(65535, pixels.length - offset);
-		compressed[cursor++] = offset + length === pixels.length ? 1 : 0;
-		compressed[cursor++] = length & 255;
-		compressed[cursor++] = length >>> 8;
-		compressed[cursor++] = ~length & 255;
-		compressed[cursor++] = ~length >>> 8 & 255;
-		compressed.set(pixels.subarray(offset, offset + length), cursor);
-		cursor += length;
-		offset += length;
-	}
-	new DataView(compressed.buffer).setUint32(cursor, adler32(pixels));
-	const output = compressed;
-	const signature = new Uint8Array([
-		137,
-		80,
-		78,
-		71,
-		13,
-		10,
-		26,
-		10
-	]);
-	const header = /* @__PURE__ */ new Uint8Array(13);
-	new DataView(header.buffer).setUint32(0, w);
-	new DataView(header.buffer).setUint32(4, h);
-	header[8] = 8;
-	header[9] = 6;
-	const chunks = [
-		signature,
-		pngChunk("IHDR", header),
-		pngChunk("IDAT", output),
-		pngChunk("IEND", /* @__PURE__ */ new Uint8Array())
-	];
-	const png = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
-	let position = 0;
-	for (const chunk of chunks) {
-		png.set(chunk, position);
-		position += chunk.length;
-	}
-	return png;
-};
 const extent = (drawing) => {
 	const value = findChildByNamespaceUri(findChildByNamespaceUri(drawing, WORD_DRAWING_NAMESPACE_URIS, "inline") ?? findChildByNamespaceUri(drawing, WORD_DRAWING_NAMESPACE_URIS, "anchor"), WORD_DRAWING_NAMESPACE_URIS, "extent");
 	return {
@@ -155,11 +24,47 @@ const extent = (drawing) => {
 	};
 };
 /** Parse the part a relationship of the given type names, by that relationship's id. */
-const partByRelationshipId = ({ rels, media, rId, type }) => {
+const partByRelationshipId = ({ rels, media, rId, type, cache }) => {
 	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;
+	const path = resolveRelativePath(DOCUMENT_PART_PATH, resolved.relationship.target);
+	const cached = cache.get(path);
+	if (cached !== void 0) return cached;
+	const file = media.get(path);
+	const parsed = file?.data ? parseXmlDocument(new TextDecoder().decode(file.data)) : null;
+	cache.set(path, parsed);
+	return parsed;
+};
+const matchesNamespace = (element, namespaceUris, localName) => element.namespaceUri !== void 0 && namespaceUris.has(element.namespaceUri) && getLocalName(element.name ?? "") === localName;
+/**
+* Descendants in document order, stopping once `limit` of them are found.
+*
+* The walk used to collect every match and slice afterwards, so a drawing with
+* ten thousand shapes built a ten-thousand-element array to keep a hundred and
+* twenty-eight of them. The bound belongs in the walk, not after it.
+*/
+const descendantsByNamespace = (root, namespaceUris, localName, limit) => {
+	const result = [];
+	const visit = (element) => {
+		if (matchesNamespace(element, namespaceUris, localName)) {
+			result.push(element);
+			return result.length < limit;
+		}
+		for (const child of element.elements ?? []) if (child.type === "element" && !visit(child)) return false;
+		return true;
+	};
+	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;
 };
 /**
 * The drawing cache this diagram points at, reached through its own ids.
@@ -170,25 +75,27 @@ const partByRelationshipId = ({ rels, media, rId, type }) => {
 * 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 cachedDiagramShapes = (graphicData, rels, media, cache) => {
 	const relIds = findChildByNamespaceUri(graphicData, DIAGRAM_NAMESPACE_URIS, "relIds");
 	const data = partByRelationshipId({
 		rels,
 		media,
+		cache,
 		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 dataModelExt = firstDescendantByNamespace(data, DIAGRAM_DRAWING_NAMESPACE_URIS, "dataModelExt");
 	const root = partByRelationshipId({
 		rels,
 		media,
+		cache,
 		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)) {
+	for (const shape of descendantsByNamespace(root, DIAGRAM_DRAWING_NAMESPACE_URIS, "sp", 128)) {
 		const properties = findChildByNamespaceUri(shape, DIAGRAM_DRAWING_NAMESPACE_URIS, "spPr");
 		const transform = findChildByNamespaceUri(properties, DRAWINGML_NAMESPACE_URIS, "xfrm");
 		const offset = findChildByNamespaceUri(transform, DRAWINGML_NAMESPACE_URIS, "off");
@@ -207,27 +114,28 @@ const cachedDiagramShapes = (graphicData, 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 (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;
+/**
+* The part cache, keyed by the package's own media map.
+*
+* The cache has to be per package: a global one would answer one document's
+* `word/diagrams/data1.xml` with another's. Keying it on the media map gets
+* that lifetime for free and without threading a reader through every drawing
+* call site, and a weak key means the cache dies with the package rather than
+* retaining its parts.
+*/
+const PART_CACHES = /* @__PURE__ */ new WeakMap();
+const partCacheFor = (media) => {
+	const existing = PART_CACHES.get(media);
+	if (existing) return existing;
+	const created = /* @__PURE__ */ new Map();
+	PART_CACHES.set(media, created);
+	return created;
 };
-/** Create a deliberately simple, bounded preview; it is never an editable diagram projection. */
+/**
+* Describe a diagram drawing, without drawing it.
+*
+* Deliberately simple and bounded; it is never an editable diagram projection.
+*/
 const parseDiagramPreview = (drawing, rels, media) => {
 	if (!rels || !media) return null;
 	const graphicData = firstDescendantByNamespace(drawing, DRAWINGML_NAMESPACE_URIS, "graphicData");
@@ -236,10 +144,14 @@ const parseDiagramPreview = (drawing, rels, media) => {
 	if (width <= 0 || height <= 0) return null;
 	return {
 		type: "image",
-		rId: "",
-		src: bytesToDataUrl(previewPng(width, height, cachedDiagramShapes(graphicData, rels, media)), PREVIEW_KINDS.smartArt.mimeType),
-		mimeType: PREVIEW_KINDS.smartArt.mimeType,
-		filename: PREVIEW_KINDS.smartArt.filename,
+		preview: {
+			kind: "diagram",
+			extent: {
+				width,
+				height
+			},
+			shapes: cachedDiagramShapes(graphicData, rels, media, partCacheFor(media))
+		},
 		size: {
 			width,
 			height
@@ -248,4 +160,4 @@ const parseDiagramPreview = (drawing, rels, media) => {
 	};
 };
 //#endregion
-export { parseDiagramPreview };
+export { MAX_PREVIEW_SHAPES, parseDiagramPreview };

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);
 	}
@@ -127,7 +127,10 @@ function parseDocumentBody(xml, styles = null, theme = null, numbering = null, r
 	if (!documentEl) return result;
 	const bodyEl = findChild(documentEl, "w", "body");
 	if (!bodyEl) return result;
-	result.content = parseBlockContent(bodyEl, styles, theme, numbering, rels, media, { rootXmlns: collectXmlnsDeclarations(documentEl) });
+	result.content = parseBlockContent(bodyEl, styles, theme, numbering, rels, media, {
+		rootXmlns: collectXmlnsDeclarations(documentEl),
+		context
+	});
 	const finalSectPr = findChild(bodyEl, "w", "sectPr");
 	if (finalSectPr) result.finalSectionProperties = parseSectionProperties(finalSectPr, context);
 	canonicalizeLeadingBodySectionProperties(bodyEl, result);
@@ -149,7 +152,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 +196,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/drawingAnchor.d.ts

@@ -0,0 +1,87 @@
+import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/drawingAnchor.d.ts
+/** WordprocessingDrawing, Transitional and Strict (ECMA-376 Parts 1 and 4). */
+declare const WORDPROCESSING_DRAWING_NAMESPACE_URIS: ReadonlySet<string>;
+/** The anchor fields that are a single `ST_OnOff`-style attribute. */
+type DrawingAnchorFlag = { [Key in keyof document_d_exports.DrawingAnchor]-?: NonNullable<document_d_exports.DrawingAnchor[Key]> extends boolean ? Key : never; }[keyof document_d_exports.DrawingAnchor];
+/** Every boolean the anchor models, from the total map above. */
+declare const DRAWING_ANCHOR_FLAG_KEYS: DrawingAnchorFlag[];
+/**
+ * Read `CT_Anchor`'s own attributes and its `wp:simplePos` offsets.
+ *
+ * Undefined when the element states none of them: an anchor whose every
+ * attribute is the spec default holds nothing the model needs to remember, and
+ * recording an empty record would make a rebuild write values the source did
+ * not.
+ */
+declare const parseDrawingAnchor: (anchorEl: XmlElement) => document_d_exports.DrawingAnchor | undefined;
+/**
+ * The insets to write on each of the two elements that can carry them.
+ *
+ * A drawing whose slots say where its insets were authored gets each one back
+ * on that element, which is the only way the wrap child's own set survives a
+ * rebuild. A drawing with no slots, or one an editor command has moved an inset
+ * on, states the value in force on the drawing: that is where OOXML reads an
+ * inset from when the wrap child states none, so the effective value is right
+ * either way, and inventing a wrap-child inset from a moved value would not be.
+ */
+declare const resolveWrapDistances: (wrap: document_d_exports.ImageWrap | undefined) => {
+  drawing: document_d_exports.WrapDistances;
+  wrapChild: document_d_exports.WrapDistances;
+};
+type ResolvedEffectExtents = {
+  /** `wp:inline` or `wp:anchor`; undefined writes the all-zero reservation. */
+  drawing: document_d_exports.ImagePadding | undefined;
+  /** `wp:wrapSquare` or `wp:wrapTopAndBottom`, which write nothing when undefined. */
+  wrapChild: document_d_exports.ImagePadding | undefined;
+};
+/**
+ * The `wp:effectExtent` to write on each of the two elements that carry one.
+ *
+ * {@link resolveWrapDistances}'s rule, one element over: a drawing whose slots
+ * say where the reservations were authored gets each one back on that element,
+ * which is the only way the wrap child's own survives a rebuild. Once the
+ * drawing's reservation has been resized the two no longer describe the same
+ * object, so the rebuild states the value in force on the drawing and lets
+ * OOXML's own default apply to the wrap — keeping a wrap reservation computed
+ * against the old size would flow text around a shape that is no longer there.
+ *
+ * `effective` is the reservation the model holds for the drawing itself:
+ * `Image.padding`. A shape and a text box have no such field — the rebuild has
+ * always written zeros — so they pass the drawing slot back and nothing can
+ * have moved a value the model cannot hold.
+ */
+declare const resolveEffectExtents: (wrap: document_d_exports.ImageWrap | undefined, effective: document_d_exports.ImagePadding | undefined) => ResolvedEffectExtents;
+/** `wp:effectExtent`, whose four sides `CT_EffectExtent` all requires. */
+declare const serializeEffectExtent: (extent: document_d_exports.ImagePadding | undefined) => string;
+/** The inset attributes an element states, in schema order, or nothing. */
+declare const serializeWrapDistances: (distances: document_d_exports.WrapDistances) => string;
+/**
+ * Only the wrap insets `wp:inline` or `wp:anchor` itself carries. OOXML
+ * defaults an omitted one to zero, so writing all four would put a value on
+ * every drawing that never had one.
+ */
+declare const serializeWrapDistanceAttributes: (wrap: document_d_exports.ImageWrap | undefined) => string;
+/** `wp:inline` carries the wrap insets and nothing else of `CT_Anchor`'s set. */
+declare const serializeInlineAttributes: (wrap: document_d_exports.ImageWrap | undefined) => string;
+type AnchorAttributesOptions = {
+  anchor: document_d_exports.DrawingAnchor | undefined;
+  wrap: document_d_exports.ImageWrap | undefined;
+  /** `@behindDoc`, which the wrap type decides rather than the anchor record. */
+  behindDoc: boolean;
+};
+/**
+ * Every attribute `CT_Anchor` declares of its own, in schema order.
+ *
+ * The walk is over {@link DRAWING_ANCHOR_FLAG_KEYS} rather than a hand-written list, so
+ * a flag added to the model cannot be written by the parser and forgotten here.
+ */
+declare const serializeAnchorAttributes: ({ anchor, wrap, behindDoc }: AnchorAttributesOptions) => string;
+/**
+ * `wp:simplePos`, which `CT_Anchor` requires whether or not `@simplePos` says to
+ * use it, so an anchor that authored no offsets still writes the origin.
+ */
+declare const serializeSimplePos: (anchor: document_d_exports.DrawingAnchor | undefined) => string;
+//#endregion
+export { AnchorAttributesOptions, DRAWING_ANCHOR_FLAG_KEYS, ResolvedEffectExtents, WORDPROCESSING_DRAWING_NAMESPACE_URIS, parseDrawingAnchor, resolveEffectExtents, resolveWrapDistances, serializeAnchorAttributes, serializeEffectExtent, serializeInlineAttributes, serializeSimplePos, serializeWrapDistanceAttributes, serializeWrapDistances };