@stll/folio-core 0.46.0 → 0.47.1

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

@@ -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);

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 };

package/dist/docx/drawingAnchor.js

@@ -0,0 +1,201 @@
+import { intAttr } from "./serializer/xmlUtils.js";
+import { findChildByNamespaceUri, getAttribute, parseNumericAttribute, parseOnOffValue } from "./xmlParser.js";
+//#region src/docx/drawingAnchor.ts
+/** WordprocessingDrawing, Transitional and Strict (ECMA-376 Parts 1 and 4). */
+const WORDPROCESSING_DRAWING_NAMESPACE_URIS = /* @__PURE__ */ new Set(["http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing", "http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing"]);
+/**
+* Model key → attribute, total over the boolean half of {@link DrawingAnchor}.
+*
+* A flag added to the model fails this map until the rebuild path decides what
+* an anchor that does not state it is.
+*/
+const ANCHOR_FLAGS = {
+	useSimplePosition: {
+		spelling: "simplePos",
+		whenUnstated: false
+	},
+	locked: {
+		spelling: "locked",
+		whenUnstated: false
+	},
+	layoutInCell: {
+		spelling: "layoutInCell",
+		whenUnstated: true
+	},
+	allowOverlap: {
+		spelling: "allowOverlap",
+		whenUnstated: true
+	},
+	hidden: {
+		spelling: "hidden",
+		whenUnstated: "omit"
+	}
+};
+/** Every boolean the anchor models, from the total map above. */
+const DRAWING_ANCHOR_FLAG_KEYS = Object.keys(ANCHOR_FLAGS);
+/**
+* `@relativeHeight` is required and unsigned; this is the value Word writes for
+* the first floating object it anchors, and the only one folio may invent.
+*/
+const DEFAULT_RELATIVE_HEIGHT = 251658240;
+/** The wrap insets, which `CT_Inline` and `CT_Anchor` both carry. */
+const WRAP_DISTANCE_ATTRIBUTES = {
+	distT: "distT",
+	distB: "distB",
+	distL: "distL",
+	distR: "distR"
+};
+const WRAP_DISTANCE_KEYS = Object.keys(WRAP_DISTANCE_ATTRIBUTES);
+/**
+* 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.
+*/
+const parseDrawingAnchor = (anchorEl) => {
+	const anchor = {};
+	let stated = false;
+	for (const key of DRAWING_ANCHOR_FLAG_KEYS) {
+		const value = parseOnOffValue(getAttribute(anchorEl, null, ANCHOR_FLAGS[key].spelling));
+		if (value !== void 0) {
+			anchor[key] = value;
+			stated = true;
+		}
+	}
+	const relativeHeight = parseNumericAttribute(anchorEl, null, "relativeHeight");
+	if (relativeHeight !== void 0) {
+		anchor.relativeHeight = relativeHeight;
+		stated = true;
+	}
+	const simplePosEl = findChildByNamespaceUri(anchorEl, WORDPROCESSING_DRAWING_NAMESPACE_URIS, "simplePos");
+	const x = parseNumericAttribute(simplePosEl, null, "x");
+	const y = parseNumericAttribute(simplePosEl, null, "y");
+	if (x !== void 0 && y !== void 0) {
+		anchor.simplePosition = {
+			x,
+			y
+		};
+		stated = true;
+	}
+	return stated ? anchor : void 0;
+};
+/**
+* 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.
+*/
+const resolveWrapDistances = (wrap) => {
+	const slots = wrap?.distanceSlots;
+	if (slots !== void 0 && WRAP_DISTANCE_KEYS.every((key) => wrap?.[key] === (slots.wrapChild?.[key] ?? slots.drawing?.[key]))) return {
+		drawing: slots.drawing ?? {},
+		wrapChild: slots.wrapChild ?? {}
+	};
+	const drawing = {};
+	for (const key of WRAP_DISTANCE_KEYS) {
+		const value = wrap?.[key];
+		if (value !== void 0) drawing[key] = value;
+	}
+	return {
+		drawing,
+		wrapChild: {}
+	};
+};
+/** `CT_EffectExtent`'s four sides, in the order the type declares them. */
+const EFFECT_EXTENT_SIDES = [
+	"left",
+	"top",
+	"right",
+	"bottom"
+];
+/**
+* Two reservations are the same document when every side matches.
+*
+* An absent side and a zero one are one value: `CT_EffectExtent` requires all
+* four and the rebuild writes zero for a side the record holds nothing for, so
+* an all-zero record and no record at all say the same thing.
+*/
+const sameEffectExtent = (left, right) => EFFECT_EXTENT_SIDES.every((side) => (left?.[side] ?? 0) === (right?.[side] ?? 0));
+/**
+* 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.
+*/
+const resolveEffectExtents = (wrap, effective) => {
+	const slots = wrap?.effectExtentSlots;
+	if (slots === void 0 || !sameEffectExtent(effective, slots.drawing)) return {
+		drawing: effective,
+		wrapChild: void 0
+	};
+	return {
+		drawing: slots.drawing,
+		wrapChild: slots.wrapChild
+	};
+};
+/** `wp:effectExtent`, whose four sides `CT_EffectExtent` all requires. */
+const serializeEffectExtent = (extent) => `<wp:effectExtent l="${intAttr(extent?.left ?? 0)}" t="${intAttr(extent?.top ?? 0)}" r="${intAttr(extent?.right ?? 0)}" b="${intAttr(extent?.bottom ?? 0)}"/>`;
+/** The inset attributes an element states, in schema order, or nothing. */
+const serializeWrapDistances = (distances) => {
+	const attrs = WRAP_DISTANCE_KEYS.flatMap((key) => {
+		const value = distances[key];
+		return value === void 0 ? [] : [`${WRAP_DISTANCE_ATTRIBUTES[key]}="${intAttr(value)}"`];
+	});
+	return attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+};
+/**
+* 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.
+*/
+const serializeWrapDistanceAttributes = (wrap) => serializeWrapDistances(resolveWrapDistances(wrap).drawing);
+/** `wp:inline` carries the wrap insets and nothing else of `CT_Anchor`'s set. */
+const serializeInlineAttributes = (wrap) => serializeWrapDistanceAttributes(wrap);
+/**
+* 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.
+*/
+const serializeAnchorAttributes = ({ anchor, wrap, behindDoc }) => {
+	const attrs = [];
+	for (const key of DRAWING_ANCHOR_FLAG_KEYS) {
+		const { spelling, whenUnstated } = ANCHOR_FLAGS[key];
+		const stated = anchor?.[key] ?? whenUnstated;
+		if (stated !== "omit") attrs.push(`${spelling}="${stated ? "1" : "0"}"`);
+		if (key === "useSimplePosition") {
+			attrs.push(`relativeHeight="${intAttr(anchor?.relativeHeight ?? DEFAULT_RELATIVE_HEIGHT)}"`);
+			attrs.push(`behindDoc="${behindDoc ? "1" : "0"}"`);
+		}
+	}
+	return `${serializeWrapDistanceAttributes(wrap)} ${attrs.join(" ")}`;
+};
+/**
+* `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.
+*/
+const serializeSimplePos = (anchor) => {
+	const { x, y } = anchor?.simplePosition ?? {
+		x: 0,
+		y: 0
+	};
+	return `<wp:simplePos x="${intAttr(x)}" y="${intAttr(y)}"/>`;
+};
+//#endregion
+export { DRAWING_ANCHOR_FLAG_KEYS, WORDPROCESSING_DRAWING_NAMESPACE_URIS, parseDrawingAnchor, resolveEffectExtents, resolveWrapDistances, serializeAnchorAttributes, serializeEffectExtent, serializeInlineAttributes, serializeSimplePos, serializeWrapDistanceAttributes, serializeWrapDistances };