@stll/folio-core 0.44.0 → 0.46.0

package/dist/docx/imageRawXml.js

@@ -26,10 +26,29 @@ const EDITED_PREVIEW_FINGERPRINT = "editedPreview";
 const editableImageProjection = ({ id: _id, rId: _rId, src: _src, mimeType: _mimeType, filename: _filename, ...image }) => image;
 /** Fingerprints modeled image fields which make raw DrawingML stale when edited. */
 const imageRawXmlFingerprint = (image) => canonicalJson(editableImageProjection(image));
-/** Editable raw drawing XML can replay only while its modeled projection is unchanged. */
+/** Whether the modeled image still says what the captured raw drawing says. */
+const modelAgreesWithRawXml = (drawing) => drawing.rawImageFingerprint === void 0 || drawing.rawImageFingerprint === imageRawXmlFingerprint(drawing.image);
+/**
+* Whether the serializer writes the captured raw XML back.
+*
+* For an unclassified drawing the capture is a cache of the model, so it
+* replays only while the two agree. For a classified one the capture *is* the
+* drawing: a preserve-only drawing has a placeholder image, and a preview-only
+* group has a raster render of shapes the model cannot hold. Regenerating
+* either writes something the source never contained — for the group, at best
+* the one child picture the rasterizer saw first under that child's
+* relationship, in place of the whole group. So a classified capture is always
+* written back; a stale fingerprint means the edit that made it stale is lost,
+* which {@link classifyDrawingSafety} reports as `opaque`, and never that
+* folio may build a replacement.
+*/
 const canReplayEditableImageRawXml = (drawing) => {
-	if (drawing.rawXmlMode === DRAWING_RAW_XML_MODES.PRESERVE_ONLY) return true;
-	return drawing.rawImageFingerprint === void 0 || drawing.rawImageFingerprint === imageRawXmlFingerprint(drawing.image);
+	switch (drawing.rawXmlMode) {
+		case DRAWING_RAW_XML_MODES.PRESERVE_ONLY:
+		case DRAWING_RAW_XML_MODES.PREVIEW_ONLY: return true;
+		case void 0: return modelAgreesWithRawXml(drawing);
+		default: return drawing;
+	}
 };
 /**
 * What a drawing costs the document when Folio writes it back.
@@ -60,9 +79,14 @@ const canRegenerateDrawing = (drawing) => drawing.image.rId !== void 0;
 */
 const classifyDrawingSafety = (drawing) => {
 	if (drawing.rawXml === void 0) return DRAWING_SAFETY_CLASSES.NATIVE;
-	if (canReplayEditableImageRawXml(drawing)) return DRAWING_SAFETY_CLASSES.REPLAYABLE;
-	if (drawing.rawXmlMode === DRAWING_RAW_XML_MODES.PREVIEW_ONLY) return DRAWING_SAFETY_CLASSES.OPAQUE;
-	return canRegenerateDrawing(drawing) ? DRAWING_SAFETY_CLASSES.NATIVE : DRAWING_SAFETY_CLASSES.OPAQUE;
+	switch (drawing.rawXmlMode) {
+		case DRAWING_RAW_XML_MODES.PRESERVE_ONLY: return DRAWING_SAFETY_CLASSES.REPLAYABLE;
+		case DRAWING_RAW_XML_MODES.PREVIEW_ONLY: return modelAgreesWithRawXml(drawing) ? DRAWING_SAFETY_CLASSES.REPLAYABLE : DRAWING_SAFETY_CLASSES.OPAQUE;
+		case void 0:
+			if (modelAgreesWithRawXml(drawing)) return DRAWING_SAFETY_CLASSES.REPLAYABLE;
+			return canRegenerateDrawing(drawing) ? DRAWING_SAFETY_CLASSES.NATIVE : DRAWING_SAFETY_CLASSES.OPAQUE;
+		default: return drawing;
+	}
 };
 //#endregion
 export { DRAWING_SAFETY_CLASSES, EDITED_PREVIEW_FINGERPRINT, allowsDirectDrawingEdit, canReplayEditableImageRawXml, classifyDrawingSafety, imageRawXmlFingerprint, isDrawingRawXmlMode };

package/dist/docx/inlineWrapperContent.d.ts

@@ -0,0 +1,85 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/docx/inlineWrapperContent.d.ts
+/**
+ * What a run-level tracked-change wrapper keeps inside itself (CT_RunTrackChange).
+ *
+ * Runs, links, fields, bookmark boundaries, equations, nested revisions and
+ * markup folio does not model.
+ *
+ * The transparent wrappers are admitted too: `w:bdo` / `w:dir` state how their
+ * content is laid out, and `w:sdt` states what the content is bound to.
+ * Neither says anything about the revision, so lifting one out of a revision
+ * takes its text out of the revision with it.
+ *
+ * The range markers are not: a `w:commentRangeStart` or `w:moveFromRangeStart`
+ * inside a revision is a marker the revision does not own, and the pairing
+ * passes read it as a paragraph-level sibling.
+ */
+declare const TRACKED_CHANGE_WRAPPER_CONTENT: {
+  readonly inlineWrapper: true;
+  readonly bookmarkEnd: true;
+  readonly bookmarkStart: true;
+  readonly complexField: true;
+  readonly deletion: true;
+  readonly hyperlink: true;
+  readonly inlineSdt: true;
+  readonly insertion: true;
+  readonly mathEquation: true;
+  readonly moveFrom: true;
+  readonly moveTo: true;
+  readonly preservedInline: true;
+  readonly run: true;
+  readonly simpleField: true;
+  readonly commentRangeEnd: false;
+  readonly commentRangeStart: false;
+  readonly commentReference: false;
+  readonly moveFromRangeEnd: false;
+  readonly moveFromRangeStart: false;
+  readonly moveToRangeEnd: false;
+  readonly moveToRangeStart: false;
+};
+/**
+ * What an inline content control keeps inside `<w:sdtContent>`.
+ *
+ * Mirror of upstream eigenpal/docx-editor PR #482 (commit 29f95751d), plus
+ * the bidirectional wrapper: OOXML allows runs, hyperlinks, simple/complex
+ * fields, nested SDTs, tracked insertions/deletions/moves, math, markup folio
+ * does not model, and the bidirectional controls directly inside
+ * `<w:sdtContent>`. Bookmarks and range markers are lifted out as siblings of
+ * the SDT so the control itself stays valid.
+ */
+declare const INLINE_SDT_CONTENT: {
+  readonly inlineWrapper: true;
+  readonly complexField: true;
+  readonly deletion: true;
+  readonly hyperlink: true;
+  readonly inlineSdt: true;
+  readonly insertion: true;
+  readonly mathEquation: true;
+  readonly moveFrom: true;
+  readonly moveTo: true;
+  readonly preservedInline: true;
+  readonly run: true;
+  readonly simpleField: true;
+  readonly bookmarkEnd: false;
+  readonly bookmarkStart: false;
+  readonly commentRangeEnd: false;
+  readonly commentRangeStart: false;
+  readonly commentReference: false;
+  readonly moveFromRangeEnd: false;
+  readonly moveFromRangeStart: false;
+  readonly moveToRangeEnd: false;
+  readonly moveToRangeStart: false;
+};
+/**
+ * Whether a revision wrapper keeps this content inside itself.
+ *
+ * Generic in the input so a caller that has already narrowed its content
+ * keeps that narrowing: filtering a list the bidirectional wrappers are
+ * already flattened out of must not put one back into the result type.
+ */
+declare const isTrackedChangeWrapperChild: <Content extends document_d_exports.ParagraphContent>(content: Content) => content is Extract<Content, document_d_exports.TrackedRunContent>;
+/** Whether an inline content control keeps this content inside `<w:sdtContent>`. */
+declare const isInlineSdtContent: <Content extends document_d_exports.ParagraphContent>(content: Content) => content is Extract<Content, document_d_exports.InlineSdt["content"][number]>;
+//#endregion
+export { INLINE_SDT_CONTENT, TRACKED_CHANGE_WRAPPER_CONTENT, isInlineSdtContent, isTrackedChangeWrapperChild };

package/dist/docx/inlineWrapperContent.js

@@ -0,0 +1,84 @@
+//#region src/docx/inlineWrapperContent.ts
+/**
+* What a run-level tracked-change wrapper keeps inside itself (CT_RunTrackChange).
+*
+* Runs, links, fields, bookmark boundaries, equations, nested revisions and
+* markup folio does not model.
+*
+* The transparent wrappers are admitted too: `w:bdo` / `w:dir` state how their
+* content is laid out, and `w:sdt` states what the content is bound to.
+* Neither says anything about the revision, so lifting one out of a revision
+* takes its text out of the revision with it.
+*
+* The range markers are not: a `w:commentRangeStart` or `w:moveFromRangeStart`
+* inside a revision is a marker the revision does not own, and the pairing
+* passes read it as a paragraph-level sibling.
+*/
+const TRACKED_CHANGE_WRAPPER_CONTENT = {
+	inlineWrapper: true,
+	bookmarkEnd: true,
+	bookmarkStart: true,
+	complexField: true,
+	deletion: true,
+	hyperlink: true,
+	inlineSdt: true,
+	insertion: true,
+	mathEquation: true,
+	moveFrom: true,
+	moveTo: true,
+	preservedInline: true,
+	run: true,
+	simpleField: true,
+	commentRangeEnd: false,
+	commentRangeStart: false,
+	commentReference: false,
+	moveFromRangeEnd: false,
+	moveFromRangeStart: false,
+	moveToRangeEnd: false,
+	moveToRangeStart: false
+};
+/**
+* What an inline content control keeps inside `<w:sdtContent>`.
+*
+* Mirror of upstream eigenpal/docx-editor PR #482 (commit 29f95751d), plus
+* the bidirectional wrapper: OOXML allows runs, hyperlinks, simple/complex
+* fields, nested SDTs, tracked insertions/deletions/moves, math, markup folio
+* does not model, and the bidirectional controls directly inside
+* `<w:sdtContent>`. Bookmarks and range markers are lifted out as siblings of
+* the SDT so the control itself stays valid.
+*/
+const INLINE_SDT_CONTENT = {
+	inlineWrapper: true,
+	complexField: true,
+	deletion: true,
+	hyperlink: true,
+	inlineSdt: true,
+	insertion: true,
+	mathEquation: true,
+	moveFrom: true,
+	moveTo: true,
+	preservedInline: true,
+	run: true,
+	simpleField: true,
+	bookmarkEnd: false,
+	bookmarkStart: false,
+	commentRangeEnd: false,
+	commentRangeStart: false,
+	commentReference: false,
+	moveFromRangeEnd: false,
+	moveFromRangeStart: false,
+	moveToRangeEnd: false,
+	moveToRangeStart: false
+};
+/**
+* Whether a revision wrapper keeps this content inside itself.
+*
+* Generic in the input so a caller that has already narrowed its content
+* keeps that narrowing: filtering a list the bidirectional wrappers are
+* already flattened out of must not put one back into the result type.
+*/
+const isTrackedChangeWrapperChild = (content) => TRACKED_CHANGE_WRAPPER_CONTENT[content.type];
+/** Whether an inline content control keeps this content inside `<w:sdtContent>`. */
+const isInlineSdtContent = (content) => INLINE_SDT_CONTENT[content.type];
+//#endregion
+export { INLINE_SDT_CONTENT, TRACKED_CHANGE_WRAPPER_CONTENT, isInlineSdtContent, isTrackedChangeWrapperChild };

package/dist/docx/mathToMathml.js

@@ -1,4 +1,5 @@
 import { findChildByLocalName, getLocalName } from "./xmlParser.js";
+import { escapeXmlText } from "@stll/docx-core";
 //#region src/docx/mathToMathml.ts
 /**
 * OMML → MathML conversion.
@@ -95,13 +96,13 @@ const MATH_OPERATOR_HINT = /* @__PURE__ */ new Set([
 	"…"
 ]);
 function renderElement(el) {
-	if (el.type === "text") return escapeXml(textValue(el));
+	if (el.type === "text") return escapeXmlText(textValue(el));
 	if (el.type !== "element") return "";
 	switch (el.name ? getLocalName(el.name) : "") {
 		case "oMath":
 		case "oMathPara": return renderChildren(el);
 		case "r": return renderRun(el);
-		case "t": return escapeXml(extractText(el));
+		case "t": return escapeXmlText(extractText(el));
 		case "f": return renderFraction(el);
 		case "num":
 		case "den": return wrapMrow(renderChildren(el));
@@ -179,8 +180,8 @@ function tokenizeMathText(text) {
 	let bufKind = null;
 	const flush = () => {
 		if (!buf) return;
-		if (bufKind === "digit") out += `<mn>${escapeXml(buf)}</mn>`;
-		else out += `<mi>${escapeXml(buf)}</mi>`;
+		if (bufKind === "digit") out += `<mn>${escapeXmlText(buf)}</mn>`;
+		else out += `<mi>${escapeXmlText(buf)}</mi>`;
 		buf = "";
 		bufKind = null;
 	};
@@ -193,7 +194,7 @@ function tokenizeMathText(text) {
 		const kind = classifyChar(ch);
 		if (kind === "operator") {
 			flush();
-			out += `<mo>${escapeXml(ch)}</mo>`;
+			out += `<mo>${escapeXmlText(ch)}</mo>`;
 			continue;
 		}
 		if (kind === "digit") {
@@ -202,7 +203,7 @@ function tokenizeMathText(text) {
 			continue;
 		}
 		flush();
-		out += `<mi>${escapeXml(ch)}</mi>`;
+		out += `<mi>${escapeXmlText(ch)}</mi>`;
 	}
 	flush();
 	return out;
@@ -258,7 +259,7 @@ function renderNary(el) {
 	const chr = (chrEl ? getAttrValue(chrEl, "val") : null) || "∫";
 	const limLocEl = naryPr ? findChildByLocalName(naryPr, "limLoc") : null;
 	const limLoc = (limLocEl ? getAttrValue(limLocEl, "val") : null) || "subSup";
-	const opMml = `<mo>${escapeXml(chr)}</mo>`;
+	const opMml = `<mo>${escapeXmlText(chr)}</mo>`;
 	const subMml = sub ? wrapMrow(renderChildren(sub)) : "";
 	const supMml = sup ? wrapMrow(renderChildren(sup)) : "";
 	const bodyMml = body ? wrapMrow(renderChildren(body)) : "<mrow/>";
@@ -277,8 +278,8 @@ function renderDelimiter(el) {
 	const begChr = begChrEl ? getAttrValue(begChrEl, "val") ?? "(" : "(";
 	const endChr = endChrEl ? getAttrValue(endChrEl, "val") ?? ")" : ")";
 	const sepChr = sepChrEl ? getAttrValue(sepChrEl, "val") ?? "|" : "|";
-	const inner = (el.elements ?? []).filter((c) => c.type === "element" && getLocalName(c.name ?? "") === "e").map((c) => wrapMrow(renderChildren(c))).join(`<mo>${escapeXml(sepChr)}</mo>`);
-	return `<mrow><mo>${escapeXml(begChr)}</mo>${inner}<mo>${escapeXml(endChr)}</mo></mrow>`;
+	const inner = (el.elements ?? []).filter((c) => c.type === "element" && getLocalName(c.name ?? "") === "e").map((c) => wrapMrow(renderChildren(c))).join(`<mo>${escapeXmlText(sepChr)}</mo>`);
+	return `<mrow><mo>${escapeXmlText(begChr)}</mo>${inner}<mo>${escapeXmlText(endChr)}</mo></mrow>`;
 }
 function renderMatrix(el) {
 	return `<mtable>${(el.elements ?? []).filter((c) => c.type === "element" && getLocalName(c.name ?? "") === "mr").map(renderMatrixRow).join("")}</mtable>`;
@@ -291,7 +292,7 @@ function renderAccent(el) {
 	const chrEl = accPr ? findChildByLocalName(accPr, "chr") : null;
 	const chr = chrEl ? getAttrValue(chrEl, "val") ?? "̂" : "̂";
 	const base = findChildByLocalName(el, "e");
-	return `<mover accent="true">${base ? wrapMrow(renderChildren(base)) : "<mrow/>"}<mo>${escapeXml(chr)}</mo></mover>`;
+	return `<mover accent="true">${base ? wrapMrow(renderChildren(base)) : "<mrow/>"}<mo>${escapeXmlText(chr)}</mo></mover>`;
 }
 function renderBar(el) {
 	const barPr = findChildByLocalName(el, "barPr");
@@ -311,7 +312,7 @@ function renderGroupChr(el) {
 	const chr = chrEl ? getAttrValue(chrEl, "val") ?? defaultChr : defaultChr;
 	const base = findChildByLocalName(el, "e");
 	const baseMml = base ? wrapMrow(renderChildren(base)) : "<mrow/>";
-	const grouper = `<mo stretchy="true">${escapeXml(chr)}</mo>`;
+	const grouper = `<mo stretchy="true">${escapeXmlText(chr)}</mo>`;
 	return pos === "top" ? `<mover>${baseMml}${grouper}</mover>` : `<munder>${baseMml}${grouper}</munder>`;
 }
 function renderLimLow(el) {
@@ -350,8 +351,5 @@ function getAttrValue(el, localAttr) {
 		return String(v);
 	}
 }
-function escapeXml(s) {
-	return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
-}
 //#endregion
 export { ommlToMathml };

package/dist/docx/nonVisualDrawingProps.d.ts

@@ -0,0 +1,34 @@
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/nonVisualDrawingProps.d.ts
+/** The authored name, alt text and title of a drawing object. */
+type NonVisualDrawingNames = {
+  /** `@name`, schema-required, so `""` means the object was never named. */
+  name?: string;
+  /** `@descr`: alt text, accessibility content. */
+  alt?: string;
+  /** `@title`. */
+  title?: string;
+};
+/**
+ * Read `@name`, `@descr` and `@title` off a `CT_NonVisualDrawingProps` element.
+ *
+ * An attribute that is not there stays absent. `@name` is schema-required, so
+ * an unnamed object still writes one, and `name=""` is the marker the writer
+ * below mints for exactly that: reading it back as an authored name would make
+ * `absent → save → parse` land on `""` instead of absent, and no reader can
+ * tell the two apart. `@descr` and `@title` are optional and written only when
+ * authored, so `""` in either is a string someone wrote.
+ */
+declare const parseNonVisualDrawingNames: (element: XmlElement | null | undefined) => NonVisualDrawingNames;
+/**
+ * The `name`, `descr` and `title` attributes of a `CT_NonVisualDrawingProps`
+ * element, leading space included.
+ *
+ * `@name` is schema-required, so an object carrying none writes the empty
+ * string. folio does not name an object it did not author: a generated
+ * "Shape 3" would overwrite the author's own name for every drawing whose
+ * name did not survive the model, and read back as authored content.
+ */
+declare const serializeNonVisualDrawingNames: (names: NonVisualDrawingNames) => string;
+//#endregion
+export { NonVisualDrawingNames, parseNonVisualDrawingNames, serializeNonVisualDrawingNames };

package/dist/docx/nonVisualDrawingProps.js

@@ -0,0 +1,46 @@
+import { getAttribute } from "./xmlParser.js";
+import { escapeXmlAttribute } from "@stll/docx-core";
+//#region src/docx/nonVisualDrawingProps.ts
+/**
+* `CT_NonVisualDrawingProps` (`wp:docPr`, `wps:cNvPr`, `pic:cNvPr`) carries the
+* three authored strings every drawing object has: its name, its alt text
+* (`descr`) and its title. They are authored content, not folio's to mint, so
+* one reader and one writer own them for every drawing kind.
+*/
+/**
+* Read `@name`, `@descr` and `@title` off a `CT_NonVisualDrawingProps` element.
+*
+* An attribute that is not there stays absent. `@name` is schema-required, so
+* an unnamed object still writes one, and `name=""` is the marker the writer
+* below mints for exactly that: reading it back as an authored name would make
+* `absent → save → parse` land on `""` instead of absent, and no reader can
+* tell the two apart. `@descr` and `@title` are optional and written only when
+* authored, so `""` in either is a string someone wrote.
+*/
+const parseNonVisualDrawingNames = (element) => {
+	if (!element) return {};
+	const name = getAttribute(element, null, "name");
+	const descr = getAttribute(element, null, "descr");
+	const title = getAttribute(element, null, "title");
+	return {
+		...name !== null && name !== "" ? { name } : {},
+		...descr !== null ? { alt: descr } : {},
+		...title !== null ? { title } : {}
+	};
+};
+/**
+* The `name`, `descr` and `title` attributes of a `CT_NonVisualDrawingProps`
+* element, leading space included.
+*
+* `@name` is schema-required, so an object carrying none writes the empty
+* string. folio does not name an object it did not author: a generated
+* "Shape 3" would overwrite the author's own name for every drawing whose
+* name did not survive the model, and read back as authored content.
+*/
+const serializeNonVisualDrawingNames = (names) => {
+	const descr = names.alt === void 0 ? "" : ` descr="${escapeXmlAttribute(names.alt)}"`;
+	const title = names.title === void 0 ? "" : ` title="${escapeXmlAttribute(names.title)}"`;
+	return ` name="${escapeXmlAttribute(names.name ?? "")}"${descr}${title}`;
+};
+//#endregion
+export { parseNonVisualDrawingNames, serializeNonVisualDrawingNames };

package/dist/docx/normalizeBaseDirection.js

@@ -44,13 +44,22 @@ const normalizeTable = (table, styles) => ({
 		...row,
 		cells: row.cells.map((cell) => ({
 			...cell,
-			content: cell.content.map((block) => block.type === "paragraph" ? normalizeParagraph(block, styles) : normalizeTable(block, styles))
+			content: cell.content.map((block) => normalizeCellBlock(block, styles))
 		}))
 	}))
 });
+const normalizeCellBlock = (block, styles) => {
+	switch (block.type) {
+		case "paragraph": return normalizeParagraph(block, styles);
+		case "table": return normalizeTable(block, styles);
+		case "preservedBlock": return block;
+		default: return block;
+	}
+};
 const normalizeBlocks = (blocks, styles) => blocks.map((block) => {
 	if (block.type === "paragraph") return normalizeParagraph(block, styles);
 	if (block.type === "table") return normalizeTable(block, styles);
+	if (block.type === "preservedBlock") return block;
 	return {
 		...block,
 		content: normalizeBlocks(block.content, styles)

package/dist/docx/paraIdAttribute.d.ts

@@ -0,0 +1,21 @@
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/paraIdAttribute.d.ts
+/**
+ * The namespaces a paraId-valued attribute may be written in: the Word 2010,
+ * 2012 and 2018 wordml extensions.
+ *
+ * The 2018 URI is read from the serializer's table rather than retyped, so the
+ * spelling folio writes and the spelling it accepts cannot drift.
+ */
+declare const PARA_ID_NAMESPACE_URIS: ReadonlySet<string>;
+/** The paraId this element carries, or `undefined` when it carries none. */
+declare const paraIdAttribute: (element: XmlElement) => string | undefined;
+/** The paraId of the parent this element names, by the same rule. */
+declare const paraIdParentAttribute: (element: XmlElement) => string | undefined;
+/**
+ * The textId this element carries: a paragraph identity written beside
+ * `paraId`, in the same namespaces and by the same rule.
+ */
+declare const textIdAttribute: (element: XmlElement) => string | undefined;
+//#endregion
+export { PARA_ID_NAMESPACE_URIS, paraIdAttribute, paraIdParentAttribute, textIdAttribute };

package/dist/docx/paraIdAttribute.js

@@ -0,0 +1,64 @@
+import { OOXML_NAMESPACES } from "./serializer/partNamespaces.js";
+import { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, getAttributeByNamespaceUri } from "./xmlParser.js";
+//#region src/docx/paraIdAttribute.ts
+/**
+* The one reader for "the paraId written on this element".
+*
+* A `paraId` is a join key: `w15:commentEx/@w15:paraId`,
+* `w16cex:comment/@w16cex:paraId` and `w15:paraIdParent` all name a paragraph
+* through the `w14:paraId` it carries. Three Word generations write the same
+* key under three prefixes, and a producer is free to bind any of those
+* namespaces to a prefix of its own choosing, so the key must be resolved by
+* namespace URI. Resolving it by local name alone is worse than missing it: an
+* unrelated `vendor:paraId` would key a comment into another thread and carry
+* that thread's date, parent and resolved state.
+*
+* Every reader of the key calls this, so no call site can come to disagree
+* with another about which attribute is a paraId.
+*/
+/**
+* The namespaces a paraId-valued attribute may be written in: the Word 2010,
+* 2012 and 2018 wordml extensions.
+*
+* The 2018 URI is read from the serializer's table rather than retyped, so the
+* spelling folio writes and the spelling it accepts cannot drift.
+*/
+const PARA_ID_NAMESPACE_URIS = /* @__PURE__ */ new Set([
+	NAMESPACES.w14,
+	NAMESPACES.w15,
+	OOXML_NAMESPACES.w16cex.uri
+]);
+/**
+* The conventional prefixes, read literally as a last resort.
+*
+* A part that writes `w14:paraId` without declaring `xmlns:w14` is malformed,
+* and no URI lookup can resolve it; Word reads those files, so folio does too.
+*/
+const CONVENTIONAL_PARA_ID_PREFIXES = [
+	"w14",
+	"w15",
+	"w16cex"
+];
+const paraIdValuedAttribute = (element, localName) => {
+	const byUri = getAttributeByNamespaceUri(element, PARA_ID_NAMESPACE_URIS, localName);
+	if (byUri !== null) return byUri;
+	for (const prefix of CONVENTIONAL_PARA_ID_PREFIXES) {
+		const literal = element.attributes?.[`${prefix}:${localName}`];
+		if (literal !== void 0) return String(literal);
+	}
+	const inWordprocessingml = getAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, localName);
+	if (inWordprocessingml !== null) return inWordprocessingml;
+	const literalW = element.attributes?.[`w:${localName}`];
+	return literalW === void 0 ? void 0 : String(literalW);
+};
+/** The paraId this element carries, or `undefined` when it carries none. */
+const paraIdAttribute = (element) => paraIdValuedAttribute(element, "paraId");
+/** The paraId of the parent this element names, by the same rule. */
+const paraIdParentAttribute = (element) => paraIdValuedAttribute(element, "paraIdParent");
+/**
+* The textId this element carries: a paragraph identity written beside
+* `paraId`, in the same namespaces and by the same rule.
+*/
+const textIdAttribute = (element) => paraIdValuedAttribute(element, "textId");
+//#endregion
+export { PARA_ID_NAMESPACE_URIS, paraIdAttribute, paraIdParentAttribute, textIdAttribute };

package/dist/docx/paragraphParser.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 { XmlElement } from "./xmlParser.js";
+import { StyleMap } from "./styleParser.js";
 //#region src/docx/paragraphParser.d.ts
 /**
  * Parse paragraph formatting properties (w:pPr)