pdf-codec 1.3.0 → 1.4.0

package/dist/winansi.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_afm_widths = require("./afm-widths-BoeTOK2r.cjs");
+exports.encodeForShow = require_afm_widths.encodeForShow;
+exports.sanitizeToWinAnsi = require_afm_widths.sanitizeToWinAnsi;
+exports.winAnsiCodeToUnicode = require_afm_widths.winAnsiCodeToUnicode;

package/dist/winansi.d.cts

@@ -0,0 +1,20 @@
+import { r as StandardFontName } from "./afm-widths-DyDq56Ph.cjs";
+//#region src/winansi.d.ts
+declare function winAnsiCodeToUnicode(code: number): number | undefined;
+interface WinAnsiSubstitution {
+  readonly from: string;
+  readonly to: string;
+}
+interface SanitizeResult {
+  readonly codes: Uint8Array<ArrayBuffer>;
+  readonly substitutions: readonly WinAnsiSubstitution[];
+}
+declare function sanitizeToWinAnsi(text: string): SanitizeResult;
+interface EncodedShow {
+  readonly codes: Uint8Array<ArrayBuffer>;
+  readonly width1000: number;
+  readonly substitutions: readonly WinAnsiSubstitution[];
+}
+declare function encodeForShow(text: string, font: StandardFontName): EncodedShow;
+//#endregion
+export { EncodedShow, SanitizeResult, WinAnsiSubstitution, encodeForShow, sanitizeToWinAnsi, winAnsiCodeToUnicode };

package/dist/winansi.d.ts

@@ -0,0 +1,20 @@
+import { r as StandardFontName } from "./afm-widths-DyDq56Ph.js";
+//#region src/winansi.d.ts
+declare function winAnsiCodeToUnicode(code: number): number | undefined;
+interface WinAnsiSubstitution {
+  readonly from: string;
+  readonly to: string;
+}
+interface SanitizeResult {
+  readonly codes: Uint8Array<ArrayBuffer>;
+  readonly substitutions: readonly WinAnsiSubstitution[];
+}
+declare function sanitizeToWinAnsi(text: string): SanitizeResult;
+interface EncodedShow {
+  readonly codes: Uint8Array<ArrayBuffer>;
+  readonly width1000: number;
+  readonly substitutions: readonly WinAnsiSubstitution[];
+}
+declare function encodeForShow(text: string, font: StandardFontName): EncodedShow;
+//#endregion
+export { EncodedShow, SanitizeResult, WinAnsiSubstitution, encodeForShow, sanitizeToWinAnsi, winAnsiCodeToUnicode };

package/dist/winansi.js

@@ -0,0 +1,2 @@
+import { c as winAnsiCodeToUnicode, o as encodeForShow, s as sanitizeToWinAnsi } from "./afm-widths-Dxucrg7D.js";
+export { encodeForShow, sanitizeToWinAnsi, winAnsiCodeToUnicode };

package/dist/write.cjs

@@ -0,0 +1,421 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_afm_widths = require("./afm-widths-BoeTOK2r.cjs");
+const require_util_base64 = require("./util/base64.cjs");
+const require_bytes_writer = require("./bytes/writer.cjs");
+const require_bytes_flate = require("./bytes/flate.cjs");
+const require_objects = require("./objects.cjs");
+const require_util_abort = require("./util/abort.cjs");
+const require_fonts = require("./fonts.cjs");
+const require_image_jpeg_info = require("./image/jpeg-info.cjs");
+const require_image_png_decode = require("./image/png-decode.cjs");
+const require_serialize = require("./serialize.cjs");
+const require_content_write = require("./content-write.cjs");
+const require_math_content_write = require("./math-content-write.cjs");
+const require_math_font = require("./math-font.cjs");
+const require_math_font_write = require("./math-font-write.cjs");
+const require_measure = require("./measure.cjs");
+//#region src/write.ts
+const MATH_FONT_RESOURCE_NAME = "MF";
+const FIRST_CHAR = 32;
+const LAST_CHAR = 255;
+const NOMINAL_STEM_V_REGULAR = 80;
+const NOMINAL_STEM_V_BOLD = 120;
+const FLAG_FIXED_PITCH = 1;
+const FLAG_SERIF = 2;
+const FLAG_NONSYMBOLIC = 32;
+const FLAG_ITALIC = 64;
+const FLAG_FORCE_BOLD = 262144;
+function textToPdfString(text) {
+	const bytes = new Uint8Array(2 + text.length * 2);
+	bytes[0] = 254;
+	bytes[1] = 255;
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		bytes[2 + i * 2] = code >> 8 & 255;
+		bytes[2 + i * 2 + 1] = code & 255;
+	}
+	return require_objects.pdfHexString(bytes);
+}
+function pad2(n) {
+	return n.toString().padStart(2, "0");
+}
+function formatPdfDate(iso) {
+	const date = new Date(iso);
+	return `D:${date.getUTCFullYear()}${pad2(date.getUTCMonth() + 1)}${pad2(date.getUTCDate())}${pad2(date.getUTCHours())}${pad2(date.getUTCMinutes())}${pad2(date.getUTCSeconds())}Z`;
+}
+function buildInfoDict(doc) {
+	const entries = /* @__PURE__ */ new Map();
+	entries.set("Producer", textToPdfString("documents.js"));
+	if (doc.metadata.title !== void 0) entries.set("Title", textToPdfString(doc.metadata.title));
+	if (doc.metadata.author !== void 0) entries.set("Author", textToPdfString(doc.metadata.author));
+	if (doc.metadata.subject !== void 0) entries.set("Subject", textToPdfString(doc.metadata.subject));
+	if (doc.metadata.keywords !== void 0) entries.set("Keywords", textToPdfString(doc.metadata.keywords.join(", ")));
+	if (doc.metadata.creator !== void 0) entries.set("Creator", textToPdfString(doc.metadata.creator));
+	if (doc.metadata.createdIso !== void 0) entries.set("CreationDate", textToPdfString(formatPdfDate(doc.metadata.createdIso)));
+	if (doc.metadata.modifiedIso !== void 0) entries.set("ModDate", textToPdfString(formatPdfDate(doc.metadata.modifiedIso)));
+	return require_objects.pdfDict(entries);
+}
+function computeFontFlags(standardName, metrics) {
+	let flags = FLAG_NONSYMBOLIC;
+	if (standardName.startsWith("Courier")) flags |= FLAG_FIXED_PITCH;
+	if (standardName.startsWith("Times")) flags |= FLAG_SERIF;
+	if (metrics.italicAngle !== 0) flags |= FLAG_ITALIC;
+	if (standardName.includes("Bold")) flags |= FLAG_FORCE_BOLD;
+	return flags;
+}
+function widthForWidthsArray(standardName, code) {
+	if (require_afm_widths.STANDARD_METRICS[standardName].fixedWidth === void 0 && require_afm_widths.winAnsiGlyphName(code) === void 0) return 0;
+	return require_afm_widths.widthOfCode(standardName, code);
+}
+function buildFontObjects(standardName, descriptorRef) {
+	const metrics = require_afm_widths.STANDARD_METRICS[standardName];
+	const widths = [];
+	for (let code = FIRST_CHAR; code <= LAST_CHAR; code++) widths.push(require_objects.pdfNum(widthForWidthsArray(standardName, code)));
+	return {
+		font: require_objects.pdfDict({
+			Type: require_objects.pdfName("Font"),
+			Subtype: require_objects.pdfName("Type1"),
+			BaseFont: require_objects.pdfName(standardName),
+			Encoding: require_objects.pdfName("WinAnsiEncoding"),
+			FirstChar: require_objects.pdfNum(FIRST_CHAR),
+			LastChar: require_objects.pdfNum(LAST_CHAR),
+			Widths: require_objects.pdfArray(widths),
+			FontDescriptor: descriptorRef
+		}),
+		descriptor: require_objects.pdfDict({
+			Type: require_objects.pdfName("FontDescriptor"),
+			FontName: require_objects.pdfName(standardName),
+			Flags: require_objects.pdfNum(computeFontFlags(standardName, metrics)),
+			FontBBox: require_objects.pdfArray(metrics.fontBBox.map((n) => require_objects.pdfNum(n))),
+			ItalicAngle: require_objects.pdfNum(metrics.italicAngle),
+			Ascent: require_objects.pdfNum(metrics.ascender),
+			Descent: require_objects.pdfNum(metrics.descender),
+			CapHeight: require_objects.pdfNum(metrics.capHeight),
+			XHeight: require_objects.pdfNum(metrics.xHeight),
+			StemV: require_objects.pdfNum(standardName.includes("Bold") ? NOMINAL_STEM_V_BOLD : NOMINAL_STEM_V_REGULAR)
+		})
+	};
+}
+function prepareJpegImage(bytes) {
+	const info = require_image_jpeg_info.readJpegInfo(bytes);
+	const colorSpace = info.components === 1 ? "DeviceGray" : info.components === 4 ? "DeviceCMYK" : "DeviceRGB";
+	const entries = /* @__PURE__ */ new Map([
+		["Type", require_objects.pdfName("XObject")],
+		["Subtype", require_objects.pdfName("Image")],
+		["Width", require_objects.pdfNum(info.width)],
+		["Height", require_objects.pdfNum(info.height)],
+		["ColorSpace", require_objects.pdfName(colorSpace)],
+		["BitsPerComponent", require_objects.pdfNum(info.precision)],
+		["Filter", require_objects.pdfName("DCTDecode")]
+	]);
+	if (info.components === 4 && (info.adobeTransform === 2 || info.adobeTransform === void 0)) entries.set("Decode", require_objects.pdfArray([
+		1,
+		0,
+		1,
+		0,
+		1,
+		0,
+		1,
+		0
+	].map((n) => require_objects.pdfNum(n))));
+	return {
+		dict: require_objects.pdfDict(entries),
+		raw: bytes
+	};
+}
+function pngImageDict(width, height, colorSpace, compress) {
+	const entries = /* @__PURE__ */ new Map([
+		["Type", require_objects.pdfName("XObject")],
+		["Subtype", require_objects.pdfName("Image")],
+		["Width", require_objects.pdfNum(width)],
+		["Height", require_objects.pdfNum(height)],
+		["ColorSpace", require_objects.pdfName(colorSpace)],
+		["BitsPerComponent", require_objects.pdfNum(8)]
+	]);
+	if (compress) entries.set("Filter", require_objects.pdfName("FlateDecode"));
+	return require_objects.pdfDict(entries);
+}
+function preparePngImage(bytes, compress) {
+	const raw = require_image_png_decode.decodePng(bytes);
+	const colorSpace = raw.channels === 1 ? "DeviceGray" : "DeviceRGB";
+	return {
+		dict: pngImageDict(raw.width, raw.height, colorSpace, compress),
+		raw: compress ? require_bytes_flate.deflate(raw.data) : raw.data,
+		alpha: raw.alpha === void 0 ? void 0 : {
+			dict: pngImageDict(raw.width, raw.height, "DeviceGray", compress),
+			raw: compress ? require_bytes_flate.deflate(raw.alpha) : raw.alpha
+		}
+	};
+}
+function prepareImage(asset, compress) {
+	const bytes = require_util_base64.base64ToBytes(asset.base64);
+	return asset.format === "jpeg" ? prepareJpegImage(bytes) : preparePngImage(bytes, compress);
+}
+function buildLinkAnnotDict(link) {
+	return require_objects.pdfDict({
+		Type: require_objects.pdfName("Annot"),
+		Subtype: require_objects.pdfName("Link"),
+		Rect: require_objects.pdfArray([
+			link.xPt,
+			link.yPt,
+			link.xPt + link.widthPt,
+			link.yPt + link.heightPt
+		].map((n) => require_objects.pdfNum(n))),
+		Border: require_objects.pdfArray([
+			0,
+			0,
+			0
+		].map((n) => require_objects.pdfNum(n))),
+		A: require_objects.pdfDict({
+			Type: require_objects.pdfName("Action"),
+			S: require_objects.pdfName("URI"),
+			URI: require_objects.pdfHexString(new TextEncoder().encode(link.uri))
+		})
+	});
+}
+function isLinkItem(item) {
+	return item.kind === "link";
+}
+const NOTES_ANNOTATION_HIDDEN_FLAG = 2;
+const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
+function buildNotesAnnotDict(notes) {
+	return require_objects.pdfDict({
+		Type: require_objects.pdfName("Annot"),
+		Subtype: require_objects.pdfName("Text"),
+		Rect: require_objects.pdfArray([
+			0,
+			0,
+			0,
+			0
+		].map((n) => require_objects.pdfNum(n))),
+		Contents: textToPdfString(notes),
+		T: textToPdfString(NOTES_ANNOTATION_AUTHOR),
+		F: require_objects.pdfNum(NOTES_ANNOTATION_HIDDEN_FLAG)
+	});
+}
+function xrefEntry(offset, generation, inUse) {
+	return `${offset.toString().padStart(10, "0")} ${generation.toString().padStart(5, "0")} ${inUse ? "n" : "f"} \n`;
+}
+function writePdf(doc, options = {}) {
+	const compress = options.compress ?? true;
+	const measurer = require_measure.createStandardFontMeasurer();
+	let nextObjNum = 1;
+	const catalogNum = nextObjNum++;
+	const pagesNum = nextObjNum++;
+	const infoNum = nextObjNum++;
+	const fontNames = /* @__PURE__ */ new Set();
+	const imageIds = /* @__PURE__ */ new Set();
+	for (const page of doc.pages) for (const item of page.items) if (item.kind === "text") fontNames.add(require_fonts.resolveStandardFont(item.font.family, item.font.weight === "bold", item.font.style === "italic").standardName);
+	else if (item.kind === "image") imageIds.add(item.imageId);
+	const fontAllocs = /* @__PURE__ */ new Map();
+	for (const [index, name] of [...fontNames].sort().entries()) {
+		const fontNum = nextObjNum++;
+		const descNum = nextObjNum++;
+		fontAllocs.set(name, {
+			fontNum,
+			descNum,
+			resourceName: `F${index + 1}`
+		});
+	}
+	const imageAllocs = /* @__PURE__ */ new Map();
+	for (const [index, imageId] of [...imageIds].sort().entries()) {
+		const asset = doc.images[imageId];
+		if (asset === void 0) throw new Error(`LayoutDocument references image "${imageId}" but it is not present in images`);
+		const prepared = prepareImage(asset, compress);
+		const imageNum = nextObjNum++;
+		const smaskNum = prepared.alpha === void 0 ? void 0 : nextObjNum++;
+		imageAllocs.set(imageId, {
+			imageNum,
+			smaskNum,
+			resourceName: `Im${index + 1}`,
+			prepared
+		});
+	}
+	const formulas = options.formulas ?? [];
+	const mathFontAlloc = formulas.length === 0 ? void 0 : {
+		type0Num: nextObjNum++,
+		cidFontNum: nextObjNum++,
+		descriptorNum: nextObjNum++,
+		fontFileNum: nextObjNum++,
+		toUnicodeNum: nextObjNum++,
+		resourceName: MATH_FONT_RESOURCE_NAME
+	};
+	const pageAllocs = doc.pages.map(() => ({
+		pageNum: nextObjNum++,
+		contentsNum: nextObjNum++
+	}));
+	const objects = [];
+	objects.push({
+		num: catalogNum,
+		value: require_objects.pdfDict({
+			Type: require_objects.pdfName("Catalog"),
+			Pages: require_objects.pdfRef(pagesNum, 0)
+		})
+	});
+	objects.push({
+		num: pagesNum,
+		value: require_objects.pdfDict({
+			Type: require_objects.pdfName("Pages"),
+			Kids: require_objects.pdfArray(pageAllocs.map((p) => require_objects.pdfRef(p.pageNum, 0))),
+			Count: require_objects.pdfNum(doc.pages.length)
+		})
+	});
+	objects.push({
+		num: infoNum,
+		value: buildInfoDict(doc)
+	});
+	for (const [standardName, alloc] of fontAllocs) {
+		const { font, descriptor } = buildFontObjects(standardName, require_objects.pdfRef(alloc.descNum, 0));
+		objects.push({
+			num: alloc.fontNum,
+			value: font
+		});
+		objects.push({
+			num: alloc.descNum,
+			value: descriptor
+		});
+	}
+	for (const alloc of imageAllocs.values()) {
+		if (alloc.smaskNum !== void 0 && alloc.prepared.alpha !== void 0) {
+			alloc.prepared.dict.entries.set("SMask", require_objects.pdfRef(alloc.smaskNum, 0));
+			objects.push({
+				num: alloc.smaskNum,
+				value: require_objects.pdfStream(alloc.prepared.alpha.dict, alloc.prepared.alpha.raw)
+			});
+		}
+		objects.push({
+			num: alloc.imageNum,
+			value: require_objects.pdfStream(alloc.prepared.dict, alloc.prepared.raw)
+		});
+	}
+	const mathFont = mathFontAlloc === void 0 ? void 0 : require_math_font.loadMathFont().font;
+	const usedGlyphs = mathFontAlloc === void 0 || mathFont === void 0 ? void 0 : require_math_content_write.collectUsedGlyphs(formulas, mathFont);
+	if (mathFontAlloc !== void 0 && mathFont !== void 0 && usedGlyphs !== void 0) {
+		const built = require_math_font_write.buildMathFontObjects(mathFont, usedGlyphs, {
+			cidFontRef: require_objects.pdfRef(mathFontAlloc.cidFontNum, 0),
+			descriptorRef: require_objects.pdfRef(mathFontAlloc.descriptorNum, 0),
+			fontFileRef: require_objects.pdfRef(mathFontAlloc.fontFileNum, 0),
+			toUnicodeRef: require_objects.pdfRef(mathFontAlloc.toUnicodeNum, 0)
+		}, compress);
+		objects.push({
+			num: mathFontAlloc.type0Num,
+			value: built.type0
+		});
+		objects.push({
+			num: mathFontAlloc.cidFontNum,
+			value: built.cidFont
+		});
+		objects.push({
+			num: mathFontAlloc.descriptorNum,
+			value: built.descriptor
+		});
+		objects.push({
+			num: mathFontAlloc.fontFileNum,
+			value: built.fontFile
+		});
+		objects.push({
+			num: mathFontAlloc.toUnicodeNum,
+			value: built.toUnicode
+		});
+	}
+	const resourceEntries = /* @__PURE__ */ new Map();
+	if (fontAllocs.size > 0 || mathFontAlloc !== void 0) {
+		const fontEntries = new Map([...fontAllocs.values()].map((alloc) => [alloc.resourceName, require_objects.pdfRef(alloc.fontNum, 0)]));
+		if (mathFontAlloc !== void 0) fontEntries.set(mathFontAlloc.resourceName, require_objects.pdfRef(mathFontAlloc.type0Num, 0));
+		resourceEntries.set("Font", require_objects.pdfDict(fontEntries));
+	}
+	if (imageAllocs.size > 0) resourceEntries.set("XObject", require_objects.pdfDict(new Map([...imageAllocs.values()].map((alloc) => [alloc.resourceName, require_objects.pdfRef(alloc.imageNum, 0)]))));
+	const resourcesDict = require_objects.pdfDict(resourceEntries);
+	const formulasByPage = /* @__PURE__ */ new Map();
+	for (const formula of formulas) {
+		const forPage = formulasByPage.get(formula.pageIndex);
+		if (forPage === void 0) formulasByPage.set(formula.pageIndex, [formula]);
+		else forPage.push(formula);
+	}
+	const context = {
+		measurer,
+		resolveFont: (font) => {
+			const standardName = require_fonts.resolveStandardFont(font.family, font.weight === "bold", font.style === "italic").standardName;
+			const alloc = fontAllocs.get(standardName);
+			if (alloc === void 0) throw new Error(`font "${standardName}" was not pre-allocated -- this is a writePdf internal invariant violation`);
+			return {
+				resourceName: alloc.resourceName,
+				standardName
+			};
+		},
+		resolveImage: (imageId) => {
+			const alloc = imageAllocs.get(imageId);
+			if (alloc === void 0) throw new Error(`image "${imageId}" was not pre-allocated -- this is a writePdf internal invariant violation`);
+			return { resourceName: alloc.resourceName };
+		}
+	};
+	doc.pages.forEach((page, pageIndex) => {
+		require_util_abort.throwIfAborted(options.signal);
+		const { pageNum, contentsNum } = pageAllocs[pageIndex];
+		const { bytes: contentBytes, substitutions } = require_content_write.writeContentStream(page.items, context);
+		for (const substitution of substitutions) options.onSubstitution?.(substitution, { pageIndex });
+		const pageFormulas = formulasByPage.get(pageIndex);
+		const formulaBytes = pageFormulas === void 0 || mathFontAlloc === void 0 || mathFont === void 0 ? void 0 : require_math_content_write.writeFormulaContentStream(pageFormulas, {
+			font: mathFont,
+			resourceName: mathFontAlloc.resourceName
+		});
+		const combinedContentBytes = formulaBytes === void 0 ? contentBytes : require_bytes_writer.concatBytes([contentBytes, formulaBytes]);
+		const finalContentBytes = compress ? require_bytes_flate.deflate(combinedContentBytes) : combinedContentBytes;
+		const contentsDict = require_objects.pdfDict(compress ? { Filter: require_objects.pdfName("FlateDecode") } : {});
+		objects.push({
+			num: contentsNum,
+			value: require_objects.pdfStream(contentsDict, finalContentBytes)
+		});
+		const annots = page.items.filter(isLinkItem).map((link) => buildLinkAnnotDict(link));
+		if (page.notes !== void 0 && page.notes.length > 0) annots.push(buildNotesAnnotDict(page.notes));
+		const pageEntries = /* @__PURE__ */ new Map([
+			["Type", require_objects.pdfName("Page")],
+			["Parent", require_objects.pdfRef(pagesNum, 0)],
+			["MediaBox", require_objects.pdfArray([
+				0,
+				0,
+				page.widthPt,
+				page.heightPt
+			].map((n) => require_objects.pdfNum(n)))],
+			["Resources", resourcesDict],
+			["Contents", require_objects.pdfRef(contentsNum, 0)]
+		]);
+		if (annots.length > 0) pageEntries.set("Annots", require_objects.pdfArray(annots));
+		objects.push({
+			num: pageNum,
+			value: require_objects.pdfDict(pageEntries)
+		});
+	});
+	const writer = new require_bytes_writer.ByteWriter();
+	writer.writeAscii("%PDF-1.7\n");
+	const offsets = /* @__PURE__ */ new Map();
+	for (const { num, value } of objects) {
+		offsets.set(num, writer.length);
+		writer.writeAscii(`${num} 0 obj\n`);
+		require_serialize.writeObject(writer, value);
+		writer.writeAscii("\nendobj\n");
+	}
+	const maxObjNum = nextObjNum - 1;
+	const xrefOffset = writer.length;
+	writer.writeAscii("xref\n");
+	writer.writeAscii(`0 ${maxObjNum + 1}\n`);
+	writer.writeAscii(xrefEntry(0, 65535, false));
+	for (let num = 1; num <= maxObjNum; num++) {
+		const offset = offsets.get(num);
+		if (offset === void 0) throw new Error(`object ${num} was allocated but never written -- this is a writePdf internal invariant violation`);
+		writer.writeAscii(xrefEntry(offset, 0, true));
+	}
+	writer.writeAscii("trailer\n");
+	require_serialize.writeObject(writer, require_objects.pdfDict({
+		Size: require_objects.pdfNum(maxObjNum + 1),
+		Root: require_objects.pdfRef(catalogNum, 0),
+		Info: require_objects.pdfRef(infoNum, 0)
+	}));
+	writer.writeAscii("\nstartxref\n");
+	writer.writeAscii(`${xrefOffset}\n`);
+	writer.writeAscii("%%EOF");
+	return writer.toBytes();
+}
+//#endregion
+exports.NOTES_ANNOTATION_AUTHOR = NOTES_ANNOTATION_AUTHOR;
+exports.writePdf = writePdf;

package/dist/write.d.cts

@@ -0,0 +1,16 @@
+import { WinAnsiSubstitution } from "./winansi.cjs";
+import { PositionedFormula } from "./formula.cjs";
+import { LayoutDocument } from "document-schema.js";
+//#region src/write.d.ts
+interface WritePdfOptions {
+  readonly compress?: boolean;
+  readonly signal?: AbortSignal;
+  readonly onSubstitution?: (substitution: WinAnsiSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+  readonly formulas?: readonly PositionedFormula[];
+}
+declare const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
+declare function writePdf(doc: LayoutDocument, options?: WritePdfOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { NOTES_ANNOTATION_AUTHOR, WritePdfOptions, writePdf };

package/dist/write.d.ts

@@ -0,0 +1,16 @@
+import { WinAnsiSubstitution } from "./winansi.js";
+import { PositionedFormula } from "./formula.js";
+import { LayoutDocument } from "document-schema.js";
+//#region src/write.d.ts
+interface WritePdfOptions {
+  readonly compress?: boolean;
+  readonly signal?: AbortSignal;
+  readonly onSubstitution?: (substitution: WinAnsiSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+  readonly formulas?: readonly PositionedFormula[];
+}
+declare const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
+declare function writePdf(doc: LayoutDocument, options?: WritePdfOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { NOTES_ANNOTATION_AUTHOR, WritePdfOptions, writePdf };