@portone/docx-editor 0.4.0 → 0.5.1

package/dist/docx/importPolicy.js

@@ -0,0 +1,195 @@
+// src/docx/importPolicy.ts
+import { M_NS, W_NS } from "../ooxml/names.js";
+import {
+  COMMENT_RANGE_MARKERS,
+  PERMISSION_MARKERS,
+  RANGE_MARKERS
+} from "../ooxml/rangeMarkers.js";
+import { WRAPPER_KINDS } from "./wrappers.js";
+var MODEL = { tier: "model" };
+var HIDDEN_MARKER = {
+  tier: "marker",
+  display: "hidden",
+  guarded: true
+};
+var IGNORABLE = {
+  tier: "ignorable",
+  display: "hidden",
+  guarded: false
+};
+function chip(tier) {
+  return { tier, display: "chip", guarded: false };
+}
+var RUN_CHIP = chip("runContent");
+var INLINE_CHIP = chip("inline");
+var BLOCK_CHIP = chip("block");
+var FIELD_PIECE = {
+  tier: "runContent",
+  display: "chip",
+  guarded: true
+};
+function clarkName(el) {
+  return `{${el.namespaceURI ?? ""}}${el.localName}`;
+}
+function wml(localName) {
+  return `{${W_NS}}${localName}`;
+}
+function rules(entries) {
+  return new Map(
+    entries.flatMap(
+      ([names, policy]) => names.map((name) => [wml(name), policy])
+    )
+  );
+}
+var REVISION_CONTAINERS = ["ins", "del", "moveFrom", "moveTo"];
+var MATH = [`{${M_NS}}oMath`, `{${M_NS}}oMathPara`];
+var RUN_LEVEL = rules([
+  [["rPr", "t", "br", "tab", "drawing"], MODEL],
+  [["commentReference", "footnoteReference", "endnoteReference"], MODEL],
+  [["lastRenderedPageBreak"], IGNORABLE],
+  [["softHyphen"], { tier: "runContent", display: "hidden", guarded: false }],
+  [
+    ["noBreakHyphen"],
+    { tier: "runContent", display: "text", text: "\u2011", guarded: false }
+  ],
+  [["cr"], { tier: "runContent", display: "break", guarded: false }],
+  // §17.16.18: a complex field is the begin, the instruction and the end read in order, so a
+  // piece taken away leaves the rest saying something the file never said
+  [["fldChar", "instrText", "delInstrText"], FIELD_PIECE],
+  [
+    [
+      "sym",
+      "ptab",
+      "pgNum",
+      "pict",
+      "object",
+      "ruby",
+      "contentPart",
+      "annotationRef",
+      "footnoteRef",
+      "endnoteRef",
+      "separator",
+      "continuationSeparator",
+      "delText",
+      "dayShort",
+      "monthShort",
+      "yearShort",
+      "dayLong",
+      "monthLong",
+      "yearLong"
+    ],
+    RUN_CHIP
+  ]
+]);
+var PARAGRAPH_CHILDREN = [
+  [RANGE_MARKERS, HIDDEN_MARKER],
+  [PERMISSION_MARKERS, HIDDEN_MARKER],
+  [["proofErr"], IGNORABLE],
+  [REVISION_CONTAINERS, INLINE_CHIP],
+  [["fldSimple", "smartTag", "customXml", "dir", "bdo", "subDoc"], INLINE_CHIP]
+];
+var WRAPPER_ELEMENTS = WRAPPER_KINDS.map(
+  (kind) => kind.element
+);
+var PARAGRAPH_LEVEL = new Map([
+  ...rules([
+    [["pPr", "r"], MODEL],
+    [COMMENT_RANGE_MARKERS, MODEL],
+    ...PARAGRAPH_CHILDREN,
+    [WRAPPER_ELEMENTS, MODEL]
+  ]),
+  ...MATH.map((name) => [name, INLINE_CHIP])
+]);
+var WRAPPER_LEVEL = new Map([
+  ...rules([
+    [["r"], MODEL],
+    [COMMENT_RANGE_MARKERS, MODEL],
+    ...PARAGRAPH_CHILDREN,
+    [WRAPPER_ELEMENTS, MODEL]
+  ]),
+  ...MATH.map((name) => [name, INLINE_CHIP])
+]);
+var BLOCK_CHILDREN = [
+  [["p", "tbl"], MODEL],
+  [RANGE_MARKERS, HIDDEN_MARKER],
+  [COMMENT_RANGE_MARKERS, HIDDEN_MARKER],
+  [PERMISSION_MARKERS, HIDDEN_MARKER],
+  [["proofErr"], IGNORABLE],
+  [REVISION_CONTAINERS, BLOCK_CHIP],
+  [["sdt", "customXml", "altChunk"], BLOCK_CHIP]
+];
+var BODY_LEVEL = new Map([
+  ...rules([...BLOCK_CHILDREN, [["sectPr"], BLOCK_CHIP]]),
+  ...MATH.map((name) => [name, BLOCK_CHIP])
+]);
+var CELL_LEVEL = new Map([
+  ...rules([...BLOCK_CHILDREN, [["tcPr"], MODEL]]),
+  ...MATH.map((name) => [name, BLOCK_CHIP])
+]);
+var TABLE_LEVEL = rules([
+  [["tblPr", "tblGrid", "tr"], MODEL],
+  [RANGE_MARKERS, HIDDEN_MARKER],
+  [COMMENT_RANGE_MARKERS, HIDDEN_MARKER],
+  [PERMISSION_MARKERS, HIDDEN_MARKER],
+  [["proofErr"], IGNORABLE]
+]);
+var ROW_LEVEL = rules([
+  [["tblPrEx", "trPr", "tc", "sdt"], MODEL],
+  [RANGE_MARKERS, HIDDEN_MARKER],
+  [COMMENT_RANGE_MARKERS, HIDDEN_MARKER],
+  [PERMISSION_MARKERS, HIDDEN_MARKER],
+  [["proofErr"], IGNORABLE]
+]);
+var WML_POLICY = {
+  r: RUN_LEVEL,
+  p: PARAGRAPH_LEVEL,
+  wrapper: WRAPPER_LEVEL,
+  body: BODY_LEVEL,
+  tc: CELL_LEVEL,
+  tbl: TABLE_LEVEL,
+  tr: ROW_LEVEL
+};
+var LEVEL_PRESERVATION = {
+  r: RUN_CHIP,
+  p: INLINE_CHIP,
+  wrapper: INLINE_CHIP,
+  body: BLOCK_CHIP,
+  tc: BLOCK_CHIP
+};
+function defaultPreservation(level) {
+  return LEVEL_PRESERVATION[level];
+}
+var LEVEL_DEFAULTS = {
+  ...LEVEL_PRESERVATION,
+  tbl: { tier: "demote" },
+  tr: { tier: "demote" }
+};
+function policyFor(el, level) {
+  return WML_POLICY[level].get(clarkName(el)) ?? LEVEL_DEFAULTS[level];
+}
+function runContentText(el) {
+  const policy = policyFor(el, "r");
+  if (policy.tier === "model") {
+    switch (el.localName) {
+      case "t":
+        return el.textContent ?? "";
+      case "tab":
+        return "	";
+      case "br":
+        return "\n";
+      // A drawing and the three annotation references draw something that is not text
+      default:
+        return null;
+    }
+  }
+  if (policy.tier === "demote") return null;
+  if (policy.display === "break") return "\n";
+  return policy.display === "text" ? policy.text ?? null : null;
+}
+export {
+  WML_POLICY,
+  clarkName,
+  defaultPreservation,
+  policyFor,
+  runContentText
+};

package/dist/docx/importPreserved.d.ts

@@ -0,0 +1,30 @@
+/**
+ * One element kept exactly as it came, at whatever level of the document it stood.
+ *
+ * `./importPolicy` says what an element is worth keeping as; this is where that answer becomes a
+ * node. Every level has a node of its own - inside a run, beside the runs of a paragraph, and in
+ * the place of a block - so the three readers build them the same way and cannot drift apart in
+ * what a chip shows or which fragments a guard answers for.
+ */
+import type { Mark, Node as PMNode } from "prosemirror-model";
+import { type DemotionPolicy, type ElementPolicy, type PreservationRule, type PreservingLevel } from "./importPolicy";
+/**
+ * The rule an element is kept under.
+ *
+ * The level's own narrowest preservation stands in wherever the table said `model` and the reader
+ * could not read the element after all, so a structure it could not take apart costs that element
+ * and no more.
+ */
+export declare function preservationOf(policy: ElementPolicy | DemotionPolicy, level: PreservingLevel): PreservationRule;
+/** One child of a run kept as it came, wearing the run mark so it goes back inside that run */
+export declare function buildPreservedRunContent(el: Element, marks: readonly Mark[], rule: PreservationRule): PMNode;
+/** One child of a paragraph, or of a wrapper inside it, kept as it came */
+export declare function buildPreservedInline(el: Element, wrappers: readonly Mark[], rule: PreservationRule): PMNode;
+/**
+ * One block kept as it came, standing where it stood.
+ *
+ * A body block is one of the fragments the session holds, so it names that fragment and the bytes
+ * it arrived as go back out untouched. A block inside a cell was never a fragment of its own, so
+ * it carries its XML along with it.
+ */
+export declare function buildPreservedBlock(el: Element, srcId: string | null, level: "body" | "tc"): PMNode;

package/dist/docx/importPreserved.js

@@ -0,0 +1,54 @@
+// src/docx/importPreserved.ts
+import { serializeXml } from "../ooxml/xml.js";
+import { docxSchema } from "../schema/index.js";
+import {
+  defaultPreservation,
+  policyFor
+} from "./importPolicy.js";
+function preservedText(el, rule) {
+  if (rule.display === "text") return rule.text ?? null;
+  if (rule.display !== "chip") return null;
+  return el.textContent === "" ? null : el.textContent ?? null;
+}
+function preservedAttrs(el, rule) {
+  return {
+    xml: serializeXml(el),
+    element: el.localName,
+    display: rule.display,
+    text: preservedText(el, rule),
+    guarded: rule.guarded
+  };
+}
+function preservationOf(policy, level) {
+  return policy.tier === "model" || policy.tier === "demote" ? defaultPreservation(level) : policy;
+}
+function buildPreservedRunContent(el, marks, rule) {
+  return docxSchema.nodes.rawRunContent.create(
+    preservedAttrs(el, rule),
+    null,
+    marks
+  );
+}
+function buildPreservedInline(el, wrappers, rule) {
+  return docxSchema.nodes.rawInline.create(
+    preservedAttrs(el, rule),
+    null,
+    wrappers
+  );
+}
+function buildPreservedBlock(el, srcId, level) {
+  const rule = preservationOf(policyFor(el, level), level);
+  return docxSchema.nodes.rawBlock.create({
+    xml: srcId === null ? serializeXml(el) : null,
+    srcId,
+    name: el.nodeName,
+    display: rule.display,
+    guarded: rule.guarded
+  });
+}
+export {
+  buildPreservedBlock,
+  buildPreservedInline,
+  buildPreservedRunContent,
+  preservationOf
+};

package/dist/docx/importTable.js

@@ -18,6 +18,8 @@ import {
   buildParagraph,
   NO_IMPORT_SOURCES
 } from "./importParagraph.js";
+import { policyFor } from "./importPolicy.js";
+import { buildPreservedBlock } from "./importPreserved.js";
 import { readSdtWrapper } from "./sdt.js";
 import {
   cellConditionsOf,
@@ -39,6 +41,13 @@ import {
   readTableWidth,
   tblStyleIdOf
 } from "./tableFormatting.js";
+function isTransparent(el, level) {
+  const tier = policyFor(el, level).tier;
+  return tier === "marker" || tier === "ignorable";
+}
+function takeGathered(gathered) {
+  return gathered.length === 0 ? null : gathered.splice(0).join("");
+}
 function readGridSpan(tcPr) {
   const value = tcPr ? childValue(tcPr, "gridSpan") : null;
   const parsed = value === null ? null : Number.parseInt(value, 10);
@@ -67,27 +76,45 @@ function readSdtCell(el) {
     }
   };
 }
+function trailCell(cells, gathered) {
+  const xml = takeGathered(gathered);
+  if (xml === null) return true;
+  const last = cells.at(-1);
+  if (!last || last.vMerge === "continue") return false;
+  last.trailingXml = (last.trailingXml ?? "") + xml;
+  return true;
+}
 function readRow(el) {
   const cells = [];
+  const gathered = [];
   let tblPrEx = null;
+  let leadingXml = null;
   for (const child of elementChildren(el)) {
     if (child.localName === "trPr") continue;
     if (child.localName === "tblPrEx") {
       tblPrEx = child;
       continue;
     }
+    if (isTransparent(child, "tr")) {
+      gathered.push(serializeXml(child));
+      continue;
+    }
     const sdt = child.localName === "sdt" ? readSdtCell(child) : null;
     if (!sdt && child.localName !== "tc") return null;
+    if (cells.length === 0) leadingXml = takeGathered(gathered);
+    else if (!trailCell(cells, gathered)) return null;
     const tc = sdt ? sdt.el : child;
     const tcPr = childByLocalName(tc, "tcPr");
     cells.push({
       el: tc,
       gridSpan: readGridSpan(tcPr),
       vMerge: readVerticalMerge(tcPr),
-      control: sdt ? sdt.control : null
+      control: sdt ? sdt.control : null,
+      trailingXml: null
     });
   }
-  return cells.length > 0 ? { el, tblPrEx, cells } : null;
+  if (cells.length === 0 || !trailCell(cells, gathered)) return null;
+  return { el, tblPrEx, cells, leadingXml, trailingXml: null };
 }
 function gridRevisionXml(grid) {
   const revision = childByLocalName(grid, "tblGridChange");
@@ -107,6 +134,8 @@ function readTableParts(el) {
   let tblGrid = null;
   let gridChange = null;
   const rows = [];
+  const gathered = [];
+  let leadingXml = null;
   for (const child of elementChildren(el)) {
     if (child.localName === "tblPr") {
       tblPr = child;
@@ -117,12 +146,22 @@ function readTableParts(el) {
       gridChange = gridRevisionXml(child);
       continue;
     }
+    if (isTransparent(child, "tbl")) {
+      gathered.push(serializeXml(child));
+      continue;
+    }
     if (child.localName !== "tr") return null;
     const row = readRow(child);
     if (!row) return null;
+    const previous = rows.at(-1);
+    if (previous) previous.trailingXml = takeGathered(gathered);
+    else leadingXml = takeGathered(gathered);
     rows.push(row);
   }
-  return rows.length > 0 ? { tblPr, tblGrid, gridChange, rows } : null;
+  const last = rows.at(-1);
+  if (!last) return null;
+  last.trailingXml = takeGathered(gathered);
+  return { tblPr, tblGrid, gridChange, rows, leadingXml };
 }
 function resolveVerticalMerges(rows, width) {
   const drafts = [];
@@ -144,7 +183,8 @@ function resolveVerticalMerges(rows, width) {
           col,
           colspan: cell.gridSpan,
           rowspan: 1,
-          control: cell.control
+          control: cell.control,
+          trailingXml: cell.trailingXml
         };
         rowDrafts.push(draft);
         if (cell.vMerge === "restart") next.set(col, draft);
@@ -167,13 +207,13 @@ function gridWidthOf(rows) {
 }
 function buildCellBlock(el, sources, context, placement) {
   if (el.localName === "p") {
-    const paragraph = buildParagraph(el, null, sources);
-    if (paragraph) return styledParagraph(paragraph, context, placement);
+    return styledParagraph(
+      buildParagraph(el, null, sources),
+      context,
+      placement
+    );
   }
-  return docxSchema.nodes.rawBlock.create({
-    xml: serializeXml(el),
-    name: el.nodeName
-  });
+  return buildPreservedBlock(el, null, "tc");
 }
 function cellRect(draft) {
   return {
@@ -203,7 +243,8 @@ function buildCell(draft, table, sources, context) {
       format: readCellFormat(tcPr, defaults),
       sdtPrefix: draft.control?.prefix ?? null,
       sdtContentsLocked: draft.control?.contentsLocked ?? false,
-      sdtDeletionLocked: draft.control?.deletionLocked ?? false
+      sdtDeletionLocked: draft.control?.deletionLocked ?? false,
+      trailingXml: draft.trailingXml
     },
     blocks
   );
@@ -221,7 +262,9 @@ function buildRow(row, drafts, table, sources, context) {
       trAttrs: attrString(row.el),
       tblPrEx: row.tblPrEx ? serializeXml(row.tblPrEx) : null,
       trPr: trPr ? serializeXml(trPr) : null,
-      format: readRowFormat(trPr)
+      format: readRowFormat(trPr),
+      leadingXml: row.leadingXml,
+      trailingXml: row.trailingXml
     },
     cells
   );
@@ -278,6 +321,7 @@ function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, context = NO_FORMATT
       tblW: readTableWidth(parts.tblPr, "tblW"),
       gridCols,
       gridChange: parts.gridChange,
+      leadingXml: parts.leadingXml,
       ...tableStyleAttrs(parts.tblPr, context)
     },
     rows

package/dist/docx/invariants.js

@@ -6,6 +6,8 @@ import {
   W_NS,
   withXmlParser
 } from "../ooxml/xml.js";
+import { visitPreservedFragments } from "../schema/preservedFragments.js";
+import { unattributedCommentAuthors } from "../schema/protection.js";
 import {
   commentReferencesIn,
   commentsChanged,
@@ -24,30 +26,21 @@ import { identityProblems } from "./identities.js";
 import { insertedImageSrcs } from "./media.js";
 import { canDefineNewList, newNumIds, startedLists } from "./newLists.js";
 import { CONTENT_TYPES_PATH } from "./packageParts.js";
-import { lostOriginal } from "./serializeBlock.js";
+import { lostOriginal } from "./serializePreserved.js";
 import {
   originalBlock,
   sessionOf
 } from "./session.js";
-function markerSourceOf(node, session) {
-  if (node.type.name === "rawInline" || node.type.name === "rawBlock") {
-    return typeof node.attrs.xml === "string" ? node.attrs.xml : null;
-  }
-  if (node.type.isInGroup("preserved")) {
-    return originalBlock(node, session)?.xml ?? null;
-  }
-  return null;
-}
 var bookmarkPairs = {
   name: "bookmarkPairs",
   check(doc, session) {
     const problems = [];
     const open = /* @__PURE__ */ new Map();
     const used = /* @__PURE__ */ new Set();
-    doc.descendants((node, pos) => {
-      const source = markerSourceOf(node, session);
-      if (source === null) return true;
-      if (!source.includes("bookmark")) return true;
+    visitPreservedFragments(doc, (node, pos, xml) => {
+      const source = xml ?? originalBlock(node, session)?.xml ?? null;
+      if (source === null) return;
+      if (!source.includes("bookmark")) return;
       let root;
       try {
         root = parseXml(
@@ -59,7 +52,7 @@ var bookmarkPairs = {
           message: "preserved bookmark XML could not be parsed",
           pos
         });
-        return true;
+        return;
       }
       for (const marker of Array.from(root.getElementsByTagName("*"))) {
         if (marker.namespaceURI !== W_NS || marker.localName !== "bookmarkStart" && marker.localName !== "bookmarkEnd")
@@ -91,7 +84,6 @@ var bookmarkPairs = {
           });
         }
       }
-      return true;
     });
     for (const [id, pos] of open) {
       problems.push({
@@ -132,11 +124,16 @@ var tableGrids = {
     return problems;
   }
 };
+var CARRIES_ITS_XML = /* @__PURE__ */ new Set([
+  "rawInline",
+  "rawRunContent"
+]);
 function lostOriginalOf(node, session) {
-  if (node.type.name === "rawInline" || node.type.name === "rawBlock") {
+  if (CARRIES_ITS_XML.has(node.type.name)) {
     return typeof node.attrs.xml === "string" ? null : "a preserved element has lost its original XML";
   }
   if (node.type.isInGroup("preserved")) {
+    if (typeof node.attrs.xml === "string") return null;
     return originalBlock(node, session) ? null : lostOriginal(node, session);
   }
   return null;
@@ -191,7 +188,8 @@ function addsCommentsPart(doc, session) {
     return true;
   return bodyChanged && (peoplePart.pathIn(session) === null || session.comments.people.xml === null) && unrecordedAuthors(
     currentCommentBodies(references).values(),
-    session.comments.people
+    session.comments.people,
+    unattributedCommentAuthors(session.comments.ordered)
   ).size > 0;
 }
 var mediaContentTypes = {

package/dist/docx/notes.d.ts

@@ -1,14 +1,19 @@
 /** Reads footnote and endnote bodies related from the main document story. */
 export type NoteKind = "footnote" | "endnote";
+/**
+ * One entry of a notes part as it arrived. What the note says is a story of its own, held on the
+ * document node under `footnote:<id>` or `endnote:<id>` (`docx/story`).
+ */
 export interface ImportedNote {
     kind: NoteKind;
     id: string;
     label: string;
-    text: string;
     type: string | null;
 }
 export interface ImportedNotePart {
     partPath: string | null;
+    /** The raw text of the part, which is what the note stories are sliced out of. null for none */
+    xml: string | null;
     ordered: readonly ImportedNote[];
     byId: ReadonlyMap<string, ImportedNote>;
 }

package/dist/docx/notes.js

@@ -4,12 +4,12 @@ import {
   decodeUtf8,
   elementChildren,
   parseXml,
-  R_NS,
-  W_NS
+  R_NS
 } from "../ooxml/xml.js";
 import { relatedPartPath } from "./packageParts.js";
 var EMPTY_PART = {
   partPath: null,
+  xml: null,
   ordered: [],
   byId: /* @__PURE__ */ new Map()
 };
@@ -17,23 +17,13 @@ var NO_NOTES = {
   footnotes: EMPTY_PART,
   endnotes: EMPTY_PART
 };
-function inlineText(node) {
-  if (node.localName === "t") return node.textContent ?? "";
-  if (node.localName === "tab") return "	";
-  if (node.localName === "br" || node.localName === "cr") return "\n";
-  if (node.localName === "noBreakHyphen") return "\u2011";
-  if (node.localName === "softHyphen") return "\xAD";
-  return elementChildren(node).map(inlineText).join("");
-}
-function noteText(el) {
-  return Array.from(el.getElementsByTagNameNS(W_NS, "p")).map(inlineText).join("\n");
-}
 function notePart(parts, mainPartPath, kind) {
   const partPath = relatedPartPath(parts, mainPartPath, `${R_NS}/${kind}s`);
   if (partPath === null) return EMPTY_PART;
   const bytes = parts.get(partPath);
   if (!bytes) return { ...EMPTY_PART, partPath };
-  const root = parseXml(decodeUtf8(bytes).text).documentElement;
+  const xml = decodeUtf8(bytes).text;
+  const root = parseXml(xml).documentElement;
   const elements = elementChildren(root).filter((el) => el.localName === kind);
   const ordered = elements.flatMap((el) => {
     const id = attributeByLocalName(el, "id");
@@ -41,13 +31,13 @@ function notePart(parts, mainPartPath, kind) {
     const type = attributeByLocalName(el, "type");
     const regular = type === null || type === "normal";
     const label = regular ? "?" : "";
-    return [{ kind, id, label, text: noteText(el), type }];
+    return [{ kind, id, label, type }];
   });
   const byId = /* @__PURE__ */ new Map();
   for (const note of ordered) {
     if (!byId.has(note.id)) byId.set(note.id, note);
   }
-  return { partPath, ordered, byId };
+  return { partPath, xml, ordered, byId };
 }
 function readNotes(parts, mainPartPath) {
   return {

package/dist/docx/pageGeometry.d.ts

@@ -1,8 +1,8 @@
 /**
  * The paper a document is written on: its size and its margins.
  *
- * A document says so in the `w:sectPr` at the end of its body. The values are read for the screen
- * only: the `w:sectPr` itself rides out with the rest of the preserved tail, so what a document
+ * A document says so in a `w:sectPr`, one per section (`./sections`). The values are read for the
+ * screen only: the `w:sectPr` itself rides out as the text it arrived as, so what a document
  * declares is never rewritten from these numbers.
  *
  * Everything here is in twips (1/1440 inch), the unit `w:pgSz` and `w:pgMar` are written in.
@@ -35,6 +35,9 @@ export declare const A4_PORTRAIT: PageGeometry;
 /**
  * The geometry a `w:sectPr` element lays down, with anything it leaves unsaid taken from A4.
  *
+ * The reading is deliberately forgiving: it runs against a document already opened, and a
+ * `w:sectPr` that cannot be read is a reason to draw A4, never a reason to refuse the file.
+ *
  * `w:orient` is not applied on top of the size: Word writes the width and the height already
  * swapped for a landscape section, so honouring both would turn the paper back upright.
  */
@@ -63,15 +66,3 @@ export declare function bodyWidth(geometry: PageGeometry): BodyWidth;
  * It is what a caller with no document to ask still gets: 11906 - 1247 * 2 = 9412 dxa.
  */
 export declare const A4_BODY_WIDTH: BodyWidth;
-/**
- * The geometry of the first section of an already parsed body.
- *
- * A document may hold a `w:sectPr` per section, each with a paper of its own. The screen draws
- * one paper for the whole document, so the first section decides it; the rest ride out
- * untouched in their preserved blocks and are drawn on the first section's paper.
- * `site/content/docs/features.mdx` records that limit.
- *
- * The reading is deliberately forgiving: this runs against a document already opened, and a
- * `w:sectPr` we cannot read is a reason to draw A4, never a reason to refuse the file.
- */
-export declare function readBodyGeometry(body: Element): PageGeometry;

package/dist/docx/pageGeometry.js

@@ -73,17 +73,6 @@ function bodyWidth(geometry) {
   return { twips, px: twipsToPx(twips) };
 }
 var A4_BODY_WIDTH = bodyWidth(A4_PORTRAIT);
-function readBodyGeometry(body) {
-  return readPageGeometry(firstSectPrIn(body));
-}
-function firstSectPrIn(root) {
-  const found = root.getElementsByTagName("w:sectPr").item(0);
-  if (found) return found;
-  for (const el of root.getElementsByTagName("*")) {
-    if (el.localName === "sectPr") return el;
-  }
-  return null;
-}
 export {
   A4_BODY_WIDTH,
   A4_PORTRAIT,
@@ -91,7 +80,6 @@ export {
   bodyHeightTwips,
   bodyWidth,
   bodyWidthTwips,
-  readBodyGeometry,
   readPageGeometry,
   twipsToPx
 };