rtf-codec 0.0.0 → 1.1.0

package/dist/read.js

@@ -0,0 +1,1209 @@
+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 { HEADER_DESTINATIONS, readRtfHeader } from "./header.js";
+import { mintRtfListNumId } from "./list-id.js";
+import "./options.js";
+import { tokenizeRtf } from "./tokenize.js";
+import { assembleTree } from "document-schema.js";
+//#region src/read.ts
+const DESTINATION_KINDS = /* @__PURE__ */ new Map([
+	["fldrslt", "body"],
+	["ud", "body"],
+	["shppict", "body"],
+	["field", "body"],
+	["pict", "picture"],
+	["fldinst", "fieldInstruction"],
+	["listtext", "listText"],
+	["pntext", "listText"],
+	["upr", "unicodeWrapper"],
+	["footnote", "skip"],
+	["header", "skip"],
+	["headerl", "skip"],
+	["headerr", "skip"],
+	["headerf", "skip"],
+	["footer", "skip"],
+	["footerl", "skip"],
+	["footerr", "skip"],
+	["footerf", "skip"],
+	["ftnsep", "skip"],
+	["ftnsepc", "skip"],
+	["ftncn", "skip"],
+	["aftnsep", "skip"],
+	["aftnsepc", "skip"],
+	["aftncn", "skip"],
+	["annotation", "skip"],
+	["atnid", "skip"],
+	["atnauthor", "skip"],
+	["atnref", "skip"],
+	["atndate", "skip"],
+	["atnparent", "skip"],
+	["atnicn", "skip"],
+	["bkmkstart", "bookmarkStart"],
+	["bkmkend", "bookmarkEnd"],
+	["object", "skip"],
+	["objdata", "skip"],
+	["objclass", "skip"],
+	["objname", "skip"],
+	["do", "skip"],
+	["shp", "skip"],
+	["shptxt", "skip"],
+	["shpinst", "skip"],
+	["nonshppict", "skip"],
+	["xe", "skip"],
+	["tc", "skip"],
+	["tcn", "skip"],
+	["pn", "skip"],
+	["pnseclvl", "skip"],
+	["template", "skip"],
+	["comment", "skip"],
+	["falt", "skip"],
+	["panose", "skip"],
+	["fname", "skip"]
+]);
+const SILENT_SKIP_DESTINATIONS = /* @__PURE__ */ new Set([
+	"pn",
+	"pnseclvl",
+	"nonshppict",
+	"falt",
+	"panose",
+	"fname",
+	"atnid",
+	"atnauthor",
+	"atnref",
+	"atndate",
+	"atnparent",
+	"atnicn",
+	"objclass",
+	"objname",
+	"objdata",
+	"shpinst",
+	"shptxt",
+	"ftnsep",
+	"ftnsepc",
+	"ftncn",
+	"aftnsep",
+	"aftnsepc",
+	"aftncn",
+	"template",
+	"comment",
+	"xe",
+	"tc",
+	"tcn"
+]);
+const SPECIAL_CHARACTER_TEXT = /* @__PURE__ */ new Map([
+	["tab", "	"],
+	["line", "\n"],
+	["softline", "\n"],
+	["emdash", "—"],
+	["endash", "–"],
+	["bullet", "•"],
+	["lquote", "‘"],
+	["rquote", "’"],
+	["ldblquote", "“"],
+	["rdblquote", "”"],
+	["emspace", " "],
+	["enspace", " "],
+	["qmspace", " "],
+	["zwj", "‍"],
+	["zwnj", "‌"],
+	["ltrmark", "‎"],
+	["rtlmark", "‏"]
+]);
+const SPECIAL_SYMBOL_TEXT = /* @__PURE__ */ new Map([
+	["~", "\xA0"],
+	["-", "­"],
+	["_", "‑"],
+	["\\", "\\"],
+	["{", "{"],
+	["}", "}"]
+]);
+const ALIGNMENTS = /* @__PURE__ */ new Map([
+	["ql", "left"],
+	["qc", "center"],
+	["qr", "right"],
+	["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,
+		italic: false,
+		underline: false,
+		strike: false,
+		hidden: false,
+		fontIndex: void 0,
+		sizeHalfPoints: 24,
+		colorIndex: void 0,
+		revision: NO_REVISION
+	};
+}
+function defaultParagraphState() {
+	return {
+		alignment: void 0,
+		indentLeftTwips: 0,
+		indentFirstLineTwips: 0,
+		spaceBeforeTwips: 0,
+		spaceAfterTwips: 0,
+		lineSpacingTwips: void 0,
+		lineSpacingIsMultiple: false,
+		styleIndex: void 0,
+		outlineLevel: void 0,
+		listOverrideIndex: void 0,
+		listLevel: 0,
+		inTable: false,
+		pageBreakBefore: false
+	};
+}
+function cloneGroupState(state) {
+	return {
+		destination: state.destination,
+		uc: state.uc,
+		char: { ...state.char },
+		para: { ...state.para },
+		field: state.field,
+		picture: state.picture,
+		bookmark: state.bookmark,
+		inUnicodeWrapper: state.inUnicodeWrapper
+	};
+}
+function runKey(char, fontName, color, hyperlink) {
+	return [
+		char.bold ? "b" : "",
+		char.italic ? "i" : "",
+		char.underline ? "u" : "",
+		char.strike ? "s" : "",
+		fontName ?? "",
+		String(char.sizeHalfPoints),
+		color === void 0 ? "" : `${String(color.r)},${String(color.g)},${String(color.b)}`,
+		hyperlink ?? "",
+		JSON.stringify(char.revision)
+	].join("|");
+}
+const HYPERLINK_TARGET = /HYPERLINK\s+"([^"]*)"/i;
+const HYPERLINK_BARE_TARGET = /HYPERLINK\s+([^\s"\\]\S*)/i;
+const HYPERLINK_ANCHOR = /\\l\s+"([^"]*)"/i;
+function hyperlinkFromInstruction(instruction) {
+	const quoted = HYPERLINK_TARGET.exec(instruction);
+	const anchor = HYPERLINK_ANCHOR.exec(instruction);
+	const target = quoted?.[1] ?? HYPERLINK_BARE_TARGET.exec(instruction)?.[1];
+	if (target === void 0) return anchor?.[1] === void 0 ? void 0 : `#${anchor[1]}`;
+	return anchor?.[1] === void 0 ? target : `${target}#${anchor[1]}`;
+}
+function skipUnicodeFallback(tokens, from, count) {
+	let { index, textOffset } = from;
+	let remaining = count;
+	while (remaining > 0 && index < tokens.length) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === "groupStart" || token.kind === "groupEnd") break;
+		if (token.kind === "text") {
+			const available = token.bytes.length - textOffset;
+			const consumed = Math.min(available, remaining);
+			remaining -= consumed;
+			textOffset += consumed;
+			if (textOffset >= token.bytes.length) {
+				index += 1;
+				textOffset = 0;
+			}
+			continue;
+		}
+		remaining -= 1;
+		index += 1;
+		textOffset = 0;
+	}
+	return {
+		index,
+		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;
+	sections = [];
+	blocks = [];
+	runs = [];
+	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;
+		const color = char.colorIndex === void 0 ? void 0 : this.header.colors[char.colorIndex];
+		const key = runKey(char, fontName, color, hyperlink);
+		if (this.pendingRunKey !== key) {
+			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
+			});
+			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,
+			...constructs.length === 0 ? {} : { constructs }
+		};
+		const withStyle = style?.name === void 0 || style.name.length === 0 ? paragraph : {
+			...paragraph,
+			styleId: style.name
+		};
+		return {
+			...headingLevel === void 0 ? withStyle : {
+				...withStyle,
+				headingLevel
+			},
+			...para.alignment === void 0 ? {} : { alignment: para.alignment },
+			...para.indentLeftTwips === 0 ? {} : { indentLeftPt: twipsToPoints(para.indentLeftTwips) },
+			...para.indentFirstLineTwips === 0 ? {} : { indentFirstLinePt: twipsToPoints(para.indentFirstLineTwips) },
+			...para.spaceBeforeTwips === 0 ? {} : { spacingBeforePt: twipsToPoints(para.spaceBeforeTwips) },
+			...para.spaceAfterTwips === 0 ? {} : { spacingAfterPt: twipsToPoints(para.spaceAfterTwips) },
+			...this.lineSpacingFields(para),
+			...para.pageBreakBefore ? { pageBreakBefore: true } : {},
+			...this.listFields(para)
+		};
+	}
+	lineSpacingFields(para) {
+		const value = para.lineSpacingTwips;
+		if (value === void 0 || value === 0 || !para.lineSpacingIsMultiple) return {};
+		const multiple = Math.abs(value) / 240;
+		return multiple > 0 ? { lineSpacing: multiple } : {};
+	}
+	listFields(para) {
+		const overrideIndex = para.listOverrideIndex;
+		if (overrideIndex === void 0 || overrideIndex === 0) return {};
+		const list = this.header.lists.get(overrideIndex);
+		const level = list?.levels[para.listLevel] ?? list?.levels[0];
+		const type = level?.numberFormat === 23 ? "bullet" : "ordered";
+		return { list: {
+			numId: mintRtfListNumId({
+				listOverrideIndex: overrideIndex,
+				type,
+				...level?.startAt === void 0 ? {} : { start: level.startAt }
+			}),
+			level: para.listLevel
+		} };
+	}
+	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.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);
+		if (this.rowCells.length === 0) {
+			this.sink({
+				code: RtfDiagnosticCodes.TABLE_ROW_WITHOUT_DEFINITION,
+				severity: "warning",
+				message: "a \\row closed a table row that contained no \\cell marks"
+			});
+			return;
+		}
+		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 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,
+			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 = [];
+		let previous = this.rowLeftTwips;
+		for (const right of rights.slice(0, columnCount)) {
+			widths.push(twipsToPoints(right - previous));
+			previous = right;
+		}
+		const usable = twipsToPoints(this.header.page.paperWidthTwips - this.header.page.marginLeftTwips - this.header.page.marginRightTwips);
+		if (widths.length !== columnCount || widths.some((width) => width <= 0)) {
+			this.sink({
+				code: RtfDiagnosticCodes.TABLE_COLUMN_WIDTH_INVALID,
+				severity: "warning",
+				message: "the row's \\cellxN boundaries do not describe increasing column widths for every column; falling back to an even split of the page's text width"
+			});
+			return Array.from({ length: columnCount }, () => usable / columnCount);
+		}
+		return widths;
+	}
+	addBlock(block) {
+		this.flushRun();
+		this.blocks.push(block);
+	}
+	endSection(section, para) {
+		this.endParagraph(para, false);
+		this.closeTable();
+		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({
+			...sectionGeometry(section),
+			...section.breakType === void 0 ? {} : { breakType: section.breakType },
+			blocks
+		});
+		this.blocks = [];
+	}
+	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({
+			...sectionGeometry(section),
+			blocks: []
+		});
+		return {
+			kind: "wordprocessing",
+			metadata,
+			sections: this.sections
+		};
+	}
+};
+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 } : {},
+		...char.italic ? { italic: true } : {},
+		...char.underline ? { underline: true } : {},
+		...char.strike ? { strike: true } : {},
+		...fontName === void 0 || fontName.length === 0 ? {} : { fontFamily: fontName },
+		sizePt: halfPointsToPoints(char.sizeHalfPoints),
+		...color === void 0 ? {} : { color },
+		...hyperlink === void 0 ? {} : { hyperlink }
+	};
+}
+function buildPicture(picture, sink) {
+	if (picture.format === void 0) {
+		sink({
+			code: RtfDiagnosticCodes.UNSUPPORTED_PICTURE_FORMAT,
+			severity: "warning",
+			message: `a \\pict destination declared ${picture.unsupportedFormat ?? "no"} picture format; ContentImageBlock carries PNG and JPEG only, so this picture is dropped`
+		});
+		return;
+	}
+	const bytes = picture.binary.length > 0 ? Uint8Array.from(picture.binary) : hexToBytes(picture.hex);
+	if (bytes.length === 0) {
+		sink({
+			code: RtfDiagnosticCodes.UNSUPPORTED_PICTURE_FORMAT,
+			severity: "warning",
+			message: "a \\pict destination carried no picture payload"
+		});
+		return;
+	}
+	const scaleX = picture.scaleXPercent / 100;
+	const scaleY = picture.scaleYPercent / 100;
+	const widthPt = picture.widthGoalTwips === void 0 ? picture.widthPixels === void 0 ? void 0 : pixelsToPoints(picture.widthPixels) : twipsToPoints(picture.widthGoalTwips);
+	const heightPt = picture.heightGoalTwips === void 0 ? picture.heightPixels === void 0 ? void 0 : pixelsToPoints(picture.heightPixels) : twipsToPoints(picture.heightGoalTwips);
+	if (widthPt === void 0 || heightPt === void 0) {
+		sink({
+			code: RtfDiagnosticCodes.PICTURE_SIZE_UNSTATED,
+			severity: "warning",
+			message: "a \\pict destination stated neither \\picwgoalN/\\pichgoalN nor \\picwN/\\pichN, so its rendered size is unknown and the picture is dropped; decoding the payload's own intrinsic size would need an image decoder this package deliberately does not carry"
+		});
+		return;
+	}
+	const scaledWidth = widthPt * scaleX;
+	const scaledHeight = heightPt * scaleY;
+	if (scaledWidth <= 0 || scaledHeight <= 0) {
+		sink({
+			code: RtfDiagnosticCodes.PICTURE_SIZE_UNSTATED,
+			severity: "warning",
+			message: "a \\pict destination's stated size scaled to zero or less, which ContentImageBlock cannot express"
+		});
+		return;
+	}
+	return {
+		kind: "image",
+		format: picture.format,
+		base64: bytesToBase64(bytes),
+		widthPt: scaledWidth,
+		heightPt: scaledHeight
+	};
+}
+function defaultPictureState() {
+	return {
+		format: void 0,
+		unsupportedFormat: void 0,
+		widthGoalTwips: void 0,
+		heightGoalTwips: void 0,
+		widthPixels: void 0,
+		heightPixels: void 0,
+		scaleXPercent: 100,
+		scaleYPercent: 100,
+		hex: "",
+		binary: []
+	};
+}
+function toggleValue(param) {
+	return param === void 0 || param !== 0;
+}
+function readRtfDetail(input, options) {
+	options.signal?.throwIfAborted();
+	const maxInputBytes = options.maxInputBytes ?? 67108864;
+	if (input.length > maxInputBytes) throw new RtfInputTooLargeError(input.length, maxInputBytes);
+	const maxGroupDepth = options.maxGroupDepth ?? 256;
+	const diagnostics = [];
+	const callerSink = options.sink;
+	const sink = (diagnostic) => {
+		diagnostics.push(diagnostic);
+		callerSink?.(diagnostic);
+	};
+	const tokens = tokenizeRtf(input);
+	assertRtfHeaderPresent(tokens);
+	const header = readRtfHeader(tokens, sink);
+	const builder = new ContentBuilder(header, sink);
+	const section = defaultSectionState(header);
+	const root = {
+		destination: "body",
+		uc: 1,
+		char: defaultCharacterState(),
+		para: defaultParagraphState(),
+		field: void 0,
+		picture: void 0,
+		bookmark: void 0,
+		inUnicodeWrapper: false
+	};
+	const stack = [root];
+	let state = root;
+	let pendingBytes = [];
+	const activeCodepage = () => {
+		return (state.char.fontIndex === void 0 ? void 0 : header.fonts.get(state.char.fontIndex)?.codepage) ?? header.codepage;
+	};
+	const flushBytes = () => {
+		if (pendingBytes.length === 0) return;
+		const text = decodeCodepageBytes(Uint8Array.from(pendingBytes), activeCodepage(), sink);
+		pendingBytes = [];
+		emitText(text);
+	};
+	const emitText = (text) => {
+		if (state.destination === "body") {
+			const hyperlink = state.field === void 0 ? void 0 : hyperlinkFromInstruction(state.field.instruction);
+			builder.appendText(text, state.char, hyperlink);
+			return;
+		}
+		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;
+	while (index < tokens.length) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === "groupStart") {
+			flushBytes();
+			const head = groupHead(tokens, index);
+			const known = head.destination === void 0 ? void 0 : DESTINATION_KINDS.get(head.destination);
+			const isHeaderTable = head.destination !== void 0 && HEADER_DESTINATIONS.has(head.destination);
+			const wrapperChild = state.inUnicodeWrapper;
+			const kind = isHeaderTable || wrapperChild && head.destination !== "ud" ? "skip" : known ?? (head.ignorable ? "skip" : state.destination);
+			if (head.destination !== void 0 && !isHeaderTable) {
+				if (head.ignorable && known === void 0) sink({
+					code: RtfDiagnosticCodes.UNKNOWN_DESTINATION_SKIPPED,
+					severity: "info",
+					message: `the ignorable destination \\${head.destination} is not recognised and its content is discarded, as the specification requires`
+				});
+				else if (known === "skip" && !SILENT_SKIP_DESTINATIONS.has(head.destination)) sink({
+					code: RtfDiagnosticCodes.CONTENT_DESTINATION_SKIPPED,
+					severity: "warning",
+					message: `the \\${head.destination} destination's content is discarded: no ContentDocument position carries it`
+				});
+			}
+			if (kind === "skip") {
+				index = matchingGroupEnd(tokens, index) + 1;
+				textOffset = 0;
+				continue;
+			}
+			if (stack.length >= maxGroupDepth) throw new RtfNestingLimitExceededError(maxGroupDepth);
+			const child = cloneGroupState(state);
+			child.inUnicodeWrapper = kind === "unicodeWrapper";
+			if (known !== void 0) {
+				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);
+			state = child;
+			textOffset = 0;
+			continue;
+		}
+		if (token.kind === "groupEnd") {
+			flushBytes();
+			if (state.destination === "picture" && state.picture !== void 0) {
+				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];
+				if (parent !== void 0) state = parent;
+			} else sink({
+				code: RtfDiagnosticCodes.UNBALANCED_GROUP,
+				severity: "warning",
+				message: "a closing brace appeared with no group open; the extra brace is ignored",
+				tokenIndex: index
+			});
+			index += 1;
+			textOffset = 0;
+			continue;
+		}
+		if (token.kind === "text") {
+			const slice = textOffset === 0 ? token.bytes : token.bytes.subarray(textOffset);
+			if (state.destination === "picture" && state.picture !== void 0) state.picture.hex += asciiStringFromBytes(slice);
+			else appendBytes(pendingBytes, slice);
+			index += 1;
+			textOffset = 0;
+			continue;
+		}
+		if (token.kind === "binary") {
+			if (state.destination === "picture" && state.picture !== void 0) appendBytes(state.picture.binary, token.bytes);
+			index += 1;
+			continue;
+		}
+		if (token.kind === "hex") {
+			if (state.destination === "picture" && state.picture !== void 0) state.picture.binary.push(token.byte);
+			else pendingBytes.push(token.byte);
+			index += 1;
+			continue;
+		}
+		if (token.kind === "controlSymbol") {
+			const text = SPECIAL_SYMBOL_TEXT.get(token.symbol);
+			if (text !== void 0) {
+				flushBytes();
+				emitText(text);
+			}
+			index += 1;
+			continue;
+		}
+		if (token.name === "u") {
+			flushBytes();
+			const code = token.param;
+			if (code !== void 0) emitText(String.fromCharCode(code < 0 ? code + 65536 : code));
+			const skipped = skipUnicodeFallback(tokens, {
+				index: index + 1,
+				textOffset: 0
+			}, state.uc);
+			index = skipped.index;
+			textOffset = skipped.textOffset;
+			continue;
+		}
+		const special = SPECIAL_CHARACTER_TEXT.get(token.name);
+		if (special !== void 0) {
+			flushBytes();
+			emitText(special);
+			index += 1;
+			continue;
+		}
+		flushBytes();
+		applyControlWord(token.name, token.param, state, builder, header, section, sink);
+		index += 1;
+	}
+	flushBytes();
+	if (stack.length > 1) sink({
+		code: RtfDiagnosticCodes.UNBALANCED_GROUP,
+		severity: "warning",
+		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, section, root.para),
+		diagnostics
+	};
+}
+function assertRtfHeaderPresent(tokens) {
+	const first = tokens[0];
+	const second = tokens[1];
+	if (first?.kind !== "groupStart" || second?.kind !== "controlWord" || second.name !== "rtf") throw new RtfNotAnRtfDocumentError();
+}
+function applyPictureControlWord(name, param, picture) {
+	const format = PICTURE_FORMATS.get(name);
+	if (format !== void 0) {
+		picture.format = format;
+		return;
+	}
+	switch (name) {
+		case "emfblip":
+		case "macpict":
+		case "wmetafile":
+		case "pmmetafile":
+		case "dibitmap":
+		case "wbitmap":
+			picture.unsupportedFormat = `\\${name}`;
+			return;
+		case "picwgoal":
+			picture.widthGoalTwips = param;
+			return;
+		case "pichgoal":
+			picture.heightGoalTwips = param;
+			return;
+		case "picw":
+			picture.widthPixels = param;
+			return;
+		case "pich":
+			picture.heightPixels = param;
+			return;
+		case "picscalex":
+			if (param !== void 0) picture.scaleXPercent = param;
+			return;
+		case "picscaley":
+			if (param !== void 0) picture.scaleYPercent = param;
+			return;
+		default: return;
+	}
+}
+function applyCharacterControlWord(name, param, state, header) {
+	switch (name) {
+		case "plain":
+			state.char = defaultCharacterState();
+			return true;
+		case "b":
+			state.char.bold = toggleValue(param);
+			return true;
+		case "i":
+			state.char.italic = toggleValue(param);
+			return true;
+		case "strike":
+			state.char.strike = toggleValue(param);
+			return true;
+		case "v":
+			state.char.hidden = toggleValue(param);
+			return true;
+		case "ulnone":
+			state.char.underline = false;
+			return true;
+		case "f":
+			state.char.fontIndex = param ?? header.defaultFontIndex;
+			return true;
+		case "fs":
+			state.char.sizeHalfPoints = param ?? 24;
+			return true;
+		case "cf":
+			state.char.colorIndex = param;
+			return true;
+		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);
+				return true;
+			}
+			return false;
+	}
+}
+function applyParagraphControlWord(name, param, state) {
+	const alignment = ALIGNMENTS.get(name);
+	if (alignment !== void 0) {
+		state.para.alignment = alignment;
+		return true;
+	}
+	switch (name) {
+		case "pard":
+			state.para = defaultParagraphState();
+			return true;
+		case "s":
+			state.para.styleIndex = param;
+			return true;
+		case "outlinelevel":
+			state.para.outlineLevel = param === void 0 || param > 8 ? void 0 : param;
+			return true;
+		case "li":
+		case "lin":
+			state.para.indentLeftTwips = param ?? 0;
+			return true;
+		case "fi":
+			state.para.indentFirstLineTwips = param ?? 0;
+			return true;
+		case "sb":
+			state.para.spaceBeforeTwips = param ?? 0;
+			return true;
+		case "sa":
+			state.para.spaceAfterTwips = param ?? 0;
+			return true;
+		case "sl":
+			state.para.lineSpacingTwips = param;
+			return true;
+		case "slmult":
+			state.para.lineSpacingIsMultiple = toggleValue(param);
+			return true;
+		case "pagebb":
+			state.para.pageBreakBefore = true;
+			return true;
+		case "ls":
+			state.para.listOverrideIndex = param;
+			return true;
+		case "ilvl":
+			state.para.listLevel = param ?? 0;
+			return true;
+		case "intbl":
+			state.para.inTable = true;
+			return true;
+		default: return false;
+	}
+}
+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);
+			return true;
+		case "trowd":
+			state.para.inTable = true;
+			builder.startRowDefinition();
+			return true;
+		case "trleft":
+			builder.setRowLeft(param ?? 0);
+			return true;
+		case "cellx":
+			if (param !== void 0) builder.addCellBoundary(param);
+			return true;
+		case "cell":
+			builder.endCell(state.para);
+			return true;
+		case "row":
+			builder.endRow(state.para);
+			state.para.inTable = false;
+			return true;
+		case "nestcell":
+		case "nestrow":
+			sink({
+				code: RtfDiagnosticCodes.NESTED_TABLE_FLATTENED,
+				severity: "warning",
+				message: "a nested table's cell/row marks are read as ordinary cell content; the inner table's own structure is not reconstructed"
+			});
+			return true;
+		case "page":
+			builder.endParagraph(state.para, false);
+			builder.addBlock({ kind: "pageBreak" });
+			return true;
+		case "sect":
+			builder.endParagraph(state.para, true);
+			builder.endSection(section, state.para);
+			return true;
+		default: return false;
+	}
+}
+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;
+	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);
+}
+function readRtf(input, options = {}) {
+	const { document, diagnostics } = readRtfContent(input, options);
+	return {
+		documentPackage: assembleTree(document),
+		diagnostics
+	};
+}
+//#endregion
+export { readRtf, readRtfContent };