@stll/folio-core 0.33.1 → 0.33.2

package/dist/docx/serializer/headerFooterSerializer.js

@@ -1,35 +1,33 @@
 import { canReplayHeaderFooterVerbatim, getHeaderFooterVerbatimXml } from "../headerFooterVerbatim.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
+import { serializePartElement } from "./partNamespaces.js";
 import { serializeTable } from "./tableSerializer.js";
 import { escapeXml } from "./xmlUtils.js";
 //#region src/docx/serializer/headerFooterSerializer.ts
-const NAMESPACES = {
-	wpc: "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
-	mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
-	o: "urn:schemas-microsoft-com:office:office",
-	r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
-	m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
-	v: "urn:schemas-microsoft-com:vml",
-	a: "http://schemas.openxmlformats.org/drawingml/2006/main",
-	pic: "http://schemas.openxmlformats.org/drawingml/2006/picture",
-	wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
-	wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
-	w10: "urn:schemas-microsoft-com:office:word",
-	w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-	w14: "http://schemas.microsoft.com/office/word/2010/wordml",
-	w15: "http://schemas.microsoft.com/office/word/2012/wordml",
-	w16: "http://schemas.microsoft.com/office/word/2018/wordml",
-	w16cex: "http://schemas.microsoft.com/office/word/2018/wordml/cex",
-	w16cid: "http://schemas.microsoft.com/office/word/2016/wordml/cid",
-	w16sdtdh: "http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash",
-	w16se: "http://schemas.microsoft.com/office/word/2015/wordml/symex",
-	wpg: "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
-	wps: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
-};
-function buildNamespaceDeclarations() {
-	return Object.entries(NAMESPACES).map(([prefix, uri]) => `xmlns:${prefix}="${uri}"`).join(" ");
-}
+const HEADER_FOOTER_BASELINE_PREFIXES = [
+	"wpc",
+	"mc",
+	"o",
+	"r",
+	"m",
+	"v",
+	"a",
+	"pic",
+	"wp14",
+	"wp",
+	"w10",
+	"w",
+	"w14",
+	"w15",
+	"w16",
+	"w16cex",
+	"w16cid",
+	"w16sdtdh",
+	"w16se",
+	"wpg",
+	"wps"
+];
 /**
 * Serialize a block content item (paragraph, table, or block-level SDT) for
 * header/footer.
@@ -43,13 +41,14 @@ function serializeBlock(block) {
 * Serialize a HeaderFooter object to valid OOXML XML
 *
 * @param hf - HeaderFooter object to serialize
+* @param source - The part being replaced, so a prefix only the source
+*   document bound keeps its URI
 * @returns Complete XML string for header*.xml or footer*.xml
 */
-function serializeHeaderFooter(hf) {
+function serializeHeaderFooter(hf, source) {
 	const verbatim = getHeaderFooterVerbatimXml(hf);
 	if (verbatim && canReplayHeaderFooterVerbatim(hf)) return verbatim;
 	const rootTag = hf.type === "header" ? "w:hdr" : "w:ftr";
-	const nsDecl = buildNamespaceDeclarations();
 	const watermarkXml = serializeWatermarkParagraph(hf);
 	const watermarkInsertIndex = hf.watermarkBlockIndex !== void 0 ? Math.max(0, Math.min(hf.watermarkBlockIndex, hf.content.length)) : 0;
 	const blocksXml = hf.content.map((block) => serializeBlock(block));
@@ -57,7 +56,13 @@ function serializeHeaderFooter(hf) {
 	if (watermarkXml) contentXml = blocksXml.slice(0, watermarkInsertIndex).join("") + watermarkXml + blocksXml.slice(watermarkInsertIndex).join("");
 	else contentXml = blocksXml.join("");
 	if (!contentXml) contentXml = "<w:p><w:pPr/></w:p>";
-	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<${rootTag} ${nsDecl}>${contentXml}</${rootTag}>`;
+	return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
+		partPath: source?.path ?? `word/${hf.type}.xml`,
+		rootName: rootTag,
+		baselinePrefixes: HEADER_FOOTER_BASELINE_PREFIXES,
+		sourceBindings: source?.bindings,
+		body: contentXml
+	});
 }
 function serializeWatermarkParagraph(hf) {
 	if (hf.rawWatermarkXml) return hf.rawWatermarkXml;

package/dist/docx/serializer/noteSerializer.js

@@ -1,33 +1,38 @@
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
+import { serializePartElement } from "./partNamespaces.js";
 import { serializeTable } from "./tableSerializer.js";
 //#region src/docx/serializer/noteSerializer.ts
-const NAMESPACES = {
-	wpc: "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
-	mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
-	o: "urn:schemas-microsoft-com:office:office",
-	r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
-	m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
-	v: "urn:schemas-microsoft-com:vml",
-	a: "http://schemas.openxmlformats.org/drawingml/2006/main",
-	pic: "http://schemas.openxmlformats.org/drawingml/2006/picture",
-	wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
-	wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
-	w10: "urn:schemas-microsoft-com:office:word",
-	w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-	w14: "http://schemas.microsoft.com/office/word/2010/wordml",
-	w15: "http://schemas.microsoft.com/office/word/2012/wordml",
-	w16: "http://schemas.microsoft.com/office/word/2018/wordml",
-	w16cex: "http://schemas.microsoft.com/office/word/2018/wordml/cex",
-	w16cid: "http://schemas.microsoft.com/office/word/2016/wordml/cid",
-	w16sdtdh: "http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash",
-	w16se: "http://schemas.microsoft.com/office/word/2015/wordml/symex",
-	wpg: "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
-	wps: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape"
-};
-function buildNamespaceDeclarations() {
-	return Object.entries(NAMESPACES).map(([prefix, uri]) => `xmlns:${prefix}="${uri}"`).join(" ");
-}
+const NOTE_BASELINE_PREFIXES = [
+	"wpc",
+	"mc",
+	"o",
+	"r",
+	"m",
+	"v",
+	"a",
+	"pic",
+	"wp14",
+	"wp",
+	"w10",
+	"w",
+	"w14",
+	"w15",
+	"w16",
+	"w16cex",
+	"w16cid",
+	"w16sdtdh",
+	"w16se",
+	"wpg",
+	"wps"
+];
+const serializeNotePart = (elementName, body) => "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
+	partPath: `word/${elementName}s.xml`,
+	rootName: `w:${elementName}s`,
+	baselinePrefixes: NOTE_BASELINE_PREFIXES,
+	sourceBindings: void 0,
+	body
+});
 /**
 * Serialize a block content item (paragraph, table, or block-level SDT) for a
 * note body.
@@ -63,9 +68,8 @@ function insertNoteReferenceMark(xml, elementName) {
 	return `${xml.slice(0, insertAt)}${referenceRun}${xml.slice(insertAt)}`;
 }
 function serializeNewNotePart(elementName, notes) {
-	const nsDecl = buildNamespaceDeclarations();
 	const serializedNotes = notes.map((note) => insertNoteReferenceMark(serializeNote(elementName, note), elementName)).join("");
-	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:${elementName}s ${nsDecl} mc:Ignorable="w14 w15 wp14">` + serializeRequiredNoteSeparators(elementName) + serializedNotes + `</w:${elementName}s>`;
+	return serializeNotePart(elementName, serializeRequiredNoteSeparators(elementName) + serializedNotes);
 }
 /**
 * Serialize footnotes to a complete word/footnotes.xml string.
@@ -74,7 +78,7 @@ function serializeNewNotePart(elementName, notes) {
 * @returns Complete footnotes.xml string.
 */
 function serializeFootnotes(footnotes) {
-	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:footnotes ${buildNamespaceDeclarations()} mc:Ignorable="w14 w15 wp14">${footnotes.map((fn) => serializeNote("footnote", fn)).join("")}</w:footnotes>`;
+	return serializeNotePart("footnote", footnotes.map((fn) => serializeNote("footnote", fn)).join(""));
 }
 /**
 * Serialize endnotes to a complete word/endnotes.xml string.
@@ -83,7 +87,7 @@ function serializeFootnotes(footnotes) {
 * @returns Complete endnotes.xml string.
 */
 function serializeEndnotes(endnotes) {
-	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:endnotes ${buildNamespaceDeclarations()} mc:Ignorable="w14 w15 wp14">${endnotes.map((en) => serializeNote("endnote", en)).join("")}</w:endnotes>`;
+	return serializeNotePart("endnote", endnotes.map((en) => serializeNote("endnote", en)).join(""));
 }
 /** Serialize a brand-new footnote part, including Word's required separators
 * and the automatic reference mark at the start of every normal note. */

package/dist/docx/serializer/numberingSerializer.js

@@ -1,7 +1,7 @@
+import { serializePartElement } from "./partNamespaces.js";
 import { serializeTextFormatting } from "./runSerializer.js";
 import { escapeXml, intAttr } from "./xmlUtils.js";
 //#region src/docx/serializer/numberingSerializer.ts
-const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 /**
 * Serialize a level's paragraph properties — the modeled subset is indentation
 * plus tab stops (see `parseLevelParagraphProps`). Returns "" when neither is
@@ -87,9 +87,13 @@ function serializeNum(instance) {
 * change detection and per-definition splicing, never to overwrite the part.
 */
 function serializeNumberingXml(numbering) {
-	const abstractNums = numbering.abstractNums.map(serializeAbstractNum).join("");
-	const nums = numbering.nums.map(serializeNum).join("");
-	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:numbering xmlns:w="${W_NS}">${abstractNums}${nums}</w:numbering>`;
+	return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
+		partPath: "word/numbering.xml",
+		rootName: "w:numbering",
+		baselinePrefixes: ["w"],
+		sourceBindings: void 0,
+		body: `${numbering.abstractNums.map(serializeAbstractNum).join("")}${numbering.nums.map(serializeNum).join("")}`
+	});
 }
 //#endregion
 export { serializeNumberingXml };

package/dist/docx/serializer/paragraphSerializer.js

@@ -150,12 +150,10 @@ function serializeParagraphFormatting(formatting, propertyChanges, pPrMark) {
 		if (formatting.styleId) parts.push(`<w:pStyle w:val="${escapeXml(formatting.styleId)}"/>`);
 		pushToggle("keepNext", formatting.keepNext);
 		pushToggle("keepLines", formatting.keepLines);
-		pushToggle("contextualSpacing", formatting.contextualSpacing);
 		pushToggle("pageBreakBefore", formatting.pageBreakBefore);
 		const frameXml = serializeFrameProperties(formatting.frame);
 		if (frameXml) parts.push(frameXml);
 		pushToggle("widowControl", formatting.widowControl);
-		pushToggle("snapToGrid", formatting.snapToGrid);
 		const numPrXml = formatting.numPrFromStyle != null && numPrEqual(formatting.numPr, formatting.numPrFromStyle) ? "" : serializeNumbering(formatting.numPr);
 		if (numPrXml) parts.push(numPrXml);
 		const bordersXml = serializeParagraphBorders(formatting.borders);
@@ -168,11 +166,13 @@ function serializeParagraphFormatting(formatting, propertyChanges, pPrMark) {
 		pushToggle("suppressAutoHyphens", formatting.suppressAutoHyphens);
 		pushToggle("kinsoku", formatting.kinsoku);
 		pushToggle("overflowPunct", formatting.overflowPunctuation);
+		pushToggle("bidi", formatting.bidi);
+		pushToggle("snapToGrid", formatting.snapToGrid);
 		const spacingXml = serializeSpacing(formatting);
 		if (spacingXml) parts.push(spacingXml);
 		const indXml = serializeIndentation(formatting);
 		if (indXml) parts.push(indXml);
-		pushToggle("bidi", formatting.bidi);
+		pushToggle("contextualSpacing", formatting.contextualSpacing);
 		if (formatting.alignment) parts.push(`<w:jc w:val="${formatting.alignment}"/>`);
 		if (formatting.outlineLevel !== void 0) parts.push(`<w:outlineLvl w:val="${formatting.outlineLevel}"/>`);
 		if (pPrMark || formatting.runProperties || formatting.runInWithNext) {

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

@@ -0,0 +1,78 @@
+import { OoxmlPrefix } from "@stll/docx-utils";
+//#region src/docx/serializer/partNamespaces.d.ts
+/**
+ * A namespace a rebuilt WordprocessingML part may declare.
+ *
+ * `ignorable` marks an extension that decorates baseline elements in place
+ * (`w14:paraId`, `w16du:dateUtc`, `wp14:sizeRelH`): a consumer that predates it
+ * has to be told through `mc:Ignorable` to skip it, or it rejects the part.
+ * Extensions reachable only inside an `mc:AlternateContent` choice or an
+ * `a:graphicData` payload (`wps`, `wpg`, `wne`, `cx*`) are already gated by
+ * that wrapper, so they stay out of the attribute, as mainstream producers
+ * leave them.
+ */
+type OoxmlNamespace = {
+  readonly uri: string;
+  readonly ignorable: boolean;
+};
+/** Packaging prefixes; they never appear inside a WordprocessingML part. */
+type PackagingPrefix = "ct" | "pr";
+/**
+ * A prefix folio can bind on a rebuilt part without consulting the source.
+ *
+ * Every prefix the parser resolves is a member, so a prefix the parser
+ * understands can always be written back, and {@link OOXML_NAMESPACES} is total
+ * over the union: a member with no entry, or an entry with no member, does not
+ * compile.
+ */
+type OoxmlNamespacePrefix = Exclude<OoxmlPrefix, PackagingPrefix> | "cx" | "cx1" | "cx2" | "cx3" | "cx4" | "cx5" | "cx6" | "cx7" | "cx8" | "aink" | "am3d" | "oel" | "w10" | "w16" | "w16cex" | "w16cid" | "w16du" | "w16sdtdh" | "w16se" | "wpi" | "wne";
+/**
+ * Every namespace a rebuilt part can declare, in the order producers write them.
+ *
+ * URIs shared with the parser are taken from its table rather than retyped, so
+ * the two cannot drift.
+ */
+declare const OOXML_NAMESPACES: Readonly<Record<OoxmlNamespacePrefix, OoxmlNamespace>>;
+declare const UnboundNamespacePrefixError_base: import("better-result").TaggedErrorClass<"UnboundNamespacePrefixError">;
+/** A rebuilt part uses a prefix that resolves to no namespace URI. */
+declare class UnboundNamespacePrefixError extends UnboundNamespacePrefixError_base<{
+  message: string;
+  partPath: string;
+  prefixes: readonly string[];
+}> {}
+/**
+ * The `xmlns:*` bindings a source part declared on its root element.
+ *
+ * Reused when the part is rebuilt so a producer-specific prefix that
+ * {@link OOXML_NAMESPACES} does not know keeps the URI the document gave it.
+ */
+declare const readRootNamespaceBindings: (partXml: string) => ReadonlyMap<string, string>;
+/** The part a rebuild replaces: where it lives, and what its root element bound. */
+type SourcePart = {
+  path: string;
+  bindings: ReadonlyMap<string, string>;
+};
+type PartElementOptions = {
+  /** Package-relative path of the part, reported when a prefix is unbound. */
+  partPath: string;
+  /** Qualified name of the root element, for example `w:document`. */
+  rootName: string;
+  /** Root-element attributes other than the namespace declarations. */
+  rootAttributes?: string;
+  /**
+   * Prefixes declared whether or not the body uses them, so the part keeps a
+   * stable shape across saves and unmodeled extensions have somewhere to land.
+   */
+  baselinePrefixes: readonly OoxmlNamespacePrefix[];
+  /** Root bindings of the part being replaced, when the save has the source. */
+  sourceBindings: ReadonlyMap<string, string> | undefined;
+  /** Assembled part content, everything between the root tags. */
+  body: string;
+};
+/**
+ * Wrap an assembled part body in a root element that declares every prefix the
+ * part uses and lists the ignorable ones in `mc:Ignorable`.
+ */
+declare const serializePartElement: ({ partPath, rootName, rootAttributes, baselinePrefixes, sourceBindings, body }: PartElementOptions) => string;
+//#endregion
+export { OOXML_NAMESPACES, OoxmlNamespace, OoxmlNamespacePrefix, PartElementOptions, SourcePart, UnboundNamespacePrefixError, readRootNamespaceBindings, serializePartElement };

package/dist/docx/serializer/partNamespaces.js

@@ -0,0 +1,324 @@
+import { toTransitionalNamespaceUri } from "../transitionalSpelling.js";
+import { escapeXml } from "./xmlUtils.js";
+import { TaggedError } from "better-result";
+import { OOXML_NS } from "@stll/docx-utils";
+//#region src/docx/serializer/partNamespaces.ts
+/**
+* Namespace declarations for parts folio rebuilds from the model.
+*
+* A rebuilt part carries content the parser preserved verbatim: raw property
+* XML, text-box bodies, drawing extensions, unmodeled attributes. That content
+* can use any prefix its producer bound on the source part's root, so a
+* hand-maintained declaration list on the serializer silently drops bindings
+* and emits an unbound prefix, which makes the part malformed and the package
+* unopenable. The declarations are therefore derived: every prefix the
+* assembled part actually uses is resolved through {@link OOXML_NAMESPACES},
+* falling back to what the source part bound, and a prefix that resolves to
+* nothing fails the save instead of being written unbound.
+*/
+/**
+* Every namespace a rebuilt part can declare, in the order producers write them.
+*
+* URIs shared with the parser are taken from its table rather than retyped, so
+* the two cannot drift.
+*/
+const OOXML_NAMESPACES = {
+	wpc: {
+		uri: OOXML_NS.wpc,
+		ignorable: false
+	},
+	cx: {
+		uri: "http://schemas.microsoft.com/office/drawing/2014/chartex",
+		ignorable: false
+	},
+	cx1: {
+		uri: "http://schemas.microsoft.com/office/drawing/2015/9/8/chartex",
+		ignorable: false
+	},
+	cx2: {
+		uri: "http://schemas.microsoft.com/office/drawing/2015/10/21/chartex",
+		ignorable: false
+	},
+	cx3: {
+		uri: "http://schemas.microsoft.com/office/drawing/2016/5/9/chartex",
+		ignorable: false
+	},
+	cx4: {
+		uri: "http://schemas.microsoft.com/office/drawing/2016/5/10/chartex",
+		ignorable: false
+	},
+	cx5: {
+		uri: "http://schemas.microsoft.com/office/drawing/2016/5/11/chartex",
+		ignorable: false
+	},
+	cx6: {
+		uri: "http://schemas.microsoft.com/office/drawing/2016/5/12/chartex",
+		ignorable: false
+	},
+	cx7: {
+		uri: "http://schemas.microsoft.com/office/drawing/2016/5/13/chartex",
+		ignorable: false
+	},
+	cx8: {
+		uri: "http://schemas.microsoft.com/office/drawing/2016/5/14/chartex",
+		ignorable: false
+	},
+	mc: {
+		uri: OOXML_NS.mc,
+		ignorable: false
+	},
+	aink: {
+		uri: "http://schemas.microsoft.com/office/drawing/2016/ink",
+		ignorable: false
+	},
+	am3d: {
+		uri: "http://schemas.microsoft.com/office/drawing/2017/model3d",
+		ignorable: false
+	},
+	o: {
+		uri: OOXML_NS.o,
+		ignorable: false
+	},
+	oel: {
+		uri: "http://schemas.microsoft.com/office/2019/extlst",
+		ignorable: false
+	},
+	r: {
+		uri: OOXML_NS.r,
+		ignorable: false
+	},
+	m: {
+		uri: OOXML_NS.m,
+		ignorable: false
+	},
+	v: {
+		uri: OOXML_NS.v,
+		ignorable: false
+	},
+	wp14: {
+		uri: OOXML_NS.wp14,
+		ignorable: true
+	},
+	wp: {
+		uri: OOXML_NS.wp,
+		ignorable: false
+	},
+	w10: {
+		uri: "urn:schemas-microsoft-com:office:word",
+		ignorable: false
+	},
+	w: {
+		uri: OOXML_NS.w,
+		ignorable: false
+	},
+	w14: {
+		uri: OOXML_NS.w14,
+		ignorable: true
+	},
+	w15: {
+		uri: OOXML_NS.w15,
+		ignorable: true
+	},
+	w16cex: {
+		uri: "http://schemas.microsoft.com/office/word/2018/wordml/cex",
+		ignorable: true
+	},
+	w16cid: {
+		uri: "http://schemas.microsoft.com/office/word/2016/wordml/cid",
+		ignorable: true
+	},
+	w16: {
+		uri: "http://schemas.microsoft.com/office/word/2018/wordml",
+		ignorable: true
+	},
+	w16du: {
+		uri: "http://schemas.microsoft.com/office/word/2023/wordml/word16du",
+		ignorable: true
+	},
+	w16sdtdh: {
+		uri: "http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash",
+		ignorable: true
+	},
+	w16se: {
+		uri: "http://schemas.microsoft.com/office/word/2015/wordml/symex",
+		ignorable: true
+	},
+	wpg: {
+		uri: OOXML_NS.wpg,
+		ignorable: false
+	},
+	wpi: {
+		uri: "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
+		ignorable: false
+	},
+	wne: {
+		uri: "http://schemas.microsoft.com/office/word/2006/wordml",
+		ignorable: false
+	},
+	wps: {
+		uri: OOXML_NS.wps,
+		ignorable: false
+	},
+	a: {
+		uri: OOXML_NS.a,
+		ignorable: false
+	},
+	pic: {
+		uri: OOXML_NS.pic,
+		ignorable: false
+	}
+};
+/** {@link OOXML_NAMESPACES} keyed for lookup by a prefix read out of markup. */
+const NAMESPACE_TABLE = new Map(Object.entries(OOXML_NAMESPACES));
+/** A rebuilt part uses a prefix that resolves to no namespace URI. */
+var UnboundNamespacePrefixError = class extends TaggedError("UnboundNamespacePrefixError") {};
+const XMLNS_ATTRIBUTE_PREFIX = "xmlns:";
+/** Bound by the XML specification itself; never declared. */
+const RESERVED_PREFIX = "xml";
+const isWhitespace = (character) => character === " " || character === "	" || character === "\n" || character === "\r";
+const isNameBoundary = (character) => isWhitespace(character) || character === ">" || character === "/" || character === "=";
+const namePrefix = (qualifiedName) => {
+	const colon = qualifiedName.indexOf(":");
+	if (colon <= 0) return;
+	const prefix = qualifiedName.slice(0, colon);
+	return prefix === RESERVED_PREFIX ? void 0 : prefix;
+};
+/**
+* Collect prefixes from element and attribute names in one quote-aware pass.
+*
+* Attribute values are skipped rather than matched, so a URI or a text value
+* containing a colon cannot be mistaken for a namespace prefix.
+*/
+const scanXmlNames = (xml, rootTagOnly) => {
+	const used = /* @__PURE__ */ new Set();
+	const declared = /* @__PURE__ */ new Map();
+	const length = xml.length;
+	let index = 0;
+	while (index < length) {
+		const tagStart = xml.indexOf("<", index);
+		if (tagStart === -1) break;
+		index = tagStart + 1;
+		if (xml.startsWith("?", index)) {
+			const end = xml.indexOf("?>", index);
+			if (end === -1) break;
+			index = end + 2;
+			continue;
+		}
+		if (xml.startsWith("!--", index)) {
+			const end = xml.indexOf("-->", index);
+			if (end === -1) break;
+			index = end + 3;
+			continue;
+		}
+		if (xml.startsWith("![CDATA[", index)) {
+			const end = xml.indexOf("]]>", index);
+			if (end === -1) break;
+			index = end + 3;
+			continue;
+		}
+		if (xml.startsWith("!", index)) {
+			const end = xml.indexOf(">", index);
+			if (end === -1) break;
+			index = end + 1;
+			continue;
+		}
+		if (xml.startsWith("/", index)) index += 1;
+		const nameStart = index;
+		while (index < length && !isNameBoundary(xml[index] ?? ">")) index += 1;
+		const elementPrefix = namePrefix(xml.slice(nameStart, index));
+		if (elementPrefix) used.add(elementPrefix);
+		while (index < length) {
+			const character = xml[index] ?? ">";
+			if (isWhitespace(character) || character === "/") {
+				index += 1;
+				continue;
+			}
+			if (character === ">") {
+				index += 1;
+				break;
+			}
+			const attributeStart = index;
+			while (index < length && !isNameBoundary(xml[index] ?? ">")) index += 1;
+			const attributeName = xml.slice(attributeStart, index);
+			while (index < length && isWhitespace(xml[index] ?? ">")) index += 1;
+			let value = "";
+			if (xml[index] === "=") {
+				index += 1;
+				while (index < length && isWhitespace(xml[index] ?? ">")) index += 1;
+				const quote = xml[index];
+				if (quote === "\"" || quote === "'") {
+					const valueEnd = xml.indexOf(quote, index + 1);
+					if (valueEnd === -1) {
+						index = length;
+						break;
+					}
+					value = xml.slice(index + 1, valueEnd);
+					index = valueEnd + 1;
+				}
+			}
+			if (attributeName.startsWith(XMLNS_ATTRIBUTE_PREFIX)) {
+				declared.set(attributeName.slice(6), value);
+				continue;
+			}
+			const attributePrefix = namePrefix(attributeName);
+			if (attributePrefix) used.add(attributePrefix);
+		}
+		if (rootTagOnly) break;
+	}
+	return {
+		used,
+		declared
+	};
+};
+/**
+* The `xmlns:*` bindings a source part declared on its root element.
+*
+* Reused when the part is rebuilt so a producer-specific prefix that
+* {@link OOXML_NAMESPACES} does not know keeps the URI the document gave it.
+*/
+const readRootNamespaceBindings = (partXml) => scanXmlNames(partXml, true).declared;
+/**
+* Wrap an assembled part body in a root element that declares every prefix the
+* part uses and lists the ignorable ones in `mc:Ignorable`.
+*/
+const serializePartElement = ({ partPath, rootName, rootAttributes, baselinePrefixes, sourceBindings, body }) => {
+	const openingTag = `<${rootName}${rootAttributes ? ` ${rootAttributes}` : ""}`;
+	const fromRoot = scanXmlNames(`${openingTag}/>`, true);
+	const { used, declared } = scanXmlNames(body, false);
+	const required = /* @__PURE__ */ new Set([...fromRoot.used, ...used]);
+	const bindings = /* @__PURE__ */ new Map();
+	for (const prefix of baselinePrefixes) bindings.set(prefix, OOXML_NAMESPACES[prefix].uri);
+	const unbound = [];
+	for (const prefix of required) {
+		if (bindings.has(prefix)) continue;
+		const sourceBinding = sourceBindings?.get(prefix);
+		const uri = NAMESPACE_TABLE.get(prefix)?.uri ?? (sourceBinding === void 0 ? void 0 : toTransitionalNamespaceUri(sourceBinding));
+		if (uri !== void 0) {
+			bindings.set(prefix, uri);
+			continue;
+		}
+		if (!declared.has(prefix)) unbound.push(prefix);
+	}
+	if (unbound.length > 0) {
+		const prefixes = unbound.sort();
+		throw new UnboundNamespacePrefixError({
+			message: `${partPath} uses namespace prefixes bound to no URI: ${prefixes.join(", ")}`,
+			partPath,
+			prefixes
+		});
+	}
+	if ([...bindings.keys()].some((prefix) => NAMESPACE_TABLE.get(prefix)?.ignorable === true)) bindings.set("mc", OOXML_NAMESPACES.mc.uri);
+	const baseline = new Set(baselinePrefixes);
+	const extra = new Set([...bindings.keys()].filter((prefix) => !baseline.has(prefix)));
+	const orderedPrefixes = [
+		...baselinePrefixes,
+		...[...NAMESPACE_TABLE.keys()].filter((prefix) => extra.has(prefix)),
+		...[...extra].filter((prefix) => !NAMESPACE_TABLE.has(prefix)).sort()
+	];
+	const attributes = orderedPrefixes.map((prefix) => `xmlns:${prefix}="${escapeXml(bindings.get(prefix))}"`);
+	const ignorable = orderedPrefixes.filter((prefix) => NAMESPACE_TABLE.get(prefix)?.ignorable === true);
+	if (ignorable.length > 0) attributes.push(`mc:Ignorable="${ignorable.join(" ")}"`);
+	return `${openingTag} ${attributes.join(" ")}>${body}</${rootName}>`;
+};
+//#endregion
+export { OOXML_NAMESPACES, UnboundNamespacePrefixError, readRootNamespaceBindings, serializePartElement };

package/dist/docx/serializer/runSerializer.js

@@ -525,7 +525,7 @@ function serializeShapeContent(content) {
 			"<wps:wsp>",
 			`<wps:cNvSpPr${isTextBox ? " txBox=\"1\"" : ""}/>`,
 			spPr,
-			textBody,
+			textBody === "" ? "<wps:bodyPr/>" : textBody,
 			"</wps:wsp>"
 		].join(""),
 		"</a:graphicData>",