rtf-codec 0.0.0 → 1.1.0

package/dist/header.cjs

@@ -0,0 +1,433 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes = require("./bytes.cjs");
+const require_units = require("./units.cjs");
+const require_codepage = require("./codepage.cjs");
+const require_group = require("./group.cjs");
+//#region src/header.ts
+const RGB_MAX = 255;
+const FONT_FAMILIES = /* @__PURE__ */ new Set([
+	"fnil",
+	"froman",
+	"fswiss",
+	"fmodern",
+	"fscript",
+	"fdecor",
+	"ftech",
+	"fbidi"
+]);
+const HEADING_STYLE_NAME = /^heading[ -]?([1-9])$/i;
+const DEFAULT_LIST_LEVEL = {
+	numberFormat: 0,
+	startAt: 1
+};
+const HEADER_DESTINATIONS = /* @__PURE__ */ new Set([
+	"fonttbl",
+	"colortbl",
+	"stylesheet",
+	"listtable",
+	"listoverridetable",
+	"info",
+	"filetbl",
+	"revtbl",
+	"rsidtbl",
+	"generator",
+	"pgptbl",
+	"themedata",
+	"colorschememapping",
+	"latentstyles",
+	"listtextoverride",
+	"xmlnstbl",
+	"wgrffmtfilter",
+	"datastore",
+	"protusertbl",
+	"mmathPr",
+	"stylerestrictions",
+	"userprops"
+]);
+function collectPlainText(tokens, start, end, codepage, sink) {
+	const pending = [];
+	let out = "";
+	const flush = () => {
+		if (pending.length === 0) return;
+		out += require_codepage.decodeCodepageBytes(Uint8Array.from(pending), codepage, sink);
+		pending.length = 0;
+	};
+	for (let index = start; index < end; index += 1) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === "groupStart") {
+			flush();
+			index = require_group.matchingGroupEnd(tokens, index);
+			continue;
+		}
+		if (token.kind === "text") {
+			require_bytes.appendBytes(pending, token.bytes);
+			continue;
+		}
+		if (token.kind === "hex") {
+			pending.push(token.byte);
+			continue;
+		}
+		if (token.kind === "controlWord" && token.name === "u") {
+			flush();
+			const code = token.param;
+			if (code !== void 0) out += String.fromCodePoint(code < 0 ? code + 65536 : code);
+		}
+	}
+	flush();
+	return out.replace(/;\s*$/, "").trim();
+}
+function parseFontTable(tokens, contentStart, end, documentCodepage, fonts, sink) {
+	let index = contentStart;
+	let sawBracedEntry = false;
+	while (index < end) {
+		if (tokens[index]?.kind !== "groupStart") {
+			index += 1;
+			continue;
+		}
+		sawBracedEntry = true;
+		const entryEnd = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+		readFontInfo(tokens, index + 1, entryEnd, documentCodepage, fonts, sink);
+		index = entryEnd + 1;
+	}
+	if (!sawBracedEntry) readFontInfo(tokens, contentStart, end, documentCodepage, fonts, sink);
+}
+function readFontInfo(tokens, start, end, documentCodepage, fonts, sink) {
+	let number;
+	let family;
+	let charsetPage;
+	let explicitPage;
+	let nameStart = start;
+	for (let index = start; index < end; index += 1) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind !== "controlWord") continue;
+		if (token.name === "f" && token.param !== void 0) {
+			number = token.param;
+			nameStart = index + 1;
+			continue;
+		}
+		if (FONT_FAMILIES.has(token.name)) {
+			family = token.name.slice(1);
+			nameStart = index + 1;
+			continue;
+		}
+		if (token.name === "fcharset" && token.param !== void 0) {
+			charsetPage = require_codepage.codepageForFontCharset(token.param);
+			nameStart = index + 1;
+			continue;
+		}
+		if (token.name === "cpg" && token.param !== void 0) {
+			explicitPage = token.param;
+			nameStart = index + 1;
+			continue;
+		}
+		if (token.name === "fprq" || token.name === "fbias") nameStart = index + 1;
+	}
+	if (number === void 0) return;
+	const name = collectPlainText(tokens, nameStart, end, explicitPage ?? charsetPage ?? documentCodepage, sink);
+	fonts.set(number, {
+		name,
+		family,
+		codepage: explicitPage ?? charsetPage
+	});
+}
+function parseColorTable(tokens, contentStart, end, colors) {
+	let red;
+	let green;
+	let blue;
+	const finishEntry = () => {
+		colors.push(red === void 0 && green === void 0 && blue === void 0 ? void 0 : {
+			r: (red ?? 0) / RGB_MAX,
+			g: (green ?? 0) / RGB_MAX,
+			b: (blue ?? 0) / RGB_MAX
+		});
+		red = void 0;
+		green = void 0;
+		blue = void 0;
+	};
+	for (let index = contentStart; index < end; index += 1) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === "controlWord") {
+			if (token.name === "red") red = token.param ?? 0;
+			else if (token.name === "green") green = token.param ?? 0;
+			else if (token.name === "blue") blue = token.param ?? 0;
+			continue;
+		}
+		if (token.kind === "text") {
+			for (const byte of token.bytes) if (byte === 59) finishEntry();
+		}
+	}
+}
+function parseStyleSheet(tokens, contentStart, end, documentCodepage, styles, sink) {
+	for (let index = contentStart; index < end; index += 1) {
+		if (tokens[index]?.kind !== "groupStart") continue;
+		const entryEnd = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+		readStyle(tokens, index, entryEnd, documentCodepage, styles, sink);
+		index = entryEnd;
+	}
+}
+function readStyle(tokens, start, end, documentCodepage, styles, sink) {
+	const head = require_group.groupHead(tokens, start);
+	if (head.ignorable) return;
+	let handle = 0;
+	let outlineLevel;
+	let nameStart = head.contentStart;
+	for (let index = start + 1; index < end; index += 1) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === "groupStart") {
+			index = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+			nameStart = index + 1;
+			continue;
+		}
+		if (token.kind !== "controlWord") continue;
+		if (token.name === "s" && token.param !== void 0) handle = token.param;
+		else if (token.name === "outlinelevel" && token.param !== void 0) outlineLevel = token.param;
+		nameStart = index + 1;
+	}
+	const name = collectPlainText(tokens, nameStart, end, documentCodepage, sink);
+	const fromName = HEADING_STYLE_NAME.exec(name)?.[1];
+	const headingLevel = outlineLevel === void 0 ? fromName === void 0 ? void 0 : Number(fromName) : outlineLevel + 1;
+	styles.set(handle, {
+		name,
+		headingLevel
+	});
+}
+function parseListTable(tokens, contentStart, end, listsById) {
+	for (let index = contentStart; index < end; index += 1) {
+		if (tokens[index]?.kind !== "groupStart") continue;
+		const entryEnd = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+		if (require_group.groupHead(tokens, index).destination === "list") readListDefinition(tokens, index, entryEnd, listsById);
+		index = entryEnd;
+	}
+}
+function readListDefinition(tokens, start, end, listsById) {
+	const levels = [];
+	let listId;
+	for (let index = start + 1; index < end; index += 1) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === "groupStart") {
+			const inner = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+			if (require_group.groupHead(tokens, index).destination === "listlevel") levels.push(readListLevel(tokens, index, inner));
+			index = inner;
+			continue;
+		}
+		if (token.kind === "controlWord" && token.name === "listid" && token.param !== void 0) listId = token.param;
+	}
+	if (listId === void 0) return;
+	listsById.set(listId, { levels });
+	return listId;
+}
+function readListLevel(tokens, start, end) {
+	let numberFormat = 0;
+	let startAt = 1;
+	for (let index = start + 1; index < end; index += 1) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === "groupStart") {
+			index = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+			continue;
+		}
+		if (token.kind !== "controlWord") continue;
+		if (token.name === "levelnfc" && token.param !== void 0) numberFormat = token.param;
+		else if (token.name === "levelstartat" && token.param !== void 0) startAt = token.param;
+	}
+	return {
+		numberFormat,
+		startAt
+	};
+}
+function parseListOverrideTable(tokens, contentStart, end, overrides) {
+	for (let index = contentStart; index < end; index += 1) {
+		if (tokens[index]?.kind !== "groupStart") continue;
+		const entryEnd = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+		let listId;
+		let overrideIndex;
+		const levelOverrides = [];
+		for (let inner = index + 1; inner < entryEnd; inner += 1) {
+			const child = tokens[inner];
+			if (child?.kind === "groupStart") {
+				const childEnd = Math.min(require_group.matchingGroupEnd(tokens, inner), entryEnd);
+				if (require_group.groupHead(tokens, inner).destination === "lfolevel") levelOverrides.push(readLevelOverride(tokens, inner, childEnd));
+				inner = childEnd;
+				continue;
+			}
+			if (child?.kind !== "controlWord" || child.param === void 0) continue;
+			if (child.name === "listid") listId = child.param;
+			else if (child.name === "ls") overrideIndex = child.param;
+		}
+		if (listId !== void 0 && overrideIndex !== void 0) overrides.set(overrideIndex, {
+			listId,
+			levelOverrides
+		});
+		index = entryEnd;
+	}
+}
+function readLevelOverride(tokens, start, end) {
+	let level;
+	let startAt;
+	for (let index = start + 1; index < end; index += 1) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === "groupStart") {
+			const inner = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+			if (require_group.groupHead(tokens, index).destination === "listlevel") level = readListLevel(tokens, index, inner);
+			index = inner;
+			continue;
+		}
+		if (token.kind === "controlWord" && token.name === "levelstartat" && token.param !== void 0) startAt = token.param;
+	}
+	return {
+		...level === void 0 ? {} : { level },
+		...startAt === void 0 ? {} : { startAt }
+	};
+}
+function applyListOverride(list, levelOverrides) {
+	if (levelOverrides.length === 0) return list;
+	const levels = [...list.levels];
+	for (const [index, override] of levelOverrides.entries()) {
+		const base = override.level ?? levels[index] ?? DEFAULT_LIST_LEVEL;
+		levels[index] = override.level === void 0 && override.startAt !== void 0 ? {
+			...base,
+			startAt: override.startAt
+		} : base;
+	}
+	return { levels };
+}
+function parseRevisionTable(tokens, contentStart, end, codepage, authors, sink) {
+	for (let index = contentStart; index < end; index += 1) {
+		if (tokens[index]?.kind !== "groupStart") continue;
+		const entryEnd = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+		const value = collectPlainText(tokens, index + 1, entryEnd, codepage, sink);
+		authors.push(value.split("\0")[0]?.trim() ?? "");
+		index = entryEnd;
+	}
+}
+function parseInfoGroup(tokens, contentStart, end, codepage, sink) {
+	const metadata = {};
+	for (let index = contentStart; index < end; index += 1) {
+		if (tokens[index]?.kind !== "groupStart") continue;
+		const fieldEnd = Math.min(require_group.matchingGroupEnd(tokens, index), end);
+		const head = require_group.groupHead(tokens, index);
+		const value = collectPlainText(tokens, head.contentStart, fieldEnd, codepage, sink);
+		if (value.length > 0) {
+			if (head.destination === "title") metadata.title = value;
+			else if (head.destination === "author") metadata.author = value;
+			else if (head.destination === "subject") metadata.subject = value;
+			else if (head.destination === "keywords") metadata.keywords = value.split(/[;,]\s*/).filter((k) => k.length > 0);
+			else if (head.destination === "operator") metadata.creator = value;
+		}
+		index = fieldEnd;
+	}
+	return metadata;
+}
+function readRtfHeader(tokens, sink) {
+	const fonts = /* @__PURE__ */ new Map();
+	const colors = [];
+	const styles = /* @__PURE__ */ new Map();
+	const listsById = /* @__PURE__ */ new Map();
+	const overrides = /* @__PURE__ */ new Map();
+	const revisionAuthors = [];
+	const page = {
+		paperWidthTwips: require_units.DEFAULT_PAPER_WIDTH_TWIPS,
+		paperHeightTwips: require_units.DEFAULT_PAPER_HEIGHT_TWIPS,
+		marginLeftTwips: require_units.DEFAULT_MARGIN_LEFT_TWIPS,
+		marginRightTwips: require_units.DEFAULT_MARGIN_RIGHT_TWIPS,
+		marginTopTwips: require_units.DEFAULT_MARGIN_TOP_TWIPS,
+		marginBottomTwips: require_units.DEFAULT_MARGIN_BOTTOM_TWIPS
+	};
+	let metadata = {};
+	let codepage = require_codepage.DEFAULT_CODEPAGE;
+	let defaultFontIndex;
+	let bodyStartIndex = 0;
+	const fileGroupEnd = require_group.matchingGroupEnd(tokens, 0);
+	for (let index = 0; index < fileGroupEnd; index += 1) {
+		const token = tokens[index];
+		if (token?.kind === "groupStart" && index > 0) {
+			index = Math.min(require_group.matchingGroupEnd(tokens, index), fileGroupEnd);
+			continue;
+		}
+		if (token?.kind !== "controlWord") continue;
+		const charsetPage = require_codepage.DOCUMENT_CHARSET_CODEPAGES.get(token.name);
+		if (charsetPage !== void 0) {
+			codepage = charsetPage;
+			continue;
+		}
+		if (token.param === void 0) continue;
+		switch (token.name) {
+			case "ansicpg":
+				codepage = token.param;
+				break;
+			case "deff":
+				defaultFontIndex = token.param;
+				break;
+			case "paperw":
+				page.paperWidthTwips = token.param;
+				break;
+			case "paperh":
+				page.paperHeightTwips = token.param;
+				break;
+			case "margl":
+				page.marginLeftTwips = token.param;
+				break;
+			case "margr":
+				page.marginRightTwips = token.param;
+				break;
+			case "margt":
+				page.marginTopTwips = token.param;
+				break;
+			case "margb": page.marginBottomTwips = token.param;
+		}
+	}
+	for (let index = 1; index < fileGroupEnd; index += 1) {
+		if (tokens[index]?.kind !== "groupStart") continue;
+		const groupEnd = Math.min(require_group.matchingGroupEnd(tokens, index), fileGroupEnd);
+		const head = require_group.groupHead(tokens, index);
+		switch (head.destination) {
+			case "fonttbl":
+				parseFontTable(tokens, head.contentStart, groupEnd, codepage, fonts, sink);
+				break;
+			case "colortbl":
+				parseColorTable(tokens, head.contentStart, groupEnd, colors);
+				break;
+			case "stylesheet":
+				parseStyleSheet(tokens, head.contentStart, groupEnd, codepage, styles, sink);
+				break;
+			case "listtable":
+				parseListTable(tokens, head.contentStart, groupEnd, listsById);
+				break;
+			case "listoverridetable":
+				parseListOverrideTable(tokens, head.contentStart, groupEnd, overrides);
+				break;
+			case "revtbl":
+				parseRevisionTable(tokens, head.contentStart, groupEnd, codepage, revisionAuthors, sink);
+				break;
+			case "info": metadata = parseInfoGroup(tokens, head.contentStart, groupEnd, codepage, sink);
+		}
+		if (head.destination !== void 0 && HEADER_DESTINATIONS.has(head.destination)) bodyStartIndex = Math.max(bodyStartIndex, groupEnd + 1);
+		index = groupEnd;
+	}
+	const lists = /* @__PURE__ */ new Map();
+	for (const [overrideIndex, override] of overrides) {
+		const list = listsById.get(override.listId);
+		if (list !== void 0) lists.set(overrideIndex, applyListOverride(list, override.levelOverrides));
+	}
+	return {
+		codepage,
+		defaultFontIndex,
+		fonts,
+		colors,
+		styles,
+		lists,
+		revisionAuthors,
+		page,
+		metadata,
+		bodyStartIndex
+	};
+}
+//#endregion
+exports.HEADER_DESTINATIONS = HEADER_DESTINATIONS;
+exports.readRtfHeader = readRtfHeader;

package/dist/header.d.cts

@@ -0,0 +1,44 @@
+import { a as RtfDiagnosticSink } from "./diagnostics-BgG_KAiN.cjs";
+import { RtfToken } from "./tokenize.cjs";
+import { Color, LayoutMetadata } from "document-schema.js";
+//#region src/header.d.ts
+interface RtfFontEntry {
+  readonly name: string;
+  readonly family: string | undefined;
+  readonly codepage: number | undefined;
+}
+interface RtfStyleEntry {
+  readonly name: string;
+  readonly headingLevel: number | undefined;
+}
+interface RtfListLevel {
+  readonly numberFormat: number;
+  readonly startAt: number;
+}
+interface RtfListEntry {
+  readonly levels: readonly RtfListLevel[];
+}
+interface RtfPageGeometry {
+  readonly paperWidthTwips: number;
+  readonly paperHeightTwips: number;
+  readonly marginLeftTwips: number;
+  readonly marginRightTwips: number;
+  readonly marginTopTwips: number;
+  readonly marginBottomTwips: number;
+}
+interface RtfHeader {
+  readonly codepage: number;
+  readonly defaultFontIndex: number | undefined;
+  readonly fonts: ReadonlyMap<number, RtfFontEntry>;
+  readonly colors: readonly (Color | undefined)[];
+  readonly styles: ReadonlyMap<number, RtfStyleEntry>;
+  readonly lists: ReadonlyMap<number, RtfListEntry>;
+  readonly revisionAuthors: readonly string[];
+  readonly page: RtfPageGeometry;
+  readonly metadata: LayoutMetadata;
+  readonly bodyStartIndex: number;
+}
+declare const HEADER_DESTINATIONS: ReadonlySet<string>;
+declare function readRtfHeader(tokens: readonly RtfToken[], sink: RtfDiagnosticSink): RtfHeader;
+//#endregion
+export { HEADER_DESTINATIONS, RtfFontEntry, RtfHeader, RtfListEntry, RtfListLevel, RtfPageGeometry, RtfStyleEntry, readRtfHeader };

package/dist/header.d.ts

@@ -0,0 +1,44 @@
+import { a as RtfDiagnosticSink } from "./diagnostics-BgG_KAiN.js";
+import { RtfToken } from "./tokenize.js";
+import { Color, LayoutMetadata } from "document-schema.js";
+//#region src/header.d.ts
+interface RtfFontEntry {
+  readonly name: string;
+  readonly family: string | undefined;
+  readonly codepage: number | undefined;
+}
+interface RtfStyleEntry {
+  readonly name: string;
+  readonly headingLevel: number | undefined;
+}
+interface RtfListLevel {
+  readonly numberFormat: number;
+  readonly startAt: number;
+}
+interface RtfListEntry {
+  readonly levels: readonly RtfListLevel[];
+}
+interface RtfPageGeometry {
+  readonly paperWidthTwips: number;
+  readonly paperHeightTwips: number;
+  readonly marginLeftTwips: number;
+  readonly marginRightTwips: number;
+  readonly marginTopTwips: number;
+  readonly marginBottomTwips: number;
+}
+interface RtfHeader {
+  readonly codepage: number;
+  readonly defaultFontIndex: number | undefined;
+  readonly fonts: ReadonlyMap<number, RtfFontEntry>;
+  readonly colors: readonly (Color | undefined)[];
+  readonly styles: ReadonlyMap<number, RtfStyleEntry>;
+  readonly lists: ReadonlyMap<number, RtfListEntry>;
+  readonly revisionAuthors: readonly string[];
+  readonly page: RtfPageGeometry;
+  readonly metadata: LayoutMetadata;
+  readonly bodyStartIndex: number;
+}
+declare const HEADER_DESTINATIONS: ReadonlySet<string>;
+declare function readRtfHeader(tokens: readonly RtfToken[], sink: RtfDiagnosticSink): RtfHeader;
+//#endregion
+export { HEADER_DESTINATIONS, RtfFontEntry, RtfHeader, RtfListEntry, RtfListLevel, RtfPageGeometry, RtfStyleEntry, readRtfHeader };