rtf-codec 0.0.0 → 1.0.0

package/dist/read.cjs

@@ -0,0 +1,854 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_base64 = require("./base64.cjs");
+const require_diagnostics = require("./diagnostics.cjs");
+const require_bytes = require("./bytes.cjs");
+const require_codepage = require("./codepage.cjs");
+const require_group = require("./group.cjs");
+const require_units = require("./units.cjs");
+const require_header = require("./header.cjs");
+const require_list_id = require("./list-id.cjs");
+require("./options.cjs");
+const require_tokenize = require("./tokenize.cjs");
+let document_schema_js = require("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", "skip"],
+	["bkmkend", "skip"],
+	["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"]]);
+function defaultCharacterState() {
+	return {
+		bold: false,
+		italic: false,
+		underline: false,
+		strike: false,
+		hidden: false,
+		fontIndex: void 0,
+		sizeHalfPoints: 24,
+		colorIndex: void 0
+	};
+}
+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,
+		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 ?? ""
+	].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
+	};
+}
+var ContentBuilder = class {
+	header;
+	sink;
+	sections = [];
+	blocks = [];
+	runs = [];
+	pendingRunKey;
+	pendingRunText = "";
+	pendingRunFields = {};
+	tableRows = [];
+	tableColumnRights = [];
+	rowCells = [];
+	cellBlocks = [];
+	pendingCellRights = [];
+	rowLeftTwips = 0;
+	constructor(header, sink) {
+		this.header = header;
+		this.sink = sink;
+	}
+	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.pendingRunText += text;
+	}
+	flushRun() {
+		if (this.pendingRunText.length > 0) this.runs.push({
+			...this.pendingRunFields,
+			text: this.pendingRunText
+		});
+		this.pendingRunText = "";
+		this.pendingRunKey = void 0;
+		this.pendingRunFields = {};
+	}
+	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();
+		target.push(this.buildParagraph(para));
+		this.runs = [];
+	}
+	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 paragraph = {
+			kind: "paragraph",
+			runs: this.runs
+		};
+		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: require_units.twipsToPoints(para.indentLeftTwips) },
+			...para.indentFirstLineTwips === 0 ? {} : { indentFirstLinePt: require_units.twipsToPoints(para.indentFirstLineTwips) },
+			...para.spaceBeforeTwips === 0 ? {} : { spacingBeforePt: require_units.twipsToPoints(para.spaceBeforeTwips) },
+			...para.spaceAfterTwips === 0 ? {} : { spacingAfterPt: require_units.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: require_list_id.mintRtfListNumId({
+				listOverrideIndex: overrideIndex,
+				type,
+				...level?.startAt === void 0 ? {} : { start: level.startAt }
+			}),
+			level: para.listLevel
+		} };
+	}
+	startRowDefinition() {
+		this.pendingCellRights = [];
+		this.rowLeftTwips = 0;
+	}
+	setRowLeft(twips) {
+		this.rowLeftTwips = twips;
+	}
+	addCellBoundary(rightTwips) {
+		this.pendingCellRights.push(rightTwips);
+	}
+	endCell(para) {
+		this.endParagraph(para, false);
+		this.rowCells.push({ blocks: this.cellBlocks });
+		this.cellBlocks = [];
+	}
+	endRow(para) {
+		if (this.cellBlocks.length > 0 || this.pendingRunText.length > 0) this.endCell(para);
+		if (this.rowCells.length === 0) {
+			this.sink({
+				code: require_diagnostics.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 });
+		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));
+		this.blocks.push({
+			kind: "table",
+			rows: this.tableRows,
+			columnWidthsPt: this.columnWidths(columnCount)
+		});
+		this.tableRows = [];
+		this.tableColumnRights = [];
+	}
+	columnWidths(columnCount) {
+		const rights = this.tableColumnRights;
+		const widths = [];
+		let previous = this.rowLeftTwips;
+		for (const right of rights.slice(0, columnCount)) {
+			widths.push(require_units.twipsToPoints(right - previous));
+			previous = right;
+		}
+		const usable = require_units.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: require_diagnostics.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(pageSize, margins, para) {
+		this.endParagraph(para, false);
+		this.closeTable();
+		if (this.blocks.length === 0 && this.sections.length > 0) return;
+		this.sections.push({
+			pageSize,
+			margins,
+			blocks: this.blocks
+		});
+		this.blocks = [];
+	}
+	finish(metadata, pageSize, margins, para) {
+		this.endSection(pageSize, margins, para);
+		if (this.sections.length === 0) this.sections.push({
+			pageSize,
+			margins,
+			blocks: []
+		});
+		return {
+			kind: "wordprocessing",
+			metadata,
+			sections: this.sections
+		};
+	}
+};
+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: require_units.halfPointsToPoints(char.sizeHalfPoints),
+		...color === void 0 ? {} : { color },
+		...hyperlink === void 0 ? {} : { hyperlink }
+	};
+}
+function buildPicture(picture, sink) {
+	if (picture.format === void 0) {
+		sink({
+			code: require_diagnostics.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) : require_base64.hexToBytes(picture.hex);
+	if (bytes.length === 0) {
+		sink({
+			code: require_diagnostics.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 : require_units.pixelsToPoints(picture.widthPixels) : require_units.twipsToPoints(picture.widthGoalTwips);
+	const heightPt = picture.heightGoalTwips === void 0 ? picture.heightPixels === void 0 ? void 0 : require_units.pixelsToPoints(picture.heightPixels) : require_units.twipsToPoints(picture.heightGoalTwips);
+	if (widthPt === void 0 || heightPt === void 0) {
+		sink({
+			code: require_diagnostics.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: require_diagnostics.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: require_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 require_diagnostics.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 = require_tokenize.tokenizeRtf(input);
+	assertRtfHeaderPresent(tokens);
+	const header = require_header.readRtfHeader(tokens, sink);
+	const builder = new ContentBuilder(header, sink);
+	const pageSize = {
+		widthPt: require_units.twipsToPoints(header.page.paperWidthTwips),
+		heightPt: require_units.twipsToPoints(header.page.paperHeightTwips)
+	};
+	const margins = {
+		topPt: require_units.twipsToPoints(header.page.marginTopTwips),
+		rightPt: require_units.twipsToPoints(header.page.marginRightTwips),
+		bottomPt: require_units.twipsToPoints(header.page.marginBottomTwips),
+		leftPt: require_units.twipsToPoints(header.page.marginLeftTwips)
+	};
+	const root = {
+		destination: "body",
+		uc: 1,
+		char: defaultCharacterState(),
+		para: defaultParagraphState(),
+		field: void 0,
+		picture: 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 = require_codepage.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;
+	};
+	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 = require_group.groupHead(tokens, index);
+			const known = head.destination === void 0 ? void 0 : DESTINATION_KINDS.get(head.destination);
+			const isHeaderTable = head.destination !== void 0 && require_header.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: require_diagnostics.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: require_diagnostics.RtfDiagnosticCodes.CONTENT_DESTINATION_SKIPPED,
+					severity: "warning",
+					message: `the \\${head.destination} destination's content is discarded: no ContentDocument position carries it`
+				});
+			}
+			if (kind === "skip") {
+				index = require_group.matchingGroupEnd(tokens, index) + 1;
+				textOffset = 0;
+				continue;
+			}
+			if (stack.length >= maxGroupDepth) throw new require_diagnostics.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();
+				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 (stack.length > 1) {
+				stack.pop();
+				const parent = stack[stack.length - 1];
+				if (parent !== void 0) state = parent;
+			} else sink({
+				code: require_diagnostics.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 += require_bytes.asciiStringFromBytes(slice);
+			else require_bytes.appendBytes(pendingBytes, slice);
+			index += 1;
+			textOffset = 0;
+			continue;
+		}
+		if (token.kind === "binary") {
+			if (state.destination === "picture" && state.picture !== void 0) require_bytes.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, sink);
+		index += 1;
+	}
+	flushBytes();
+	if (stack.length > 1) sink({
+		code: require_diagnostics.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, pageSize, margins, 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 require_diagnostics.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;
+		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 applyStructureControlWord(name, param, state, builder, 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: require_diagnostics.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);
+			return true;
+		case "sectd": return true;
+		default: return false;
+	}
+}
+function applyControlWord(name, param, state, builder, header, sink) {
+	const picture = state.picture;
+	if (state.destination === "picture" && picture !== void 0) {
+		applyPictureControlWord(name, param, picture);
+		return;
+	}
+	if (applyCharacterControlWord(name, param, state, header)) return;
+	if (applyParagraphControlWord(name, param, state)) return;
+	applyStructureControlWord(name, param, state, builder, sink);
+}
+function readRtfContent(input, options = {}) {
+	return readRtfDetail(typeof input === "string" ? require_bytes.rtfBytesFromLatin1(input) : input, options);
+}
+function readRtf(input, options = {}) {
+	const { document, diagnostics } = readRtfContent(input, options);
+	return {
+		documentPackage: (0, document_schema_js.assembleTree)(document),
+		diagnostics
+	};
+}
+//#endregion
+exports.readRtf = readRtf;
+exports.readRtfContent = readRtfContent;