@stll/folio-core 0.45.0 → 0.46.0

package/dist/display-list/build/paragraphPrimitives.js

@@ -6,7 +6,7 @@ import { countCompressibleSpaces, toPaintedText } from "../../layout-engine/meas
 import { isFloatingImageRun } from "../../layout-engine/types.js";
 import { resolveParagraphBorderHorizontalOutsets } from "../../layout-painter/borderStroke.js";
 import { getAutomaticTextColorForBackground } from "../../layout-painter/documentColors.js";
-import { getLeaderChar, getRenderableTextColor, sliceRunsForLine, splitCollapsibleLineEdgeSpaces, splitTextRunsByEastAsia, startsAfterSoftWrap } from "../../layout-painter/renderParagraph.js";
+import { UNICODE_BIDI_BY_WRAPPER_CONTROL, getLeaderChar, getRenderableTextColor, sliceRunsForLine, splitCollapsibleLineEdgeSpaces, splitTextRunsByEastAsia, startsAfterSoftWrap } from "../../layout-painter/renderParagraph.js";
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
 import { resolvePhysicalParagraphInlineLayout } from "../../utils/paragraphInlineLayout.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
@@ -278,6 +278,23 @@ const modelRangeOf = (run, context) => run.pmStart === void 0 || run.pmEnd === v
 	story: context.story
 };
 /**
+* The base direction one run's glyphs are laid out in.
+*
+* A bidirectional wrapper the author wrote around the run states it, and is
+* nearer than the paragraph's own base direction: an override (`w:bdo`) lays
+* every character out that way, and an embedding (`w:dir`) opens a level in
+* that direction. A wrapper with no `w:val` states nothing, and the paragraph
+* decides as before.
+*/
+const runGlyphDirection = (run, paragraphIsRtl) => run.bidiWrapper?.direction ?? (paragraphIsRtl ? "rtl" : "ltr");
+/**
+* The wrapper's control, for the backend that resolves the order itself.
+*
+* The direction alone does not separate the two: an override forces the
+* order, an embedding leaves the algorithm to resolve within it.
+*/
+const runUnicodeBidi = (run) => run.bidiWrapper === void 0 ? void 0 : UNICODE_BIDI_BY_WRAPPER_CONTROL[run.bidiWrapper.control];
+/**
 * One `glyphRun` plus everything painted around it: the run's background rect
 * first, then the glyphs, then the decorations whose geometry CSS would have
 * derived from the font.
@@ -342,6 +359,7 @@ const emitGlyphRun = ({ sink, context, run, glyphs, style, paintXPx, baselineYPx
 		thicknessPx: 1,
 		pattern: "solid"
 	} : void 0;
+	const unicodeBidi = runUnicodeBidi(run);
 	sink.glyphs.push({
 		kind: "glyphRun",
 		font,
@@ -350,7 +368,8 @@ const emitGlyphRun = ({ sink, context, run, glyphs, style, paintXPx, baselineYPx
 		xPx: paintXPx,
 		baselineYPx: runBaselineYPx,
 		...glyphRunText(glyphs),
-		direction: isRtl ? "rtl" : "ltr",
+		direction: runGlyphDirection(run, isRtl),
+		...unicodeBidi === void 0 ? {} : { unicodeBidi },
 		...stroke === void 0 ? {} : { stroke },
 		...pmRange === void 0 ? {} : { pmRange },
 		...collapsedEdge === void 0 ? {} : { collapsedEdge }

package/dist/display-list/dom/renderDisplayListToDom.js

@@ -1,4 +1,6 @@
+import { writeCommentAnchorIds } from "../../render-dom/commentAnchorAttributes.js";
 import { bytesToDataUrl } from "../../utils/base64.js";
+import { imageLuminanceFilter } from "../../utils/imageLuminance.js";
 import { anchorTargetAttrs } from "../../utils/urlSecurity.js";
 import { STROKE_DASH_FACTORS, walkRegions } from "../primitives.js";
 import { panic } from "better-result";
@@ -310,6 +312,7 @@ const paintGlyphRun = (run, context) => {
 	span.style.fontStyle = face.italic ? "italic" : "normal";
 	span.style.color = cssColor(run.color);
 	span.style.direction = run.direction;
+	if (run.unicodeBidi !== void 0) span.style.unicodeBidi = run.unicodeBidi;
 	if (run.stroke !== void 0) span.style.webkitTextStroke = `${px(run.stroke.thicknessPx)} ${cssColor(run.stroke.color)}`;
 	span.style.fontKerning = run.kerning ? "normal" : "none";
 	if (run.smallCaps) span.style.fontVariant = "small-caps";
@@ -387,13 +390,18 @@ const paintRect = ({ rect, fill, stroke }, context) => {
 		default: panic(`renderDisplayListToDom: unhandled rect stroke painter ${JSON.stringify(painter)}`);
 	}
 };
-const paintImage = ({ image, rect, crop, opacity }, context) => {
+const paintImage = ({ image, rect, crop, opacity, brightness, contrast }, context) => {
 	const source = resolveImage(image, context.images);
 	const clip = createAbsoluteDiv(context, rect);
 	clip.style.overflow = "hidden";
 	const element = context.doc.createElement("img");
 	element.style.position = "absolute";
 	element.style.opacity = String(opacity);
+	const filter = imageLuminanceFilter({
+		...brightness === void 0 ? {} : { brightness },
+		...contrast === void 0 ? {} : { contrast }
+	});
+	if (filter !== void 0) element.style.filter = filter;
 	element.style.left = "0px";
 	element.style.top = "0px";
 	element.style.width = px(rect.widthPx);
@@ -549,7 +557,7 @@ const applyRegionModel = (element, region) => {
 		element.dataset["pmEnd"] = String(model.pmRange.end);
 	}
 	if (model.blockId !== void 0) element.dataset["blockId"] = model.blockId;
-	if (model.commentIds !== void 0 && model.commentIds.length > 0) element.dataset["commentId"] = String(model.commentIds[0]);
+	if (model.commentIds !== void 0) writeCommentAnchorIds(element, model.commentIds);
 	if (model.rowIndex !== void 0) element.dataset["rowIndex"] = String(model.rowIndex);
 	if (model.columnIndex !== void 0) element.dataset["columnIndex"] = String(model.columnIndex);
 	const story = model.story ?? model.pmRange?.story;

package/dist/display-list/types.d.ts

@@ -215,6 +215,19 @@ type DisplayGlyphRun = {
   readonly text: string;
   readonly advancesPx: readonly number[];
   readonly direction: "ltr" | "rtl";
+  /**
+   * How a backend that resolves bidirectional text itself must treat the run.
+   *
+   * `direction` alone is the base direction, and a backend that hands the text
+   * to such a resolver gets the ordinary algorithm: a Latin word inside an
+   * `rtl` run reads forwards. That is an embedding, and it is wrong for the
+   * run the author wrapped in an override (`w:bdo`), where every character is
+   * laid out in `direction` whatever its own script. Absent is the ordinary
+   * run, whose base direction the paragraph or the run itself decided; a
+   * backend that positions every glyph from `advancesPx` reorders nothing and
+   * ignores this.
+   */
+  readonly unicodeBidi?: "embed" | "bidi-override";
   /**
    * Whether the glyphs kern.
    *
@@ -299,6 +312,10 @@ type DisplayImagePrimitive = {
     readonly b: number;
   };
   readonly opacity: number;
+  /** DrawingML picture brightness as a signed percentage. */
+  readonly brightness?: number;
+  /** DrawingML picture contrast as a signed percentage. */
+  readonly contrast?: number;
 };
 /** Clips its children to `rect`. Used for cropped images and cell overflow. */
 type DisplayClipGroup = {

package/dist/docx/attributeRemainder.d.ts

@@ -0,0 +1,43 @@
+import { XmlElement } from "./xmlParser.js";
+import { PreservedAttribute } from "@stll/docx-core/model";
+//#region src/docx/attributeRemainder.d.ts
+/**
+ * The modelled set of an element whose serializer writes no attribute at all.
+ *
+ * `w:r`, `w:tr` and `w:sectPr` are rebuilt as bare start tags, so everything
+ * their source wrote is the remainder. Named rather than spelled `new Set()`
+ * at each call site, so the claim is visible and one place has to change when
+ * one of them gains a modelled attribute.
+ */
+declare const NO_MODELLED_ATTRIBUTES: ReadonlySet<string>;
+type AttributeRemainderOptions = {
+  /** The element, as the source wrote it. */
+  element: XmlElement;
+  /**
+   * Local names this element's own parser reads.
+   *
+   * Local names rather than qualified ones, because folio's attribute readers
+   * fall back to a local-name match across prefixes: an attribute the parser
+   * would read under any binding has to be out of the remainder, or the save
+   * writes the value twice under two spellings.
+   */
+  modelled: ReadonlySet<string>;
+};
+/**
+ * Every attribute on the element the model has no field for.
+ *
+ * @returns the remainder, or `undefined` when the parser read them all — an
+ *   empty list is never written, so a fully modelled element stays identical
+ *   in the model.
+ */
+declare const attributeRemainder: ({ element, modelled }: AttributeRemainderOptions) => PreservedAttribute[] | undefined;
+/**
+ * The element's attributes, modelled first and the remainder after them.
+ *
+ * @param modelled the fragments the serializer is about to emit, already
+ *   spelled — they win a collision, because the model is the editable copy
+ * @returns the fragments to write, so an element with neither writes nothing
+ */
+declare const serializePreservedAttributes: (modelled: readonly string[], preserved: readonly PreservedAttribute[] | undefined) => string[];
+//#endregion
+export { NO_MODELLED_ATTRIBUTES, attributeRemainder, serializePreservedAttributes };

package/dist/docx/attributeRemainder.js

@@ -0,0 +1,65 @@
+import { OOXML_NAMESPACES } from "./serializer/partNamespaces.js";
+import { getLocalName, resolveAttributeNamespaceUri } from "./xmlParser.js";
+import { escapeXmlAttribute } from "@stll/docx-core";
+//#region src/docx/attributeRemainder.ts
+/** Namespace URI to the prefix a rebuilt part binds for it. */
+const CANONICAL_PREFIX = new Map(Object.entries(OOXML_NAMESPACES).map(([prefix, { uri }]) => [uri, prefix]));
+/**
+* The modelled set of an element whose serializer writes no attribute at all.
+*
+* `w:r`, `w:tr` and `w:sectPr` are rebuilt as bare start tags, so everything
+* their source wrote is the remainder. Named rather than spelled `new Set()`
+* at each call site, so the claim is visible and one place has to change when
+* one of them gains a modelled attribute.
+*/
+const NO_MODELLED_ATTRIBUTES = /* @__PURE__ */ new Set();
+/**
+* Every attribute on the element the model has no field for.
+*
+* @returns the remainder, or `undefined` when the parser read them all — an
+*   empty list is never written, so a fully modelled element stays identical
+*   in the model.
+*/
+const attributeRemainder = ({ element, modelled }) => {
+	const attributes = element.attributes;
+	if (!attributes) return;
+	const remainder = [];
+	for (const [spelling, value] of Object.entries(attributes)) {
+		if (value === void 0 || spelling === "xmlns" || spelling.startsWith("xmlns:")) continue;
+		const name = getLocalName(spelling);
+		if (modelled.has(name)) continue;
+		const namespace = resolveAttributeNamespaceUri(element, spelling);
+		if (namespace !== void 0 && !CANONICAL_PREFIX.has(namespace)) continue;
+		remainder.push({
+			...namespace === void 0 ? {} : { namespace },
+			name,
+			value: String(value)
+		});
+	}
+	return remainder.length === 0 ? void 0 : remainder;
+};
+/** The name a fragment such as `w14:paraId="1F2E"` writes. */
+const spelledName = (fragment) => fragment.slice(0, fragment.indexOf("="));
+/**
+* The element's attributes, modelled first and the remainder after them.
+*
+* @param modelled the fragments the serializer is about to emit, already
+*   spelled — they win a collision, because the model is the editable copy
+* @returns the fragments to write, so an element with neither writes nothing
+*/
+const serializePreservedAttributes = (modelled, preserved) => {
+	if (preserved === void 0 || preserved.length === 0) return [...modelled];
+	const written = new Set(modelled.map(spelledName));
+	const fragments = [...modelled];
+	for (const { namespace, name, value } of preserved) {
+		const prefix = namespace === void 0 ? void 0 : CANONICAL_PREFIX.get(namespace);
+		if (namespace !== void 0 && prefix === void 0) continue;
+		const spelling = prefix === void 0 ? name : `${prefix}:${name}`;
+		if (written.has(spelling)) continue;
+		written.add(spelling);
+		fragments.push(`${spelling}="${escapeXmlAttribute(value)}"`);
+	}
+	return fragments;
+};
+//#endregion
+export { NO_MODELLED_ATTRIBUTES, attributeRemainder, serializePreservedAttributes };

package/dist/docx/blockContentParser.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/blockContentParser.d.ts
 type ParseBlockContentOptions = {
   inHeaderFooter?: boolean;

package/dist/docx/blockContentParser.js

@@ -1,7 +1,7 @@
-import { attachPendingRangeMarkers, attachTrailingRangeMarkers, isBlockRangeMarker } from "./blockRangeMarkers.js";
 import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
 import { appendBookmarkMarkerToLastParagraphInBlocks, prependBookmarkMarkersToFirstParagraphInBlocks } from "./bookmarkPlacement.js";
 import { convertBulletToUnicode } from "./bulletMarkers.js";
+import { CAPTURE, OWNED_ELSEWHERE, dispatchChildren, withPreservedChildren } from "./containerChildren.js";
 import { isNumberingReference } from "./numberingReference.js";
 import { formatOoxmlCounter } from "./ooxmlCounterFormatter.js";
 import { parseParagraph } from "./paragraphParser.js";
@@ -9,7 +9,7 @@ import { enrichParagraphTextBoxes } from "./paragraphTextBoxEnrichment.js";
 import { parseSdtProperties } from "./sdtProperties.js";
 import { parseTable } from "./tableParser.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
-import { findChild, getChildElements, getLocalName, mergeXmlnsDeclarations, selectAlternateContentBranch } from "./xmlParser.js";
+import { findChild, getLocalName, mergeXmlnsDeclarations, selectAlternateContentBranch } from "./xmlParser.js";
 //#region src/docx/blockContentParser.ts
 const computeListMarker = (paragraph, { numbering, listCounters, abstractCounters, restartedNumIds, previousList }) => {
 	const listRendering = paragraph.listRendering;
@@ -104,72 +104,100 @@ const parseBlockContent = (parent, styles, theme, numbering, rels, media, option
 	}
 });
 const parseBlockContentWithState = (parent, styles, theme, numbering, rels, media, state) => {
-	const content = [];
-	const children = getChildElements(parent);
+	const modelled = [];
 	const pendingBookmarkMarkers = [];
-	const pendingRangeMarkers = [];
-	for (const child of children) {
-		const localName = getLocalName(child.name ?? "");
-		if (localName === "p") {
-			const paragraph = parseParagraph(child, styles, theme, numbering, rels, media, state.options);
-			prependPendingBookmarkMarkers(paragraph, pendingBookmarkMarkers);
-			enrichParagraphTextBoxes(paragraph, child, styles, theme, numbering, rels, media, parseTable);
-			computeListMarker(paragraph, {
-				numbering,
-				listCounters: state.listCounters,
-				abstractCounters: state.abstractCounters,
-				restartedNumIds: state.restartedNumIds,
-				previousList: state.previousList
-			});
-			attachPendingRangeMarkers(paragraph, pendingRangeMarkers);
-			content.push(paragraph);
-			continue;
-		}
-		if (localName === "tbl") {
-			const table = parseTable(child, styles, theme, numbering, rels, media, state.options);
-			if (!table) continue;
-			if (prependBookmarkMarkersToFirstParagraphInBlocks([table], pendingBookmarkMarkers)) pendingBookmarkMarkers.length = 0;
-			attachPendingRangeMarkers(table, pendingRangeMarkers);
-			content.push(table);
-			continue;
-		}
-		if (localName === "sdt") {
-			const sdtPr = findChild(child, "w", "sdtPr");
-			const sdtEndPr = findChild(child, "w", "sdtEndPr");
-			const sdtContent = findChild(child, "w", "sdtContent");
-			const properties = parseSdtProperties(sdtPr, sdtEndPr);
-			const captured = captureSdtSiblingMarkers(child);
-			if (captured.before.length > 0) properties.rawSdtChildrenBeforeContent = captured.before;
-			if (captured.after.length > 0) properties.rawSdtChildrenAfterContent = captured.after;
-			const blockSdt = {
-				type: "blockSdt",
-				properties,
-				content: sdtContent ? parseBlockContentWithState(sdtContent, styles, theme, numbering, rels, media, withContainerXmlns(withContainerXmlns(state, child), sdtContent)) : []
-			};
-			if (prependBookmarkMarkersToFirstParagraphInBlocks(blockSdt.content, pendingBookmarkMarkers)) pendingBookmarkMarkers.length = 0;
-			attachPendingRangeMarkers(blockSdt, pendingRangeMarkers);
-			content.push(blockSdt);
-			continue;
-		}
-		if (localName === "AlternateContent") {
+	const content = withPreservedChildren(modelled, dispatchChildren({
+		element: parent,
+		container: "block-content",
+		modelledCount: () => modelled.length,
+		undeclared: { AlternateContent: (child) => {
 			const selectedBranch = selectAlternateContentBranch(child);
-			if (selectedBranch) content.push(...parseBlockContentWithState(selectedBranch, styles, theme, numbering, rels, media, withContainerXmlns(withContainerXmlns(state, child), selectedBranch)));
-			continue;
+			if (!selectedBranch) return;
+			modelled.push(...parseBlockContentWithState(selectedBranch, styles, theme, numbering, rels, media, withContainerXmlns(withContainerXmlns(state, child), selectedBranch)));
+		} },
+		handlers: {
+			p: (child) => {
+				const paragraph = parseParagraph(child, styles, theme, numbering, rels, media, state.options);
+				prependPendingBookmarkMarkers(paragraph, pendingBookmarkMarkers);
+				enrichParagraphTextBoxes(paragraph, child, styles, theme, numbering, rels, media, parseTable);
+				computeListMarker(paragraph, {
+					numbering,
+					listCounters: state.listCounters,
+					abstractCounters: state.abstractCounters,
+					restartedNumIds: state.restartedNumIds,
+					previousList: state.previousList
+				});
+				modelled.push(paragraph);
+			},
+			tbl: (child) => {
+				const table = parseTable(child, styles, theme, numbering, rels, media, state.options);
+				if (!table) return;
+				if (prependBookmarkMarkersToFirstParagraphInBlocks([table], pendingBookmarkMarkers)) pendingBookmarkMarkers.length = 0;
+				modelled.push(table);
+			},
+			sdt: (child) => {
+				const blockSdt = parseBlockSdt(child, styles, theme, numbering, rels, media, state);
+				if (prependBookmarkMarkersToFirstParagraphInBlocks(blockSdt.content, pendingBookmarkMarkers)) pendingBookmarkMarkers.length = 0;
+				modelled.push(blockSdt);
+			},
+			bookmarkStart: (child) => {
+				collectBookmarkMarker(child, "bookmarkStart", modelled, pendingBookmarkMarkers);
+			},
+			bookmarkEnd: (child) => {
+				collectBookmarkMarker(child, "bookmarkEnd", modelled, pendingBookmarkMarkers);
+			},
+			sectPr: OWNED_ELSEWHERE,
+			tcPr: OWNED_ELSEWHERE,
+			altChunk: CAPTURE,
+			commentRangeEnd: CAPTURE,
+			commentRangeStart: CAPTURE,
+			customXml: CAPTURE,
+			customXmlDelRangeEnd: CAPTURE,
+			customXmlDelRangeStart: CAPTURE,
+			customXmlInsRangeEnd: CAPTURE,
+			customXmlInsRangeStart: CAPTURE,
+			customXmlMoveFromRangeEnd: CAPTURE,
+			customXmlMoveFromRangeStart: CAPTURE,
+			customXmlMoveToRangeEnd: CAPTURE,
+			customXmlMoveToRangeStart: CAPTURE,
+			del: CAPTURE,
+			ins: CAPTURE,
+			moveFrom: CAPTURE,
+			moveFromRangeEnd: CAPTURE,
+			moveFromRangeStart: CAPTURE,
+			moveTo: CAPTURE,
+			moveToRangeEnd: CAPTURE,
+			moveToRangeStart: CAPTURE,
+			permEnd: CAPTURE,
+			permStart: CAPTURE,
+			proofErr: CAPTURE
 		}
-		if (localName === "bookmarkStart" || localName === "bookmarkEnd") {
-			const marker = parseBookmarkMarker(child, localName);
-			if (!appendBookmarkMarkerToLastParagraphInBlocks(content, marker)) pendingBookmarkMarkers.push(marker);
-			continue;
-		}
-		if (isBlockRangeMarker(localName)) pendingRangeMarkers.push(captureVerbatimXml(child));
-	}
+	}), (xml) => ({
+		type: "preservedBlock",
+		xml
+	}));
 	if (pendingBookmarkMarkers.length > 0) content.push({
 		type: "paragraph",
 		content: [...pendingBookmarkMarkers]
 	});
-	attachTrailingRangeMarkers(content, pendingRangeMarkers);
 	return content;
 };
+const parseBlockSdt = (child, styles, theme, numbering, rels, media, state) => {
+	const sdtContent = findChild(child, "w", "sdtContent");
+	const properties = parseSdtProperties(findChild(child, "w", "sdtPr"), findChild(child, "w", "sdtEndPr"));
+	const captured = captureSdtSiblingMarkers(child);
+	if (captured.before.length > 0) properties.rawSdtChildrenBeforeContent = captured.before;
+	if (captured.after.length > 0) properties.rawSdtChildrenAfterContent = captured.after;
+	return {
+		type: "blockSdt",
+		properties,
+		content: sdtContent ? parseBlockContentWithState(sdtContent, styles, theme, numbering, rels, media, withContainerXmlns(withContainerXmlns(state, child), sdtContent)) : []
+	};
+};
+const collectBookmarkMarker = (child, localName, content, pending) => {
+	const marker = localName === "bookmarkStart" ? parseBookmarkStart(child) : parseBookmarkEnd(child);
+	if (!appendBookmarkMarkerToLastParagraphInBlocks(content, marker)) pending.push(marker);
+};
 /**
 * Walk a `<w:sdt>` element's direct children and return the verbatim XML
 * for every child that is NOT `<w:sdtPr>`, `<w:sdtEndPr>`, or
@@ -202,10 +230,6 @@ const captureSdtSiblingMarkers = (sdt) => {
 		after: afterParts.join("")
 	};
 };
-const parseBookmarkMarker = (child, localName) => {
-	if (localName === "bookmarkStart") return parseBookmarkStart(child);
-	return parseBookmarkEnd(child);
-};
 const prependPendingBookmarkMarkers = (paragraph, pendingBookmarkMarkers) => {
 	if (pendingBookmarkMarkers.length === 0) return;
 	paragraph.content.unshift(...pendingBookmarkMarkers);

package/dist/docx/blockPlainText.d.ts

@@ -1,8 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/blockPlainText.d.ts
-type PlainTextBlock = document_d_exports.Paragraph | document_d_exports.Table | document_d_exports.BlockSdt;
 /** One entry per block, so callers can join or count lines as they need. */
-declare const collectBlockTexts: (blocks: readonly PlainTextBlock[]) => string[];
-declare const blockPlainText: (blocks: readonly PlainTextBlock[]) => string;
+declare const collectBlockTexts: (blocks: readonly document_d_exports.BlockContent[]) => string[];
+declare const blockPlainText: (blocks: readonly document_d_exports.BlockContent[]) => string;
 //#endregion
-export { PlainTextBlock, blockPlainText, collectBlockTexts };
+export { blockPlainText, collectBlockTexts };

package/dist/docx/blockPlainText.js

@@ -31,6 +31,7 @@ const collectBlockTexts = (blocks) => {
 		case "blockSdt":
 			texts.push(...collectBlockTexts(block.content));
 			break;
+		case "preservedBlock": break;
 		default: panic(`Unsupported block in plain-text extraction: ${JSON.stringify(block)}`);
 	}
 	return texts;

package/dist/docx/bookmarkPlacement.js

@@ -25,6 +25,7 @@ const appendBookmarkMarkerToLastParagraph = (block, marker) => {
 		return true;
 	}
 	if (block.type === "table") return appendBookmarkMarkerToLastParagraphInTable(block, marker);
+	if (block.type === "preservedBlock") return false;
 	return appendBookmarkMarkerToLastParagraphInBlocks(block.content, marker);
 };
 const appendBookmarkMarkerToLastParagraphInTable = (table, marker) => {
@@ -40,6 +41,7 @@ const prependBookmarkMarkersToFirstParagraph = (block, markers) => {
 		return true;
 	}
 	if (block.type === "table") return prependBookmarkMarkersToFirstParagraphInTable(block, markers);
+	if (block.type === "preservedBlock") return false;
 	return prependBookmarkMarkersToFirstParagraphInBlocks(block.content, markers);
 };
 const prependBookmarkMarkersToFirstParagraphInTable = (table, markers) => {

package/dist/docx/commentAnchorIndex.d.ts

@@ -0,0 +1,30 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/docx/commentAnchorIndex.d.ts
+type CommentMarkerSlot = {
+  /** The inline-content array the marker sits in, so a caller can splice it. */
+  content: document_d_exports.ParagraphContent[];
+  index: number;
+  item: Extract<document_d_exports.ParagraphContent, {
+    type: "commentRangeStart";
+  } | {
+    type: "commentRangeEnd";
+  } | {
+    type: "commentReference";
+  }>;
+};
+declare const visitCommentMarkers: (blocks: readonly document_d_exports.BlockContent[], visit: (slot: CommentMarkerSlot) => void) => void;
+/**
+ * Comments that open a range anywhere in these blocks.
+ *
+ * A `commentReference` whose id is absent has no highlight of its own — the
+ * point-comment shape the model's `CommentReference` documents — and only that
+ * one needs its mark anchored onto neighbouring text. Anchoring one whose range
+ * exists stretches that range to wherever the reference sits, which is how a
+ * comment on one word came back covering the rest of the sentence. The range
+ * and the reference need not share a paragraph, so the question is asked of the
+ * whole story: a reference that trails the end of a range three paragraphs back
+ * is still not a point comment.
+ */
+declare const rangedCommentIds: (blocks: readonly document_d_exports.BlockContent[]) => ReadonlySet<number>;
+//#endregion
+export { CommentMarkerSlot, rangedCommentIds, visitCommentMarkers };

package/dist/docx/commentAnchorIndex.js

@@ -0,0 +1,50 @@
+import { visitInlineContentSlots } from "./paragraphTraversal.js";
+//#region src/docx/commentAnchorIndex.ts
+const visitCommentMarkers = (blocks, visit) => {
+	const visitParagraph = (paragraph) => {
+		visitInlineContentSlots(paragraph, ({ content, index, item }) => {
+			if (item.type === "commentRangeStart" || item.type === "commentRangeEnd" || item.type === "commentReference") visit({
+				content,
+				index,
+				item
+			});
+		});
+	};
+	const visitBlock = (block) => {
+		if (block.type === "paragraph") {
+			visitParagraph(block);
+			return;
+		}
+		if (block.type === "table") {
+			for (const row of block.rows) for (const cell of row.cells) visitBlocks(cell.content);
+			return;
+		}
+		if (block.type === "preservedBlock") return;
+		visitBlocks(block.content);
+	};
+	const visitBlocks = (nested) => {
+		for (const block of nested) visitBlock(block);
+	};
+	visitBlocks(blocks);
+};
+/**
+* Comments that open a range anywhere in these blocks.
+*
+* A `commentReference` whose id is absent has no highlight of its own — the
+* point-comment shape the model's `CommentReference` documents — and only that
+* one needs its mark anchored onto neighbouring text. Anchoring one whose range
+* exists stretches that range to wherever the reference sits, which is how a
+* comment on one word came back covering the rest of the sentence. The range
+* and the reference need not share a paragraph, so the question is asked of the
+* whole story: a reference that trails the end of a range three paragraphs back
+* is still not a point comment.
+*/
+const rangedCommentIds = (blocks) => {
+	const ids = /* @__PURE__ */ new Set();
+	visitCommentMarkers(blocks, ({ item }) => {
+		if (item.type === "commentRangeStart") ids.add(item.id);
+	});
+	return ids;
+};
+//#endregion
+export { rangedCommentIds, visitCommentMarkers };

package/dist/docx/commentParser.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../types/document.js";
-import { StyleMap } from "./styleParser.js";
 import { ParseContext } from "./parseContext.js";
+import { StyleMap } from "./styleParser.js";
 //#region src/docx/commentParser.d.ts
 type CommentExtendedInfo = {
   parentParaId?: string;