rtf-codec 1.0.0 → 1.1.0

package/dist/read.d.cts

@@ -1,4 +1,4 @@
-import { n as RtfDiagnostic } from "./diagnostics-DdDFJLNO.cjs";
+import { n as RtfDiagnostic } from "./diagnostics-BgG_KAiN.cjs";
 import { ReadRtfOptions } from "./options.cjs";
 import { ContentDocument, DocumentTree } from "document-schema.js";
 //#region src/read.d.ts

package/dist/read.d.ts

@@ -1,4 +1,4 @@
-import { n as RtfDiagnostic } from "./diagnostics-DdDFJLNO.js";
+import { n as RtfDiagnostic } from "./diagnostics-BgG_KAiN.js";
 import { ReadRtfOptions } from "./options.js";
 import { ContentDocument, DocumentTree } from "document-schema.js";
 //#region src/read.d.ts

package/dist/read.js

@@ -1,9 +1,11 @@
 import { bytesToBase64, hexToBytes } from "./base64.js";
 import { RtfDiagnosticCodes, RtfInputTooLargeError, RtfNestingLimitExceededError, RtfNotAnRtfDocumentError } from "./diagnostics.js";
 import { appendBytes, asciiStringFromBytes, rtfBytesFromLatin1 } from "./bytes.js";
+import { halfPointsToPoints, pixelsToPoints, twipsToPoints } from "./units.js";
+import { applyCellDefinitionControlWord, newPendingCell, resolveBorder } from "./cell-format.js";
+import { NO_REVISION, bookmarkAnchorDescriptor, coalesceRunConstructs, provenanceDescriptors } from "./constructs.js";
 import { decodeCodepageBytes } from "./codepage.js";
 import { groupHead, matchingGroupEnd } from "./group.js";
-import { halfPointsToPoints, pixelsToPoints, twipsToPoints } from "./units.js";
 import { HEADER_DESTINATIONS, readRtfHeader } from "./header.js";
 import { mintRtfListNumId } from "./list-id.js";
 import "./options.js";
@@ -42,8 +44,8 @@ const DESTINATION_KINDS = /* @__PURE__ */ new Map([
 	["atndate", "skip"],
 	["atnparent", "skip"],
 	["atnicn", "skip"],
-	["bkmkstart", "skip"],
-	["bkmkend", "skip"],
+	["bkmkstart", "bookmarkStart"],
+	["bkmkend", "bookmarkEnd"],
 	["object", "skip"],
 	["objdata", "skip"],
 	["objclass", "skip"],
@@ -128,6 +130,12 @@ const ALIGNMENTS = /* @__PURE__ */ new Map([
 	["qj", "justify"]
 ]);
 const PICTURE_FORMATS = /* @__PURE__ */ new Map([["pngblip", "png"], ["jpegblip", "jpeg"]]);
+const SECTION_BREAK_TYPES = /* @__PURE__ */ new Map([
+	["sbknone", "continuous"],
+	["sbkpage", void 0],
+	["sbkeven", "evenPage"],
+	["sbkodd", "oddPage"]
+]);
 function defaultCharacterState() {
 	return {
 		bold: false,
@@ -137,7 +145,8 @@ function defaultCharacterState() {
 		hidden: false,
 		fontIndex: void 0,
 		sizeHalfPoints: 24,
-		colorIndex: void 0
+		colorIndex: void 0,
+		revision: NO_REVISION
 	};
 }
 function defaultParagraphState() {
@@ -165,6 +174,7 @@ function cloneGroupState(state) {
 		para: { ...state.para },
 		field: state.field,
 		picture: state.picture,
+		bookmark: state.bookmark,
 		inUnicodeWrapper: state.inUnicodeWrapper
 	};
 }
@@ -177,7 +187,8 @@ function runKey(char, fontName, color, hyperlink) {
 		fontName ?? "",
 		String(char.sizeHalfPoints),
 		color === void 0 ? "" : `${String(color.r)},${String(color.g)},${String(color.b)}`,
-		hyperlink ?? ""
+		hyperlink ?? "",
+		JSON.stringify(char.revision)
 	].join("|");
 }
 const HYPERLINK_TARGET = /HYPERLINK\s+"([^"]*)"/i;
@@ -217,6 +228,28 @@ function skipUnicodeFallback(tokens, from, count) {
 		textOffset
 	};
 }
+function insertConstructMarkers(blocks, extents) {
+	if (extents.length === 0) return [...blocks];
+	const ordered = [...extents].sort((left, right) => left.startIndex - right.startIndex || right.endIndex - left.endIndex);
+	const closing = [...ordered].reverse();
+	const out = [];
+	for (let index = 0; index <= blocks.length; index += 1) {
+		for (const extent of closing) if (extent.endIndex === index) out.push({ kind: "constructEnd" });
+		for (const extent of ordered) if (extent.startIndex === index) out.push({
+			kind: "constructStart",
+			descriptor: extent.descriptor
+		});
+		const block = blocks[index];
+		if (block !== void 0) out.push(block);
+	}
+	return out;
+}
+function horizontalSpanAt(definitions, index) {
+	if (definitions[index]?.horizontalMergeFirst !== true) return 1;
+	let span = 1;
+	while (definitions[index + span]?.horizontalMergeContinuation === true) span += 1;
+	return span;
+}
 var ContentBuilder = class {
 	header;
 	sink;
@@ -226,16 +259,63 @@ var ContentBuilder = class {
 	pendingRunKey;
 	pendingRunText = "";
 	pendingRunFields = {};
+	runProvenance = [];
+	pendingRunProvenance = [];
 	tableRows = [];
 	tableColumnRights = [];
 	rowCells = [];
 	cellBlocks = [];
 	pendingCellRights = [];
+	pendingCellDefinitions = [];
+	pendingCell = newPendingCell();
 	rowLeftTwips = 0;
+	paragraphSerial = 0;
+	openBookmarks = /* @__PURE__ */ new Map();
+	sectionBlockExtents = [];
+	cellBlockExtents = [];
+	pendingRunConstructs = [];
+	closingBookmarks = [];
 	constructor(header, sink) {
 		this.header = header;
 		this.sink = sink;
 	}
+	startBookmark(bookmark, para) {
+		this.flushRun();
+		const name = bookmark.name;
+		if (name.length === 0) return;
+		this.openBookmarks.set(name, {
+			descriptor: bookmarkAnchorDescriptor(name, bookmark.columnFirst === void 0 && bookmark.columnLast === void 0 ? void 0 : {
+				first: bookmark.columnFirst,
+				last: bookmark.columnLast
+			}),
+			paragraphSerial: this.paragraphSerial,
+			runIndex: this.runs.length,
+			inTable: para.inTable,
+			blockIndex: void 0
+		});
+	}
+	endBookmark(name) {
+		this.flushRun();
+		const open = this.openBookmarks.get(name);
+		if (open === void 0) {
+			this.sink({
+				code: RtfDiagnosticCodes.BOOKMARK_UNPAIRED,
+				severity: "warning",
+				message: `a \\bkmkend named '${name}' has no matching \\bkmkstart, so no anchor construct is produced for it`
+			});
+			return;
+		}
+		this.openBookmarks.delete(name);
+		if (open.paragraphSerial === this.paragraphSerial) {
+			this.pendingRunConstructs.push({
+				descriptor: open.descriptor,
+				startRun: open.runIndex,
+				endRun: this.runs.length
+			});
+			return;
+		}
+		this.closingBookmarks.push(open);
+	}
 	appendText(text, char, hyperlink) {
 		if (text.length === 0 || char.hidden) return;
 		const fontName = char.fontIndex === void 0 ? void 0 : this.header.fonts.get(char.fontIndex)?.name;
@@ -245,32 +325,73 @@ var ContentBuilder = class {
 			this.flushRun();
 			this.pendingRunKey = key;
 			this.pendingRunFields = buildRunFields(char, fontName, color, hyperlink);
+			this.pendingRunProvenance = provenanceDescriptors(char.revision, this.header.revisionAuthors);
 		}
 		this.pendingRunText += text;
 	}
 	flushRun() {
-		if (this.pendingRunText.length > 0) this.runs.push({
-			...this.pendingRunFields,
-			text: this.pendingRunText
-		});
+		if (this.pendingRunText.length > 0) {
+			this.runs.push({
+				...this.pendingRunFields,
+				text: this.pendingRunText
+			});
+			this.runProvenance.push(this.pendingRunProvenance);
+		}
 		this.pendingRunText = "";
 		this.pendingRunKey = void 0;
 		this.pendingRunFields = {};
+		this.pendingRunProvenance = [];
 	}
 	endParagraph(para, force) {
 		this.flushRun();
 		if (!force && this.runs.length === 0) return;
 		const target = para.inTable ? this.cellBlocks : this.blocks;
 		if (!para.inTable) this.closeTable();
+		const blockIndex = target.length;
 		target.push(this.buildParagraph(para));
 		this.runs = [];
+		this.runProvenance = [];
+		this.resolveBookmarkPositions(para, blockIndex);
+		this.paragraphSerial += 1;
+	}
+	resolveBookmarkPositions(para, blockIndex) {
+		for (const open of this.openBookmarks.values()) if (open.blockIndex === void 0 && open.paragraphSerial === this.paragraphSerial) open.blockIndex = blockIndex;
+		this.flushClosingBookmarks(para.inTable, blockIndex + 1);
+	}
+	flushClosingBookmarks(inTable, endIndex) {
+		if (this.closingBookmarks.length === 0) return;
+		const target = inTable ? this.cellBlockExtents : this.sectionBlockExtents;
+		for (const closing of this.closingBookmarks) {
+			if (closing.inTable !== inTable) {
+				this.sink({
+					code: RtfDiagnosticCodes.BOOKMARK_UNPAIRED,
+					severity: "warning",
+					message: `the bookmark '${closing.descriptor.name}' spans a table cell boundary; a construct extent cannot straddle two block lists, so no anchor construct is produced for it`
+				});
+				continue;
+			}
+			target.push({
+				descriptor: closing.descriptor,
+				startIndex: closing.blockIndex ?? Math.max(0, endIndex - 1),
+				endIndex
+			});
+		}
+		this.closingBookmarks = [];
+	}
+	takeRunConstructs() {
+		const extents = [...this.pendingRunConstructs, ...coalesceRunConstructs(this.runProvenance)].filter((extent) => extent.endRun <= this.runs.length);
+		this.pendingRunConstructs = [];
+		this.runProvenance = [];
+		return extents.sort((left, right) => left.startRun - right.startRun || left.endRun - right.endRun);
 	}
 	buildParagraph(para) {
 		const style = para.styleIndex === void 0 ? void 0 : this.header.styles.get(para.styleIndex);
 		const headingLevel = para.outlineLevel === void 0 ? style?.headingLevel : para.outlineLevel + 1;
+		const constructs = this.takeRunConstructs();
 		const paragraph = {
 			kind: "paragraph",
-			runs: this.runs
+			runs: this.runs,
+			...constructs.length === 0 ? {} : { constructs }
 		};
 		const withStyle = style?.name === void 0 || style.name.length === 0 ? paragraph : {
 			...paragraph,
@@ -314,18 +435,27 @@ var ContentBuilder = class {
 	}
 	startRowDefinition() {
 		this.pendingCellRights = [];
+		this.pendingCellDefinitions = [];
+		this.pendingCell = newPendingCell();
 		this.rowLeftTwips = 0;
 	}
 	setRowLeft(twips) {
 		this.rowLeftTwips = twips;
 	}
+	applyCellDefinition(name, param) {
+		return applyCellDefinitionControlWord(name, param, this.pendingCell);
+	}
 	addCellBoundary(rightTwips) {
 		this.pendingCellRights.push(rightTwips);
+		this.pendingCellDefinitions.push(this.pendingCell);
+		this.pendingCell = newPendingCell();
 	}
 	endCell(para) {
 		this.endParagraph(para, false);
-		this.rowCells.push({ blocks: this.cellBlocks });
+		this.flushClosingBookmarks(true, this.cellBlocks.length);
+		this.rowCells.push({ blocks: insertConstructMarkers(this.cellBlocks, this.cellBlockExtents) });
 		this.cellBlocks = [];
+		this.cellBlockExtents = [];
 	}
 	endRow(para) {
 		if (this.cellBlocks.length > 0 || this.pendingRunText.length > 0) this.endCell(para);
@@ -337,21 +467,75 @@ var ContentBuilder = class {
 			});
 			return;
 		}
-		this.tableRows.push({ cells: this.rowCells });
+		this.tableRows.push({
+			cells: this.rowCells,
+			definitions: this.pendingCellDefinitions
+		});
 		if (this.tableColumnRights.length === 0) this.tableColumnRights = [...this.pendingCellRights];
 		this.rowCells = [];
 	}
 	closeTable() {
 		if (this.tableRows.length === 0) return;
-		const columnCount = Math.max(...this.tableRows.map((row) => row.cells.length));
+		const rows = this.resolveRows();
+		const columnCount = Math.max(this.tableColumnRights.length, ...rows.map((row) => row.cells.reduce((total, cell) => total + (cell.colSpan ?? 1), 0)));
 		this.blocks.push({
 			kind: "table",
-			rows: this.tableRows,
+			rows,
 			columnWidthsPt: this.columnWidths(columnCount)
 		});
 		this.tableRows = [];
 		this.tableColumnRights = [];
 	}
+	resolveRows() {
+		const rows = this.tableRows;
+		const columnIndices = rows.map((row) => {
+			const indices = [];
+			let column = 0;
+			for (const [index] of row.cells.entries()) {
+				indices.push(column);
+				column += horizontalSpanAt(row.definitions, index);
+			}
+			return indices;
+		});
+		return rows.map((row, rowIndex) => ({ cells: row.cells.map((cell, cellIndex) => ({
+			cell,
+			cellIndex
+		})).filter(({ cellIndex }) => row.definitions[cellIndex]?.horizontalMergeContinuation !== true).map(({ cell, cellIndex }) => {
+			const definition = row.definitions[cellIndex];
+			if (definition?.verticalMergeContinuation === true) return { blocks: [] };
+			const colSpan = horizontalSpanAt(row.definitions, cellIndex);
+			const column = columnIndices[rowIndex]?.[cellIndex];
+			let rowSpan = 1;
+			if (definition?.verticalMergeFirst === true && column !== void 0) for (let next = rowIndex + 1; next < rows.length; next += 1) {
+				const matchIndex = columnIndices[next]?.indexOf(column) ?? -1;
+				if ((matchIndex === -1 ? void 0 : rows[next]?.definitions[matchIndex])?.verticalMergeContinuation !== true) break;
+				rowSpan += 1;
+			}
+			const borders = this.resolveBorders(definition);
+			const background = definition?.backgroundIndex === void 0 ? void 0 : this.header.colors[definition.backgroundIndex];
+			return {
+				blocks: cell.blocks,
+				...colSpan > 1 ? { colSpan } : {},
+				...rowSpan > 1 ? { rowSpan } : {},
+				...background === void 0 ? {} : { background },
+				...borders === void 0 ? {} : { borders }
+			};
+		}) }));
+	}
+	resolveBorders(definition) {
+		if (definition === void 0) return;
+		const colorAt = (index) => this.header.colors[index];
+		const present = [
+			"top",
+			"left",
+			"bottom",
+			"right"
+		].map((side) => {
+			const pending = definition.borders[side];
+			return [side, pending === void 0 ? void 0 : resolveBorder(pending, colorAt)];
+		}).filter((entry) => entry[1] !== void 0);
+		return present.length === 0 ? void 0 : Object.fromEntries(present);
+	}
 	columnWidths(columnCount) {
 		const rights = this.tableColumnRights;
 		const widths = [];
@@ -375,22 +559,36 @@ var ContentBuilder = class {
 		this.flushRun();
 		this.blocks.push(block);
 	}
-	endSection(pageSize, margins, para) {
+	endSection(section, para) {
 		this.endParagraph(para, false);
 		this.closeTable();
-		if (this.blocks.length === 0 && this.sections.length > 0) return;
+		this.flushClosingBookmarks(false, this.blocks.length);
+		this.reportUnclosedBookmarks();
+		const blocks = insertConstructMarkers(this.blocks, this.sectionBlockExtents);
+		this.sectionBlockExtents = [];
+		if (blocks.length === 0 && this.sections.length > 0) {
+			this.blocks = [];
+			return;
+		}
 		this.sections.push({
-			pageSize,
-			margins,
-			blocks: this.blocks
+			...sectionGeometry(section),
+			...section.breakType === void 0 ? {} : { breakType: section.breakType },
+			blocks
 		});
 		this.blocks = [];
 	}
-	finish(metadata, pageSize, margins, para) {
-		this.endSection(pageSize, margins, para);
+	reportUnclosedBookmarks() {
+		for (const open of this.openBookmarks.values()) this.sink({
+			code: RtfDiagnosticCodes.BOOKMARK_UNPAIRED,
+			severity: "warning",
+			message: `the bookmark '${open.descriptor.name}' has no matching \\bkmkend within its own block flow, so no anchor construct is produced for it`
+		});
+		this.openBookmarks.clear();
+	}
+	finish(metadata, section, para) {
+		this.endSection(section, para);
 		if (this.sections.length === 0) this.sections.push({
-			pageSize,
-			margins,
+			...sectionGeometry(section),
 			blocks: []
 		});
 		return {
@@ -400,6 +598,31 @@ var ContentBuilder = class {
 		};
 	}
 };
+function sectionGeometry(section) {
+	return {
+		pageSize: {
+			widthPt: twipsToPoints(section.paperWidthTwips),
+			heightPt: twipsToPoints(section.paperHeightTwips)
+		},
+		margins: {
+			topPt: twipsToPoints(section.marginTopTwips),
+			rightPt: twipsToPoints(section.marginRightTwips),
+			bottomPt: twipsToPoints(section.marginBottomTwips),
+			leftPt: twipsToPoints(section.marginLeftTwips)
+		}
+	};
+}
+function defaultSectionState(header) {
+	return {
+		paperWidthTwips: header.page.paperWidthTwips,
+		paperHeightTwips: header.page.paperHeightTwips,
+		marginLeftTwips: header.page.marginLeftTwips,
+		marginRightTwips: header.page.marginRightTwips,
+		marginTopTwips: header.page.marginTopTwips,
+		marginBottomTwips: header.page.marginBottomTwips,
+		breakType: void 0
+	};
+}
 function buildRunFields(char, fontName, color, hyperlink) {
 	return {
 		...char.bold ? { bold: true } : {},
@@ -492,16 +715,7 @@ function readRtfDetail(input, options) {
 	assertRtfHeaderPresent(tokens);
 	const header = readRtfHeader(tokens, sink);
 	const builder = new ContentBuilder(header, sink);
-	const pageSize = {
-		widthPt: twipsToPoints(header.page.paperWidthTwips),
-		heightPt: twipsToPoints(header.page.paperHeightTwips)
-	};
-	const margins = {
-		topPt: twipsToPoints(header.page.marginTopTwips),
-		rightPt: twipsToPoints(header.page.marginRightTwips),
-		bottomPt: twipsToPoints(header.page.marginBottomTwips),
-		leftPt: twipsToPoints(header.page.marginLeftTwips)
-	};
+	const section = defaultSectionState(header);
 	const root = {
 		destination: "body",
 		uc: 1,
@@ -509,6 +723,7 @@ function readRtfDetail(input, options) {
 		para: defaultParagraphState(),
 		field: void 0,
 		picture: void 0,
+		bookmark: void 0,
 		inUnicodeWrapper: false
 	};
 	const stack = [root];
@@ -529,7 +744,14 @@ function readRtfDetail(input, options) {
 			builder.appendText(text, state.char, hyperlink);
 			return;
 		}
-		if (state.destination === "fieldInstruction" && state.field !== void 0) state.field.instruction += text;
+		if (state.destination === "fieldInstruction" && state.field !== void 0) {
+			state.field.instruction += text;
+			return;
+		}
+		if ((state.destination === "bookmarkStart" || state.destination === "bookmarkEnd") && state.bookmark !== void 0) {
+			state.bookmark.name += text;
+			return;
+		}
 	};
 	let index = 0;
 	let textOffset = 0;
@@ -567,6 +789,11 @@ function readRtfDetail(input, options) {
 				child.destination = kind;
 				if (head.destination === "field") child.field = { instruction: "" };
 				if (kind === "picture") child.picture = defaultPictureState();
+				if (kind === "bookmarkStart" || kind === "bookmarkEnd") child.bookmark = {
+					name: "",
+					columnFirst: void 0,
+					columnLast: void 0
+				};
 				index = head.contentStart;
 			} else index += 1;
 			stack.push(child);
@@ -580,6 +807,14 @@ function readRtfDetail(input, options) {
 				const image = buildPicture(state.picture, sink);
 				if (image !== void 0) builder.addBlock(image);
 			}
+			if (state.bookmark !== void 0) {
+				const bookmark = {
+					...state.bookmark,
+					name: state.bookmark.name.trim()
+				};
+				if (state.destination === "bookmarkStart") builder.startBookmark(bookmark, state.para);
+				else if (state.destination === "bookmarkEnd") builder.endBookmark(bookmark.name);
+			}
 			if (stack.length > 1) {
 				stack.pop();
 				const parent = stack[stack.length - 1];
@@ -642,7 +877,7 @@ function readRtfDetail(input, options) {
 			continue;
 		}
 		flushBytes();
-		applyControlWord(token.name, token.param, state, builder, header, sink);
+		applyControlWord(token.name, token.param, state, builder, header, section, sink);
 		index += 1;
 	}
 	flushBytes();
@@ -652,7 +887,7 @@ function readRtfDetail(input, options) {
 		message: `${String(stack.length - 1)} group(s) were still open at the end of the input; each is treated as closing there`
 	});
 	return {
-		document: builder.finish(header.metadata, pageSize, margins, root.para),
+		document: builder.finish(header.metadata, section, root.para),
 		diagnostics
 	};
 }
@@ -729,6 +964,78 @@ function applyCharacterControlWord(name, param, state, header) {
 		case "uc":
 			if (param !== void 0 && param >= 0) state.uc = param;
 			return true;
+		case "revised":
+			state.char.revision = {
+				...state.char.revision,
+				revised: toggleValue(param)
+			};
+			return true;
+		case "revauth":
+			state.char.revision = {
+				...state.char.revision,
+				revisedAuthor: param
+			};
+			return true;
+		case "revdttm":
+			state.char.revision = {
+				...state.char.revision,
+				revisedDateTime: param
+			};
+			return true;
+		case "deleted":
+			state.char.revision = {
+				...state.char.revision,
+				deleted: toggleValue(param)
+			};
+			return true;
+		case "revauthdel":
+			state.char.revision = {
+				...state.char.revision,
+				deletedAuthor: param
+			};
+			return true;
+		case "revdttmdel":
+			state.char.revision = {
+				...state.char.revision,
+				deletedDateTime: param
+			};
+			return true;
+		case "mvf":
+			state.char.revision = {
+				...state.char.revision,
+				moved: toggleValue(param) ? "moveFrom" : void 0
+			};
+			return true;
+		case "mvt":
+			state.char.revision = {
+				...state.char.revision,
+				moved: toggleValue(param) ? "moveTo" : void 0
+			};
+			return true;
+		case "mvauth":
+			state.char.revision = {
+				...state.char.revision,
+				movedAuthor: param
+			};
+			return true;
+		case "mvdate":
+			state.char.revision = {
+				...state.char.revision,
+				movedDateTime: param
+			};
+			return true;
+		case "crauth":
+			state.char.revision = {
+				...state.char.revision,
+				formatAuthor: param
+			};
+			return true;
+		case "crdate":
+			state.char.revision = {
+				...state.char.revision,
+				formatDateTime: param
+			};
+			return true;
 		default:
 			if (name.startsWith("ul") && name !== "ulc") {
 				state.char.underline = toggleValue(param);
@@ -787,7 +1094,48 @@ function applyParagraphControlWord(name, param, state) {
 		default: return false;
 	}
 }
-function applyStructureControlWord(name, param, state, builder, sink) {
+function applySectionControlWord(name, param, section, header, sink) {
+	if (name === "sectd") {
+		Object.assign(section, defaultSectionState(header));
+		return true;
+	}
+	if (name === "sbkcol") {
+		sink({
+			code: RtfDiagnosticCodes.SECTION_BREAK_UNREPRESENTED,
+			severity: "info",
+			message: "\\sbkcol starts the section at a new column; ContentSection.breakType names page-level breaks only, so the break kind is dropped and the section itself is kept"
+		});
+		section.breakType = void 0;
+		return true;
+	}
+	if (SECTION_BREAK_TYPES.has(name)) {
+		section.breakType = SECTION_BREAK_TYPES.get(name);
+		return true;
+	}
+	if (param === void 0) return false;
+	switch (name) {
+		case "pgwsxn":
+			section.paperWidthTwips = param;
+			return true;
+		case "pghsxn":
+			section.paperHeightTwips = param;
+			return true;
+		case "marglsxn":
+			section.marginLeftTwips = param;
+			return true;
+		case "margrsxn":
+			section.marginRightTwips = param;
+			return true;
+		case "margtsxn":
+			section.marginTopTwips = param;
+			return true;
+		case "margbsxn":
+			section.marginBottomTwips = param;
+			return true;
+		default: return false;
+	}
+}
+function applyStructureControlWord(name, param, state, builder, section, sink) {
 	switch (name) {
 		case "par":
 			builder.endParagraph(state.para, true);
@@ -823,20 +1171,29 @@ function applyStructureControlWord(name, param, state, builder, sink) {
 			return true;
 		case "sect":
 			builder.endParagraph(state.para, true);
+			builder.endSection(section, state.para);
 			return true;
-		case "sectd": return true;
 		default: return false;
 	}
 }
-function applyControlWord(name, param, state, builder, header, sink) {
+function applyControlWord(name, param, state, builder, header, section, sink) {
 	const picture = state.picture;
 	if (state.destination === "picture" && picture !== void 0) {
 		applyPictureControlWord(name, param, picture);
 		return;
 	}
+	const bookmark = state.bookmark;
+	if (bookmark !== void 0 && state.destination === "bookmarkStart") {
+		if (name === "bkmkcolf") bookmark.columnFirst = param;
+		else if (name === "bkmkcoll") bookmark.columnLast = param;
+		return;
+	}
+	if (state.destination === "bookmarkEnd") return;
 	if (applyCharacterControlWord(name, param, state, header)) return;
+	if (builder.applyCellDefinition(name, param)) return;
 	if (applyParagraphControlWord(name, param, state)) return;
-	applyStructureControlWord(name, param, state, builder, sink);
+	if (applySectionControlWord(name, param, section, header, sink)) return;
+	applyStructureControlWord(name, param, state, builder, section, sink);
 }
 function readRtfContent(input, options = {}) {
 	return readRtfDetail(typeof input === "string" ? rtfBytesFromLatin1(input) : input, options);