reamkit 1.16.0 → 1.18.0

package/dist/esm/word/index.d.ts

@@ -1,9 +1,9 @@
-export type { HyperlinkResolver, ImageResolver, ParseContext } from './document-parser.js';
-export type { CommentExtension } from './document-parser.js';
+export type { HyperlinkResolver, ImageResolver, ParseContext, ResolvedDiagram, } from './document-parser.js';
+export type { BlockCounter, CommentExtension } from './document-parser.js';
 export { extractParagraphs } from './text-extractor.js';
-export { parseDocument, parseBodyElements, parseSection, parseSections, parseHeaderFooter, parseNotes, parseComments, parseCommentThreads, parseCommentsExtended, parsePeople, applyAuthorIds, EMPTY_SECTION, } from './document-parser.js';
+export { parseDocument, parseBackgroundColor, parseBackgroundFill, parseBodyElements, parseSection, parseSections, parseHeaderFooter, parseNotes, parseComments, parseCommentThreads, parseCommentsExtended, parsePeople, applyAuthorIds, bodyIndexForBlock, newBlockCounter, EMPTY_SECTION, } from './document-parser.js';
 export { parseRunProperties } from './run-properties.js';
-export { parseParagraphProperties } from './paragraph-properties.js';
+export { HTML_AUTO_SPACING_PT, parseParagraphProperties } from './paragraph-properties.js';
 export { parseStyles } from './styles-parser.js';
 export { parseTable } from './table-parser.js';
 export { loadEmbeddedFonts, deobfuscateEmbeddedFont, parseFontTable } from './font-table.js';

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

@@ -1,4 +1,5 @@
 import { Numbering } from '../core/document-model/index.js';
+import { ResourceId } from '../core/ir/index.js';
 /** The empty {@link Numbering} returned when a document has no `numbering.xml`. */
 export declare const EMPTY_NUMBERING: Numbering;
 /**
@@ -11,4 +12,4 @@ export declare const EMPTY_NUMBERING: Numbering;
  * @param data The raw `numbering.xml` bytes.
  * @returns The parsed numbering, or {@link EMPTY_NUMBERING} when the root is absent.
  */
-export declare function parseNumbering(data: Uint8Array): Numbering;
+export declare function parseNumbering(data: Uint8Array, resolveImage?: (relId: string) => ResourceId | undefined): Numbering;

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

@@ -1,3 +1,4 @@
+import { pt } from "../core/ir/units.js";
 import { asArray, asElement, getAttr } from "./xml-helpers.js";
 import { parseRunProperties } from "./run-properties.js";
 import { parseParagraphProperties } from "./paragraph-properties.js";
@@ -15,10 +16,28 @@ var parser = new XMLParser({
 });
 var FORMATS = new Set([
 	"decimal",
+	"decimalZero",
+	"decimalFullWidth",
+	"ordinal",
 	"lowerLetter",
 	"upperLetter",
 	"lowerRoman",
 	"upperRoman",
+	"ideographTraditional",
+	"ideographZodiac",
+	"ideographLegalTraditional",
+	"ideographDigital",
+	"koreanDigital2",
+	"chineseCounting",
+	"chineseCountingThousand",
+	"japaneseCounting",
+	"koreanCounting",
+	"taiwaneseCounting",
+	"taiwaneseCountingThousand",
+	"hebrew1",
+	"hebrew2",
+	"decimalEnclosedCircle",
+	"chicago",
 	"bullet",
 	"none"
 ]);
@@ -37,10 +56,11 @@ var EMPTY_NUMBERING = {
 * @param data The raw `numbering.xml` bytes.
 * @returns The parsed numbering, or {@link EMPTY_NUMBERING} when the root is absent.
 */
-function parseNumbering(data) {
+function parseNumbering(data, resolveImage) {
 	const xml = decoder.decode(data);
 	const root = asElement(parser.parse(xml)["w:numbering"]);
 	if (!root) return EMPTY_NUMBERING;
+	const picBullets = parsePicBullets(root, resolveImage);
 	const abstractNums = /* @__PURE__ */ new Map();
 	for (const a of asArray(root["w:abstractNum"])) {
 		const el = asElement(a);
@@ -49,25 +69,8 @@ function parseNumbering(data) {
 		if (!id) continue;
 		const levels = /* @__PURE__ */ new Map();
 		for (const lvlNode of asArray(el["w:lvl"])) {
-			const lvlEl = asElement(lvlNode);
-			if (!lvlEl) continue;
-			const ilvlStr = getAttr(lvlEl, "ilvl");
-			if (!ilvlStr) continue;
-			const ilvl = Number(ilvlStr);
-			if (!Number.isFinite(ilvl)) continue;
-			const startAttr = getValVal(lvlEl["w:start"]);
-			const start = startAttr !== void 0 ? Number(startAttr) : 1;
-			const fmtStr = getValVal(lvlEl["w:numFmt"]) ?? "decimal";
-			const format = FORMATS.has(fmtStr) ? fmtStr : "decimal";
-			const lvlText = getValVal(lvlEl["w:lvlText"]) ?? "";
-			levels.set(ilvl, {
-				ilvl,
-				start: Number.isFinite(start) ? start : 1,
-				format,
-				lvlText,
-				paragraphProperties: parseParagraphProperties(lvlEl["w:pPr"]),
-				runProperties: parseRunProperties(lvlEl["w:rPr"])
-			});
+			const lvl = parseLevel(lvlNode, picBullets);
+			if (lvl) levels.set(lvl.ilvl, lvl);
 		}
 		abstractNums.set(id, {
 			id,
@@ -82,9 +85,23 @@ function parseNumbering(data) {
 		if (!numId) continue;
 		const abstractNumId = getValVal(el["w:abstractNumId"]);
 		if (!abstractNumId) continue;
+		const startOverrides = /* @__PURE__ */ new Map();
+		const levelOverrides = /* @__PURE__ */ new Map();
+		for (const o of asArray(el["w:lvlOverride"])) {
+			const ovr = asElement(o);
+			if (!ovr) continue;
+			const ilvl = Number(getAttr(ovr, "ilvl"));
+			if (!Number.isFinite(ilvl)) continue;
+			const start = Number(getValVal(ovr["w:startOverride"]));
+			if (Number.isFinite(start)) startOverrides.set(ilvl, start);
+			const lvl = parseLevel(ovr["w:lvl"], picBullets);
+			if (lvl) levelOverrides.set(ilvl, lvl);
+		}
 		numInstances.set(numId, {
 			numId,
-			abstractNumId
+			abstractNumId,
+			...startOverrides.size > 0 ? { startOverrides } : {},
+			...levelOverrides.size > 0 ? { levelOverrides } : {}
 		});
 	}
 	return {
@@ -92,6 +109,75 @@ function parseNumbering(data) {
 		numInstances
 	};
 }
+function parseLevel(node, picBullets) {
+	const lvlEl = asElement(node);
+	if (!lvlEl) return void 0;
+	const ilvlStr = getAttr(lvlEl, "ilvl");
+	if (!ilvlStr) return void 0;
+	const ilvl = Number(ilvlStr);
+	if (!Number.isFinite(ilvl)) return void 0;
+	const startAttr = getValVal(lvlEl["w:start"]);
+	const start = startAttr !== void 0 ? Number(startAttr) : 0;
+	const fmtStr = getValVal(lvlEl["w:numFmt"]) ?? "decimal";
+	const format = FORMATS.has(fmtStr) ? fmtStr : "decimal";
+	const lvlText = getValVal(lvlEl["w:lvlText"]) ?? "";
+	const picId = getValVal(lvlEl["w:lvlPicBulletId"]);
+	const picBullet = picId !== void 0 ? picBullets.get(picId) : void 0;
+	const isLegal = "w:isLgl" in lvlEl && getValVal(lvlEl["w:isLgl"]) !== "0";
+	return {
+		ilvl,
+		start: Number.isFinite(start) ? start : 1,
+		format,
+		lvlText,
+		...isLegal ? { isLegal: true } : {},
+		...picBullet ? { picBullet } : {},
+		paragraphProperties: parseParagraphProperties(lvlEl["w:pPr"]),
+		runProperties: parseRunProperties(lvlEl["w:rPr"])
+	};
+}
+function parsePicBullets(root, resolveImage) {
+	const out = /* @__PURE__ */ new Map();
+	for (const node of asArray(root["w:numPicBullet"])) {
+		const el = asElement(node);
+		if (!el) continue;
+		const id = getAttr(el, "numPicBulletId");
+		if (id === void 0) continue;
+		const pict = asElement(el["w:pict"]);
+		const shape = pict ? asElement(pict["v:shape"]) : void 0;
+		if (!shape) continue;
+		const data = asElement(shape["v:imagedata"]);
+		const relId = data ? getAttr(data, "id") ?? getAttr(data, "r:id") : void 0;
+		const style = getAttr(shape, "style") ?? "";
+		const widthPt = cssLengthPt(/(?:^|;)\s*width\s*:\s*([^;]+)/u.exec(style)?.[1]);
+		const heightPt = cssLengthPt(/(?:^|;)\s*height\s*:\s*([^;]+)/u.exec(style)?.[1]);
+		if (widthPt === void 0 || heightPt === void 0) continue;
+		const resource = relId !== void 0 ? resolveImage?.(relId) : void 0;
+		if (resource === void 0) continue;
+		out.set(id, {
+			resource,
+			widthPt: pt(widthPt),
+			heightPt: pt(heightPt)
+		});
+	}
+	return out;
+}
+var CSS_UNITS = new Map([
+	["pt", 1],
+	["in", 72],
+	["cm", 72 / 2.54],
+	["mm", 72 / 25.4],
+	["pc", 12],
+	["px", .75]
+]);
+function cssLengthPt(raw) {
+	const m = raw !== void 0 ? /^\s*(-?[\d.]+)\s*([a-z%]*)\s*$/u.exec(raw) : null;
+	if (!m) return void 0;
+	const n = Number(m[1]);
+	if (!Number.isFinite(n)) return void 0;
+	const unit = m[2] === "" ? "pt" : m[2];
+	const scale = CSS_UNITS.get(unit);
+	return scale === void 0 ? void 0 : n * scale;
+}
 function getValVal(node) {
 	if (!node || typeof node !== "object") return void 0;
 	const v = node["@_w:val"] ?? node["@_val"];

package/dist/esm/word/paragraph-properties.d.ts

@@ -1,4 +1,11 @@
 import { ParagraphProperties } from '../core/document-model/index.js';
+/**
+ * §17.3.1.1/§17.3.1.3 — the gap `w:*Autospacing` asks the consumer for. Word's
+ * own automatic value is HTML's 14pt, and only a document old enough to state
+ * no `w:compatSetting compatibilityMode` still gets it: from Word 2007 on the
+ * automatic value is nothing at all, which is what both references leave.
+ */
+export declare const HTML_AUTO_SPACING_PT = 14;
 /**
  * Parse a `w:pPr` element (ECMA-376 Part 1 §17.3.1) into {@link ParagraphProperties}.
  * Reads the style reference, alignment, spacing, indentation, page-break-before,
@@ -7,6 +14,9 @@ import { ParagraphProperties } from '../core/document-model/index.js';
  *
  * @param pPr The `w:pPr` element in flat (fast-xml-parser) shape, or anything
  *   non-element (yielding an empty result).
+ * @param autoSpacingPt What `w:beforeAutospacing`/`w:afterAutospacing` resolve
+ *   to — {@link HTML_AUTO_SPACING_PT} for a document that states no
+ *   compatibility mode, and 0 (the default) for every Word 2007-or-later one.
  * @returns The extracted properties; an empty object when `pPr` is absent.
  */
-export declare function parseParagraphProperties(pPr: unknown): ParagraphProperties;
+export declare function parseParagraphProperties(pPr: unknown, autoSpacingPt?: number): ParagraphProperties;

package/dist/esm/word/paragraph-properties.js

@@ -1,5 +1,5 @@
-import { twipsToPt } from "../core/ir/units.js";
-import { asElement, getAttr, getVal, parseIntAttr, parseToggle } from "./xml-helpers.js";
+import { eighthPtToPt, pt, twipsToPt } from "../core/ir/units.js";
+import { asArray, asElement, getAttr, getVal, parseIntAttr, parseToggle } from "./xml-helpers.js";
 import { parseRunProperties } from "./run-properties.js";
 //#region src/word/paragraph-properties.ts
 var ALIGNMENTS = new Set([
@@ -14,6 +14,83 @@ var LINE_RULES = new Set([
 	"exact",
 	"atLeast"
 ]);
+function isAutospacing(node, name) {
+	const v = getAttr(node, name);
+	return v !== void 0 && v !== "false" && v !== "0" && v !== "off";
+}
+var X_ALIGNS = new Set([
+	"left",
+	"center",
+	"right",
+	"inside",
+	"outside"
+]);
+var Y_ALIGNS = new Set([
+	"top",
+	"center",
+	"bottom",
+	"inside",
+	"outside"
+]);
+var ANCHORS = new Set([
+	"text",
+	"margin",
+	"page"
+]);
+var WRAPS = new Set([
+	"auto",
+	"around",
+	"none",
+	"notBeside",
+	"tight",
+	"through"
+]);
+/**
+* §17.3.1.11 `w:framePr` — the box a floating text frame takes and where it
+* hangs. Lengths are twips; the alignments and anchors are read only when they
+* name a value the spec defines.
+*
+* @param node The `w:framePr` element in flat shape.
+* @returns The frame, or `undefined` when the element says nothing usable.
+*/
+function parseFramePr(node) {
+	if (!asElement(node)) return void 0;
+	const twips = (name) => {
+		const v = parseIntAttr(node, name);
+		return v === void 0 ? void 0 : twipsToPt(v);
+	};
+	const pick = (name, allowed) => {
+		const v = getAttr(node, name);
+		return v !== void 0 && allowed.has(v) ? v : void 0;
+	};
+	const rule = getAttr(node, "hRule");
+	const out = {};
+	const w = twips("w");
+	const h = twips("h");
+	const x = twips("x");
+	const y = twips("y");
+	const hSpace = twips("hSpace");
+	const vSpace = twips("vSpace");
+	if (w !== void 0) out.widthPt = w;
+	if (h !== void 0) out.heightPt = h;
+	if (rule === "auto" || rule === "exact" || rule === "atLeast") out.heightRule = rule;
+	if (x !== void 0) out.xPt = x;
+	if (y !== void 0) out.yPt = y;
+	if (hSpace !== void 0) out.hSpacePt = hSpace;
+	if (vSpace !== void 0) out.vSpacePt = vSpace;
+	const xAlign = pick("xAlign", X_ALIGNS);
+	const yAlign = pick("yAlign", Y_ALIGNS);
+	const hAnchor = pick("hAnchor", ANCHORS);
+	const vAnchor = pick("vAnchor", ANCHORS);
+	const wrap = pick("wrap", WRAPS);
+	if (xAlign) out.xAlign = xAlign;
+	if (yAlign) out.yAlign = yAlign;
+	if (hAnchor) out.hAnchor = hAnchor;
+	if (vAnchor) out.vAnchor = vAnchor;
+	if (wrap) out.wrap = wrap;
+	if (!(w !== void 0 && w > 0 || h !== void 0 && h > 0) && !((x !== void 0 || y !== void 0 || xAlign !== void 0 || yAlign !== void 0) && (x ?? 0) + (y ?? 0) !== 0)) return void 0;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
 /**
 * Parse a `w:pPr` element (ECMA-376 Part 1 §17.3.1) into {@link ParagraphProperties}.
 * Reads the style reference, alignment, spacing, indentation, page-break-before,
@@ -22,9 +99,12 @@ var LINE_RULES = new Set([
 *
 * @param pPr The `w:pPr` element in flat (fast-xml-parser) shape, or anything
 *   non-element (yielding an empty result).
+* @param autoSpacingPt What `w:beforeAutospacing`/`w:afterAutospacing` resolve
+*   to — {@link HTML_AUTO_SPACING_PT} for a document that states no
+*   compatibility mode, and 0 (the default) for every Word 2007-or-later one.
 * @returns The extracted properties; an empty object when `pPr` is absent.
 */
-function parseParagraphProperties(pPr) {
+function parseParagraphProperties(pPr, autoSpacingPt = 0) {
 	const el = asElement(pPr);
 	if (!el) return {};
 	const out = {};
@@ -42,6 +122,8 @@ function parseParagraphProperties(pPr) {
 		const after = parseIntAttr(node, "after");
 		const line = parseIntAttr(node, "line");
 		const lineRule = getAttr(node, "lineRule");
+		if (isAutospacing(node, "beforeAutospacing")) out.spacingBeforeAuto = pt(autoSpacingPt);
+		if (isAutospacing(node, "afterAutospacing")) out.spacingAfterAuto = pt(autoSpacingPt);
 		if (before !== void 0) out.spacingBefore = twipsToPt(before);
 		if (after !== void 0) out.spacingAfter = twipsToPt(after);
 		if (line !== void 0) out.spacingLine = twipsToPt(line);
@@ -58,6 +140,34 @@ function parseParagraphProperties(pPr) {
 		if (firstLine !== void 0) out.indentFirstLine = twipsToPt(firstLine);
 		else if (hanging !== void 0) out.indentFirstLine = twipsToPt(-hanging);
 	}
+	if ("w:framePr" in el) {
+		const frame = parseFramePr(el["w:framePr"]);
+		if (frame) out.frame = frame;
+	}
+	if ("w:tabs" in el) {
+		const stops = parseTabs(el["w:tabs"]);
+		if (stops.length > 0) out.tabs = stops;
+	}
+	if ("w:pBdr" in el) {
+		const borders = parseParagraphBorders(el["w:pBdr"]);
+		if (borders) out.borders = borders;
+	}
+	if ("w:shd" in el) {
+		const fill = getAttr(el["w:shd"], "fill");
+		if (fill && fill !== "auto" && /^[0-9A-Fa-f]{6}$/u.test(fill)) out.shading = { colorHex: fill.toUpperCase() };
+	}
+	if ("w:textDirection" in el) {
+		const v = getVal(el["w:textDirection"]);
+		if (v === "btLr" || v === "tbRl") out.textDirection = v;
+	}
+	if ("w:snapToGrid" in el) {
+		const v = parseToggle(el["w:snapToGrid"]);
+		if (v !== void 0) out.snapToGrid = v;
+	}
+	if ("w:contextualSpacing" in el) {
+		const v = parseToggle(el["w:contextualSpacing"]);
+		if (v !== void 0) out.contextualSpacing = v;
+	}
 	if ("w:pageBreakBefore" in el) {
 		const v = parseToggle(el["w:pageBreakBefore"]);
 		if (v !== void 0) out.pageBreakBefore = v;
@@ -77,13 +187,13 @@ function parseParagraphProperties(pPr) {
 			const ilvlVal = numPr["w:ilvl"];
 			const numIdAttr = typeof numIdVal === "object" && numIdVal !== null ? getAttr(numIdVal, "val") : void 0;
 			const ilvlAttr = typeof ilvlVal === "object" && ilvlVal !== null ? getAttr(ilvlVal, "val") : void 0;
-			if (numIdAttr !== void 0) {
-				const ilvlNum = ilvlAttr !== void 0 ? Number(ilvlAttr) : 0;
-				out.numbering = {
-					numId: numIdAttr,
-					ilvl: Number.isFinite(ilvlNum) ? ilvlNum : 0
-				};
-			}
+			const ilvlNum = ilvlAttr !== void 0 ? Number(ilvlAttr) : 0;
+			const ilvl = Number.isFinite(ilvlNum) ? ilvlNum : 0;
+			if (numIdAttr !== void 0) out.numbering = {
+				numId: numIdAttr,
+				ilvl
+			};
+			else if (ilvlAttr !== void 0) out.numberingLevel = ilvl;
 		}
 	}
 	if ("w:rPr" in el) {
@@ -92,5 +202,104 @@ function parseParagraphProperties(pPr) {
 	}
 	return out;
 }
+var TAB_ALIGNMENTS = new Map([
+	["left", "left"],
+	["start", "left"],
+	["center", "center"],
+	["right", "right"],
+	["end", "right"],
+	["decimal", "decimal"]
+]);
+var TAB_LEADERS = new Set([
+	"dot",
+	"hyphen",
+	"underscore",
+	"middleDot"
+]);
+var BORDER_STYLES = new Set([
+	"none",
+	"single",
+	"double",
+	"thick",
+	"dotted",
+	"dashed",
+	"dashSmallGap"
+]);
+/**
+* §17.18.2 ST_Border — the rule's pattern, of which the standard names some
+* hundred and eighty. The handful we draw pass through; `nil` and `none` are no
+* rule at all; everything else is a rule we cannot draw exactly, and a solid
+* one of the stated width and colour is far closer than none. Rejected
+* outright, SdtContent.docx lost the `thickThinSmallGap` rule under its header.
+*
+* @param val The `w:val` attribute.
+* @returns The style to draw, or `undefined` when there is nothing to draw.
+*/
+function borderStyleOf(val) {
+	if (!val) return void 0;
+	if (val === "nil" || val === "none") return "none";
+	return BORDER_STYLES.has(val) ? val : "single";
+}
+/**
+* §17.3.1.24 `w:pBdr` — the rules around a paragraph. Spelled exactly as a
+* cell's `w:tcBorders` is, but reached through the flat parse shape this module
+* works in, and with the `w:space` a cell border does not have.
+*
+* @param node The `w:pBdr` element.
+* @returns The edges that name a rule, or `undefined` when none do.
+*/
+function parseParagraphBorders(node) {
+	const el = asElement(node);
+	if (!el) return void 0;
+	const edge = (...names) => {
+		const b = asElement(names.map((n) => el[n]).find((v) => v !== void 0));
+		if (!b) return void 0;
+		const style = borderStyleOf(getVal(b));
+		if (!style) return void 0;
+		const sz = parseIntAttr(b, "sz");
+		const space = parseIntAttr(b, "space");
+		const color = getAttr(b, "color");
+		return {
+			style,
+			...sz !== void 0 ? { width: eighthPtToPt(sz) } : {},
+			...space !== void 0 ? { spacePt: pt(space) } : {},
+			...color && color !== "auto" && /^[0-9A-Fa-f]{6}$/u.test(color) ? { colorHex: color.toUpperCase() } : {}
+		};
+	};
+	const out = {};
+	const top = edge("w:top");
+	const bottom = edge("w:bottom");
+	const left = edge("w:left", "w:start");
+	const right = edge("w:right", "w:end");
+	if (top) out.top = top;
+	if (bottom) out.bottom = bottom;
+	if (left) out.left = left;
+	if (right) out.right = right;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+/**
+* §17.3.1.37 `w:tabs` — the paragraph's own stops, in ascending position.
+*
+* @param node The `w:tabs` element.
+* @returns The stops that place text, sorted; `[]` when it declares none.
+*/
+function parseTabs(node) {
+	const out = [];
+	for (const raw of asArray(asElement(node)?.["w:tab"])) {
+		const el = asElement(raw);
+		if (!el) continue;
+		const pos = parseIntAttr(el, "pos");
+		if (pos === void 0) continue;
+		const alignment = TAB_ALIGNMENTS.get(getAttr(el, "val") ?? "left");
+		if (!alignment) continue;
+		const leader = getAttr(el, "leader");
+		out.push({
+			positionPt: twipsToPt(pos),
+			alignment,
+			...leader !== void 0 && TAB_LEADERS.has(leader) ? { leader } : {}
+		});
+	}
+	return out.sort((a, b) => a.positionPt - b.positionPt);
+}
 //#endregion
 export { parseParagraphProperties };

package/dist/esm/word/run-properties.js

@@ -1,5 +1,6 @@
-import { halfPtToPt } from "../core/ir/units.js";
+import { halfPtToPt, twipsToPt } from "../core/ir/units.js";
 import { asElement, getAttr, getVal, parseIntAttr, parseToggle } from "./xml-helpers.js";
+import { shadingFillHex } from "./shading.js";
 //#region src/word/run-properties.ts
 var UNDERLINE_STYLES = new Set([
 	"none",
@@ -17,6 +18,24 @@ var VERTICAL_ALIGNS = new Set([
 	"superscript",
 	"subscript"
 ]);
+var HIGHLIGHT_COLORS = new Map([
+	["black", "000000"],
+	["blue", "0000FF"],
+	["cyan", "00FFFF"],
+	["darkBlue", "000080"],
+	["darkCyan", "008080"],
+	["darkGray", "808080"],
+	["darkGreen", "008000"],
+	["darkMagenta", "800080"],
+	["darkRed", "800000"],
+	["darkYellow", "808000"],
+	["green", "00FF00"],
+	["lightGray", "C0C0C0"],
+	["magenta", "FF00FF"],
+	["red", "FF0000"],
+	["white", "FFFFFF"],
+	["yellow", "FFFF00"]
+]);
 /**
 * Parse a run-properties element (`w:rPr`, ECMA-376 Part 1 §17.3.2) into the
 * typed {@link RunProperties}. Reads the character formatting the renderer needs:
@@ -47,9 +66,19 @@ function parseRunProperties(rPr) {
 		const v = parseToggle(el["w:strike"]);
 		if (v !== void 0) out.strike = v;
 	}
+	if ("w:caps" in el) {
+		const v = parseToggle(el["w:caps"]);
+		if (v !== void 0) out.caps = v;
+	}
+	if ("w:smallCaps" in el) {
+		const v = parseToggle(el["w:smallCaps"]);
+		if (v !== void 0) out.smallCaps = v;
+	}
 	if ("w:u" in el) {
 		const v = getVal(el["w:u"]);
 		if (v && UNDERLINE_STYLES.has(v)) out.underline = v;
+		const c = getAttr(el["w:u"], "color");
+		if (c && /^[0-9A-Fa-f]{6}$/u.test(c)) out.underlineColorHex = c.toUpperCase();
 	}
 	if ("w:sz" in el) {
 		const v = parseIntAttr(el["w:sz"], "val");
@@ -58,6 +87,7 @@ function parseRunProperties(rPr) {
 	if ("w:color" in el) {
 		const v = getVal(el["w:color"]);
 		if (v && /^[0-9A-Fa-f]{6}$/.test(v)) out.colorHex = v.toUpperCase();
+		else if (v === "auto") out.colorHex = "000000";
 	}
 	if ("w:rFonts" in el) {
 		const ff = parseFontFamily(el["w:rFonts"]);
@@ -71,6 +101,20 @@ function parseRunProperties(rPr) {
 		const v = parseToggle(el["w:rtl"]);
 		if (v !== void 0) out.rtl = v;
 	}
+	if ("w:spacing" in el) {
+		const v = getVal(el["w:spacing"]);
+		const n = v === void 0 ? NaN : Number(v);
+		if (Number.isFinite(n) && n !== 0) out.letterSpacingPt = twipsToPt(n);
+	}
+	if ("w:shd" in el) {
+		const shd = el["w:shd"];
+		const hex = shadingFillHex(getVal(shd), getAttr(shd, "color"), getAttr(shd, "fill"));
+		if (hex !== void 0 && hex !== "FFFFFF") out.shadingColorHex = hex;
+	}
+	if ("w:highlight" in el) {
+		const hex = HIGHLIGHT_COLORS.get(getVal(el["w:highlight"]) ?? "");
+		if (hex !== void 0) out.shadingColorHex = hex;
+	}
 	if ("w:lang" in el) {
 		const v = getAttr(el["w:lang"], "val");
 		if (v) out.lang = v;

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

@@ -5,6 +5,30 @@ export interface DocumentSettings {
      * pages use the `'even'` header/footer references instead of `'default'`.
      */
     readonly evenAndOddHeaders: boolean;
+    /**
+     * ECMA-376 §17.15.1.35 — `w:compat/w:doNotExpandShiftReturn`. When `true`, a
+     * justified line that ends at a soft line break (`w:br`) is left at its
+     * natural width instead of being stretched to the measure.
+     */
+    readonly doNotExpandShiftReturn: boolean;
+    /**
+     * ECMA-376 §17.15.1.28 — `w:displayBackgroundShape`. The page background
+     * (§17.2.1 `w:background`) is drawn only when this is set; without it Word
+     * keeps the colour but prints white.
+     */
+    readonly displayBackgroundShape: boolean;
+    /**
+     * ECMA-376 §17.15.1.38 — `w:gutterAtTop`. The binding space (`w:pgMar
+     * @w:gutter`) is added to the TOP margin rather than the left.
+     */
+    readonly gutterAtTop: boolean;
+    /**
+     * `w:compat/w:compatSetting @w:name="compatibilityMode"` — the Word version
+     * the document was saved for. Absent means the file predates the setting,
+     * which is the only case where §17.3.1.1's automatic paragraph spacing is
+     * still HTML's 14pt rather than nothing.
+     */
+    readonly compatibilityMode?: number;
 }
 /** The all-defaults {@link DocumentSettings}, returned when no `w:settings` root is found. */
 export declare const EMPTY_SETTINGS: DocumentSettings;

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

@@ -12,7 +12,12 @@ var parser = new XMLParser({
 	trimValues: false
 });
 /** The all-defaults {@link DocumentSettings}, returned when no `w:settings` root is found. */
-var EMPTY_SETTINGS = { evenAndOddHeaders: false };
+var EMPTY_SETTINGS = {
+	evenAndOddHeaders: false,
+	doNotExpandShiftReturn: false,
+	displayBackgroundShape: false,
+	gutterAtTop: false
+};
 /**
 * Parse `word/settings.xml` (ECMA-376 §17.15), extracting only the flags the
 * renderer needs; everything else (compat, autoSpaceDE, …) is ignored.
@@ -25,11 +30,32 @@ function parseSettings(data) {
 	const settings = poFindByPath(parser.parse(xml), ["w:settings"]);
 	if (!settings) return EMPTY_SETTINGS;
 	let evenAndOddHeaders = false;
-	for (const child of poChildren(settings)) if (poIs(child, "w:evenAndOddHeaders")) {
-		const val = poAttr(child, "val");
-		evenAndOddHeaders = val === void 0 || val === "" || val !== "0" && val !== "false";
+	let doNotExpandShiftReturn = false;
+	let displayBackgroundShape = false;
+	let gutterAtTop = false;
+	let compatibilityMode;
+	for (const child of poChildren(settings)) if (poIs(child, "w:evenAndOddHeaders")) evenAndOddHeaders = onOff(child);
+	else if (poIs(child, "w:displayBackgroundShape")) displayBackgroundShape = onOff(child);
+	else if (poIs(child, "w:gutterAtTop")) gutterAtTop = onOff(child);
+	else if (poIs(child, "w:compat")) {
+		for (const flag of poChildren(child)) if (poIs(flag, "w:doNotExpandShiftReturn")) doNotExpandShiftReturn = onOff(flag);
+		else if (poIs(flag, "w:compatSetting") && poAttr(flag, "name") === "compatibilityMode") {
+			const n = Number(poAttr(flag, "val"));
+			if (Number.isFinite(n)) compatibilityMode = n;
+		}
 	}
-	return { evenAndOddHeaders };
+	return {
+		evenAndOddHeaders,
+		doNotExpandShiftReturn,
+		displayBackgroundShape,
+		gutterAtTop,
+		...compatibilityMode !== void 0 ? { compatibilityMode } : {}
+	};
+}
+/** §17.17.4 ST_OnOff: an absent or empty `w:val` means on; `0`/`false` mean off. */
+function onOff(node) {
+	const val = poAttr(node, "val");
+	return val === void 0 || val === "" || val !== "0" && val !== "false";
 }
 //#endregion
 export { EMPTY_SETTINGS, parseSettings };

package/dist/esm/word/shading.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The colour a `w:shd` actually paints: its `w:fill` background with the
+ * pattern colour blended in at the pattern's density. `clear` (and an absent
+ * `w:val`) is the fill alone; `nil` paints nothing.
+ *
+ * @param val   `w:val` — the pattern.
+ * @param color `w:color` — the pattern's own colour (`auto` ⇒ black).
+ * @param fill  `w:fill` — the background (`auto` ⇒ white).
+ * @returns The 6-hex colour to paint, or `undefined` when nothing is painted.
+ */
+export declare function shadingFillHex(val: string | undefined, color: string | undefined, fill: string | undefined): string | undefined;