@stll/folio-core 0.52.0 → 0.53.0

package/dist/docx/tableParser.js

@@ -1,4 +1,5 @@
 import { NO_MODELLED_ATTRIBUTES, attributeRemainder } from "./attributeRemainder.js";
+import { blockCustomXmlShell } from "./blockCustomXmlShell.js";
 import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
 import { parseBorderSpec } from "./borderParser.js";
 import { CAPTURE, dispatchChildrenWithContext, keptUnless, ownedElsewhere, sequencePositions, withPreservedChildren } from "./containerChildren.js";
@@ -14,6 +15,7 @@ import { parsePropertyChangeInfo, parseTrackedChangeInfo } from "./trackedChange
 import { percentageSpelling, transitionalSlotEncoding } from "./transitionalSpelling.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, findChild, findChildren, findWordprocessingChild, getAttribute, getAttributeByNamespaceUri, getLocalName, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseOnOffAttribute, parseTableMeasurementValue, selectAlternateContentBranch } from "./xmlParser.js";
+import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
 //#region src/docx/tableParser.ts
 /**
 * Sanity cap on `w:gridSpan` (and the derived table column count). Word's
@@ -556,6 +558,12 @@ function parseTableCellVerticalMergeRevisionValue(value) {
 	if (value === "cont") return "continue";
 	if (value === "rest") return "rest";
 }
+function isTableCellMergeRevisionValue(value) {
+	return value === "continue" || value === "rest";
+}
+function isTableCellMergeRevisionContinuation(value) {
+	return value === "continue";
+}
 const ROW_PROPERTY_HANDLERS = {
 	cnfStyle: (child, formatting) => {
 		const conditionalFormat = parseConditionalFormatStyle(child);
@@ -755,13 +763,35 @@ function parseTableCellProperties(tcPrElement) {
 	if (preserved) formatting.preserved = preserved;
 	return withSourceXml(formatting, tcPrElement);
 }
+const createCustomXmlWrapper = (element, identity) => ({
+	id: identity.next++,
+	...blockCustomXmlShell(element)
+});
+const recordCustomXmlWrapper = (wrapped, wrapper) => {
+	for (const item of wrapped) item.carrierStack = [{
+		type: "customXml",
+		wrapper
+	}, ...item.carrierStack ?? []];
+};
 const recordContentControl = (wrapped, carriers, sdtElement) => {
 	const properties = parseSdtProperties(findWordprocessingChild(sdtElement, "sdtPr"), findWordprocessingChild(sdtElement, "sdtEndPr"));
 	const siblings = captureSdtSiblingMarkers(sdtElement);
 	if (siblings.before.length > 0) properties.rawSdtChildrenBeforeContent = siblings.before;
 	if (siblings.after.length > 0) properties.rawSdtChildrenAfterContent = siblings.after;
-	for (const item of wrapped) item.contentControls = [properties, ...item.contentControls ?? []];
-	for (const item of carriers) item.contentControls = [properties, ...item.contentControls ?? []];
+	for (const item of wrapped) {
+		item.contentControls = [properties, ...item.contentControls ?? []];
+		item.carrierStack = [{
+			type: "sdt",
+			properties
+		}, ...item.carrierStack ?? []];
+	}
+	for (const item of carriers) {
+		item.contentControls = [properties, ...item.contentControls ?? []];
+		item.carrierStack = [{
+			type: "sdt",
+			properties
+		}, ...item.carrierStack ?? []];
+	}
 };
 /**
 * Accumulate a table container's own `xmlns:*` onto the inherited in-scope set,
@@ -779,7 +809,7 @@ const findLastFlowBlock = (blocks) => {
 	for (let index = blocks.length - 1; index >= 0; index -= 1) {
 		const block = blocks[index];
 		if (block?.type === "paragraph" || block?.type === "table") return block;
-		if (block?.type === "blockSdt") {
+		if (block?.type === "blockSdt" || block?.type === "blockCustomXml") {
 			const nested = findLastFlowBlock(block.content);
 			if (nested) return nested;
 		}
@@ -825,6 +855,19 @@ const CELL_CONTENT_HANDLERS = {
 			})
 		});
 	},
+	customXml: (child, { resources, options, modelled }) => {
+		const customXml = {
+			type: "blockCustomXml",
+			...blockCustomXmlShell(child),
+			content: parseCellChildren({
+				element: child,
+				resources,
+				options: withContainerXmlns(options, child),
+				requireTrailingParagraph: false
+			})
+		};
+		modelled.push(customXml);
+	},
 	bookmarkStart: (child, { modelled }) => {
 		modelled.push(parseBookmarkStart(child));
 	},
@@ -836,7 +879,6 @@ const CELL_CONTENT_HANDLERS = {
 	altChunk: CAPTURE,
 	commentRangeEnd: CAPTURE,
 	commentRangeStart: CAPTURE,
-	customXml: CAPTURE,
 	customXmlDelRangeEnd: CAPTURE,
 	customXmlDelRangeStart: CAPTURE,
 	customXmlInsRangeEnd: CAPTURE,
@@ -959,6 +1001,21 @@ const ROW_CONTENT_HANDLERS = {
 		}
 		recordContentControl(wrapped, [...preservedChildren.slice(firstCaptured), ...bookmarks.slice(firstBookmark)], child);
 	},
+	customXml: (child, walk) => {
+		const firstWrapped = walk.row.cells.length;
+		const firstCaptured = walk.preservedChildren.length;
+		const firstBookmark = walk.bookmarks.length;
+		dispatchRowChildren(child, walk);
+		if (walk.row.cells.length === firstWrapped) {
+			walk.preservedChildren.splice(firstCaptured);
+			walk.bookmarks.splice(firstBookmark);
+			return CAPTURE;
+		}
+		const wrapper = createCustomXmlWrapper(child, walk.customXmlIdentity);
+		recordCustomXmlWrapper(walk.row.cells.slice(firstWrapped), wrapper);
+		recordCustomXmlWrapper(walk.preservedChildren.slice(firstCaptured), wrapper);
+		recordCustomXmlWrapper(walk.bookmarks.slice(firstBookmark), wrapper);
+	},
 	bookmarkStart: (child, { row, bookmarks }) => {
 		bookmarks.push({
 			index: row.cells.length,
@@ -974,7 +1031,7 @@ const ROW_CONTENT_HANDLERS = {
 	...ROW_CHILD_OWNERS,
 	commentRangeEnd: CAPTURE,
 	commentRangeStart: CAPTURE,
-	customXml: CAPTURE,
+	customXmlPr: CAPTURE,
 	customXmlDelRangeEnd: CAPTURE,
 	customXmlDelRangeStart: CAPTURE,
 	customXmlInsRangeEnd: CAPTURE,
@@ -994,7 +1051,13 @@ const ROW_CONTENT_HANDLERS = {
 	permEnd: CAPTURE,
 	permStart: CAPTURE,
 	proofErr: CAPTURE,
-	tr: CAPTURE
+	tr: (child, { options }) => {
+		options.context?.warn({
+			code: PARSE_WARNING_CODES.nestedRowOpaque,
+			element: child.name ?? "w:tr"
+		});
+		return CAPTURE;
+	}
 };
 /**
 * One row's children, or a cell-level content control's.
@@ -1055,7 +1118,8 @@ function parseTableRow(trElement, styles, theme, numbering, rels, media, options
 		options: withContainerXmlns(options, trElement),
 		row,
 		bookmarks,
-		preservedChildren
+		preservedChildren,
+		customXmlIdentity: { next: 0 }
 	});
 	if (preservedChildren.length > 0) row.preserved = { children: preservedChildren };
 	if (bookmarks.length > 0) row.bookmarks = bookmarks;
@@ -1167,6 +1231,21 @@ const TABLE_CONTENT_HANDLERS = {
 		}
 		recordContentControl(wrapped, [...preservedChildren.slice(firstCaptured), ...bookmarks.slice(firstBookmark)], child);
 	},
+	customXml: (child, walk) => {
+		const firstWrapped = walk.table.rows.length;
+		const firstCaptured = walk.preservedChildren.length;
+		const firstBookmark = walk.bookmarks.length;
+		dispatchTableChildren(child, walk);
+		if (walk.table.rows.length === firstWrapped) {
+			walk.preservedChildren.splice(firstCaptured);
+			walk.bookmarks.splice(firstBookmark);
+			return CAPTURE;
+		}
+		const wrapper = createCustomXmlWrapper(child, walk.customXmlIdentity);
+		recordCustomXmlWrapper(walk.table.rows.slice(firstWrapped), wrapper);
+		recordCustomXmlWrapper(walk.preservedChildren.slice(firstCaptured), wrapper);
+		recordCustomXmlWrapper(walk.bookmarks.slice(firstBookmark), wrapper);
+	},
 	...TABLE_CHILD_OWNERS,
 	bookmarkStart: (child, { table, bookmarks }) => {
 		bookmarks.push({
@@ -1182,7 +1261,6 @@ const TABLE_CONTENT_HANDLERS = {
 	},
 	commentRangeEnd: CAPTURE,
 	commentRangeStart: CAPTURE,
-	customXml: CAPTURE,
 	customXmlPr: CAPTURE,
 	customXmlDelRangeEnd: CAPTURE,
 	customXmlDelRangeStart: CAPTURE,
@@ -1269,7 +1347,8 @@ function parseTable(tblElement, styles, theme, numbering, rels, media, options)
 		table,
 		rowsWithGridOffsets,
 		bookmarks,
-		preservedChildren
+		preservedChildren,
+		customXmlIdentity: { next: 0 }
 	});
 	if (table.rows.length === 0) return;
 	if (preservedChildren.length > 0) table.preserved = { children: preservedChildren };
@@ -1382,4 +1461,4 @@ function isFloatingTable(table) {
 	return table.formatting?.floating !== void 0;
 }
 //#endregion
-export { MAX_TABLE_COLUMNS, getHeaderRows, getTableColumnCount, getTableRowCount, getTableText, hasHeaderRow, isCellHorizontallyMerged, isCellMergeContinuation, isCellMergeStart, isFloatingTable, parseCellMargins, parseConditionalFormatStyle, parseFloatingTableProperties, parseTable, parseTableBorders, parseTableCell, parseTableCellProperties, parseTableGrid, parseTableLook, parseTableMeasurement, parseTableProperties, parseTablePropertyExceptions, parseTableRow, parseTableRowProperties };
+export { CELL_CONTENT_HANDLERS, MAX_TABLE_COLUMNS, ROW_CONTENT_HANDLERS, TABLE_CONTENT_HANDLERS, getHeaderRows, getTableColumnCount, getTableRowCount, getTableText, hasHeaderRow, isCellHorizontallyMerged, isCellMergeContinuation, isCellMergeStart, isFloatingTable, isTableCellMergeRevisionContinuation, isTableCellMergeRevisionValue, parseCellMargins, parseConditionalFormatStyle, parseFloatingTableProperties, parseTable, parseTableBorders, parseTableCell, parseTableCellProperties, parseTableGrid, parseTableLook, parseTableMeasurement, parseTableProperties, parseTablePropertyExceptions, parseTableRow, parseTableRowProperties };

package/dist/docx/textBoxParser.js

@@ -300,7 +300,7 @@ const getTextBoxBlockText = (block) => {
 		return runTexts.join("");
 	}
 	if (block.type === "table") return block.rows.map((row) => row.cells.map((cell) => cell.content.map(getTextBoxBlockText).join("\n")).join("	")).join("\n");
-	if (block.type !== "blockSdt") return "";
+	if (block.type !== "blockSdt" && block.type !== "blockCustomXml") return "";
 	return block.content.map(getTextBoxBlockText).join("\n");
 };
 /**

package/dist/docx/unzip.d.ts

@@ -82,6 +82,7 @@ type RawDocxContent = {
  * @returns Promise resolving to extracted content
  */
 declare function unzipDocx(buffer: ArrayBuffer, options?: DocxUnzipOptions): Promise<RawDocxContent>;
+declare function getEntryUncompressedSize(file: JSZip.JSZipObject): number | null;
 /**
  * Get a list of all files in the DOCX
  *
@@ -142,4 +143,4 @@ declare function getContentSummary(content: RawDocxContent): {
   totalFiles: number;
 };
 //#endregion
-export { DocxSecurityError, DocxUnzipLimits, DocxUnzipOptions, RawDocxContent, extractFile, getContentSummary, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, unzipDocx };
+export { DocxSecurityError, DocxUnzipLimits, DocxUnzipOptions, RawDocxContent, extractFile, getContentSummary, getEntryUncompressedSize, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, unzipDocx };

package/dist/docx/unzip.js

@@ -494,4 +494,4 @@ function getContentSummary(content) {
 	};
 }
 //#endregion
-export { DocxSecurityError, extractFile, getContentSummary, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, unzipDocx };
+export { DocxSecurityError, extractFile, getContentSummary, getEntryUncompressedSize, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, unzipDocx };

package/dist/docx/wordprocessingPrefixes.d.ts

@@ -0,0 +1,78 @@
+//#region src/docx/wordprocessingPrefixes.d.ts
+/**
+ * Which prefixes a WordprocessingML part spells its namespaces with.
+ *
+ * A prefix is an alias: `<w:p>`, `<x:p>` and an unprefixed `<p>` under a
+ * default namespace are the same paragraph when the prefix (or the default)
+ * is bound to the WordprocessingML URI. The parser resolves names by URI, so
+ * every such package opens. The patchers that work on part XML as a string
+ * (`ensureParaIds`, the selective-save splices) find elements by their
+ * literal tags instead, and a literal `<w:p` finds nothing in a part that
+ * spells it `<x:p`: the patch reports success having touched nothing.
+ *
+ * {@link resolveWordprocessingPrefixes} is the one place those patchers ask
+ * how a part spells WordprocessingML, the `w14` extensions and
+ * markup compatibility (`mc`). A patcher either scans with every prefix the
+ * part binds, or checks the names its literal scan needs in their namespace
+ * scope. A prefix conflict on one of those names is refused.
+ */
+/** How one part spells the namespaces a string-level patcher scans for. */
+type WordprocessingPrefixes = {
+  /**
+   * Prefixes bound to WordprocessingML (Transitional or Strict), `""` for the
+   * default namespace. Never empty: an undeclared part reads as `w`.
+   */
+  main: readonly string[];
+  /** Prefixes bound to the `w14` extensions namespace. */
+  w14: readonly string[];
+  /** Whether a `w14` prefix is declared on the root (else `w14` is assumed). */
+  w14Declared: boolean;
+  /** Prefixes bound to markup compatibility (`mc`). */
+  mc: readonly string[];
+  /** Whether an `mc` prefix is declared on the root (else `mc` is assumed). */
+  mcDeclared: boolean;
+  /**
+   * The spelling folio's serializer writes: WordprocessingML only as `w`,
+   * `w14` and `mc` under their conventional prefixes. Splicing serializer
+   * output into a part is only sound when this holds.
+   */
+  canonical: boolean;
+};
+type WordprocessingPrefixResolution = {
+  type: "resolved";
+  prefixes: WordprocessingPrefixes;
+} | {
+  type: "unsupported";
+  reason: string;
+};
+declare const resolveWordprocessingPrefixes: (xml: string) => WordprocessingPrefixResolution;
+/** Root spelling for a selective scan whose relevant nested names are checked separately. */
+declare const resolveSelectiveScanPrefixes: (xml: string) => WordprocessingPrefixResolution;
+/**
+ * Whether a patcher that reads `<w:…>` literally sees every element it looks
+ * for in `xml`, and may splice the serializer's `w:` markup into it.
+ *
+ * True for the canonical spelling. Also true when the part binds
+ * WordprocessingML under an extra prefix besides `w` but never spells the
+ * names the patcher scans under that alias, or binds markup compatibility
+ * under another prefix. Relevant nested names are checked in their own scope.
+ */
+declare const splicesAsCanonical: (xml: string, localNames: readonly string[]) => boolean;
+/** The names the paragraph splices scan for: paragraphs, their containers and ids. */
+declare const PARAGRAPH_SCAN_NAMES: readonly ["p", "tc", "txbxContent", "paraId", "textId"];
+/** Whether `xml` spells WordprocessingML the way folio's serializer does. */
+declare const hasCanonicalWordprocessingPrefixes: (xml: string) => boolean;
+/** `<p`, `<w:p`, … — the open-tag literal of `localName` under `prefix`. */
+declare const openTagLiteral: (prefix: string, localName: string) => string;
+/** `</p>`, `</w:p>`, … — the close-tag literal of `localName` under `prefix`. */
+declare const closeTagLiteral: (prefix: string, localName: string) => string;
+/**
+ * Whether `xml` opens `localName` under one of `prefixes` at `start`, and the
+ * length of the literal that matched (`-1` when none did). The character after
+ * the name must end it, so `<w:pPr` is not `<w:p`.
+ */
+declare const matchOpenTag: (xml: string, start: number, prefixes: readonly string[], localName: string) => number;
+/** The length of the close tag of `localName` under one of `prefixes` at `start`, or -1. */
+declare const matchCloseTag: (xml: string, start: number, prefixes: readonly string[], localName: string) => number;
+//#endregion
+export { PARAGRAPH_SCAN_NAMES, WordprocessingPrefixResolution, WordprocessingPrefixes, closeTagLiteral, hasCanonicalWordprocessingPrefixes, matchCloseTag, matchOpenTag, openTagLiteral, resolveSelectiveScanPrefixes, resolveWordprocessingPrefixes, splicesAsCanonical };

package/dist/docx/wordprocessingPrefixes.js

@@ -0,0 +1,286 @@
+import { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, getLocalName, getNamespacePrefix, getNamespaceUri, parseXmlDocument, resolveAttributeNamespaceUri } from "./xmlParser.js";
+//#region src/docx/wordprocessingPrefixes.ts
+/**
+* Which prefixes a WordprocessingML part spells its namespaces with.
+*
+* A prefix is an alias: `<w:p>`, `<x:p>` and an unprefixed `<p>` under a
+* default namespace are the same paragraph when the prefix (or the default)
+* is bound to the WordprocessingML URI. The parser resolves names by URI, so
+* every such package opens. The patchers that work on part XML as a string
+* (`ensureParaIds`, the selective-save splices) find elements by their
+* literal tags instead, and a literal `<w:p` finds nothing in a part that
+* spells it `<x:p`: the patch reports success having touched nothing.
+*
+* {@link resolveWordprocessingPrefixes} is the one place those patchers ask
+* how a part spells WordprocessingML, the `w14` extensions and
+* markup compatibility (`mc`). A patcher either scans with every prefix the
+* part binds, or checks the names its literal scan needs in their namespace
+* scope. A prefix conflict on one of those names is refused.
+*/
+const XMLNS = "xmlns";
+const isWhitespace = (character) => character === " " || character === "	" || character === "\n" || character === "\r";
+/** End offset (exclusive) of the tag opening at `start`, skipping quoted values. */
+const tagEnd = (xml, start) => {
+	let quote = null;
+	for (let index = start + 1; index < xml.length; index += 1) {
+		const character = xml[index];
+		if (quote !== null) {
+			if (character === quote) quote = null;
+			continue;
+		}
+		if (character === "\"" || character === "'") quote = character;
+		else if (character === ">") return index + 1;
+	}
+	return -1;
+};
+/** The `xmlns` / `xmlns:*` declarations written in one start tag. */
+const declarationsIn = (tag) => {
+	const declarations = [];
+	for (const match of tag.matchAll(/\sxmlns(?::(?<prefix>[^\s=/>]+))?\s*=\s*(?<quote>["'])(?<uri>[\s\S]*?)\k<quote>/gu)) declarations.push({
+		prefix: match.groups?.["prefix"] ?? "",
+		uri: match.groups?.["uri"] ?? ""
+	});
+	return declarations;
+};
+const OPAQUE_REGIONS = [
+	{
+		open: "<!--",
+		close: "-->"
+	},
+	{
+		open: "<![CDATA[",
+		close: "]]>"
+	},
+	{
+		open: "<?",
+		close: "?>"
+	}
+];
+/** Visit every start tag of `xml` that declares a namespace, root first. */
+const visitDeclaringStartTags = (xml, visit) => {
+	let seenRoot = false;
+	let pos = 0;
+	scan: while (pos < xml.length) {
+		const start = xml.indexOf("<", pos);
+		if (start === -1) break;
+		for (const { open, close } of OPAQUE_REGIONS) if (xml.startsWith(open, start)) {
+			const closeStart = xml.indexOf(close, start + open.length);
+			if (closeStart === -1) return false;
+			pos = closeStart + close.length;
+			continue scan;
+		}
+		const next = xml[start + 1];
+		if (next === "!" || next === "/") {
+			const end = xml.indexOf(">", start);
+			if (end === -1) return false;
+			pos = end + 1;
+			continue;
+		}
+		const end = tagEnd(xml, start);
+		if (end === -1) return false;
+		const isRoot = !seenRoot;
+		seenRoot = true;
+		const tag = xml.slice(start, end);
+		if (isRoot || tag.includes(XMLNS)) visit(tag, isRoot);
+		pos = end;
+	}
+	return seenRoot;
+};
+const MAIN_URIS = WORDPROCESSINGML_NAMESPACE_URIS;
+const W14_URI = NAMESPACES.w14;
+const MC_URI = NAMESPACES.mc;
+const NESTED_BINDINGS = {
+	strict: "strict",
+	scoped: "scoped"
+};
+const slotOf = (uri) => {
+	if (MAIN_URIS.has(uri)) return "main";
+	if (uri === W14_URI) return "w14";
+	if (uri === MC_URI) return "mc";
+	return null;
+};
+const CONVENTIONAL_PREFIX = {
+	main: "w",
+	w14: "w14",
+	mc: "mc"
+};
+/**
+* Resolve the prefixes `xml` binds to WordprocessingML, `w14` and `mc`.
+*
+* Root declarations decide. A namespace the root never declares is read under
+* its conventional prefix, the tolerant reading of a malformed part. A declaration on
+* a nested element is accepted only when it repeats a binding the scan already
+* uses; anything else changes what a literal tag means partway through the
+* part and is reported as unsupported.
+*/
+const resolvePrefixes = (xml, nestedBindings) => {
+	const bound = {
+		main: [],
+		w14: [],
+		mc: []
+	};
+	const rootPrefixes = /* @__PURE__ */ new Map();
+	const nested = [];
+	if (!visitDeclaringStartTags(xml, (tag, isRoot) => {
+		for (const declaration of declarationsIn(tag)) {
+			if (!isRoot) {
+				nested.push(declaration);
+				continue;
+			}
+			rootPrefixes.set(declaration.prefix, declaration.uri);
+			const slot = slotOf(declaration.uri);
+			if (slot !== null) bound[slot].push(declaration.prefix);
+		}
+	})) return {
+		type: "unsupported",
+		reason: "no root element or unterminated markup"
+	};
+	const declared = {
+		main: bound.main.length > 0,
+		w14: bound.w14.length > 0,
+		mc: bound.mc.length > 0
+	};
+	for (const slot of [
+		"main",
+		"w14",
+		"mc"
+	]) {
+		if (declared[slot]) {
+			if (slot !== "main" && bound[slot].includes("")) return {
+				type: "unsupported",
+				reason: `${slot} is bound only as the default namespace`
+			};
+			continue;
+		}
+		const conventional = CONVENTIONAL_PREFIX[slot];
+		if (rootPrefixes.has(conventional)) {
+			if (slot === "main") return {
+				type: "unsupported",
+				reason: `no WordprocessingML binding; ${conventional} is bound to another namespace`
+			};
+			continue;
+		}
+		bound[slot].push(conventional);
+	}
+	const inUse = /* @__PURE__ */ new Map();
+	for (const slot of [
+		"main",
+		"w14",
+		"mc"
+	]) for (const prefix of bound[slot]) inUse.set(prefix, slot);
+	for (const { prefix, uri } of nestedBindings === NESTED_BINDINGS.strict ? nested : []) {
+		const slot = slotOf(uri);
+		const spelling = prefix === "" ? "the default namespace" : `prefix ${prefix}`;
+		if (slot !== null) {
+			if (!bound[slot].includes(prefix)) return {
+				type: "unsupported",
+				reason: `a nested element binds ${slot} under ${spelling}`
+			};
+			continue;
+		}
+		if (inUse.has(prefix)) return {
+			type: "unsupported",
+			reason: `a nested element rebinds ${spelling} to ${uri === "" ? "no namespace" : uri}`
+		};
+	}
+	const only = (prefixes, prefix) => prefixes.length === 1 && prefixes[0] === prefix;
+	const canonical = only(bound.main, "w") && only(bound.w14, "w14") && only(bound.mc, "mc");
+	return {
+		type: "resolved",
+		prefixes: {
+			main: bound.main,
+			w14: bound.w14,
+			w14Declared: declared.w14,
+			mc: bound.mc,
+			mcDeclared: declared.mc,
+			canonical
+		}
+	};
+};
+const resolveWordprocessingPrefixes = (xml) => resolvePrefixes(xml, NESTED_BINDINGS.strict);
+/** Root spelling for a selective scan whose relevant nested names are checked separately. */
+const resolveSelectiveScanPrefixes = (xml) => resolvePrefixes(xml, NESTED_BINDINGS.scoped);
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+/**
+* Whether a patcher that reads `<w:…>` literally sees every element it looks
+* for in `xml`, and may splice the serializer's `w:` markup into it.
+*
+* True for the canonical spelling. Also true when the part binds
+* WordprocessingML under an extra prefix besides `w` but never spells the
+* names the patcher scans under that alias, or binds markup compatibility
+* under another prefix. Relevant nested names are checked in their own scope.
+*/
+const splicesAsCanonical = (xml, localNames) => {
+	const resolution = resolveWordprocessingPrefixes(xml);
+	if (resolution.type === "resolved" && resolution.prefixes.canonical) return true;
+	const relaxed = resolveSelectiveScanPrefixes(xml);
+	if (relaxed.type !== "resolved") return false;
+	const { prefixes } = relaxed;
+	const only = (list, prefix) => list.length === 1 && list[0] === prefix;
+	const aliases = prefixes.main.filter((prefix) => prefix !== "w");
+	if (!prefixes.main.includes("w") || aliases.includes("") || !only(prefixes.w14, "w14") || prefixes.mc.length === 0) return false;
+	const names = localNames.map(escapeRegExp).join("|");
+	if (!aliases.every((alias) => !new RegExp(`[<\\s/]${escapeRegExp(alias)}:(?:${names})[\\s/>=]`, "u").test(xml))) return false;
+	const root = parseXmlDocument(xml);
+	if (!root) return false;
+	const mainNames = new Set(localNames.filter((name) => name !== "paraId" && name !== "textId"));
+	const idNames = /* @__PURE__ */ new Set(["paraId", "textId"]);
+	const mcNames = /* @__PURE__ */ new Set(["Fallback", "AlternateContent"]);
+	const visit = (element) => {
+		if (element.type !== "element") return true;
+		const name = element.name ?? "";
+		const local = getLocalName(name);
+		const prefix = getNamespacePrefix(name) ?? "";
+		const uri = getNamespaceUri(element) ?? "";
+		if (prefix === "mc" && uri !== MC_URI || mainNames.has(local) && WORDPROCESSINGML_NAMESPACE_URIS.has(uri) !== (prefix === "w") || mcNames.has(local) && uri === MC_URI !== prefixes.mc.includes(prefix)) return false;
+		for (const attribute of Object.keys(element.attributes ?? {})) {
+			const attributePrefix = getNamespacePrefix(attribute);
+			if (attributePrefix === "mc" && resolveAttributeNamespaceUri(element, attribute) !== MC_URI) return false;
+			if (!idNames.has(getLocalName(attribute))) continue;
+			if (resolveAttributeNamespaceUri(element, attribute) === W14_URI !== (attributePrefix === "w14")) return false;
+		}
+		return (element.elements ?? []).every(visit);
+	};
+	return visit(root);
+};
+/** The names the paragraph splices scan for: paragraphs, their containers and ids. */
+const PARAGRAPH_SCAN_NAMES = [
+	"p",
+	"tc",
+	"txbxContent",
+	"paraId",
+	"textId"
+];
+/** Whether `xml` spells WordprocessingML the way folio's serializer does. */
+const hasCanonicalWordprocessingPrefixes = (xml) => {
+	const resolution = resolveWordprocessingPrefixes(xml);
+	return resolution.type === "resolved" && resolution.prefixes.canonical;
+};
+/** `<p`, `<w:p`, … — the open-tag literal of `localName` under `prefix`. */
+const openTagLiteral = (prefix, localName) => prefix === "" ? `<${localName}` : `<${prefix}:${localName}`;
+/** `</p>`, `</w:p>`, … — the close-tag literal of `localName` under `prefix`. */
+const closeTagLiteral = (prefix, localName) => prefix === "" ? `</${localName}>` : `</${prefix}:${localName}>`;
+/**
+* Whether `xml` opens `localName` under one of `prefixes` at `start`, and the
+* length of the literal that matched (`-1` when none did). The character after
+* the name must end it, so `<w:pPr` is not `<w:p`.
+*/
+const matchOpenTag = (xml, start, prefixes, localName) => {
+	for (const prefix of prefixes) {
+		const literal = openTagLiteral(prefix, localName);
+		if (!xml.startsWith(literal, start)) continue;
+		const after = xml[start + literal.length];
+		if (after === ">" || after === "/" || isWhitespace(after)) return literal.length;
+	}
+	return -1;
+};
+/** The length of the close tag of `localName` under one of `prefixes` at `start`, or -1. */
+const matchCloseTag = (xml, start, prefixes, localName) => {
+	for (const prefix of prefixes) {
+		const literal = closeTagLiteral(prefix, localName);
+		if (xml.startsWith(literal, start)) return literal.length;
+	}
+	return -1;
+};
+//#endregion
+export { PARAGRAPH_SCAN_NAMES, closeTagLiteral, hasCanonicalWordprocessingPrefixes, matchCloseTag, matchOpenTag, openTagLiteral, resolveSelectiveScanPrefixes, resolveWordprocessingPrefixes, splicesAsCanonical };