reamkit 1.30.0 → 1.31.0

package/dist/esm/pdf-reader/text.js

@@ -5,6 +5,7 @@ import { textMarkupOf } from "./annot-draw.js";
 import { appearanceContent, collectPageAppearances } from "./annots.js";
 import { buildContentFont } from "./font.js";
 import { hiddenProperties, hiddenXObject } from "./optional-content.js";
+import { addShown } from "./face-outlines.js";
 import { patternTint, tintedHex } from "./pattern-tint.js";
 //#region src/pdf-reader/text.ts
 var MAX_FORM_DEPTH = 8;
@@ -15,22 +16,24 @@ var MAX_FORM_DEPTH = 8;
 * origin falls inside a `/Link` annotation's `/Rect` with that link's URI (EP8)
 * so hyperlinks survive.
 *
-* @param file The owning {@link PdfFile}.
-* @param page The page to extract.
+* @param file  The owning {@link PdfFile}.
+* @param page  The page to extract.
+* @param painted Where to gather the codes each font painted, for a caller
+*                that embeds the faces (see `./face-outlines`).
 * @returns The page's runs, each carrying an `href` when it sits under a link.
 */
-function extractPageText(file, page) {
+function extractPageText(file, page, painted) {
 	const runs = [];
-	collectRuns(file, page.resources, file.pageContent(page), IDENTITY, 0, /* @__PURE__ */ new Set(), runs);
+	collectRuns(file, page.resources, file.pageContent(page), IDENTITY, 0, /* @__PURE__ */ new Set(), runs, painted);
 	const own = runs.length;
-	for (const appearance of collectPageAppearances(file, page)) collectRuns(file, appearance.resources ?? page.resources, appearanceContent(file, appearance), appearance.ctm, 1, new Set([appearance.stream]), runs);
+	for (const appearance of collectPageAppearances(file, page)) collectRuns(file, appearance.resources ?? page.resources, appearanceContent(file, appearance), appearance.ctm, 1, new Set([appearance.stream]), runs, painted);
 	for (let i = own; i < runs.length; i++) runs[i] = {
 		...runs[i],
 		annotation: true
 	};
 	const links = collectLinks(file, page);
 	const marks = collectTextMarkup(file, page);
-	const shown = withoutRestrikes(runs);
+	const shown = withAccentsComposed(withoutRestrikes(runs));
 	if (links.length === 0 && marks.length === 0) return shown;
 	return shown.flatMap((run) => {
 		const link = links.find((l) => inRect(run.x, run.y, l.rect));
@@ -168,6 +171,91 @@ function withoutRestrikes(runs) {
 }
 /** How near, in ems, a re-strike of the same text lands to the one it thickens. */
 var RESTRIKE_EM = .08;
+/**
+* §9.4.3 — an accent struck over a letter, composed with it.
+*
+* TeX sets an accented letter its font has no glyph for as two: the accent,
+* and the letter drawn back under it — "ï" is a dieresis and a dotless i.
+* Read as they come, comments.pdf's "naïve" came back "na¨ıve", the accent a
+* character of the word. A run that is one spacing accent, with the pen taken
+* back under it for the run after it, is the accent of that run's first letter
+* — or, where the accent was struck after its letter, of the last letter of the
+* run before it. The two are written as the one character Unicode composes them
+* into, a dotless i or j taking back its dot's place under the accent.
+*
+* @param runs The page's runs, in painting order.
+* @returns The runs with each such accent composed into its letter.
+*/
+function withAccentsComposed(runs) {
+	const out = [];
+	for (let i = 0; i < runs.length; i++) {
+		const run = runs[i];
+		const mark = ACCENTS.get(run.text);
+		const next = runs[i + 1];
+		const prev = out[out.length - 1];
+		if (mark !== void 0 && next !== void 0 && struckOver(run, next, "first")) {
+			const [first = "", ...rest] = [...next.text];
+			out.push({
+				...next,
+				text: accented(first, mark) + rest.join("")
+			});
+			i++;
+			continue;
+		}
+		if (mark !== void 0 && prev !== void 0 && struckOver(run, prev, "last")) {
+			const chars = [...prev.text];
+			const last = chars.pop() ?? "";
+			out[out.length - 1] = {
+				...prev,
+				text: chars.join("") + accented(last, mark)
+			};
+			continue;
+		}
+		out.push(run);
+	}
+	return out;
+}
+/**
+* Whether an accent stands over the first letter of a run (the pen taken back
+* under it) or over the last (the pen taken back to strike it): on one
+* baseline, give or take the lift an accent over a capital takes, and
+* overlapping it by more than a hair.
+*/
+function struckOver(accent, base, which) {
+	if (accent.angleDeg !== void 0 || base.angleDeg !== void 0) return false;
+	const size = base.fontSizePt || accent.fontSizePt || 10;
+	if (Math.abs(accent.y - base.y) > size * ACCENT_LIFT_EM) return false;
+	if (!/^\p{L}/u.test(which === "first" ? base.text : [...base.text].at(-1) ?? "")) return false;
+	const hair = size * ACCENT_OVERLAP_EM;
+	return which === "first" ? base.x < accent.endX - hair && base.x > accent.x - size : accent.x < base.endX - hair && accent.x > base.x;
+}
+/** A letter with an accent composed onto it: a dotless i or j takes back its dot's place. */
+function accented(letter, mark) {
+	return ((letter === "ı" ? "i" : letter === "ȷ" ? "j" : letter) + mark).normalize("NFC");
+}
+/** How far over the line, in ems, TeX lifts an accent to stand over a capital. */
+var ACCENT_LIFT_EM = .6;
+/** How far, in ems, an accent must overlap its letter to stand over it. */
+var ACCENT_OVERLAP_EM = .05;
+/** The spacing accents TeX strikes over a letter, and the combining marks they are. */
+var ACCENTS = new Map([
+	["`", "̀"],
+	["´", "́"],
+	["ˆ", "̂"],
+	["^", "̂"],
+	["˜", "̃"],
+	["~", "̃"],
+	["¯", "̄"],
+	["ˉ", "̄"],
+	["˘", "̆"],
+	["˙", "̇"],
+	["¨", "̈"],
+	["˚", "̊"],
+	["˝", "̋"],
+	["ˇ", "̌"],
+	["¸", "̧"],
+	["˛", "̨"]
+]);
 var spaceCache = /* @__PURE__ */ new WeakMap();
 /** The page's shading patterns, read once per resource dictionary. */
 var shadingCache = /* @__PURE__ */ new WeakMap();
@@ -187,14 +275,15 @@ function spacesOf(file, resources) {
 	spaceCache.set(resources, made);
 	return made;
 }
-function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
+function collectRuns(file, resources, content, baseCtm, depth, visiting, out, shown) {
 	const result = interpretContent(content, buildFonts(file, resources), baseCtm, shadingsOf(file, resources), void 0, spacesOf(file, resources), hiddenProperties(file, resources));
 	out.push(...result.texts.map((r) => withPatternColour(file, resources, r, visiting)));
+	if (shown) addShown(shown, result.shown);
 	if (depth >= MAX_FORM_DEPTH) return;
 	for (const glyph of result.glyphs) {
 		if (visiting.has(glyph.stream)) continue;
 		visiting.add(glyph.stream);
-		collectRuns(file, glyph.resources ?? resources, file.streamData(glyph.stream), glyph.ctm, depth + 1, visiting, out);
+		collectRuns(file, glyph.resources ?? resources, file.streamData(glyph.stream), glyph.ctm, depth + 1, visiting, out, shown);
 		visiting.delete(glyph.stream);
 	}
 	if (!resources) return;
@@ -208,7 +297,7 @@ function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
 		if (!(sub instanceof PdfName) || sub.value !== "Form") continue;
 		visiting.add(stream);
 		const formRes = file.get(stream.dict, "Resources");
-		collectRuns(file, formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, visiting, out);
+		collectRuns(file, formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, visiting, out, shown);
 		visiting.delete(stream);
 	}
 }

package/dist/esm/pdf-reader/type1-outline.d.ts

@@ -10,6 +10,17 @@ export interface Type1Font {
     readonly has: (name: string) => boolean;
     /** The program's own `/Encoding`: code → glyph name, where it states one. */
     readonly encoding?: ReadonlyMap<number, string>;
+    /**
+     * The embedding the program's licence allows — the OS/2 `fsType` Adobe
+     * writes into `FontInfo` as `/FSType`, where the program states one.
+     */
+    readonly fsType?: number;
+    /**
+     * §6.4 — how far the pen moves after a glyph, in thousandths of an em: the
+     * width its `hsbw` (or `sbw`) states. `undefined` where the program holds no
+     * such glyph or its charstring states no width first.
+     */
+    readonly advance: (name: string) => number | undefined;
 }
 /**
  * Read an embedded Type 1 program.

package/dist/esm/pdf-reader/type1-outline.js

@@ -1,3 +1,4 @@
+import { postScriptFsType } from "./cff-outline.js";
 //#region src/pdf-reader/type1-outline.ts
 /**
 * Read an embedded Type 1 program.
@@ -31,7 +32,13 @@ function type1Font(program) {
 			return out;
 		},
 		has: (name) => parsed.charstrings.has(name),
-		...parsed.encoding ? { encoding: parsed.encoding } : {}
+		advance: (name) => {
+			const charstring = parsed.charstrings.get(name);
+			const width = charstring ? statedWidth(charstring) : void 0;
+			return width === void 0 ? void 0 : width * parsed.scale * 1e3;
+		},
+		...parsed.encoding ? { encoding: parsed.encoding } : {},
+		...parsed.fsType !== void 0 ? { fsType: parsed.fsType } : {}
 	};
 }
 function parseType1(program) {
@@ -47,11 +54,13 @@ function parseType1(program) {
 	const charstrings = readCharstrings(plain, text, lenIV);
 	if (charstrings.size === 0) return void 0;
 	const encoding = readEncoding(clear);
+	const fsType = postScriptFsType(clear);
 	return {
 		charstrings,
 		subrs: readSubrs(plain, text, lenIV),
 		...encoding ? { encoding } : {},
-		scale: readMatrixScale(clear) ?? .001
+		scale: readMatrixScale(clear) ?? .001,
+		...fsType !== void 0 ? { fsType } : {}
 	};
 }
 /** The `eexec` key (§7), and the one every charstring is encrypted with (§6.2). */
@@ -211,6 +220,7 @@ function runGlyph(font, program, depth) {
 	let inFlex = false;
 	let x = 0;
 	let y = 0;
+	let sideBearing = 0;
 	let open = false;
 	let steps = 0;
 	const moveTo = () => {
@@ -255,6 +265,7 @@ function runGlyph(font, program, depth) {
 				case 13:
 					x = stack[0] ?? 0;
 					y = 0;
+					sideBearing = x;
 					stack.length = 0;
 					break;
 				case 9:
@@ -404,18 +415,25 @@ function runGlyph(font, program, depth) {
 						break;
 					}
 					if (op2 === 6) {
-						const base = STANDARD_ENCODING[stack[3] ?? 0];
-						const charstring = base !== void 0 ? font.charstrings.get(base) : void 0;
-						if (charstring && depth < 2) {
+						const [asb = 0, adx = 0, ady = 0, bchar = 0, achar = 0] = stack;
+						if (open) out.push({ op: "close" });
+						open = false;
+						const part = (charCode, dx, dy) => {
+							const name = STANDARD_ENCODING[charCode];
+							const charstring = name !== void 0 ? font.charstrings.get(name) : void 0;
+							if (!charstring || depth >= 2) return;
 							const drawn = runGlyph(font, charstring, depth + 1);
-							if (drawn) out.push(...drawn.map((seg) => unscale(seg, font.scale)));
-						}
+							if (drawn) out.push(...drawn.map((seg) => shift(unscale(seg, font.scale), dx, dy)));
+						};
+						part(bchar, 0, 0);
+						part(achar, adx + sideBearing - asb, ady);
 						stack.length = 0;
 						return false;
 					}
 					if (op2 === 7) {
 						x = stack[0] ?? 0;
 						y = stack[1] ?? 0;
+						sideBearing = x;
 						stack.length = 0;
 						break;
 					}
@@ -457,10 +475,47 @@ function scaleSeg(seg, k) {
 		y: seg.y * k
 	};
 }
-/** The base of a `seac` comes back already scaled; this puts it back in glyph space. */
+/**
+* §6.4 — the width a charstring states before it draws: the second operand of
+* `hsbw` (`sbx wx hsbw`), or the third of `sbw` (`sbx sby wx wy sbw`).
+*/
+function statedWidth(code) {
+	const stack = [];
+	for (let i = 0; i < code.length && stack.length <= 4;) {
+		const b = code[i++];
+		if (b >= 32 && b <= 246) stack.push(b - 139);
+		else if (b >= 247 && b <= 250) stack.push((b - 247) * 256 + (code[i++] ?? 0) + 108);
+		else if (b >= 251 && b <= 254) stack.push(-(b - 251) * 256 - (code[i++] ?? 0) - 108);
+		else if (b === 255) {
+			stack.push(code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3] | 0);
+			i += 4;
+		} else if (b === 13) return stack[1];
+		else if (b === 12 && code[i] === 7) return stack[2];
+		else return void 0;
+	}
+}
+/** The parts of a `seac` come back already scaled; this puts them back in glyph space. */
 function unscale(seg, k) {
 	return scaleSeg(seg, k === 0 ? 1 : 1 / k);
 }
+/** A segment moved by `(dx, dy)`: where a `seac` puts its accent. */
+function shift(seg, dx, dy) {
+	if (seg.op === "close" || dx === 0 && dy === 0) return seg;
+	if (seg.op === "cubic") return {
+		op: "cubic",
+		x1: seg.x1 + dx,
+		y1: seg.y1 + dy,
+		x2: seg.x2 + dx,
+		y2: seg.y2 + dy,
+		x: seg.x + dx,
+		y: seg.y + dy
+	};
+	return {
+		op: seg.op,
+		x: seg.x + dx,
+		y: seg.y + dy
+	};
+}
 /** §C.1 — the names `seac` selects its two parts by, at the codes it states. */
 var STANDARD_ENCODING = {
 	32: "space",

package/dist/esm/pdf-reader/vector.js

@@ -266,15 +266,23 @@ function overlaps(a, b) {
 * path intersection, and where the two merely overlap the answer is the smaller
 * of them — bounded, never larger than the truth.
 *
+* A path is measured by where its curves reach, not where their handles stand,
+* and one that reaches past its clip by no more than a sliver is inside it. An
+* appearance's `/BBox` is drawn round the path it holds: comments.pdf signs its
+* sixth page with a stamp of sixty-seven strokes that its box meets exactly,
+* and a handle standing 0.03pt past the box made the signature a path round
+* its clip — it came back a black bar the width of the text.
+*
 * @param v The painted path as the interpreter saw it.
 * @returns The path to draw, or `undefined` when the clip leaves nothing.
 */
 function clipped(v) {
 	const clip = v.clip;
 	if (!clip) return v;
-	const b = bbox(v.segs);
+	const b = reachOf(v.segs);
 	if (!b) return v;
 	if (clip.minX >= b.maxX || clip.maxX <= b.minX || clip.minY >= b.maxY || clip.maxY <= b.minY) return;
+	if (b.minX >= clip.minX - SLIVER_PT && b.maxX <= clip.maxX + SLIVER_PT && b.minY >= clip.minY - SLIVER_PT && b.maxY <= clip.maxY + SLIVER_PT) return v;
 	const pathArea = Math.max(0, b.maxX - b.minX) * Math.max(0, b.maxY - b.minY);
 	if (Math.max(0, clip.maxX - clip.minX) * Math.max(0, clip.maxY - clip.minY) >= pathArea) return v;
 	return {
@@ -283,6 +291,68 @@ function clipped(v) {
 		segs: clip.segs
 	};
 }
+/** How far past its clip a path may reach and still be inside it: a box's rounding. */
+var SLIVER_PT = .5;
+/**
+* The box a path's curves reach: its points, and the turns of its curves —
+* a Bézier stays inside its handles, and rarely reaches them.
+*
+* @param segs The path.
+*/
+function reachOf(segs) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	const add = (x, y) => {
+		minX = Math.min(minX, x);
+		minY = Math.min(minY, y);
+		maxX = Math.max(maxX, x);
+		maxY = Math.max(maxY, y);
+	};
+	let [x, y] = [0, 0];
+	let [startX, startY] = [0, 0];
+	for (const s of segs) {
+		if (s.op === "close") {
+			[x, y] = [startX, startY];
+			continue;
+		}
+		if (s.op === "cubic") {
+			const [x0, y0] = [x, y];
+			for (const t of [...turnsOf(x0, s.x1, s.x2, s.x), ...turnsOf(y0, s.y1, s.y2, s.y)]) add(bezierAt(x0, s.x1, s.x2, s.x, t), bezierAt(y0, s.y1, s.y2, s.y, t));
+		}
+		add(s.x, s.y);
+		[x, y] = [s.x, s.y];
+		if (s.op === "move") [startX, startY] = [s.x, s.y];
+	}
+	return Number.isFinite(minX) ? {
+		minX,
+		minY,
+		maxX,
+		maxY
+	} : void 0;
+}
+/** Where, between its ends, one coordinate of a cubic Bézier turns back. */
+function turnsOf(p0, p1, p2, p3) {
+	const a = p3 - 3 * p2 + 3 * p1 - p0;
+	const b = 2 * (p2 - 2 * p1 + p0);
+	const c = p1 - p0;
+	let roots = [];
+	if (Math.abs(a) < FLAT) {
+		if (Math.abs(b) >= FLAT) roots = [-c / b];
+	} else {
+		const d = b * b - 4 * a * c;
+		if (d >= 0) roots = [(-b + Math.sqrt(d)) / (2 * a), (-b - Math.sqrt(d)) / (2 * a)];
+	}
+	return roots.filter((t) => t > 0 && t < 1);
+}
+/** A coefficient this small is none: the curve's derivative is of lower degree. */
+var FLAT = 1e-12;
+/** One coordinate of a cubic Bézier at `t`. */
+function bezierAt(p0, p1, p2, p3, t) {
+	const u = 1 - t;
+	return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3;
+}
 function bbox(segs) {
 	let minX = Infinity;
 	let minY = Infinity;

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

@@ -178,7 +178,8 @@ function readDoc(bytes) {
 			},
 			styles: EMPTY_STYLE_SHEET,
 			resources,
-			...headersFooters.size > 0 ? { headersFooters } : {}
+			...headersFooters.size > 0 ? { headersFooters } : {},
+			typesetBy: "word"
 		},
 		losses: [content.encrypted ? DOC_ENCRYPTED_LOSS : DOC_TEXT_LOSS]
 	};
@@ -406,7 +407,10 @@ function toParaProperties(p) {
 		...p.indentRightTwips !== void 0 ? { indentRight: pt(p.indentRightTwips / 20) } : {},
 		...p.indentFirstTwips !== void 0 ? { indentFirstLine: pt(p.indentFirstTwips / 20) } : {},
 		...p.spaceBeforeTwips !== void 0 ? { spacingBefore: pt(p.spaceBeforeTwips / 20) } : {},
-		...p.spaceAfterTwips !== void 0 ? { spacingAfter: pt(p.spaceAfterTwips / 20) } : {}
+		...p.spaceAfterTwips !== void 0 ? { spacingAfter: pt(p.spaceAfterTwips / 20) } : {},
+		...p.widowControl !== void 0 ? { widowControl: p.widowControl } : {},
+		...p.keepNext !== void 0 ? { keepNext: p.keepNext } : {},
+		...p.keepLines !== void 0 ? { keepLines: p.keepLines } : {}
 	};
 }
 function underlineStyle(kul) {

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

@@ -74,6 +74,12 @@ export interface DocParaProps {
     readonly listIlfo?: number;
     /** `sprmPIlvl` — list level (0–8). */
     readonly listIlvl?: number;
+    /** `sprmPFWidowControl` — no first or last line left alone on a page. */
+    readonly widowControl?: boolean;
+    /** `sprmPFKeepFollow` — on the same page as the start of the next paragraph. */
+    readonly keepNext?: boolean;
+    /** `sprmPFKeep` — every line on one page. */
+    readonly keepLines?: boolean;
 }
 /** One maximal same-formatting run of text, or an embedded picture. */
 export interface DocRun {

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

@@ -40,6 +40,9 @@ var SPRM_P_DYA_BEFORE = 42003;
 var SPRM_P_DYA_AFTER = 42004;
 var SPRM_P_F_IN_TABLE = 9238;
 var SPRM_P_F_TTP = 9239;
+var SPRM_P_F_WIDOW_CONTROL = 9265;
+var SPRM_P_F_KEEP = 9221;
+var SPRM_P_F_KEEP_FOLLOW = 9222;
 var SPRM_T_DEF_TABLE = 54792;
 var SPRM_T_DEF_TABLE_SHD = 54802;
 var MAX_ROW_CELLS = 256;
@@ -433,6 +436,9 @@ function decodePapxGrpprl(d) {
 	let cellShadings;
 	let listIlfo;
 	let listIlvl;
+	let widowControl;
+	let keepNext;
+	let keepLines;
 	for (const s of sprms(d)) switch (s.sprm) {
 		case SPRM_P_JC:
 			jc = d[s.op];
@@ -458,6 +464,15 @@ function decodePapxGrpprl(d) {
 		case SPRM_P_F_TTP:
 			rowEnd = d[s.op] !== 0;
 			break;
+		case SPRM_P_F_WIDOW_CONTROL:
+			widowControl = d[s.op] !== 0;
+			break;
+		case SPRM_P_F_KEEP_FOLLOW:
+			keepNext = d[s.op] !== 0;
+			break;
+		case SPRM_P_F_KEEP:
+			keepLines = d[s.op] !== 0;
+			break;
 		case SPRM_T_DEF_TABLE: {
 			const cols = d[s.op] ?? 0;
 			const edges = [];
@@ -498,7 +513,10 @@ function decodePapxGrpprl(d) {
 		...cellDescriptors ? { cellDescriptors } : {},
 		...cellShadings ? { cellShadings } : {},
 		...listIlfo !== void 0 ? { listIlfo } : {},
-		...listIlvl !== void 0 ? { listIlvl } : {}
+		...listIlvl !== void 0 ? { listIlvl } : {},
+		...widowControl !== void 0 ? { widowControl } : {},
+		...keepNext !== void 0 ? { keepNext } : {},
+		...keepLines !== void 0 ? { keepLines } : {}
 	};
 }
 function* sprms(d) {

package/dist/esm/word/document-parser.d.ts

@@ -80,8 +80,8 @@ export interface ParseContext {
     readonly openCommentRanges?: Set<string>;
     /**
      * §17.3.1.1/§17.3.1.3 — what `w:beforeAutospacing`/`w:afterAutospacing`
-     * resolve to for THIS document: 14pt when it states no compatibility mode,
-     * and nothing (the default) for every Word 2007-or-later one.
+     * resolve to: HTML's 14pt for a Word document, nothing (the default) where
+     * the caller gives none.
      */
     readonly autoSpacingPt?: number;
 }

package/dist/esm/word/document-parser.js

@@ -9,6 +9,7 @@ import { parseRunProperties } from "./run-properties.js";
 import { parseParagraphProperties } from "./paragraph-properties.js";
 import { poElementToFlat } from "./po-to-flat.js";
 import { parseBorders, parseTable } from "./table-parser.js";
+import { FORMATS } from "./numbering-parser.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/word/document-parser.ts
 var decoder = new TextDecoder("utf-8");
@@ -199,11 +200,13 @@ function parseSectPrNode(sectPr) {
 	let margins;
 	let titlePg = false;
 	let pageNumberStart;
+	let pageNumberFormat;
 	let lineNumbering;
 	let columns;
 	let sectionStart;
 	let pageBorders;
 	let gridLinePitchPt;
+	let textDirection;
 	const headers = [];
 	const footers = [];
 	for (const child of poChildren(sectPr)) if (poIs(child, "w:pgSz")) {
@@ -251,6 +254,8 @@ function parseSectPrNode(sectPr) {
 	} else if (poIs(child, "w:pgNumType")) {
 		const start = poIntAttr(child, "start");
 		if (start !== void 0) pageNumberStart = start;
+		const fmt = poAttr(child, "fmt");
+		if (fmt !== void 0 && FORMATS.has(fmt) && fmt !== "decimal") pageNumberFormat = fmt;
 	} else if (poIs(child, "w:cols")) columns = parseColumns(child);
 	else if (poIs(child, "w:pgBorders")) {
 		const borders = parseBorders(child);
@@ -265,6 +270,9 @@ function parseSectPrNode(sectPr) {
 	} else if (poIs(child, "w:type")) {
 		const val = poAttr(child, "val");
 		sectionStart = val === "continuous" || val === "oddPage" || val === "evenPage" ? val : "nextPage";
+	} else if (poIs(child, "w:textDirection")) {
+		const val = poAttr(child, "val");
+		if (val === "tbRl" || val === "btLr") textDirection = val;
 	}
 	return {
 		pageSize,
@@ -273,11 +281,13 @@ function parseSectPrNode(sectPr) {
 		footers,
 		...titlePg ? { titlePg: true } : {},
 		...pageNumberStart !== void 0 ? { pageNumberStart } : {},
+		...pageNumberFormat !== void 0 ? { pageNumberFormat } : {},
 		...lineNumbering ? { lineNumbering } : {},
 		...columns ? { columns } : {},
 		...sectionStart ? { sectionStart } : {},
 		...pageBorders ? { pageBorders } : {},
-		...gridLinePitchPt !== void 0 ? { gridLinePitchPt } : {}
+		...gridLinePitchPt !== void 0 ? { gridLinePitchPt } : {},
+		...textDirection ? { textDirection } : {}
 	};
 }
 function parseColumns(cols) {

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

@@ -15,10 +15,10 @@ import { OpcPackage } from "../core/opc/package.js";
 import { parseCoreProperties } from "../core/opc/core-properties.js";
 import "../core/opc/index.js";
 import { parseXml } from "../pptx/pptx-reader.js";
+import { EMPTY_NUMBERING, parseNumbering } from "./numbering-parser.js";
 import { EMPTY_SECTION, applyAuthorIds, bodyIndexForBlock, newBlockCounter, parseBackgroundColor, parseBackgroundFill, parseCommentThreads, parseDocument, parseHeaderFooter, parseNotes, parsePeople, parseSections } from "./document-parser.js";
 import { parseStyles } from "./styles-parser.js";
 import { loadEmbeddedFonts } from "./font-table.js";
-import { EMPTY_NUMBERING, parseNumbering } from "./numbering-parser.js";
 import { EMPTY_SETTINGS, parseSettings } from "./settings-parser.js";
 import "./index.js";
 //#region src/word/docx-reader.ts
@@ -66,7 +66,7 @@ function readDocx(docx) {
 	const settings = settingsData ? parseSettings(settingsData) : EMPTY_SETTINGS;
 	const ctx = {
 		resolveColor,
-		...settings.compatibilityMode === void 0 ? { autoSpacingPt: 14 } : {},
+		autoSpacingPt: 14,
 		...themeLineWidths && themeLineWidths.length > 0 ? { themeLineWidths } : {},
 		...themeStyles ? { themeStyles } : {},
 		...themeFonts ? { themeFonts } : {},
@@ -142,7 +142,9 @@ function readDocx(docx) {
 			...settings.doNotExpandShiftReturn ? { doNotExpandShiftReturn: true } : {},
 			...settings.displayBackgroundShape && backgroundFill ? { pageBackgroundFill: backgroundFill } : {},
 			...settings.displayBackgroundShape && backgroundColorHex ? { pageBackgroundColorHex: backgroundColorHex } : {},
-			...settings.gutterAtTop ? { gutterAtTop: true } : {}
+			...settings.gutterAtTop ? { gutterAtTop: true } : {},
+			...settings.compatibilityMode !== void 0 ? { compatibilityMode: settings.compatibilityMode } : {},
+			typesetBy: "word"
 		},
 		losses
 	};