@libpdf/core 0.2.3 → 0.2.5

package/README.md

@@ -1,5 +1,12 @@
 # LibPDF
 
+[![npm](https://img.shields.io/npm/v/@libpdf/core)](https://www.npmjs.com/package/@libpdf/core)
+[![npm downloads](https://img.shields.io/npm/dm/@libpdf/core)](https://www.npmjs.com/package/@libpdf/core)
+[![CI](https://github.com/LibPDF-js/core/actions/workflows/ci.yml/badge.svg)](https://github.com/LibPDF-js/core/actions/workflows/ci.yml)
+[![GitHub stars](https://img.shields.io/github/stars/libpdf-js/core?style=flat)](https://github.com/LibPDF-js/core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+
 A modern PDF library for TypeScript. Parse, modify, and generate PDFs with a clean, intuitive API.
 
 > **Beta Software**: LibPDF is under active development and APIs may change between minor versions, but we use it in production at [Documenso](https://documenso.com) and consider it ready for real-world use.
@@ -51,7 +58,7 @@ bun add @libpdf/core
 import { PDF } from "@libpdf/core";
 
 const pdf = await PDF.load(bytes);
-const pages = await pdf.getPages();
+const pages = pdf.getPages();
 
 console.log(`${pages.length} pages`);
 ```
@@ -66,7 +73,7 @@ const pdf = await PDF.load(bytes, { credentials: "password" });
 
 ```typescript
 const pdf = await PDF.load(bytes);
-const form = await pdf.getForm();
+const form = pdf.getForm();
 
 form.fill({
   name: "Jane Doe",

package/dist/index.d.mts

@@ -3767,19 +3767,6 @@ interface SvgPathExecutorOptions {
 }
 //#endregion
 //#region src/fonts/standard-14.d.ts
-/**
- * Standard 14 PDF Fonts
- *
- * These are the 14 fonts that every PDF reader must support.
- * They don't require embedding - the reader provides them.
- *
- * Width tables are stored by glyph name (like pdf.js) which works
- * with any encoding. Use getWidthByGlyphName() for lookup.
- *
- * Widths are in glyph units (1000 units = 1 em).
- *
- * Data extracted from pdf.js metrics.js (Mozilla, Apache 2.0 License)
- */
 /**
  * Standard 14 font names.
  */
@@ -4103,8 +4090,9 @@ declare function lineJoinToNumber(join: LineJoin): 0 | 1 | 2;
 //#region src/api/drawing/path-builder.d.ts
 /**
  * Callback type for appending content to a page.
+ * Accepts a string (for ASCII-only content) or raw bytes.
  */
-type ContentAppender = (content: string) => void;
+type ContentAppender = (content: string | Uint8Array) => void;
 /**
  * Callback type for registering a graphics state and returning its name.
  */
@@ -5662,6 +5650,9 @@ declare class PDFPage {
   private formatNumber;
   /**
    * Create and register a content stream.
+   *
+   * Accepts either a string (for ASCII-only content like operator names and numbers)
+   * or raw bytes (for content that may contain non-ASCII data).
    */
   private createContentStream;
   /**
@@ -5689,6 +5680,9 @@ declare class PDFPage {
   private registerGraphicsStateForOpacity;
   /**
    * Append operators to the page content stream.
+   *
+   * Uses Operator.toBytes() directly to avoid UTF-8 round-trip corruption
+   * of non-ASCII bytes in PdfString operands (e.g., WinAnsi-encoded text).
    */
   private appendOperators;
   /**
@@ -5697,6 +5691,10 @@ declare class PDFPage {
   private addFontResource;
   /**
    * Encode text to a PDF string for the given font.
+   *
+   * Standard 14 fonts use WinAnsiEncoding (or SymbolEncoding/ZapfDingbatsEncoding).
+   * Unencodable characters are substituted with .notdef (byte 0x00).
+   * Embedded fonts use Identity-H encoding with glyph IDs.
    */
   private encodeTextForFont;
   /**

package/dist/index.mjs

@@ -9,7 +9,7 @@ import { createCMSECDSASignature } from "pkijs";
 import { base64 } from "@scure/base";
 
 //#region package.json
-var version = "0.2.3";
+var version = "0.2.5";
 
 //#endregion
 //#region src/objects/pdf-array.ts
@@ -13790,19 +13790,6 @@ var ZapfDingbatsEncoding = class ZapfDingbatsEncoding extends SimpleEncoding {
 //#endregion
 //#region src/fonts/standard-14.ts
 /**
-* Standard 14 PDF Fonts
-*
-* These are the 14 fonts that every PDF reader must support.
-* They don't require embedding - the reader provides them.
-*
-* Width tables are stored by glyph name (like pdf.js) which works
-* with any encoding. Use getWidthByGlyphName() for lookup.
-*
-* Widths are in glyph units (1000 units = 1 em).
-*
-* Data extracted from pdf.js metrics.js (Mozilla, Apache 2.0 License)
-*/
-/**
 * Standard 14 font names.
 */
 const STANDARD_14_FONTS = [
@@ -13861,6 +13848,27 @@ function getBaseFontName(name) {
 	return name.includes("+") ? name.split("+")[1] : name;
 }
 /**
+* Get the font encoding for a Standard 14 font.
+*
+* - Symbol → SymbolEncoding
+* - ZapfDingbats → ZapfDingbatsEncoding
+* - All others (Helvetica, Times, Courier) → WinAnsiEncoding
+*/
+function getEncodingForStandard14(name) {
+	const baseName = getBaseFontName(name);
+	if (baseName === "Symbol") return SymbolEncoding.instance;
+	if (baseName === "ZapfDingbats") return ZapfDingbatsEncoding.instance;
+	return WinAnsiEncoding.instance;
+}
+/**
+* Check if a Standard 14 font uses WinAnsiEncoding.
+* Returns false for Symbol and ZapfDingbats (they use built-in encodings).
+*/
+function isWinAnsiStandard14(name) {
+	const baseName = getBaseFontName(name);
+	return baseName !== "Symbol" && baseName !== "ZapfDingbats";
+}
+/**
 * Get basic metrics (ascent, descent, etc.) for a Standard 14 font.
 */
 function getStandard14BasicMetrics(name) {
@@ -13987,7 +13995,130 @@ const CHAR_TO_GLYPH = {
 	123: "braceleft",
 	124: "bar",
 	125: "braceright",
-	126: "asciitilde"
+	126: "asciitilde",
+	8364: "Euro",
+	8218: "quotesinglbase",
+	402: "florin",
+	8222: "quotedblbase",
+	8230: "ellipsis",
+	8224: "dagger",
+	8225: "daggerdbl",
+	710: "circumflex",
+	8240: "perthousand",
+	352: "Scaron",
+	8249: "guilsinglleft",
+	338: "OE",
+	381: "Zcaron",
+	8216: "quoteleft",
+	8217: "quoteright",
+	8220: "quotedblleft",
+	8221: "quotedblright",
+	8226: "bullet",
+	8211: "endash",
+	8212: "emdash",
+	732: "tilde",
+	8482: "trademark",
+	353: "scaron",
+	8250: "guilsinglright",
+	339: "oe",
+	382: "zcaron",
+	376: "Ydieresis",
+	160: "space",
+	161: "exclamdown",
+	162: "cent",
+	163: "sterling",
+	164: "currency",
+	165: "yen",
+	166: "brokenbar",
+	167: "section",
+	168: "dieresis",
+	169: "copyright",
+	170: "ordfeminine",
+	171: "guillemotleft",
+	172: "logicalnot",
+	173: "hyphen",
+	174: "registered",
+	175: "macron",
+	176: "degree",
+	177: "plusminus",
+	178: "twosuperior",
+	179: "threesuperior",
+	180: "acute",
+	181: "mu",
+	182: "paragraph",
+	183: "periodcentered",
+	184: "cedilla",
+	185: "onesuperior",
+	186: "ordmasculine",
+	187: "guillemotright",
+	188: "onequarter",
+	189: "onehalf",
+	190: "threequarters",
+	191: "questiondown",
+	192: "Agrave",
+	193: "Aacute",
+	194: "Acircumflex",
+	195: "Atilde",
+	196: "Adieresis",
+	197: "Aring",
+	198: "AE",
+	199: "Ccedilla",
+	200: "Egrave",
+	201: "Eacute",
+	202: "Ecircumflex",
+	203: "Edieresis",
+	204: "Igrave",
+	205: "Iacute",
+	206: "Icircumflex",
+	207: "Idieresis",
+	208: "Eth",
+	209: "Ntilde",
+	210: "Ograve",
+	211: "Oacute",
+	212: "Ocircumflex",
+	213: "Otilde",
+	214: "Odieresis",
+	215: "multiply",
+	216: "Oslash",
+	217: "Ugrave",
+	218: "Uacute",
+	219: "Ucircumflex",
+	220: "Udieresis",
+	221: "Yacute",
+	222: "Thorn",
+	223: "germandbls",
+	224: "agrave",
+	225: "aacute",
+	226: "acircumflex",
+	227: "atilde",
+	228: "adieresis",
+	229: "aring",
+	230: "ae",
+	231: "ccedilla",
+	232: "egrave",
+	233: "eacute",
+	234: "ecircumflex",
+	235: "edieresis",
+	236: "igrave",
+	237: "iacute",
+	238: "icircumflex",
+	239: "idieresis",
+	240: "eth",
+	241: "ntilde",
+	242: "ograve",
+	243: "oacute",
+	244: "ocircumflex",
+	245: "otilde",
+	246: "odieresis",
+	247: "divide",
+	248: "oslash",
+	249: "ugrave",
+	250: "uacute",
+	251: "ucircumflex",
+	252: "udieresis",
+	253: "yacute",
+	254: "thorn",
+	255: "ydieresis"
 };
 /**
 * Get glyph name for a character (for Standard 14 font width lookup).
@@ -26317,9 +26448,12 @@ var PDFPage = class PDFPage {
 	}
 	/**
 	* Create and register a content stream.
+	*
+	* Accepts either a string (for ASCII-only content like operator names and numbers)
+	* or raw bytes (for content that may contain non-ASCII data).
 	*/
 	createContentStream(content) {
-		const stream = new PdfStream([], new TextEncoder().encode(content));
+		const stream = new PdfStream([], typeof content === "string" ? new TextEncoder().encode(content) : content);
 		if (this.ctx) return this.ctx.register(stream);
 		return stream;
 	}
@@ -26328,13 +26462,22 @@ var PDFPage = class PDFPage {
 	*/
 	prependContent(content) {
 		const existingContents = this.dict.get("Contents");
-		const newContent = this.createContentStream(`${content}\n`);
+		const contentWithNewline = typeof content === "string" ? `${content}\n` : concatBytes([content, new Uint8Array([10])]);
+		const newContent = this.createContentStream(contentWithNewline);
 		if (!existingContents) {
 			this.dict.set("Contents", newContent);
 			return;
 		}
 		if (existingContents instanceof PdfRef) {
-			this.dict.set("Contents", new PdfArray([newContent, existingContents]));
+			const resolved = this.ctx.resolve(existingContents);
+			if (resolved instanceof PdfArray) {
+				const newArray = new PdfArray([newContent]);
+				for (let i = 0; i < resolved.length; i++) {
+					const item = resolved.at(i);
+					if (item) newArray.push(item);
+				}
+				this.dict.set("Contents", newArray);
+			} else this.dict.set("Contents", new PdfArray([newContent, existingContents]));
 			this._contentWrapped = true;
 			return;
 		}
@@ -26360,7 +26503,8 @@ var PDFPage = class PDFPage {
 	*/
 	appendContent(content) {
 		const existingContents = this.dict.get("Contents");
-		const newContent = this.createContentStream(`\n${content}`);
+		const contentWithNewline = typeof content === "string" ? `\n${content}` : concatBytes([new Uint8Array([10]), content]);
+		const newContent = this.createContentStream(contentWithNewline);
 		if (!existingContents) {
 			this.dict.set("Contents", newContent);
 			return;
@@ -26370,7 +26514,17 @@ var PDFPage = class PDFPage {
 			const qStream = this.createContentStream("q\n");
 			const QStream = this.createContentStream("\nQ");
 			if (existingContents instanceof PdfRef) {
-				this.dict.set("Contents", new PdfArray([
+				const resolved = this.ctx.resolve(existingContents);
+				if (resolved instanceof PdfArray) {
+					const newArray = new PdfArray([qStream]);
+					for (let i = 0; i < resolved.length; i++) {
+						const item = resolved.at(i);
+						if (item) newArray.push(item);
+					}
+					newArray.push(QStream);
+					newArray.push(newContent);
+					this.dict.set("Contents", newArray);
+				} else this.dict.set("Contents", new PdfArray([
 					qStream,
 					existingContents,
 					QStream,
@@ -26436,10 +26590,18 @@ var PDFPage = class PDFPage {
 	}
 	/**
 	* Append operators to the page content stream.
+	*
+	* Uses Operator.toBytes() directly to avoid UTF-8 round-trip corruption
+	* of non-ASCII bytes in PdfString operands (e.g., WinAnsi-encoded text).
 	*/
 	appendOperators(ops) {
-		const content = ops.map((op) => op.toString()).join("\n");
-		this.appendContent(content);
+		const newline = new Uint8Array([10]);
+		const parts = [];
+		for (let i = 0; i < ops.length; i++) {
+			if (i > 0) parts.push(newline);
+			parts.push(ops[i].toBytes());
+		}
+		this.appendContent(concatBytes(parts));
 	}
 	/**
 	* Add a font resource to the page and return its name.
@@ -26457,7 +26619,12 @@ var PDFPage = class PDFPage {
 				const baseFont = value.get("BaseFont", this.ctx.resolve.bind(this.ctx));
 				if (baseFont instanceof PdfName && baseFont.value === font) return existingName.value;
 			}
-			const fontDict = PdfDict.of({
+			const fontDict = isWinAnsiStandard14(font) ? PdfDict.of({
+				Type: PdfName.of("Font"),
+				Subtype: PdfName.of("Type1"),
+				BaseFont: PdfName.of(font),
+				Encoding: PdfName.of("WinAnsiEncoding")
+			}) : PdfDict.of({
 				Type: PdfName.of("Font"),
 				Subtype: PdfName.of("Type1"),
 				BaseFont: PdfName.of(font)
@@ -26477,9 +26644,20 @@ var PDFPage = class PDFPage {
 	}
 	/**
 	* Encode text to a PDF string for the given font.
+	*
+	* Standard 14 fonts use WinAnsiEncoding (or SymbolEncoding/ZapfDingbatsEncoding).
+	* Unencodable characters are substituted with .notdef (byte 0x00).
+	* Embedded fonts use Identity-H encoding with glyph IDs.
 	*/
 	encodeTextForFont(text, font) {
-		if (typeof font === "string") return PdfString.fromString(text);
+		if (typeof font === "string") {
+			const encoding = getEncodingForStandard14(font);
+			const codes = [];
+			for (const char of text) if (encoding.canEncode(char)) codes.push(encoding.getCode(char.codePointAt(0)));
+			else codes.push(0);
+			const bytes$1 = new Uint8Array(codes);
+			return PdfString.fromBytes(bytes$1);
+		}
 		const gids = font.encodeTextToGids(text);
 		const bytes = new Uint8Array(gids.length * 2);
 		for (let i = 0; i < gids.length; i++) {