@beyondwork/docx-react-component 1.0.71 → 1.0.73

package/src/io/export/serialize-footnotes.ts

@@ -18,6 +18,7 @@ import {
 } from "./table-properties-xml.ts";
 import { twip } from "./twip.ts";
 import { escapeXmlAttribute } from "./escape-xml-attribute.ts";
+import { buildFrameXml } from "./serialize-paragraph-formatting.ts";
 
 export const WORD_FOOTNOTES_CONTENT_TYPE =
   "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml";
@@ -222,6 +223,11 @@ function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
   if (paragraph.styleId) {
     parts.push(`<w:pStyle w:val="${escapeXmlAttribute(paragraph.styleId)}"/>`);
   }
+  // Coord-04 §1.19.d — direct-paragraph framePr (footnotes path).
+  {
+    const frameXml = buildFrameXml(paragraph.frameProperties);
+    if (frameXml) parts.push(frameXml);
+  }
   if (paragraph.alignment) {
     parts.push(`<w:jc w:val="${escapeXmlAttribute(paragraph.alignment)}"/>`);
   }

package/src/io/export/serialize-headers-footers.ts

@@ -18,6 +18,7 @@ import {
 } from "./table-properties-xml.ts";
 import { twip } from "./twip.ts";
 import { escapeXmlAttribute } from "./escape-xml-attribute.ts";
+import { buildFrameXml } from "./serialize-paragraph-formatting.ts";
 
 export const WORD_HEADER_CONTENT_TYPE =
   "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml";
@@ -186,6 +187,11 @@ function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
   if (paragraph.styleId) {
     parts.push(`<w:pStyle w:val="${escapeXmlAttribute(paragraph.styleId)}"/>`);
   }
+  // Coord-04 §1.19.d — direct-paragraph framePr (headers/footers path).
+  {
+    const frameXml = buildFrameXml(paragraph.frameProperties);
+    if (frameXml) parts.push(frameXml);
+  }
   if (paragraph.spacing) {
     const s = paragraph.spacing;
     const attrs: string[] = [];
@@ -284,6 +290,7 @@ function serializeInlineNode(node: InlineNode): string {
       throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);
     case "image":
     case "column_break":
+    case "page_break":
     case "symbol":
     default:
       throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);

package/src/io/export/serialize-main-document.ts

@@ -22,6 +22,7 @@ import { SCOPE_MARKER_BOOKMARK_PREFIX } from "../ooxml/parse-scope-markers.ts";
 import { getOpaqueFragment } from "../../preservation/store.ts";
 import { retainRelationshipsForFragment } from "../../preservation/relationship-retention.ts";
 import { serializeParagraphNumberingProperties } from "./serialize-numbering.ts";
+import { buildFrameXml } from "./serialize-paragraph-formatting.ts";
 import {
   serializeTableCellPropertiesXml,
   serializeTablePropertiesXml,
@@ -581,6 +582,8 @@ function serializeTableInlineNode(
       return "<w:r><w:tab/></w:r>";
     case "column_break":
       return "<w:r><w:br w:type=\"column\"/></w:r>";
+    case "page_break":
+      return "<w:r><w:br w:type=\"page\"/></w:r>";
     case "hard_break":
       return "<w:r><w:br/></w:r>";
     case "symbol": {
@@ -714,6 +717,12 @@ function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
   pushOnOffParagraphProperty(children, "keepNext", paragraph.keepNext);
   pushOnOffParagraphProperty(children, "keepLines", paragraph.keepLines);
   pushOnOffParagraphProperty(children, "pageBreakBefore", paragraph.pageBreakBefore);
+  // ECMA-376 §17.3.1 canonical slot for framePr: between pageBreakBefore
+  // and pBdr. Coord-04 §1.19.d — direct-paragraph path.
+  {
+    const frameXml = buildFrameXml(paragraph.frameProperties);
+    if (frameXml) children.push(frameXml);
+  }
   pushOnOffParagraphProperty(children, "widowControl", paragraph.widowControl);
   if (paragraph.outlineLevel !== undefined) {
     children.push(`<w:outlineLvl w:val="${paragraph.outlineLevel}"/>`);
@@ -1010,6 +1019,17 @@ function serializeInlineNode(
         boundaries,
       };
     }
+    case "page_break": {
+      const xml = `<w:r><w:br w:type="page"/></w:r>`;
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
     case "hard_break": {
       const xml = serializeRun({ kind: "hard_break" });
       const boundaries = new Map<number, number>();

package/src/io/export/serialize-paragraph-formatting.ts

@@ -6,6 +6,7 @@
 
 import type {
   CanonicalParagraphFormatting,
+  FrameProperties,
   ParagraphBorders,
   ParagraphIndentation,
   ParagraphShading,
@@ -92,6 +93,34 @@ function buildSpacingXml(s: ParagraphSpacing | undefined): string {
   return attrs.length > 0 ? `<w:spacing ${attrs.join(" ")}/>` : "";
 }
 
+export function buildFrameXml(f: FrameProperties | undefined): string {
+  if (!f) return "";
+  // Prefer parsed rawXml when available — preserves extension attributes
+  // (`w14:*`, `w15:*`, `mc:Ignorable`) that the typed field set doesn't
+  // cover. When rawXml isn't present (parser couldn't capture the source
+  // string), emit from typed fields only; extension attrs are lost in
+  // that round-trip path, but every CCEP-class framed paragraph we've
+  // seen uses only modelled attributes.
+  if (f.rawXml) return f.rawXml;
+  const attrs: string[] = [];
+  if (f.widthTwips !== undefined) attrs.push(`w:w="${f.widthTwips}"`);
+  if (f.heightTwips !== undefined) attrs.push(`w:h="${f.heightTwips}"`);
+  if (f.hRule) attrs.push(`w:hRule="${escXml(f.hRule)}"`);
+  if (f.xTwips !== undefined) attrs.push(`w:x="${f.xTwips}"`);
+  if (f.yTwips !== undefined) attrs.push(`w:y="${f.yTwips}"`);
+  if (f.xAlign) attrs.push(`w:xAlign="${escXml(f.xAlign)}"`);
+  if (f.yAlign) attrs.push(`w:yAlign="${escXml(f.yAlign)}"`);
+  if (f.hAnchor) attrs.push(`w:hAnchor="${escXml(f.hAnchor)}"`);
+  if (f.vAnchor) attrs.push(`w:vAnchor="${escXml(f.vAnchor)}"`);
+  if (f.wrap) attrs.push(`w:wrap="${escXml(f.wrap)}"`);
+  if (f.hSpaceTwips !== undefined) attrs.push(`w:hSpace="${f.hSpaceTwips}"`);
+  if (f.vSpaceTwips !== undefined) attrs.push(`w:vSpace="${f.vSpaceTwips}"`);
+  if (f.dropCap) attrs.push(`w:dropCap="${escXml(f.dropCap)}"`);
+  if (f.lines !== undefined) attrs.push(`w:lines="${f.lines}"`);
+  if (f.anchorLock !== undefined) attrs.push(`w:anchorLock="${f.anchorLock ? "1" : "0"}"`);
+  return attrs.length > 0 ? `<w:framePr ${attrs.join(" ")}/>` : "";
+}
+
 function buildIndentXml(i: ParagraphIndentation | undefined): string {
   if (!i) return "";
   const attrs: string[] = [];
@@ -114,6 +143,11 @@ export function buildParagraphPropertiesXml(
   parts.push(toggleEl("keepLines", pPr.keepLines));
   parts.push(toggleEl("pageBreakBefore", pPr.pageBreakBefore));
 
+  // 2. framePr (ECMA-376 §17.3.1 canonical order slot, between pageBreakBefore
+  // and pBdr). Emit before pBdr so the OpenXML SDK validator accepts a framed
+  // paragraph that also carries borders (coord-04 §1.18.d).
+  parts.push(buildFrameXml(pPr.frameProperties));
+
   // 4. pBdr
   parts.push(buildBordersXml(pPr.borders));
 

package/src/io/export/split-review-boundaries.ts

@@ -340,6 +340,7 @@ function measureInlineNodeForReviewBoundaries(node: InlineNode): number {
     case "tab":
     case "hard_break":
     case "column_break":
+    case "page_break":
     case "footnote_ref":
     case "image":
     case "opaque_inline":

package/src/io/normalize/normalize-text.ts

@@ -264,6 +264,7 @@ function normalizeParagraph(
     ...(paragraph.suppressLineNumbers !== undefined
       ? { suppressLineNumbers: paragraph.suppressLineNumbers }
       : {}),
+    ...(paragraph.frameProperties ? { frameProperties: paragraph.frameProperties } : {}),
     // A.7: preserve w14:paraId / w14:textId across import → export so
     // downstream tools that diff documents by paragraph id stay stable.
     ...(paragraph.wordExtensionIds
@@ -481,6 +482,17 @@ function normalizeInlineChildren(
         normalized.push({ type: "column_break" });
         state.cursor += 1;
         break;
+      case "page_break":
+        // coord-04 §1.18.5 follow-up: the fde93da3 cross-layer page_break
+        // ship added parse + surface-projection + pagination but missed
+        // this normalize-text switch. Without this case, every
+        // `<w:br w:type="page"/>` run parsed by L01 falls through and gets
+        // silently dropped during canonical assembly — so L04's
+        // `hasPageBreak` never fires on real documents. Mirrors the
+        // `column_break` branch.
+        normalized.push({ type: "page_break" });
+        state.cursor += 1;
+        break;
       case "chart_preview":
         registerComplexPreviewMedia(state, node);
         normalized.push({
@@ -704,9 +716,30 @@ function registerComplexPreviewMedia(
 function normalizeHyperlink(node: ParsedHyperlinkNode): {
   type: "hyperlink";
   href: string;
-  children: Array<TextNode | { type: "hard_break" } | { type: "tab" }>;
+  children: Array<
+    | TextNode
+    | { type: "hard_break" }
+    | { type: "column_break" }
+    | { type: "page_break" }
+    | { type: "tab" }
+    | { type: "symbol"; char: string; font?: string; marks?: TextMark[] }
+  >;
 } {
-  const children: Array<TextNode | { type: "hard_break" } | { type: "tab" }> = [];
+  // Canonical `HyperlinkNode.children` accepts the full inline-leaf set
+  // (TextNode | HardBreakNode | ColumnBreakNode | PageBreakNode | TabNode |
+  // SymbolNode). Matching the canonical shape here keeps rare
+  // hyperlink-inside-break patterns (a link spanning a column or page
+  // break in Word's output) from silently dropping at the normalize step —
+  // same class of drop that `coord-04 §1.19.b` fixed one level up in
+  // `normalizeInlineChildren`.
+  const children: Array<
+    | TextNode
+    | { type: "hard_break" }
+    | { type: "column_break" }
+    | { type: "page_break" }
+    | { type: "tab" }
+    | { type: "symbol"; char: string; font?: string; marks?: TextMark[] }
+  > = [];
 
   for (const child of node.children) {
     switch (child.type) {
@@ -732,6 +765,20 @@ function normalizeHyperlink(node: ParsedHyperlinkNode): {
       case "hard_break":
         children.push({ type: "hard_break" });
         break;
+      case "column_break":
+        children.push({ type: "column_break" });
+        break;
+      case "page_break":
+        children.push({ type: "page_break" });
+        break;
+      case "symbol":
+        children.push({
+          type: "symbol",
+          char: child.char,
+          ...(child.font ? { font: child.font } : {}),
+          ...(child.marks && child.marks.length > 0 ? { marks: child.marks } : {}),
+        });
+        break;
     }
   }
 

package/src/io/ooxml/parse-headers-footers.ts

@@ -328,6 +328,37 @@ function parseParagraphElement(
         activeComplexField = null;
       }
       pushFieldNode(children, child, "simple");
+    } else if (name === "sdt") {
+      // coord-11 §22 — structured-document-tag wrapping run-level content
+      // inside a header/footer paragraph. Word commonly uses these to
+      // bundle the page-number field + decorative drawings (e.g. CCEP's
+      // footer "Copyright CCEP STRICTLY CONFIDENTIAL" red rectangle +
+      // "Page N" label both sit inside one `<w:sdt>` in footer1.xml).
+      // Without this case the sdt was silently dropped at the paragraph
+      // walker and every run it carried — including WPS shapes bearing
+      // the brand-strip text — never reached the canonical tree.
+      // Treat `<w:sdtContent>` as a transparent wrapper and re-process
+      // its `<w:r>` / `<w:hyperlink>` / `<w:sdt>` children as if they
+      // were direct paragraph children.
+      const sdtContent = findChildElementOptional(child, "sdtContent");
+      if (sdtContent) {
+        for (const grandchild of sdtContent.children) {
+          if (grandchild.type !== "element") continue;
+          const gname = localName(grandchild.name);
+          if (gname === "r") {
+            activeComplexField = appendRunNodes(grandchild, children, activeComplexField, sourceXml, opts);
+          } else if (gname === "hyperlink") {
+            children.push(parseHyperlinkElement(grandchild, opts));
+          } else if (gname === "bookmarkStart" || gname === "bookmarkEnd") {
+            children.push(parseBookmarkElement(grandchild));
+          } else if (gname === "fldSimple") {
+            pushFieldNode(children, grandchild, "simple");
+          }
+          // Nested sdt / other elements ignored — deeper nesting is rare
+          // enough that opaque round-trip via the block-level sdt parser
+          // handles it if it matters.
+        }
+      }
     }
   }
 

package/src/io/ooxml/parse-main-document.ts

@@ -1,6 +1,7 @@
 import type {
   BorderSpec,
   CellShading,
+  FrameProperties,
   TextMark,
   ParagraphBorders,
   ParagraphShading,
@@ -39,6 +40,7 @@ import { parseComplexContentXml, type ChartPartLookup } from "./parse-complex-co
 import { parseShapeXml, parseVmlXml } from "./parse-shapes.ts";
 import { parseObject } from "./parse-object.ts";
 import { parseDrawingFrame } from "./parse-drawing.ts";
+import { readFrameProperties } from "./parse-paragraph-formatting.ts";
 import { classifyFieldInstruction } from "./parse-fields.ts";
 import { parseFFDataFromFldChar } from "./parse-ffdata.ts";
 import { resolveHighlightColor } from "./highlight-colors.ts";
@@ -217,6 +219,41 @@ function captureGrabBagFromContainer(
 export interface ParsedMainDocument {
   blocks: ParsedBlockNode[];
   finalSectionProperties?: SectionProperties;
+  /**
+   * Aggregate count of cosmetic markers stripped during parse (see
+   * {@link ParseMainDocumentOptions.stripCosmeticMarkers}). Keyed by
+   * local element name (e.g. `lastRenderedPageBreak`). Absent when no
+   * markers were stripped.
+   */
+  skippedCosmeticMarkerCounts?: Readonly<Record<string, number>>;
+}
+
+/**
+ * Cosmetic markers that Word re-inserts on reopen and that carry no
+ * contract semantics. Stripping them at parse time unblocks
+ * `replaceText` on ranges that today cross them as `opaque_inline`
+ * boundaries. See `docs/architecture/cosmetic-marker-strip.md`.
+ *
+ * This is the Phase 1 set. Bookmark-pair stripping (with reference
+ * scan) is Phase 2.
+ */
+export const COSMETIC_MARKER_ELEMENT_NAMES: ReadonlySet<string> = new Set([
+  "lastRenderedPageBreak",
+  "proofErr",
+  "noBreakHyphen",
+]);
+
+export interface ParseMainDocumentOptions {
+  /**
+   * When `true` (the default), drops `<w:lastRenderedPageBreak/>`,
+   * `<w:proofErr/>`, and `<w:noBreakHyphen/>` during the parse walk
+   * instead of emitting them as `opaque_inline` nodes. Counts are
+   * reported on {@link ParsedMainDocument.skippedCosmeticMarkerCounts}.
+   *
+   * Set to `false` to preserve the pre-strip behavior exactly — every
+   * cosmetic marker becomes an `opaque_inline` with its source XML.
+   */
+  stripCosmeticMarkers?: boolean;
 }
 
 export type ParsedBlockNode =
@@ -256,6 +293,15 @@ export interface ParsedParagraphNode {
   bidi?: boolean;
   suppressLineNumbers?: boolean;
   cnfStyle?: string;
+  /**
+   * `<w:framePr>` declared directly on the paragraph's own `<w:pPr>`.
+   * Coord-04 §1.19.d step 2 (inline path). The style-cascade path
+   * flows through `CanonicalParagraphFormatting.frameProperties` on
+   * the style side; this slot captures the direct-override path so
+   * L02 `ParagraphNode.frameProperties` (added 2026-04-24 `4b3ea0b2`)
+   * can reach its canonical shape.
+   */
+  frameProperties?: FrameProperties;
   /** A.7: preserved w14 extension ids (paraId/textId). */
   wordExtensionIds?: {
     paraId?: string;
@@ -271,6 +317,7 @@ export type ParsedInlineNode =
   | ParsedTextNode
   | ParsedBreakNode
   | ParsedColumnBreakNode
+  | ParsedPageBreakNode
   | ParsedTabNode
   | ParsedSymbolNode
   | ParsedImageNode
@@ -306,6 +353,10 @@ export interface ParsedColumnBreakNode {
   type: "column_break";
 }
 
+export interface ParsedPageBreakNode {
+  type: "page_break";
+}
+
 export interface ParsedTabNode {
   type: "tab";
 }
@@ -350,7 +401,7 @@ export interface ParsedImageNode {
 export interface ParsedHyperlinkNode {
   type: "hyperlink";
   href: string;
-  children: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode>;
+  children: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedPageBreakNode | ParsedTabNode | ParsedSymbolNode>;
   rawXml: string;
 }
 
@@ -606,7 +657,7 @@ interface XmlTextNode {
 type XmlNode = XmlElementNode | XmlTextNode;
 
 interface RunParseResult {
-  nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode>;
+  nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedPageBreakNode | ParsedTabNode | ParsedSymbolNode>;
   supported: boolean;
 }
 
@@ -651,24 +702,61 @@ export function setActiveParseTelemetryBus(bus: ParseTelemetryBus | undefined):
   activeParseTelemetryBus = bus;
 }
 
+/**
+ * Request-scoped cosmetic-marker strip context. Set by
+ * `parseMainDocumentXml` for the duration of a single parse; read at
+ * the four emission sites in `parseBodyChild` / `parseRun` /
+ * `parseRunContentOnly` / `parseRevisionContainer`. Using a module
+ * variable instead of threading the flag through ~15 intermediate
+ * function signatures keeps the call sites readable; the try/finally
+ * in the entry point ensures the variable never leaks across calls.
+ *
+ * Re-entrancy invariant matches `activeChartPartLookup` above.
+ */
+interface CosmeticStripContext {
+  readonly strip: boolean;
+  readonly counts: Record<string, number>;
+}
+let activeCosmeticStripContext: CosmeticStripContext | null = null;
+
+function noteStrippedCosmeticMarker(tag: string): void {
+  if (!activeCosmeticStripContext) return;
+  activeCosmeticStripContext.counts[tag] =
+    (activeCosmeticStripContext.counts[tag] ?? 0) + 1;
+}
+
+function shouldStripCosmeticMarker(): boolean {
+  return activeCosmeticStripContext?.strip === true;
+}
+
 export function parseMainDocumentXml(
   xml: string,
   relationships: readonly OpcRelationship[] = [],
   mediaParts: ReadonlyMap<string, InlineMediaPart> = new Map(),
   sourcePartPath = "/word/document.xml",
   chartPartLookup?: ChartPartLookup,
+  parseOptions: ParseMainDocumentOptions = {},
 ): ParsedMainDocument {
   activeChartPartLookup = chartPartLookup;
+  const stripContext: CosmeticStripContext = {
+    strip: parseOptions.stripCosmeticMarkers !== false,
+    counts: Object.create(null) as Record<string, number>,
+  };
+  activeCosmeticStripContext = stripContext;
   const bus = activeParseTelemetryBus;
   const started = bus?.isEnabled("parse") ? performanceNow() : 0;
   try {
     const result = parseMainDocumentXmlInner(xml, relationships, mediaParts, sourcePartPath);
+    if (Object.keys(stripContext.counts).length > 0) {
+      result.skippedCosmeticMarkerCounts = Object.freeze({ ...stripContext.counts });
+    }
     if (bus?.isEnabled("parse")) {
       emitParseSummary(bus, result, sourcePartPath, performanceNow() - started);
     }
     return result;
   } finally {
     activeChartPartLookup = undefined;
+    activeCosmeticStripContext = null;
   }
 }
 
@@ -699,6 +787,13 @@ function emitParseSummary(
       blockCount: result.blocks.length,
       blockKindCounts: counts,
       ms,
+      // Strip counts are surfaced here (telemetry-only) rather than as a
+      // warning on `diagnostics.warnings` — the markers carry no
+      // contract semantics and surfacing them in the user-visible
+      // warnings feed would be noise. Available to debug UX / tests via
+      // the `parse` channel; absent when the feature is disabled or no
+      // markers were stripped.
+      skippedCosmeticMarkerCounts: result.skippedCosmeticMarkerCounts,
     },
   });
 }
@@ -999,6 +1094,7 @@ function parseBodyChild(
   let bidi: ParsedParagraphNode["bidi"];
   let suppressLineNumbers: ParsedParagraphNode["suppressLineNumbers"];
   let cnfStyle: ParsedParagraphNode["cnfStyle"];
+  let frameProperties: ParsedParagraphNode["frameProperties"];
   let sectionProperties: SectionProperties | undefined;
   let sectionPropertiesXml: string | undefined;
   let paragraphSupported = true;
@@ -1045,6 +1141,12 @@ function parseBodyChild(
         bidi = readOnOffParagraphProperty(child, "bidi");
         suppressLineNumbers = readOnOffParagraphProperty(child, "suppressLineNumbers");
         cnfStyle = readParagraphCnfStyle(child);
+        {
+          const framePrNode = child.children.find(
+            (c): c is XmlElementNode => c.type === "element" && localName(c.name) === "framePr",
+          );
+          if (framePrNode) frameProperties = readFrameProperties(framePrNode);
+        }
         sectionProperties = readSectionPropertiesFromPPr(child);
         sectionPropertiesXml = readSectionPropertiesXmlFromPPr(child, sourceXml);
         paragraphSupported = paragraphSupported && supportsParagraphProperties(child);
@@ -1143,6 +1245,10 @@ function parseBodyChild(
         flushActiveComplexField(children, () => {
           activeComplexField = null;
         }, activeComplexField);
+        if (shouldStripCosmeticMarker()) {
+          noteStrippedCosmeticMarker("proofErr");
+          break;
+        }
         children.push({
           type: "opaque_inline",
           rawXml: sourceXml.slice(child.start, child.end),
@@ -1230,6 +1336,7 @@ function parseBodyChild(
     ...(bidi !== undefined ? { bidi } : {}),
     ...(suppressLineNumbers !== undefined ? { suppressLineNumbers } : {}),
     ...(cnfStyle ? { cnfStyle } : {}),
+    ...(frameProperties ? { frameProperties } : {}),
     ...(wordExtensionIds ? { wordExtensionIds } : {}),
     ...(sectionProperties ? { sectionProperties } : {}),
     ...(sectionPropertiesXml ? { sectionPropertiesXml } : {}),
@@ -2390,7 +2497,9 @@ function parseRun(
         break;
       }
       case "br":
-        if (isColumnBreak(child)) {
+        if (isPageBreak(child)) {
+          result.push({ type: "page_break" });
+        } else if (isColumnBreak(child)) {
           result.push({ type: "column_break" });
         } else if (isSimpleLineBreak(child)) {
           result.push({ type: "hard_break" });
@@ -2577,6 +2686,11 @@ function parseRun(
       }
       case "lastRenderedPageBreak":
       case "proofErr":
+      case "noBreakHyphen":
+        if (shouldStripCosmeticMarker()) {
+          noteStrippedCosmeticMarker(localName(child.name));
+          break;
+        }
         result.push({
           type: "opaque_inline",
           rawXml: sourceXml.slice(child.start, child.end),
@@ -2650,12 +2764,23 @@ function parseRevisionContainer(
         result.push(hyperlink);
         break;
       }
+      case "proofErr":
+      case "lastRenderedPageBreak":
+      case "noBreakHyphen":
+        if (shouldStripCosmeticMarker()) {
+          noteStrippedCosmeticMarker(localName(child.name));
+          break;
+        }
+        return [
+          {
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(node.start, node.end),
+          },
+        ];
       case "commentRangeStart":
       case "commentRangeEnd":
       case "bookmarkStart":
       case "bookmarkEnd":
-      case "proofErr":
-      case "lastRenderedPageBreak":
         return [
           {
             type: "opaque_inline",
@@ -2714,7 +2839,7 @@ function parseHyperlink(
     };
   }
 
-  const children: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode> = [];
+  const children: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedPageBreakNode | ParsedTabNode | ParsedSymbolNode> = [];
 
   for (const child of node.children) {
     if (child.type !== "element") {
@@ -2764,7 +2889,7 @@ function parseRunContentOnly(
   }
 
   const marks = marksResult.marks;
-  const nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode> = [];
+  const nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedPageBreakNode | ParsedTabNode | ParsedSymbolNode> = [];
 
   for (const child of node.children) {
     if (child.type !== "element") {
@@ -2812,6 +2937,10 @@ function parseRunContentOnly(
         break;
       }
       case "br":
+        if (isPageBreak(child)) {
+          nodes.push({ type: "page_break" });
+          break;
+        }
         if (isColumnBreak(child)) {
           nodes.push({ type: "column_break" });
           break;
@@ -2824,10 +2953,17 @@ function parseRunContentOnly(
       case "commentReference":
       case "lastRenderedPageBreak":
       case "proofErr":
+      case "noBreakHyphen": {
+        const tag = localName(child.name);
+        if (shouldStripCosmeticMarker() && tag !== "commentReference") {
+          noteStrippedCosmeticMarker(tag);
+          break;
+        }
         if (options.preserveUnsupportedReviewMarkup) {
           return { nodes: [], supported: false };
         }
         break;
+      }
       default:
         return { nodes: [], supported: false };
     }
@@ -3149,6 +3285,11 @@ function isColumnBreak(node: XmlElementNode): boolean {
   return value === "column";
 }
 
+function isPageBreak(node: XmlElementNode): boolean {
+  const value = (node.attributes["w:type"] ?? node.attributes.type ?? "").toLowerCase();
+  return value === "page";
+}
+
 function findChildElement(node: XmlElementNode, childLocalName: string): XmlElementNode {
   const child = node.children.find(
     (entry): entry is XmlElementNode =>