rtf-codec 0.0.0 → 1.1.0

package/dist/write.js

@@ -0,0 +1,530 @@
+import { base64ToBytes, bytesToHex } from "./base64.js";
+import { RtfDiagnosticCodes, RtfUnsupportedDocumentKindError } from "./diagnostics.js";
+import { pointsToHalfPoints, pointsToTwips } from "./units.js";
+import { borderControlWords } from "./cell-format.js";
+import { bookmarkResidueControlWords, dttmFromIso, isBookmarkAnchor } from "./constructs.js";
+import { parseRtfListNumId } from "./list-id.js";
+import { clampHeadingLevel, colorToRgbHex, flattenTree } from "document-schema.js";
+//#region src/write.ts
+const LEVEL_NUMBER_FORMAT_BULLET = 23;
+const LEVEL_NUMBER_FORMAT_ARABIC = 0;
+const LIST_LEVEL_INDENT_TWIPS = 720;
+const LIST_MARKER_HANG_TWIPS = 360;
+const BULLET_LEVEL_TEXT = "\\'01\\u183 ?";
+const ARABIC_LEVEL_TEXT = "\\'02\\'00.";
+const OUTPUT_CODEPAGE = 1252;
+const SECTION_BREAK_CONTROL_WORDS = /* @__PURE__ */ new Map([
+	["continuous", "\\sbknone"],
+	["evenPage", "\\sbkeven"],
+	["oddPage", "\\sbkodd"]
+]);
+const ALIGNMENT_CONTROL_WORDS = /* @__PURE__ */ new Map([
+	["left", "\\ql"],
+	["center", "\\qc"],
+	["right", "\\qr"],
+	["justify", "\\qj"]
+]);
+const UNKNOWN_REVISION_AUTHOR = "Unknown";
+const DEFAULT_FONT_NAME = "Times New Roman";
+function collectTables(document) {
+	const fonts = /* @__PURE__ */ new Map([[DEFAULT_FONT_NAME, 0]]);
+	const colors = /* @__PURE__ */ new Map();
+	const headingStyles = /* @__PURE__ */ new Map();
+	const lists = /* @__PURE__ */ new Map();
+	const revisionAuthors = /* @__PURE__ */ new Map([[UNKNOWN_REVISION_AUTHOR, 0]]);
+	const noteDescriptor = (descriptor) => {
+		if (descriptor.kind !== "provenance") return;
+		const author = descriptor.author;
+		if (author !== void 0 && !revisionAuthors.has(author)) revisionAuthors.set(author, revisionAuthors.size);
+	};
+	const noteColor = (color) => {
+		if (color === void 0) return;
+		const hex = colorToRgbHex(color);
+		if (!colors.has(hex)) colors.set(hex, colors.size + 1);
+	};
+	const noteRun = (run) => {
+		if (run.fontFamily !== void 0 && !fonts.has(run.fontFamily)) fonts.set(run.fontFamily, fonts.size);
+		noteColor(run.color);
+	};
+	const noteBlock = (block) => {
+		if (block.kind === "constructStart") {
+			noteDescriptor(block.descriptor);
+			return;
+		}
+		if (block.kind === "paragraph") {
+			for (const run of block.runs) noteRun(run);
+			for (const extent of block.constructs ?? []) noteDescriptor(extent.descriptor);
+			if (block.headingLevel !== void 0) {
+				const level = clampHeadingLevel(block.headingLevel);
+				if (!headingStyles.has(level)) headingStyles.set(level, level);
+			}
+			const numId = block.list?.numId;
+			if (numId !== void 0 && !lists.has(numId)) {
+				const parsed = parseRtfListNumId(numId);
+				lists.set(numId, {
+					index: lists.size + 1,
+					definition: {
+						type: parsed?.type ?? "bullet",
+						start: parsed?.start ?? 1
+					}
+				});
+			}
+			return;
+		}
+		if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) {
+			noteColor(cell.background);
+			for (const side of CELL_BORDER_ORDER) noteColor(cell.borders?.[side]?.color);
+			for (const inner of cell.blocks) noteBlock(inner);
+		}
+	};
+	if (document.kind === "wordprocessing") for (const section of document.sections) for (const block of section.blocks) noteBlock(block);
+	return {
+		fonts,
+		colors,
+		headingStyles,
+		lists,
+		revisionAuthors
+	};
+}
+function escapeText(text) {
+	let out = "";
+	for (const character of text) {
+		switch (character) {
+			case "\\":
+				out += "\\\\";
+				continue;
+			case "{":
+				out += "\\{";
+				continue;
+			case "}":
+				out += "\\}";
+				continue;
+			case "	":
+				out += "\\tab ";
+				continue;
+			case "\n":
+			case "\r":
+				out += "\\line ";
+				continue;
+		}
+		const code = character.codePointAt(0) ?? 0;
+		if (code >= 32 && code < 127) {
+			out += character;
+			continue;
+		}
+		for (let unit = 0; unit < character.length; unit += 1) {
+			const value = character.charCodeAt(unit);
+			const signed = value > 32767 ? value - 65536 : value;
+			out += `\\u${String(signed)} ?`;
+		}
+	}
+	return out;
+}
+function bookmarkStartGroup(descriptor) {
+	if (!isBookmarkAnchor(descriptor)) return "";
+	return `{\\*\\bkmkstart${bookmarkResidueControlWords(descriptor)} ${escapeText(descriptor.name)}}`;
+}
+const CHREV_CONTROL_WORDS = {
+	insertion: {
+		flag: "\\revised",
+		author: "revauth",
+		date: "revdttm"
+	},
+	deletion: {
+		flag: "\\deleted",
+		author: "revauthdel",
+		date: "revdttmdel"
+	},
+	moveFrom: {
+		flag: "\\mvf",
+		author: "mvauth",
+		date: "mvdate"
+	},
+	moveTo: {
+		flag: "\\mvt",
+		author: "mvauth",
+		date: "mvdate"
+	},
+	formatChange: {
+		flag: "",
+		author: "crauth",
+		date: "crdate"
+	}
+};
+function revisionsCovering(extents, index) {
+	return extents.filter((extent) => extent.descriptor.kind === "provenance" && extent.startRun <= index && index < extent.endRun).map((extent) => extent.descriptor).filter((descriptor) => descriptor.kind === "provenance");
+}
+const CELL_BORDER_ORDER = [
+	"top",
+	"left",
+	"bottom",
+	"right"
+];
+function verticalMergeCoverage(table) {
+	const covered = table.rows.map((row) => row.cells.map(() => false));
+	for (const [rowIndex, row] of table.rows.entries()) for (const [cellIndex, cell] of row.cells.entries()) {
+		const rowSpan = cell.rowSpan ?? 1;
+		for (let next = 1; next < rowSpan; next += 1) {
+			const target = covered[rowIndex + next];
+			if (target !== void 0 && cellIndex < target.length) target[cellIndex] = true;
+		}
+	}
+	return covered;
+}
+function nameOf(descriptor) {
+	return isBookmarkAnchor(descriptor) ? descriptor.name : "";
+}
+function describeConstructGap(descriptor) {
+	switch (descriptor.kind) {
+		case "contentControl": return "structured-document-tag equivalent; its own \\*\\formfield production is a narrower construct this writer does not yet mint";
+		case "provenance": return "block-scoped revision mark: its <chrev> production is a character property, so a tracked change reaches RTF only as a run-level extent";
+		case "anchor": return `spelling for a '${descriptor.anchorType}' anchor, whose body would need the note or annotation destination this reader does not place`;
+		case "field": return "block-scoped field: a field is a character-stream construct, written from a run's own hyperlink rather than from a block marker";
+		case "link": return "block-scoped link; an external target rides ContentRun.hyperlink instead";
+		default: return "equivalent construct";
+	}
+}
+var RtfWriter = class {
+	tables;
+	sink;
+	lineEnding;
+	out = "";
+	openConstructs = [];
+	constructor(tables, sink, lineEnding) {
+		this.tables = tables;
+		this.sink = sink;
+		this.lineEnding = lineEnding;
+	}
+	raw(text) {
+		this.out += text;
+	}
+	line(text) {
+		this.out += text + this.lineEnding;
+	}
+	get text() {
+		return this.out;
+	}
+	writeHeader(document) {
+		this.raw(`{\\rtf1\\ansi\\ansicpg${String(OUTPUT_CODEPAGE)}\\deff0\\uc1`);
+		this.writeDocumentGeometry(document);
+		this.writeFontTable();
+		this.writeColorTable();
+		this.writeStyleSheet();
+		this.writeListTables();
+		this.writeRevisionTable();
+		this.writeInfoGroup(document);
+		this.line("");
+	}
+	writeFontTable() {
+		this.raw("{\\fonttbl");
+		for (const [name, index] of [...this.tables.fonts].sort((left, right) => left[1] - right[1])) this.raw(`{\\f${String(index)}\\fnil\\fcharset0 ${escapeText(name)};}`);
+		this.raw("}");
+	}
+	writeColorTable() {
+		if (this.tables.colors.size === 0) return;
+		this.raw("{\\colortbl;");
+		for (const [hex] of [...this.tables.colors].sort((left, right) => left[1] - right[1])) {
+			const red = Number.parseInt(hex.slice(0, 2), 16);
+			const green = Number.parseInt(hex.slice(2, 4), 16);
+			const blue = Number.parseInt(hex.slice(4, 6), 16);
+			this.raw(`\\red${String(red)}\\green${String(green)}\\blue${String(blue)};`);
+		}
+		this.raw("}");
+	}
+	writeStyleSheet() {
+		if (this.tables.headingStyles.size === 0) return;
+		this.raw("{\\stylesheet{\\s0\\snext0 Normal;}");
+		for (const [level, handle] of [...this.tables.headingStyles].sort((left, right) => left[0] - right[0])) this.raw(`{\\s${String(handle)}\\sbasedon0\\snext0\\outlinelevel${String(level - 1)} heading ${String(level)};}`);
+		this.raw("}");
+	}
+	writeListTables() {
+		if (this.tables.lists.size === 0) return;
+		const entries = [...this.tables.lists.values()].sort((left, right) => left.index - right.index);
+		this.raw("{\\*\\listtable");
+		for (const entry of entries) {
+			const bullet = entry.definition.type === "bullet";
+			const numberFormat = bullet ? LEVEL_NUMBER_FORMAT_BULLET : LEVEL_NUMBER_FORMAT_ARABIC;
+			const levelText = bullet ? BULLET_LEVEL_TEXT : ARABIC_LEVEL_TEXT;
+			const levelNumbers = bullet ? "" : "\\'01";
+			this.raw(`{\\list\\listtemplateid${String(entry.index)}\\listhybrid`);
+			for (let level = 0; level < 9; level += 1) {
+				const indent = LIST_LEVEL_INDENT_TWIPS * (level + 1);
+				this.raw(`{\\listlevel\\levelnfc${String(numberFormat)}\\levelnfcn${String(numberFormat)}\\leveljc0\\leveljcn0\\levelfollow0\\levelstartat${String(entry.definition.start)}\\levelspace0\\levelindent0{\\leveltext${levelText};}{\\levelnumbers${levelNumbers};}\\fi-${String(LIST_MARKER_HANG_TWIPS)}\\li${String(indent)}\\lin${String(indent)}}`);
+			}
+			this.raw(`\\listid${String(1e3 + entry.index)}}`);
+		}
+		this.raw("}{\\*\\listoverridetable");
+		for (const entry of entries) this.raw(`{\\listoverride\\listid${String(1e3 + entry.index)}\\listoverridecount0\\ls${String(entry.index)}}`);
+		this.raw("}");
+	}
+	writeRevisionTable() {
+		if (this.tables.revisionAuthors.size <= 1) return;
+		this.raw("{\\*\\revtbl");
+		for (const [author] of [...this.tables.revisionAuthors].sort((left, right) => left[1] - right[1])) this.raw(`{${escapeText(author)};}`);
+		this.raw("}");
+	}
+	writeInfoGroup(document) {
+		const { title, author, subject, keywords } = document.metadata;
+		const fields = [];
+		if (title !== void 0) fields.push(`{\\title ${escapeText(title)}}`);
+		if (author !== void 0) fields.push(`{\\author ${escapeText(author)}}`);
+		if (subject !== void 0) fields.push(`{\\subject ${escapeText(subject)}}`);
+		if (keywords !== void 0 && keywords.length > 0) fields.push(`{\\keywords ${escapeText(keywords.join("; "))}}`);
+		if (fields.length > 0) this.raw(`{\\info${fields.join("")}}`);
+	}
+	writeDocumentGeometry(document) {
+		const first = document.sections[0];
+		if (first === void 0) return;
+		this.raw(`\\paperw${String(pointsToTwips(first.pageSize.widthPt))}\\paperh${String(pointsToTwips(first.pageSize.heightPt))}\\margl${String(pointsToTwips(first.margins.leftPt))}\\margr${String(pointsToTwips(first.margins.rightPt))}\\margt${String(pointsToTwips(first.margins.topPt))}\\margb${String(pointsToTwips(first.margins.bottomPt))}`);
+	}
+	writeSection(section, isFirst) {
+		if (!isFirst) this.line("\\sect");
+		this.line(`\\sectd${SECTION_BREAK_CONTROL_WORDS.get(section.breakType ?? "") ?? ""}\\pgwsxn${String(pointsToTwips(section.pageSize.widthPt))}\\pghsxn${String(pointsToTwips(section.pageSize.heightPt))}\\marglsxn${String(pointsToTwips(section.margins.leftPt))}\\margrsxn${String(pointsToTwips(section.margins.rightPt))}\\margtsxn${String(pointsToTwips(section.margins.topPt))}\\margbsxn${String(pointsToTwips(section.margins.bottomPt))}`);
+		this.writeBlocks(section.blocks);
+	}
+	writeBlocks(blocks) {
+		for (const block of blocks) this.writeBlock(block);
+	}
+	writeBlock(block) {
+		switch (block.kind) {
+			case "paragraph":
+				this.writeParagraph(block, false);
+				return;
+			case "table":
+				this.writeTable(block);
+				return;
+			case "image":
+				this.writeImageParagraph(block.base64, block);
+				return;
+			case "pageBreak":
+				this.line("\\page\\pard");
+				return;
+			case "embeddedObject":
+				this.sink({
+					code: RtfDiagnosticCodes.EMBEDDED_OBJECT_DROPPED,
+					severity: "warning",
+					message: `an embedded ${block.objectKind} object is dropped: writing it as an RTF \\object would need the OLE container this package does not build`
+				});
+				return;
+			case "constructStart":
+				this.openConstruct(block.descriptor);
+				return;
+			case "constructEnd":
+				this.closeConstruct();
+				return;
+			default: return;
+		}
+	}
+	openConstruct(descriptor) {
+		if (!isBookmarkAnchor(descriptor)) {
+			this.sink({
+				code: RtfDiagnosticCodes.CONSTRUCT_UNREPRESENTED,
+				severity: "warning",
+				message: `a ${descriptor.kind} construct is dropped: RTF has no ${describeConstructGap(descriptor)}`
+			});
+			this.openConstructs.push(void 0);
+			return;
+		}
+		this.openConstructs.push(descriptor.name);
+		this.line(bookmarkStartGroup(descriptor));
+	}
+	closeConstruct() {
+		const name = this.openConstructs.pop();
+		if (name !== void 0) this.line(`{\\*\\bkmkend ${escapeText(name)}}`);
+	}
+	writeParagraph(paragraph, inTable) {
+		this.raw("\\pard\\plain");
+		if (inTable) this.raw("\\intbl");
+		this.raw(this.paragraphProperties(paragraph));
+		this.raw(" ");
+		const bookmarks = (paragraph.constructs ?? []).filter((extent) => isBookmarkAnchor(extent.descriptor));
+		const revisions = (paragraph.constructs ?? []).filter((extent) => extent.descriptor.kind === "provenance");
+		for (const [index, run] of paragraph.runs.entries()) {
+			this.writeRunBoundaries(bookmarks, index);
+			this.writeRun(run, revisionsCovering(revisions, index));
+		}
+		this.writeRunBoundaries(bookmarks, paragraph.runs.length);
+		if (!inTable) this.line("\\par");
+	}
+	writeRunBoundaries(extents, position) {
+		for (const extent of extents) if (extent.endRun === position && extent.startRun !== position) this.raw(`{\\*\\bkmkend ${escapeText(nameOf(extent.descriptor))}}`);
+		for (const extent of extents) if (extent.startRun === position) {
+			this.raw(bookmarkStartGroup(extent.descriptor));
+			if (extent.endRun === position) this.raw(`{\\*\\bkmkend ${escapeText(nameOf(extent.descriptor))}}`);
+		}
+	}
+	paragraphProperties(paragraph) {
+		let out = "";
+		const level = paragraph.headingLevel === void 0 ? void 0 : clampHeadingLevel(paragraph.headingLevel);
+		const styleHandle = level === void 0 ? void 0 : this.tables.headingStyles.get(level);
+		if (styleHandle !== void 0 && level !== void 0) out += `\\s${String(styleHandle)}\\outlinelevel${String(level - 1)}`;
+		const alignment = paragraph.alignment === void 0 ? void 0 : ALIGNMENT_CONTROL_WORDS.get(paragraph.alignment);
+		if (alignment !== void 0) out += alignment;
+		const list = paragraph.list;
+		if (list !== void 0) {
+			const numId = list.numId;
+			const entry = numId === void 0 ? void 0 : this.tables.lists.get(numId);
+			if (entry === void 0) this.sink({
+				code: RtfDiagnosticCodes.CONSTRUCT_UNREPRESENTED,
+				severity: "info",
+				message: "a list membership carries no numId this writer minted a list for; the paragraph keeps its indentation but no list marker"
+			});
+			else {
+				const indent = LIST_LEVEL_INDENT_TWIPS * (list.level + 1);
+				out += `\\ls${String(entry.index)}\\ilvl${String(list.level)}\\fi-${String(LIST_MARKER_HANG_TWIPS)}\\li${String(indent)}`;
+			}
+		}
+		if (paragraph.indentLeftPt !== void 0) out += `\\li${String(pointsToTwips(paragraph.indentLeftPt))}`;
+		if (paragraph.indentFirstLinePt !== void 0) out += `\\fi${String(pointsToTwips(paragraph.indentFirstLinePt))}`;
+		if (paragraph.spacingBeforePt !== void 0) out += `\\sb${String(pointsToTwips(paragraph.spacingBeforePt))}`;
+		if (paragraph.spacingAfterPt !== void 0) out += `\\sa${String(pointsToTwips(paragraph.spacingAfterPt))}`;
+		if (paragraph.lineSpacing !== void 0) out += `\\sl${String(Math.round(paragraph.lineSpacing * 240))}\\slmult1`;
+		if (paragraph.pageBreakBefore === true) out += "\\pagebb";
+		return out;
+	}
+	writeRun(run, revisions = []) {
+		const properties = this.runProperties(run) + this.revisionProperties(revisions);
+		const body = `${properties}${properties.length > 0 ? " " : ""}${escapeText(run.text)}`;
+		if (run.hyperlink === void 0) {
+			this.raw(`{${body}}`);
+			return;
+		}
+		this.raw(`{\\field{\\*\\fldinst{HYPERLINK "${escapeText(run.hyperlink)}"}}{\\fldrslt{${body}}}}`);
+	}
+	revisionProperties(revisions) {
+		let out = "";
+		for (const descriptor of revisions) {
+			const author = descriptor.author;
+			const authorIndex = author === void 0 ? void 0 : this.tables.revisionAuthors.get(author);
+			const dttm = descriptor.dateIso === void 0 ? void 0 : dttmFromIso(descriptor.dateIso);
+			const words = CHREV_CONTROL_WORDS[descriptor.change];
+			out += words.flag;
+			if (authorIndex !== void 0) out += `\\${words.author}${String(authorIndex)}`;
+			if (dttm !== void 0) out += `\\${words.date}${String(dttm)}`;
+		}
+		return out;
+	}
+	runProperties(run) {
+		let out = "";
+		const fontIndex = run.fontFamily === void 0 ? void 0 : this.tables.fonts.get(run.fontFamily);
+		if (fontIndex !== void 0 && fontIndex !== 0) out += `\\f${String(fontIndex)}`;
+		const halfPoints = run.sizePt === void 0 ? 24 : pointsToHalfPoints(run.sizePt);
+		if (halfPoints !== 24) out += `\\fs${String(halfPoints)}`;
+		if (run.bold === true) out += "\\b";
+		if (run.italic === true) out += "\\i";
+		if (run.underline === true) out += "\\ul";
+		if (run.strike === true) out += "\\strike";
+		const colorIndex = colorIndexOf(run.color, this.tables.colors);
+		if (colorIndex !== void 0) out += `\\cf${String(colorIndex)}`;
+		return out;
+	}
+	writeTable(table) {
+		const covered = verticalMergeCoverage(table);
+		for (const [rowIndex, row] of table.rows.entries()) {
+			let right = 0;
+			let column = 0;
+			const definitions = [];
+			const marks = [];
+			for (const [cellIndex, cell] of row.cells.entries()) {
+				const colSpan = cell.colSpan ?? 1;
+				for (let offset = 0; offset < colSpan; offset += 1) {
+					right += pointsToTwips(table.columnWidthsPt[column] ?? 0);
+					column += 1;
+					definitions.push(this.cellDefinition(cell, covered[rowIndex]?.[cellIndex] === true, colSpan > 1 ? offset === 0 ? "mergeFirst" : "mergeContinuation" : "single", right));
+					marks.push({
+						cell,
+						empty: offset > 0
+					});
+				}
+			}
+			const rowDefinition = `\\trowd\\trgaph108\\trleft0${definitions.join("")}`;
+			this.line(rowDefinition);
+			for (const mark of marks) {
+				this.writeCellBlocks(mark.empty ? [] : mark.cell.blocks);
+				this.raw("\\cell");
+			}
+			this.line(`${rowDefinition}\\row`);
+		}
+		this.line("\\pard");
+	}
+	cellDefinition(cell, isVerticalContinuation, horizontal, rightTwips) {
+		let out = "";
+		if (isVerticalContinuation) out += "\\clvmrg";
+		else if ((cell.rowSpan ?? 1) > 1) out += "\\clvmgf";
+		if (horizontal === "mergeFirst") out += "\\clmgf";
+		else if (horizontal === "mergeContinuation") return `${out}\\clmrg\\cellx${String(rightTwips)}`;
+		const borders = cell.borders;
+		if (borders !== void 0) for (const side of CELL_BORDER_ORDER) {
+			const border = borders[side];
+			if (border !== void 0) out += borderControlWords(side, border, colorIndexOf(border.color, this.tables.colors));
+		}
+		if (cell.background !== void 0) {
+			const index = colorIndexOf(cell.background, this.tables.colors);
+			if (index !== void 0) out += `\\clcbpat${String(index)}`;
+		}
+		return `${out}\\cellx${String(rightTwips)}`;
+	}
+	writeCellBlocks(blocks) {
+		const paragraphs = blocks.filter((block) => block.kind === "paragraph");
+		if (paragraphs.length === 0) {
+			this.raw("\\pard\\plain\\intbl ");
+			return;
+		}
+		for (const [index, paragraph] of paragraphs.entries()) {
+			this.writeParagraph(paragraph, true);
+			if (index < paragraphs.length - 1) this.raw("\\par");
+		}
+	}
+	writeImageParagraph(base64, image) {
+		const bytes = base64ToBytes(base64);
+		if (bytes === void 0 || bytes.length === 0) {
+			this.sink({
+				code: RtfDiagnosticCodes.UNSUPPORTED_PICTURE_FORMAT,
+				severity: "warning",
+				message: "an image block's base64 payload could not be decoded, so no \\pict destination is written for it"
+			});
+			return;
+		}
+		const widthTwips = pointsToTwips(image.widthPt);
+		const heightTwips = pointsToTwips(image.heightPt);
+		this.line(`\\pard\\plain {\\*\\shppict{\\pict\\${image.format === "png" ? "pngblip" : "jpegblip"}\\picwgoal${String(widthTwips)}\\pichgoal${String(heightTwips)}${this.lineEnding}${wrapHex(bytesToHex(bytes), this.lineEnding)}}}\\par`);
+	}
+};
+function colorIndexOf(color, colors) {
+	return color === void 0 ? void 0 : colors.get(colorToRgbHex(color));
+}
+const HEX_LINE_LENGTH = 128;
+function wrapHex(hex, lineEnding) {
+	const lines = [];
+	for (let index = 0; index < hex.length; index += HEX_LINE_LENGTH) lines.push(hex.slice(index, index + HEX_LINE_LENGTH));
+	return lines.join(lineEnding);
+}
+function encodeAscii(text) {
+	const out = new Uint8Array(text.length);
+	for (let index = 0; index < text.length; index += 1) out[index] = text.charCodeAt(index) & 127;
+	return out;
+}
+function writeRtfContent(document, options = {}) {
+	options.signal?.throwIfAborted();
+	if (document.kind !== "wordprocessing") throw new RtfUnsupportedDocumentKindError(document.kind);
+	const sink = options.sink ?? (() => {});
+	const writer = new RtfWriter(collectTables(document), sink, options.lineEnding ?? "\n");
+	writer.writeHeader(document);
+	for (const [index, section] of document.sections.entries()) writer.writeSection(section, index === 0);
+	writer.raw("}");
+	return encodeAscii(writer.text);
+}
+function writeRtf(documentPackage, options = {}) {
+	const sink = options.sink;
+	if (sink !== void 0 && hasPackageTables(documentPackage)) sink({
+		code: RtfDiagnosticCodes.PACKAGE_TABLE_DROPPED,
+		severity: "info",
+		message: "the package's definitions/layers/attachments/destinations tables are dropped: flattening resolves style refs, and RTF has no destination for the remaining tenants"
+	});
+	return writeRtfContent(flattenTree(documentPackage), options);
+}
+function hasPackageTables(documentPackage) {
+	return documentPackage.definitions !== void 0 || documentPackage.layers !== void 0 || documentPackage.attachments !== void 0 || documentPackage.destinations !== void 0;
+}
+//#endregion
+export { writeRtf, writeRtfContent };

package/package.json

@@ -1,5 +1,98 @@
 {
   "name": "rtf-codec",
-  "version": "0.0.0",
-  "private": false
+  "version": "1.1.0",
+  "description": "Hand-written Rich Text Format (RTF 1.9.1) reader and writer against the shared document-schema.js content pivot.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExaDev/documents.js.git",
+    "directory": "packages/rtf-codec"
+  },
+  "homepage": "https://github.com/ExaDev/documents.js/tree/main/packages/rtf-codec",
+  "bugs": {
+    "url": "https://github.com/ExaDev/documents.js/issues"
+  },
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./*": {
+      "types": {
+        "import": "./dist/*.d.ts",
+        "require": "./dist/*.d.cts"
+      },
+      "import": "./dist/*.js",
+      "require": "./dist/*.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "turbo run _build",
+    "_build": "tsdown",
+    "prepublishOnly": "pnpm run lint && pnpm run typecheck && tsdown && publint && attw --pack",
+    "lint": "turbo run _lint",
+    "_lint": "eslint . --fix --cache --max-warnings 0",
+    "typecheck": "turbo run _typecheck _typecheck:node _typecheck:attw",
+    "_typecheck": "tsc -p tsconfig.json",
+    "_typecheck:node": "tsc -p tsconfig.node.json",
+    "_typecheck:attw": "attw --pack",
+    "test": "turbo run _test",
+    "_test": "vitest run --project unit",
+    "test:workers": "turbo run _test:workers",
+    "_test:workers": "vitest run --config vitest.workers.config.ts",
+    "test:watch": "vitest --project unit",
+    "test:coverage": "turbo run _test:coverage",
+    "_test:coverage": "vitest run --project unit --coverage",
+    "test:smoke": "turbo run _test:smoke",
+    "_test:smoke": "vitest run --project smoke",
+    "prepare": "husky",
+    "release": "semantic-release"
+  },
+  "keywords": [
+    "rtf",
+    "rich-text-format",
+    "codec",
+    "round-trip",
+    "zod",
+    "wordprocessing"
+  ],
+  "license": "MIT",
+  "packageManager": "pnpm@11.6.0",
+  "dependencies": {
+    "document-schema.js": "^5.5.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@cloudflare/vitest-pool-workers": "^0.21.2",
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^4.1.10",
+    "eslint": "^10.8.0",
+    "husky": "^9.1.7",
+    "publint": "^0.3.21",
+    "semantic-release": "^25.0.8",
+    "tsdown": "^0.22.13",
+    "turbo": "^2.10.8",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
+  }
 }