reamkit 1.15.0 → 1.15.2

package/dist/esm/pptx/slide-parser.js

@@ -21,6 +21,17 @@ var RECT_GEOMETRY = {
 	adjust: /* @__PURE__ */ new Map()
 };
 var IDENTITY_TRANSFORM = (box) => box;
+/**
+* Walk a shape container (`p:spTree` or a `p:grpSp`), turning each `p:sp` into a
+* floating text/graphic shape, each `p:pic` into a floating image, each
+* `p:graphicFrame` into a chart/table, and recursing into nested `p:grpSp` groups
+* (composing their transforms).
+*
+* @param container The shape container node.
+* @param ctx       The per-slide parsing context.
+* @param transform Maps child-space boxes to the slide (identity at the top level).
+* @returns The container's shapes as positioned {@link BodyElement}s.
+*/
 function parseSlideShapes(container, ctx = {}, transform = IDENTITY_TRANSFORM) {
 	const out = [];
 	for (const child of poChildren(container)) if (poIs(child, "p:sp")) {
@@ -148,6 +159,16 @@ function parseGraphicFrame(gf, ctx, transform) {
 	}
 	return [];
 }
+/**
+* The diagram's child shapes live in the spTree's own coordinate space
+* (`dsp:grpSpPr/a:xfrm` `chOff`/`chExt`); map that onto a target box (the frame on
+* a slide, or the inline/anchored box in docx). Usually the child space equals
+* the box, so the scale is 1. Shared by pptx and docx (E-SMARTART).
+*
+* @param spTree The diagram drawing's `dsp:spTree`.
+* @param frame  The target box the diagram is placed into.
+* @returns A transform mapping diagram-space boxes onto `frame`.
+*/
 function diagramTransform(spTree, frame) {
 	const grpSpPr = poChildren(spTree).find((c) => poIs(c, "dsp:grpSpPr"));
 	const xfrm = grpSpPr ? poChildren(grpSpPr).find((c) => poIs(c, "a:xfrm")) : void 0;
@@ -166,6 +187,16 @@ function diagramTransform(spTree, frame) {
 		cy: b.cy * sy
 	});
 }
+/**
+* A {@link Loss} for a SmartArt diagram that declares its data part but ships no
+* pre-rendered drawing override (older files, or a generator that omitted the
+* fallback). Ream renders the override rather than executing Office's layout
+* engine, so without it the diagram can't be drawn — this records the gap as a
+* dropped feature instead of letting it vanish. Shared by pptx and docx
+* (E-SMARTART SA3).
+*
+* @param where Optional location tag for the loss report (e.g. `slide 3`).
+*/
 function noDiagramOverrideLoss(where) {
 	return {
 		severity: "dropped",
@@ -174,6 +205,20 @@ function noDiagramOverrideLoss(where) {
 		...where ? { where } : {}
 	};
 }
+/**
+* Render a SmartArt drawing override (a `dsp:spTree`) into floating shapes. The
+* `dsp:` wrapper holds an ordinary `a:` `spPr`/`txBody`, so the shared DrawingML
+* readers apply unchanged. Shared by pptx and docx (E-SMARTART); diagrams carry
+* no placeholder cascade.
+*
+* @param spTree      The diagram drawing's `dsp:spTree`.
+* @param transform   Maps each shape's diagram-space box to the target space.
+* @param makeFloat   Anchors a box — page-relative for a slide, column/paragraph-
+*                    relative for an inline docx diagram.
+* @param colors      The colour resolver for the shapes' fills/strokes/text.
+* @param resolveLink A run hyperlink resolver, or `undefined`.
+* @returns The diagram's visible shapes as positioned {@link ShapeBlock}s.
+*/
 function parseDiagramDrawing(spTree, transform, makeFloat, colors, resolveLink) {
 	const out = [];
 	for (const sp of poChildren(spTree)) {
@@ -202,6 +247,13 @@ function parseDiagramDrawing(spTree, transform, makeFloat, colors, resolveLink)
 	}
 	return out;
 }
+/**
+* `p:bg` → the background fill, or `undefined` when none/unsupported. `p:bgPr`
+* carries the fill directly (`a:solidFill`/`a:gradFill` — the same children
+* `parseFill` reads; a picture background is not yet supported); `p:bgRef` (a
+* theme fill-style index) is approximated by its colour child as a solid fill.
+* Used for the slide's own background and the inherited layout/master one (PX5b).
+*/
 function parseBackgroundFill(bg, colors) {
 	const bgPr = poChildren(bg).find((c) => poIs(c, "p:bgPr"));
 	if (bgPr) {
@@ -217,6 +269,14 @@ function parseBackgroundFill(bg, colors) {
 		};
 	}
 }
+/**
+* A full-slide backdrop element for a background fill: a rectangle covering the
+* page, anchored behind the content (PX5b).
+*
+* @param fill     The resolved background fill.
+* @param widthPt  The page width in points.
+* @param heightPt The page height in points.
+*/
 function backdropElement(fill, widthPt, heightPt) {
 	return {
 		kind: "shape",
@@ -241,6 +301,11 @@ function backdropElement(fill, widthPt, heightPt) {
 		}
 	};
 }
+/**
+* `p:spPr` geometry: `a:prstGeom` (preset) or `a:custGeom` (custom path), default
+* rect. Exported for sheet shapes (E-SHEET W2), whose `xdr:spPr` carries the same
+* `a:` children.
+*/
 function parseGeometry(spPr) {
 	if (!spPr) return RECT_GEOMETRY;
 	const prst = poChildren(spPr).find((c) => poIs(c, "a:prstGeom"));
@@ -286,6 +351,19 @@ function txBodyParagraphs(txBody, ph, cascade, colors, resolveLink) {
 	}
 	return content;
 }
+/**
+* `p:txBody` → {@link ShapeTextBody}. `a:bodyPr` carries the insets and the
+* vertical anchor (PX6: anchor `t`/`ctr`/`b`). Exported for sheet shapes
+* (E-SHEET W2) — like SmartArt, they pass no placeholder cascade, so runs use
+* their direct `a:rPr` formatting.
+*
+* @param txBody      The `p:txBody` node.
+* @param ph          The owning placeholder ref, when this is a placeholder shape.
+* @param cascade     The placeholder cascade supplying inherited run defaults.
+* @param colors      The colour resolver for run colours.
+* @param resolveLink A run hyperlink resolver, or `undefined`.
+* @returns The text body, or `undefined` when it holds no paragraphs.
+*/
 function parseTxBody(txBody, ph, cascade, colors, resolveLink) {
 	const content = txBodyParagraphs(txBody, ph, cascade, colors, resolveLink);
 	if (content.length === 0) return void 0;

package/dist/esm/pptx/sp-helpers.d.ts

@@ -1,17 +1,45 @@
 import { RunProperties } from '../core/document-model/index.js';
 import { ColorResolver } from '../core/drawingml/colors.js';
 import { PoNode } from '../core/po-helpers.js';
+/**
+ * §19.3.1.36 `p:ph` — a shape's placeholder reference. `type`/`idx` tie a slide
+ * shape to the matching prototype in its layout and master.
+ */
 export interface PlaceholderRef {
+    /** The placeholder type, e.g. `'title'`, `'ctrTitle'`, `'subTitle'`, `'body'`, `'obj'`. */
     readonly type?: string;
     readonly idx?: string;
 }
+/** An `a:xfrm` box in EMU (`off` + `ext`). */
 export interface ShapeBoxEmu {
     readonly x: number;
     readonly y: number;
     readonly cx: number;
     readonly cy: number;
 }
+/**
+ * `p:nvSpPr/p:nvPr/p:ph` → the placeholder reference, or `undefined` for an
+ * ordinary (non-placeholder) shape. A bare `<p:ph/>` returns an empty ref (still
+ * a placeholder: `type` defaults to `'obj'`).
+ */
 export declare function parsePh(sp: PoNode): PlaceholderRef | undefined;
+/**
+ * An xfrm node (`a:off` + `a:ext` children) → the EMU box. Works for both
+ * `a:xfrm` (in `p:spPr`) and `p:xfrm` (on a `p:graphicFrame`), whose children are
+ * identical. Returns `undefined` for a missing or degenerate (non-positive)
+ * extent.
+ */
 export declare function boxFromXfrm(xfrm: PoNode | undefined): ShapeBoxEmu | undefined;
+/**
+ * `p:spPr/a:xfrm` → the EMU box, or `undefined` when the shape carries no
+ * explicit transform (a placeholder that inherits it from the layout/master).
+ */
 export declare function parseXfrmBox(spPr: PoNode | undefined): ShapeBoxEmu | undefined;
+/**
+ * `a:rPr` / `a:defRPr` → {@link RunProperties}. Both the direct run formatting on
+ * a slide (`a:rPr`) and the per-level defaults in a master's `p:txStyles`
+ * (`a:defRPr`) share this element, so the cascade reuses the same reader: size
+ * (`sz`, hundredths of a point), bold/italic/underline, solid colour and the
+ * latin typeface. Scheme colours and the theme font cascade come in PX5.
+ */
 export declare function rPrToRunProps(rPr: PoNode | undefined, colors: ColorResolver): RunProperties;

package/dist/esm/pptx/sp-helpers.js

@@ -3,6 +3,11 @@ import { poAttr, poChildren, poIntAttr, poIs } from "../core/po-helpers.js";
 import { resolveColorNode } from "../core/drawingml/colors.js";
 //#region src/pptx/sp-helpers.ts
 var isTrue = (v) => v === "1" || v === "true" || v === "on";
+/**
+* `p:nvSpPr/p:nvPr/p:ph` → the placeholder reference, or `undefined` for an
+* ordinary (non-placeholder) shape. A bare `<p:ph/>` returns an empty ref (still
+* a placeholder: `type` defaults to `'obj'`).
+*/
 function parsePh(sp) {
 	const nvSpPr = poChildren(sp).find((c) => poIs(c, "p:nvSpPr"));
 	const nvPr = nvSpPr ? poChildren(nvSpPr).find((c) => poIs(c, "p:nvPr")) : void 0;
@@ -15,6 +20,12 @@ function parsePh(sp) {
 		...idx !== void 0 ? { idx } : {}
 	};
 }
+/**
+* An xfrm node (`a:off` + `a:ext` children) → the EMU box. Works for both
+* `a:xfrm` (in `p:spPr`) and `p:xfrm` (on a `p:graphicFrame`), whose children are
+* identical. Returns `undefined` for a missing or degenerate (non-positive)
+* extent.
+*/
 function boxFromXfrm(xfrm) {
 	if (!xfrm) return void 0;
 	const off = poChildren(xfrm).find((c) => poIs(c, "a:off"));
@@ -29,9 +40,20 @@ function boxFromXfrm(xfrm) {
 		cy
 	};
 }
+/**
+* `p:spPr/a:xfrm` → the EMU box, or `undefined` when the shape carries no
+* explicit transform (a placeholder that inherits it from the layout/master).
+*/
 function parseXfrmBox(spPr) {
 	return boxFromXfrm(spPr ? poChildren(spPr).find((c) => poIs(c, "a:xfrm")) : void 0);
 }
+/**
+* `a:rPr` / `a:defRPr` → {@link RunProperties}. Both the direct run formatting on
+* a slide (`a:rPr`) and the per-level defaults in a master's `p:txStyles`
+* (`a:defRPr`) share this element, so the cascade reuses the same reader: size
+* (`sz`, hundredths of a point), bold/italic/underline, solid colour and the
+* latin typeface. Scheme colours and the theme font cascade come in PX5.
+*/
 function rPrToRunProps(rPr, colors) {
 	if (!rPr) return {};
 	const sz = poIntAttr(rPr, "sz");

package/dist/esm/svg/svg-writer.d.ts

@@ -1,8 +1,25 @@
 import { DocumentWriter, WriteResult } from '../core/ir/adapters.js';
 import { LaidOutDocument } from '../layout/page-doc.js';
+/** Options for {@link writeSvg}. */
 export interface SvgWriteOptions {
     /** Gap between stacked pages, in px/pt (default 12). */
     readonly pageGap?: number;
 }
+/**
+ * Render a {@link LaidOutDocument} to a single SVG preview (ir-design §7 /
+ * stage 6). Written purely against the PageDoc schema; knows nothing about OOXML
+ * or the PDF writer. PageItem coordinates are already top-left/y-down — SVG's own
+ * frame — so they are emitted verbatim. Pages stack vertically in one `<svg>`,
+ * separated by {@link SvgWriteOptions.pageGap}, each on a white outlined rect so
+ * they read as pages.
+ *
+ * @param laid The laid-out, paginated document from the layout engine.
+ * @param opts Optional page-gap override.
+ * @returns The encoded SVG bytes plus the recorded {@link Loss} list.
+ */
 export declare function writeSvg(laid: LaidOutDocument, opts?: SvgWriteOptions): WriteResult;
+/**
+ * The page-medium {@link DocumentWriter} adapter (id `'svg'`), wrapping
+ * {@link writeSvg}, with the set of {@link FEATURES} it renders.
+ */
 export declare const svgWriter: DocumentWriter<LaidOutDocument>;

package/dist/esm/svg/svg-writer.js

@@ -5,6 +5,18 @@ import { paintPlan } from "../layout/page-doc.js";
 import { toBase64 } from "../core/bytes.js";
 //#region src/svg/svg-writer.ts
 var PAGE_GAP = 12;
+/**
+* Render a {@link LaidOutDocument} to a single SVG preview (ir-design §7 /
+* stage 6). Written purely against the PageDoc schema; knows nothing about OOXML
+* or the PDF writer. PageItem coordinates are already top-left/y-down — SVG's own
+* frame — so they are emitted verbatim. Pages stack vertically in one `<svg>`,
+* separated by {@link SvgWriteOptions.pageGap}, each on a white outlined rect so
+* they read as pages.
+*
+* @param laid The laid-out, paginated document from the layout engine.
+* @param opts Optional page-gap override.
+* @returns The encoded SVG bytes plus the recorded {@link Loss} list.
+*/
 function writeSvg(laid, opts = {}) {
 	const gap = opts.pageGap ?? PAGE_GAP;
 	const losses = [];
@@ -27,6 +39,10 @@ function writeSvg(laid, opts = {}) {
 		losses
 	};
 }
+/**
+* The page-medium {@link DocumentWriter} adapter (id `'svg'`), wrapping
+* {@link writeSvg}, with the set of {@link FEATURES} it renders.
+*/
 var svgWriter = {
 	id: "svg",
 	consumes: "page",

package/dist/esm/word/doc/doc-reader.d.ts

@@ -1,4 +1,20 @@
 import { DocumentReader, ReadResult } from '../../core/ir/adapters.js';
 import { FlowDoc } from '../../core/ir/flow.js';
+/**
+ * Read a legacy Word 97–2003 `.doc` (DOC-1..11) into the same {@link FlowDoc} the
+ * OOXML docx reader produces: paragraphs of formatted runs, tables (column widths,
+ * cell borders, vertical merges, shading), inline images, list items, the first
+ * section's page size and the section's headers/footers. The text + formatting is
+ * read; drawing shapes / text boxes and comments are not, so a `degraded` (or
+ * `dropped`, for an encrypted file) {@link Loss} is reported.
+ *
+ * @param bytes The `.doc` (OLE2/CFB) bytes.
+ * @returns The projected {@link FlowDoc} and the read loss(es).
+ */
 export declare function readDoc(bytes: Uint8Array): ReadResult<FlowDoc>;
+/**
+ * The {@link DocumentReader} for legacy `.doc`: sniffs a Word 97–2003 binary (a
+ * CFB with a `WordDocument` stream) and reads it via {@link readDoc} into a
+ * {@link FlowDoc}.
+ */
 export declare const docReader: DocumentReader<FlowDoc>;

package/dist/esm/word/doc/doc-reader.js

@@ -114,6 +114,17 @@ var DOC_ENCRYPTED_LOSS = {
 	feature: FEATURES.text,
 	detail: "legacy .doc is encrypted/obfuscated — its text cannot be read"
 };
+/**
+* Read a legacy Word 97–2003 `.doc` (DOC-1..11) into the same {@link FlowDoc} the
+* OOXML docx reader produces: paragraphs of formatted runs, tables (column widths,
+* cell borders, vertical merges, shading), inline images, list items, the first
+* section's page size and the section's headers/footers. The text + formatting is
+* read; drawing shapes / text boxes and comments are not, so a `degraded` (or
+* `dropped`, for an encrypted file) {@link Loss} is reported.
+*
+* @param bytes The `.doc` (OLE2/CFB) bytes.
+* @returns The projected {@link FlowDoc} and the read loss(es).
+*/
 function readDoc(bytes) {
 	const content = extractDocContent(bytes);
 	const resources = new ResourceStore();
@@ -140,16 +151,22 @@ function readDoc(bytes) {
 		addStory(hf.firstFooter, "footer", "first");
 		addStory(hf.evenFooter, "footer", "even");
 	}
+	const ps = content.pageSize;
+	const pageSize = ps ? {
+		width: pt(ps.widthPt),
+		height: pt(ps.heightPt),
+		orientation: ps.widthPt > ps.heightPt ? "landscape" : "portrait"
+	} : {
+		width: pt(612),
+		height: pt(792)
+	};
 	return {
 		doc: {
 			kind: "flow",
 			body: resolveBodyStyles(body, EMPTY_STYLE_SHEET),
 			sections: [],
 			section: {
-				pageSize: {
-					width: pt(612),
-					height: pt(792)
-				},
+				pageSize,
 				margins: {
 					top: pt(72),
 					right: pt(72),
@@ -410,6 +427,11 @@ function alignmentFromJc(jc) {
 		default: return;
 	}
 }
+/**
+* The {@link DocumentReader} for legacy `.doc`: sniffs a Word 97–2003 binary (a
+* CFB with a `WordDocument` stream) and reads it via {@link readDoc} into a
+* {@link FlowDoc}.
+*/
 var docReader = {
 	id: "doc",
 	produces: "flow",

package/dist/esm/word/doc/doc-text.d.ts

@@ -1,21 +1,37 @@
+/** Run (character) formatting decoded from a CHPX grpprl. */
 export interface DocCharProps {
     readonly bold?: boolean;
     readonly italic?: boolean;
+    /** Word `kul` underline code (0 = none). */
     readonly underlineKul?: number;
+    /** Font size in half-points. */
     readonly sizeHalfPts?: number;
+    /** The character is special — `sprmCFSpec` (e.g. a picture placeholder). */
     readonly fSpec?: boolean;
+    /** `sprmCPicLocation` — offset into the `Data` stream of the picture's PICF. */
     readonly picOffset?: number;
 }
+/** An embedded picture: the extracted image bytes and its display size (twips). */
 export interface DocPicture {
     readonly bytes: Uint8Array;
     readonly widthTwips: number;
     readonly heightTwips: number;
 }
+/**
+ * One cell border (DOC-11) from a Brc80: its width in points, colour and whether
+ * it is a double line. Absent when the cell edge has no border.
+ */
 export interface DocBorder {
     readonly widthPt: number;
     readonly colorHex: string;
+    /** The border is a double line (`brcType` 0x03). */
     readonly double?: boolean;
 }
+/**
+ * A table cell's TC80 descriptor (DOC-11): its four edge borders and its
+ * vertical-merge marker (`restart` = the top of a vertical span, `continue` = a
+ * cell merged into the one above). Carried per cell on the row's TTP.
+ */
 export interface DocTc {
     readonly borders?: {
         readonly top?: DocBorder;
@@ -25,31 +41,62 @@ export interface DocTc {
     };
     readonly vMerge?: 'restart' | 'continue';
 }
+/** Paragraph formatting decoded from a PAPX grpprl. */
 export interface DocParaProps {
+    /** Word justification (0 left, 1 center, 2 right, 3 both, 4 distribute). */
     readonly jc?: number;
     readonly indentLeftTwips?: number;
     readonly indentRightTwips?: number;
+    /** First-line indent, signed (negative = hanging). */
     readonly indentFirstTwips?: number;
     readonly spaceBeforeTwips?: number;
     readonly spaceAfterTwips?: number;
+    /** The paragraph is in a table — `sprmPFInTable`. */
     readonly inTable?: boolean;
+    /** This is the row's terminating paragraph (TTP) — `sprmPFTtp`. */
     readonly rowEnd?: boolean;
+    /**
+     * `sprmTDefTable` rgdxaCenter — the (cols+1) cell-boundary x-positions (twips);
+     * present on the TTP. Cell `i` width = `edge[i+1] − edge[i]`.
+     */
     readonly cellEdgesTwips?: ReadonlyArray<number>;
+    /**
+     * `sprmTDefTable` TC80 per-cell descriptors (borders + vertical merge), one per
+     * cell, present on the TTP alongside `cellEdgesTwips` (DOC-11).
+     */
     readonly cellDescriptors?: ReadonlyArray<DocTc>;
+    /**
+     * `sprmTDefTableShd` — each cell's background fill hex (cvBack), or `undefined`
+     * for an auto (no-fill) cell. Indexed parallel to `cellDescriptors`.
+     */
     readonly cellShadings?: ReadonlyArray<string | undefined>;
+    /** `sprmPIlfo` — list-format override index (>0 ⇒ the paragraph is a list item). */
     readonly listIlfo?: number;
+    /** `sprmPIlvl` — list level (0–8). */
     readonly listIlvl?: number;
 }
+/** One maximal same-formatting run of text, or an embedded picture. */
 export interface DocRun {
     readonly text: string;
     readonly props: DocCharProps;
+    /** Set instead of `text` when the run is an embedded picture. */
     readonly picture?: DocPicture;
 }
+/** One paragraph: its runs plus the decoded paragraph properties. */
 export interface DocParagraph {
     readonly runs: ReadonlyArray<DocRun>;
     readonly props: DocParaProps;
+    /**
+     * The paragraph was ended by a cell mark (0x07) rather than a CR — i.e. it
+     * closes a table cell. With `props.rowEnd` it also closes the row.
+     */
     readonly cellMark?: boolean;
 }
+/**
+ * The section's header/footer stories (best-effort: the binary story ordering
+ * cannot be validated against a real file, so only well-formed, non-empty stories
+ * are surfaced). `default` is the odd-page (primary) header/footer.
+ */
 export interface DocHeaderFooters {
     readonly defaultHeader?: ReadonlyArray<DocParagraph>;
     readonly defaultFooter?: ReadonlyArray<DocParagraph>;
@@ -58,11 +105,21 @@ export interface DocHeaderFooters {
     readonly evenHeader?: ReadonlyArray<DocParagraph>;
     readonly evenFooter?: ReadonlyArray<DocParagraph>;
 }
+/**
+ * One list level (LVL) — the format of its number (DOC-10). `nfc` is the MSONFC
+ * code (0 arabic, 1/2 upper/lower roman, 3/4 upper/lower letter, 23 bullet, 0xFF
+ * none); `xst` is the number-text template as UTF-16 code units, where a code unit
+ * ≤ 8 is a placeholder for the number of that (zero-based) level.
+ */
 export interface DocLvl {
     readonly nfc: number;
     readonly iStartAt: number;
     readonly xst: ReadonlyArray<number>;
 }
+/**
+ * The document's list tables (DOC-10): an LFO → lsid map (a paragraph's 1-based
+ * `sprmPIlfo` indexes it) and, per lsid, the list's levels.
+ */
 export interface DocListTables {
     readonly lfoLsids: ReadonlyArray<number>;
     readonly lists: ReadonlyMap<number, {
@@ -70,10 +127,34 @@ export interface DocListTables {
         readonly levels: ReadonlyArray<DocLvl>;
     }>;
 }
+/** Everything extracted from a `.doc`'s `WordDocument` stream. */
 export interface DocContent {
     readonly paragraphs: ReadonlyArray<DocParagraph>;
     readonly headerFooters?: DocHeaderFooters;
+    /** The list tables resolving a paragraph's (ilfo, ilvl) to its number format. */
     readonly listTables?: DocListTables;
+    /**
+     * The first section's page size in points (xaPage/yaPage from its SEP), when
+     * present and sane; absent ⇒ the reader's default (US Letter) applies.
+     */
+    readonly pageSize?: {
+        readonly widthPt: number;
+        readonly heightPt: number;
+    };
+    /** The file is encrypted/obfuscated — text cannot be read without the key. */
     readonly encrypted: boolean;
 }
+/**
+ * Extract a `.doc`'s `WordDocument` stream into its main-document paragraphs plus
+ * the section's header/footer stories, list tables and first-section page size.
+ * Joins the piece table (CLX → CPs/FCs), CHPX run formatting and PAPX paragraph
+ * formatting, splitting at the CR / cell marks. Every offset is bounds-checked, so
+ * a structurally odd file yields no text rather than throwing.
+ *
+ * @param bytes The `.doc` (OLE2/CFB) bytes.
+ * @returns The extracted {@link DocContent}; `encrypted` is set (with no
+ *   paragraphs) for an encrypted file, and an empty result is returned when the
+ *   stream is missing, not a Word file, or has no piece table (Word 6/95 is out of
+ *   scope).
+ */
 export declare function extractDocContent(bytes: Uint8Array): DocContent;

package/dist/esm/word/doc/doc-text.js

@@ -13,6 +13,8 @@ var OFF_FCPLCFBTEPAPX = 258;
 var OFF_LCBPLCFBTEPAPX = 262;
 var OFF_FCCLX = 418;
 var OFF_LCBCLX = 422;
+var OFF_FCPLCFSED = 202;
+var OFF_LCBPLCFSED = 206;
 var OFF_FCPLFLST = 738;
 var OFF_LCBPLFLST = 742;
 var OFF_FCPLFLFO = 746;
@@ -43,6 +45,9 @@ var SPRM_T_DEF_TABLE_SHD = 54802;
 var MAX_ROW_CELLS = 256;
 var SPRM_P_ILVL = 9738;
 var SPRM_P_ILFO = 17931;
+var SPRM_S_XA_PAGE = 45087;
+var SPRM_S_YA_PAGE = 45088;
+var MAX_PAGE_TWIPS = 31680;
 var SPRA_LEN = [
 	1,
 	1,
@@ -63,6 +68,37 @@ var EMPTY = {
 	paragraphs: [],
 	encrypted: false
 };
+function readSectionPageSize(wd, table) {
+	const fc = u32(wd, OFF_FCPLCFSED);
+	const lcb = u32(wd, OFF_LCBPLCFSED);
+	if (lcb < 20 || fc + lcb > table.length) return void 0;
+	const fcSepx = u32(table.subarray(fc, fc + lcb), (Math.floor((lcb - 4) / 16) + 1) * 4 + 2);
+	if (fcSepx === 4294967295 || fcSepx + 2 > wd.length) return void 0;
+	const cb = u16(wd, fcSepx);
+	const grpprl = wd.subarray(fcSepx + 2, Math.min(wd.length, fcSepx + 2 + cb));
+	let xa = 0;
+	let ya = 0;
+	for (const { sprm, op } of sprms(grpprl)) if (sprm === SPRM_S_XA_PAGE) xa = u16(grpprl, op);
+	else if (sprm === SPRM_S_YA_PAGE) ya = u16(grpprl, op);
+	if (xa < 1 || ya < 1 || xa > MAX_PAGE_TWIPS || ya > MAX_PAGE_TWIPS) return void 0;
+	return {
+		widthPt: xa / 20,
+		heightPt: ya / 20
+	};
+}
+/**
+* Extract a `.doc`'s `WordDocument` stream into its main-document paragraphs plus
+* the section's header/footer stories, list tables and first-section page size.
+* Joins the piece table (CLX → CPs/FCs), CHPX run formatting and PAPX paragraph
+* formatting, splitting at the CR / cell marks. Every offset is bounds-checked, so
+* a structurally odd file yields no text rather than throwing.
+*
+* @param bytes The `.doc` (OLE2/CFB) bytes.
+* @returns The extracted {@link DocContent}; `encrypted` is set (with no
+*   paragraphs) for an encrypted file, and an empty result is returned when the
+*   stream is missing, not a Word file, or has no piece table (Word 6/95 is out of
+*   scope).
+*/
 function extractDocContent(bytes) {
 	const cfb = openCfb(bytes);
 	const wd = cfb.readStream("WordDocument");
@@ -89,10 +125,12 @@ function extractDocContent(bytes) {
 	const main = buildParagraphs(wd, pieces, chpx, papx, 0, ccpText, data);
 	const headerFooters = extractHeaderFooters(wd, table, pieces, chpx, papx, data, ccpText);
 	const listTables = parseListTables(wd, table);
+	const pageSize = readSectionPageSize(wd, table);
 	return {
 		paragraphs: main,
 		...headerFooters ? { headerFooters } : {},
 		...listTables ? { listTables } : {},
+		...pageSize ? { pageSize } : {},
 		encrypted: false
 	};
 }