modern-pdf-lib 0.13.0 → 0.14.0

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_pdfPage = require('./pdfPage-BebMv6fN.cjs');
-const require_pdfCatalog = require('./pdfCatalog-y_XG8Hq1.cjs');
+const require_pdfPage = require('./pdfPage-DBfdinTR.cjs');
+const require_pdfCatalog = require('./pdfCatalog-COKoYQ8C.cjs');
 const require_libdeflateWasm = require('./libdeflateWasm-OkNoqBnO.cjs');
 const require_fontSubset = require('./fontSubset-pFc8Dueu.cjs');
 const require_pngEmbed = require('./pngEmbed-OYyOe_W0.cjs');
@@ -200,20 +200,19 @@ var PdfWriter = class {
 	*/
 	writeObjectStream(entries, xrefEntries) {
 		const serializedObjects = [];
-		new StringByteWriter();
 		for (const entry of entries) {
 			const objWriter = new StringByteWriter();
 			entry.object.serialize(objWriter);
 			serializedObjects.push(objWriter.toUint8Array());
 		}
-		let headerStr = "";
+		const headerParts = [];
 		let dataOffset = 0;
 		for (let i = 0; i < entries.length; i++) {
-			if (i > 0) headerStr += " ";
-			headerStr += `${entries[i].ref.objectNumber} ${dataOffset}`;
+			headerParts.push(`${entries[i].ref.objectNumber} ${dataOffset}`);
 			dataOffset += serializedObjects[i].length;
 			if (i < entries.length - 1) dataOffset += 1;
 		}
+		const headerStr = headerParts.join(" ");
 		const headerBytes = encoder$5.encode(headerStr + " ");
 		const firstOffset = headerBytes.length;
 		let totalDataLen = firstOffset;
@@ -3755,7 +3754,7 @@ const isDelimiter = /* @__PURE__ */ (() => {
 * `hexVal[b]` is the numeric value (0-15) of a hex character, or -1 if
 * the byte is not a valid hex digit.
 */
-const hexVal = /* @__PURE__ */ (() => {
+const hexVal$1 = /* @__PURE__ */ (() => {
 	const t = new Int8Array(256).fill(-1);
 	for (let i = 0; i <= 9; i++) t[CH_0 + i] = i;
 	for (let i = 0; i < 6; i++) {
@@ -4052,7 +4051,7 @@ var PdfLexer = class {
 		const d = this._data;
 		let pos = startPos + 1;
 		let depth = 1;
-		let result = "";
+		const parts = [];
 		while (pos < this.len && depth > 0) {
 			const c = d[pos];
 			if (c === CH_BACKSLASH) {
@@ -4061,35 +4060,35 @@ var PdfLexer = class {
 				const esc = d[pos];
 				switch (esc) {
 					case 110:
-						result += "\n";
+						parts.push("\n");
 						pos++;
 						break;
 					case 114:
-						result += "\r";
+						parts.push("\r");
 						pos++;
 						break;
 					case 116:
-						result += "	";
+						parts.push("	");
 						pos++;
 						break;
 					case 98:
-						result += "\b";
+						parts.push("\b");
 						pos++;
 						break;
 					case 102:
-						result += "\f";
+						parts.push("\f");
 						pos++;
 						break;
 					case CH_LPAREN:
-						result += "(";
+						parts.push("(");
 						pos++;
 						break;
 					case CH_RPAREN:
-						result += ")";
+						parts.push(")");
 						pos++;
 						break;
 					case CH_BACKSLASH:
-						result += "\\";
+						parts.push("\\");
 						pos++;
 						break;
 					case WS_LF:
@@ -4111,9 +4110,9 @@ var PdfLexer = class {
 									pos++;
 								}
 							}
-							result += String.fromCharCode(octal & 255);
+							parts.push(String.fromCharCode(octal & 255));
 						} else {
-							result += String.fromCharCode(esc);
+							parts.push(String.fromCharCode(esc));
 							pos++;
 						}
 						break;
@@ -4122,23 +4121,23 @@ var PdfLexer = class {
 			}
 			if (c === CH_LPAREN) {
 				depth++;
-				result += "(";
+				parts.push("(");
 				pos++;
 				continue;
 			}
 			if (c === CH_RPAREN) {
 				depth--;
-				if (depth > 0) result += ")";
+				if (depth > 0) parts.push(")");
 				pos++;
 				continue;
 			}
 			if (c === WS_CR) {
-				result += "\n";
+				parts.push("\n");
 				pos++;
 				if (pos < this.len && d[pos] === WS_LF) pos++;
 				continue;
 			}
-			result += String.fromCharCode(c);
+			parts.push(String.fromCharCode(c));
 			pos++;
 		}
 		if (depth !== 0) throw new PdfParseError({
@@ -4151,7 +4150,7 @@ var PdfLexer = class {
 		this.position = pos;
 		return {
 			type: TokenType$1.LiteralString,
-			value: result,
+			value: parts.join(""),
 			offset: startPos
 		};
 	}
@@ -4164,7 +4163,8 @@ var PdfLexer = class {
 	readHexString(startPos) {
 		const d = this._data;
 		let pos = startPos + 1;
-		let hex = "";
+		const bytes = [];
+		let hi = -1;
 		while (pos < this.len) {
 			const c = d[pos];
 			if (c === CH_GT) {
@@ -4175,27 +4175,26 @@ var PdfLexer = class {
 				pos++;
 				continue;
 			}
-			if (hexVal[c] === -1) throw new PdfParseError({
+			const v = hexVal$1[c];
+			if (v === -1) throw new PdfParseError({
 				message: `PdfLexer: invalid hex digit 0x${c.toString(16).padStart(2, "0")} at offset ${pos} in hex string starting at ${startPos}`,
 				offset: pos,
 				expected: "hex digit (0-9, a-f, A-F)",
 				actual: `0x${c.toString(16).padStart(2, "0")}`,
 				data: this._data
 			});
-			hex += String.fromCharCode(c);
+			if (hi === -1) hi = v;
+			else {
+				bytes.push(hi << 4 | v);
+				hi = -1;
+			}
 			pos++;
 		}
-		if (hex.length % 2 !== 0) hex += "0";
-		let result = "";
-		for (let i = 0; i < hex.length; i += 2) {
-			const hi = hexVal[hex.charCodeAt(i)];
-			const lo = hexVal[hex.charCodeAt(i + 1)];
-			result += String.fromCharCode(hi << 4 | lo);
-		}
+		if (hi !== -1) bytes.push(hi << 4);
 		this.position = pos;
 		return {
 			type: TokenType$1.HexString,
-			value: result,
+			value: String.fromCharCode.apply(null, bytes),
 			offset: startPos
 		};
 	}
@@ -4208,7 +4207,7 @@ var PdfLexer = class {
 	readName(startPos) {
 		const d = this._data;
 		let pos = startPos + 1;
-		let name = "/";
+		const parts = ["/"];
 		while (pos < this.len) {
 			const c = d[pos];
 			if (isWhitespace[c] || isDelimiter[c]) break;
@@ -4220,8 +4219,8 @@ var PdfLexer = class {
 					actual: "end of input",
 					data: this._data
 				});
-				const hi = hexVal[d[pos + 1]];
-				const lo = hexVal[d[pos + 2]];
+				const hi = hexVal$1[d[pos + 1]];
+				const lo = hexVal$1[d[pos + 2]];
 				if (hi === -1 || lo === -1) throw new PdfParseError({
 					message: `PdfLexer: invalid #XX escape in name at offset ${pos}`,
 					offset: pos,
@@ -4229,17 +4228,17 @@ var PdfLexer = class {
 					actual: `#${String.fromCharCode(d[pos + 1])}${String.fromCharCode(d[pos + 2])}`,
 					data: this._data
 				});
-				name += String.fromCharCode(hi << 4 | lo);
+				parts.push(String.fromCharCode(hi << 4 | lo));
 				pos += 3;
 				continue;
 			}
-			name += String.fromCharCode(c);
+			parts.push(String.fromCharCode(c));
 			pos++;
 		}
 		this.position = pos;
 		return {
 			type: TokenType$1.Name,
-			value: name,
+			value: parts.join(""),
 			offset: startPos
 		};
 	}
@@ -4354,10 +4353,7 @@ var PdfLexer = class {
 	* because it avoids the per-call overhead of the streaming decoder.
 	*/
 	bytesToAscii(from, to) {
-		const d = this._data;
-		let s = "";
-		for (let i = from; i < to; i++) s += String.fromCharCode(d[i]);
-		return s;
+		return String.fromCharCode.apply(null, this._data.subarray(from, to));
 	}
 };
 
@@ -5251,18 +5247,20 @@ var XrefParser = class {
 	parseTraditionalXref(offset) {
 		const entries = [];
 		let pos = offset;
-		const xrefTag = TEXT_DECODER$1.decode(this.data.subarray(pos, pos + 4));
-		if (xrefTag !== "xref") throw new PdfParseError({
-			message: `Invalid PDF: expected "xref" keyword at offset ${offset}, found "${xrefTag}".`,
-			offset,
-			expected: "\"xref\" keyword",
-			actual: `"${xrefTag}"`,
-			data: this.data
-		});
+		if (!this.isTraditionalXref(pos)) {
+			const xrefTag = TEXT_DECODER$1.decode(this.data.subarray(pos, pos + 4));
+			throw new PdfParseError({
+				message: `Invalid PDF: expected "xref" keyword at offset ${offset}, found "${xrefTag}".`,
+				offset,
+				expected: "\"xref\" keyword",
+				actual: `"${xrefTag}"`,
+				data: this.data
+			});
+		}
 		pos += 4;
 		pos = this.skipWhitespaceAt(pos);
 		while (pos < this.data.length) {
-			if (TEXT_DECODER$1.decode(this.data.subarray(pos, Math.min(pos + 7, this.data.length))).startsWith("trailer")) break;
+			if (this.matchesBytes(pos, 116, 114, 97, 105, 108, 101, 114)) break;
 			const headerLine = this.readLineAt(pos);
 			const headerMatch = headerLine.text.trim().match(/^(\d+)\s+(\d+)/);
 			if (!headerMatch) throw new PdfParseError({
@@ -5277,35 +5275,45 @@ var XrefParser = class {
 			pos = headerLine.nextPos;
 			for (let i = 0; i < count; i++) {
 				const objectNumber = firstObjNum + i;
-				const entryText = this.readXrefEntryAt(pos);
-				const entryMatch = entryText.text.trim().match(/^(\d{10})\s+(\d{5})\s+([fn])/);
-				if (!entryMatch) throw new PdfParseError({
-					message: `Invalid PDF: malformed xref entry at offset ${pos} for object ${objectNumber}: "${entryText.text.trim()}"`,
-					offset: pos,
-					expected: "xref entry \"OOOOOOOOOO GGGGG f/n\"",
-					actual: `"${entryText.text.trim()}"`,
-					data: this.data
-				});
-				const entryOffset = parseInt(entryMatch[1], 10);
-				const gen = parseInt(entryMatch[2], 10);
-				const marker = entryMatch[3];
-				entries.push({
-					objectNumber,
-					generationNumber: gen,
-					offset: entryOffset,
-					type: marker === "n" ? "in-use" : "free"
-				});
-				pos = entryText.nextPos;
+				const parsed = this.parseXrefEntryDirect(pos);
+				if (parsed) {
+					entries.push({
+						objectNumber,
+						generationNumber: parsed.gen,
+						offset: parsed.offset,
+						type: parsed.type
+					});
+					pos = parsed.nextPos;
+				} else {
+					const entryText = this.readXrefEntryAt(pos);
+					const entryMatch = entryText.text.trim().match(/^(\d{10})\s+(\d{5})\s+([fn])/);
+					if (!entryMatch) throw new PdfParseError({
+						message: `Invalid PDF: malformed xref entry at offset ${pos} for object ${objectNumber}: "${entryText.text.trim()}"`,
+						offset: pos,
+						expected: "xref entry \"OOOOOOOOOO GGGGG f/n\"",
+						actual: `"${entryText.text.trim()}"`,
+						data: this.data
+					});
+					entries.push({
+						objectNumber,
+						generationNumber: parseInt(entryMatch[2], 10),
+						offset: parseInt(entryMatch[1], 10),
+						type: entryMatch[3] === "n" ? "in-use" : "free"
+					});
+					pos = entryText.nextPos;
+				}
 			}
 		}
-		const trailerTag = TEXT_DECODER$1.decode(this.data.subarray(pos, pos + 7));
-		if (trailerTag !== "trailer") throw new PdfParseError({
-			message: `Invalid PDF: expected "trailer" keyword at offset ${pos}, found "${trailerTag}".`,
-			offset: pos,
-			expected: "\"trailer\" keyword",
-			actual: `"${trailerTag}"`,
-			data: this.data
-		});
+		if (!this.matchesBytes(pos, 116, 114, 97, 105, 108, 101, 114)) {
+			const trailerTag = TEXT_DECODER$1.decode(this.data.subarray(pos, pos + 7));
+			throw new PdfParseError({
+				message: `Invalid PDF: expected "trailer" keyword at offset ${pos}, found "${trailerTag}".`,
+				offset: pos,
+				expected: "\"trailer\" keyword",
+				actual: `"${trailerTag}"`,
+				data: this.data
+			});
+		}
 		pos += 7;
 		const trailerObj = this.objectParser.parseObjectAt(pos);
 		if (trailerObj.kind !== "dict") throw new PdfParseError({
@@ -5460,17 +5468,33 @@ var XrefParser = class {
 	*/
 	rebuildXrefFromScan() {
 		const entries = /* @__PURE__ */ new Map();
-		const fileText = TEXT_DECODER$1.decode(this.data);
-		const objPattern = /(\d+)\s+(\d+)\s+obj\b/g;
-		let match;
-		while ((match = objPattern.exec(fileText)) !== null) {
-			const objectNumber = parseInt(match[1], 10);
-			const gen = parseInt(match[2], 10);
-			const offset = match.index;
+		const d = this.data;
+		const len = d.length;
+		for (let i = 0; i < len - 2; i++) {
+			if (d[i] !== 111 || d[i + 1] !== 98 || d[i + 2] !== 106) continue;
+			if (i + 3 < len) {
+				const after = d[i + 3];
+				if (after > 32 && after !== 37 && after !== 40 && after !== 41 && after !== 47 && after !== 60 && after !== 62 && after !== 91 && after !== 93 && after !== 123 && after !== 125) continue;
+			}
+			let j = i - 1;
+			while (j >= 0 && (d[j] === 32 || d[j] === 10 || d[j] === 13 || d[j] === 9 || d[j] === 0)) j--;
+			const genEnd = j + 1;
+			while (j >= 0 && d[j] >= 48 && d[j] <= 57) j--;
+			const genStart = j + 1;
+			if (genStart >= genEnd) continue;
+			while (j >= 0 && (d[j] === 32 || d[j] === 10 || d[j] === 13 || d[j] === 9 || d[j] === 0)) j--;
+			const objEnd = j + 1;
+			while (j >= 0 && d[j] >= 48 && d[j] <= 57) j--;
+			const objStart = j + 1;
+			if (objStart >= objEnd) continue;
+			let objectNumber = 0;
+			for (let k = objStart; k < objEnd; k++) objectNumber = objectNumber * 10 + (d[k] - 48);
+			let gen = 0;
+			for (let k = genStart; k < genEnd; k++) gen = gen * 10 + (d[k] - 48);
 			entries.set(objectNumber, {
 				objectNumber,
 				generationNumber: gen,
-				offset,
+				offset: objStart,
 				type: "in-use"
 			});
 		}
@@ -5483,7 +5507,11 @@ var XrefParser = class {
 		});
 		let rootRef;
 		let infoRef;
-		const trailerIdx = fileText.lastIndexOf("trailer");
+		let trailerIdx = -1;
+		for (let i = len - 7; i >= 0; i--) if (d[i] === 116 && d[i + 1] === 114 && d[i + 2] === 97 && d[i + 3] === 105 && d[i + 4] === 108 && d[i + 5] === 101 && d[i + 6] === 114) {
+			trailerIdx = i;
+			break;
+		}
 		if (trailerIdx !== -1) try {
 			const trailerObj = this.objectParser.parseObjectAt(trailerIdx + 7);
 			if (trailerObj.kind === "dict") {
@@ -5524,6 +5552,48 @@ var XrefParser = class {
 	* Determine whether the data at the given offset starts with the
 	* "xref" keyword (indicating a traditional xref table).
 	*/
+	/**
+	* Check if the bytes at `pos` match the given byte values.
+	*/
+	matchesBytes(pos, ...bytes) {
+		if (pos + bytes.length > this.data.length) return false;
+		for (let i = 0; i < bytes.length; i++) if (this.data[pos + i] !== bytes[i]) return false;
+		return true;
+	}
+	/**
+	* Parse a standard xref entry directly from bytes, avoiding TextDecoder
+	* and regex. Returns null if the bytes don't form a valid entry.
+	*
+	* Standard format: `OOOOOOOOOO GGGGG f/n` (18 significant bytes)
+	*/
+	parseXrefEntryDirect(pos) {
+		const d = this.data;
+		if (pos + 18 > d.length) return null;
+		let offset = 0;
+		for (let k = 0; k < 10; k++) {
+			const b = d[pos + k];
+			if (b < 48 || b > 57) return null;
+			offset = offset * 10 + (b - 48);
+		}
+		if (d[pos + 10] !== 32) return null;
+		let gen = 0;
+		for (let k = 0; k < 5; k++) {
+			const b = d[pos + 11 + k];
+			if (b < 48 || b > 57) return null;
+			gen = gen * 10 + (b - 48);
+		}
+		if (d[pos + 16] !== 32) return null;
+		const marker = d[pos + 17];
+		if (marker !== 110 && marker !== 102) return null;
+		let nextPos = pos + 18;
+		while (nextPos < d.length && (d[nextPos] === 32 || d[nextPos] === 13 || d[nextPos] === 10)) nextPos++;
+		return {
+			offset,
+			gen,
+			type: marker === 110 ? "in-use" : "free",
+			nextPos
+		};
+	}
 	isTraditionalXref(offset) {
 		if (offset + 4 > this.data.length) return false;
 		return this.data[offset] === 120 && this.data[offset + 1] === 114 && this.data[offset + 2] === 101 && this.data[offset + 3] === 102;
@@ -6321,10 +6391,12 @@ function computeOwnerPasswordValue(ownerPassword, userPassword, revision, keyLen
 	if (revision >= 3) for (let i = 0; i < 50; i++) hash = md5(hash.subarray(0, keyByteLength));
 	const rc4Key = hash.subarray(0, keyByteLength);
 	let encrypted = rc4(rc4Key, padPassword(userPassword));
-	if (revision >= 3) for (let i = 1; i <= 19; i++) {
+	if (revision >= 3) {
 		const modKey = new Uint8Array(rc4Key.length);
-		for (let j = 0; j < rc4Key.length; j++) modKey[j] = (rc4Key[j] ^ i) & 255;
-		encrypted = rc4(modKey, encrypted);
+		for (let i = 1; i <= 19; i++) {
+			for (let j = 0; j < rc4Key.length; j++) modKey[j] = (rc4Key[j] ^ i) & 255;
+			encrypted = rc4(modKey, encrypted);
+		}
 	}
 	return encrypted;
 }
@@ -6354,10 +6426,12 @@ function computeUserPasswordR2(fileKey) {
 */
 function computeUserPasswordR3R4(fileKey, fileId) {
 	let encrypted = rc4(fileKey, md5(concat$1(PASSWORD_PADDING, fileId)));
-	for (let i = 1; i <= 19; i++) {
+	{
 		const modKey = new Uint8Array(fileKey.length);
-		for (let j = 0; j < fileKey.length; j++) modKey[j] = (fileKey[j] ^ i) & 255;
-		encrypted = rc4(modKey, encrypted);
+		for (let i = 1; i <= 19; i++) {
+			for (let j = 0; j < fileKey.length; j++) modKey[j] = (fileKey[j] ^ i) & 255;
+			encrypted = rc4(modKey, encrypted);
+		}
 	}
 	const result = new Uint8Array(32);
 	result.set(encrypted.subarray(0, 16));
@@ -6423,9 +6497,17 @@ async function algorithm2B(password, salt, uKey) {
 	let K = await sha256(uKey ? concat$1(password, salt, uKey) : concat$1(password, salt));
 	let round = 0;
 	while (true) {
-		const K1block = uKey ? concat$1(password, K, uKey) : concat$1(password, K);
-		const K1 = new Uint8Array(K1block.length * 64);
-		for (let i = 0; i < 64; i++) K1.set(K1block, i * K1block.length);
+		const pLen = password.length;
+		const kLen = K.length;
+		const uLen = uKey ? uKey.length : 0;
+		const blockLen = pLen + kLen + uLen;
+		const K1 = new Uint8Array(blockLen * 64);
+		for (let i = 0; i < 64; i++) {
+			const base = i * blockLen;
+			K1.set(password, base);
+			K1.set(K, base + pLen);
+			if (uKey) K1.set(uKey, base + pLen + kLen);
+		}
 		const E = await aesEncryptCBCNoPad(K.subarray(0, 16), K.subarray(16, 32), K1);
 		let bigModVal = 0;
 		for (let i = 0; i < 16; i++) bigModVal = (bigModVal * 256 + E[i]) % 3;
@@ -8577,7 +8659,17 @@ const NS_PDFAID = "http://www.aiim.org/pdfa/ns/id/";
 * @internal
 */
 function escapeXml(str) {
-	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+	const parts = [];
+	for (let i = 0; i < str.length; i++) {
+		const c = str.charCodeAt(i);
+		if (c === 38) parts.push("&amp;");
+		else if (c === 60) parts.push("&lt;");
+		else if (c === 62) parts.push("&gt;");
+		else if (c === 34) parts.push("&quot;");
+		else if (c === 39) parts.push("&apos;");
+		else parts.push(str[i]);
+	}
+	return parts.join("");
 }
 /**
 * Format a Date as an ISO 8601 string for XMP.
@@ -9880,9 +9972,10 @@ function remapRef$1(sourceRef, context) {
 		context.refMap.set(sourceRef.objectNumber, placeholderRef);
 		return placeholderRef;
 	}
+	let streamHash;
 	if (sourceObj.kind === "stream") {
-		const hash = hashBytes(sourceObj.data);
-		const dedup = context.hashMap.get(hash);
+		streamHash = hashBytes(sourceObj.data);
+		const dedup = context.hashMap.get(streamHash);
 		if (dedup) {
 			context.refMap.set(sourceRef.objectNumber, dedup);
 			return dedup;
@@ -9892,10 +9985,7 @@ function remapRef$1(sourceRef, context) {
 	context.refMap.set(sourceRef.objectNumber, targetRef);
 	const clonedObj = deepClone$1(sourceObj, context);
 	context.targetRegistry.assign(targetRef, clonedObj);
-	if (sourceObj.kind === "stream") {
-		const hash = hashBytes(sourceObj.data);
-		context.hashMap.set(hash, targetRef);
-	}
+	if (streamHash !== void 0) context.hashMap.set(streamHash, targetRef);
 	return targetRef;
 }
 /**
@@ -14474,7 +14564,6 @@ function read2DMode(reader) {
 	if (bit === 1) {
 		bit = reader.readBit();
 		if (bit < 0) return Mode2D.EOL;
-		if (bit === 1) return Mode2D.HORIZONTAL;
 		if (bit === 0) return Mode2D.VERTICAL_MINUS_1;
 		return Mode2D.VERTICAL_PLUS_1;
 	}
@@ -17605,9 +17694,28 @@ function hexValue(ch) {
 * `~>` marks end-of-data.
 */
 function decodeASCII85(data) {
-	const result = [];
-	const group = [];
+	let out = new Uint8Array(Math.max(data.length * 4 / 5 | 0, 256));
+	let outPos = 0;
+	const group = new Uint8Array(5);
+	let groupLen = 0;
 	let i = 0;
+	function ensureOut(needed) {
+		if (outPos + needed > out.length) {
+			const newBuf = new Uint8Array(Math.max(out.length * 2, outPos + needed));
+			newBuf.set(out.subarray(0, outPos));
+			out = newBuf;
+		}
+	}
+	function decodeGroup(count) {
+		for (let k = count; k < 5; k++) group[k] = 84;
+		const val = group[0] * 85 * 85 * 85 * 85 + group[1] * 85 * 85 * 85 + group[2] * 85 * 85 + group[3] * 85 + group[4];
+		const numBytes = count === 5 ? 4 : count - 1;
+		ensureOut(numBytes);
+		if (numBytes >= 1) out[outPos++] = val >>> 24 & 255;
+		if (numBytes >= 2) out[outPos++] = val >>> 16 & 255;
+		if (numBytes >= 3) out[outPos++] = val >>> 8 & 255;
+		if (numBytes >= 4) out[outPos++] = val & 255;
+	}
 	while (i < data.length) {
 		const ch = data[i];
 		if (ch === 126) break;
@@ -17616,8 +17724,12 @@ function decodeASCII85(data) {
 			continue;
 		}
 		if (ch === 122) {
-			if (group.length > 0) throw new Error("ASCII85Decode: \"z\" inside a group");
-			result.push(0, 0, 0, 0);
+			if (groupLen > 0) throw new Error("ASCII85Decode: \"z\" inside a group");
+			ensureOut(4);
+			out[outPos++] = 0;
+			out[outPos++] = 0;
+			out[outPos++] = 0;
+			out[outPos++] = 0;
 			i++;
 			continue;
 		}
@@ -17625,24 +17737,15 @@ function decodeASCII85(data) {
 			i++;
 			continue;
 		}
-		group.push(ch - 33);
-		if (group.length === 5) {
-			const val = group[0] * 85 * 85 * 85 * 85 + group[1] * 85 * 85 * 85 + group[2] * 85 * 85 + group[3] * 85 + group[4];
-			result.push(val >>> 24 & 255, val >>> 16 & 255, val >>> 8 & 255, val & 255);
-			group.length = 0;
+		group[groupLen++] = ch - 33;
+		if (groupLen === 5) {
+			decodeGroup(5);
+			groupLen = 0;
 		}
 		i++;
 	}
-	if (group.length >= 2) {
-		const origLen = group.length;
-		while (group.length < 5) group.push(84);
-		const val = group[0] * 85 * 85 * 85 * 85 + group[1] * 85 * 85 * 85 + group[2] * 85 * 85 + group[3] * 85 + group[4];
-		const numBytes = origLen - 1;
-		if (numBytes >= 1) result.push(val >>> 24 & 255);
-		if (numBytes >= 2) result.push(val >>> 16 & 255);
-		if (numBytes >= 3) result.push(val >>> 8 & 255);
-	}
-	return new Uint8Array(result);
+	if (groupLen >= 2) decodeGroup(groupLen);
+	return out.subarray(0, outPos);
 }
 /**
 * Decode an LZWDecode stream.
@@ -17662,6 +17765,10 @@ function decodeLZW(data, parms) {
 }
 /**
 * Core LZW decompression.
+*
+* Uses a flat pooled buffer for the code table instead of per-entry
+* Uint8Array allocations, and a pre-allocated output buffer with
+* manual growth instead of `number[]` + push.
 */
 function lzwDecompress(data, earlyChange) {
 	const CLEAR_TABLE = 256;
@@ -17686,71 +17793,88 @@ function lzwDecompress(data, earlyChange) {
 		}
 		return result;
 	}
-	let table = [];
+	let tableBuf = new Uint8Array(65536);
+	const tableOff = new Int32Array(4096);
+	const tableLen = new Int32Array(4096);
+	let tableBufUsed = 256;
 	let codeSize = 9;
 	let nextCode = 258;
+	for (let i = 0; i < 256; i++) {
+		tableBuf[i] = i;
+		tableOff[i] = i;
+		tableLen[i] = 1;
+	}
 	function resetTable() {
-		table = [];
-		for (let i = 0; i < 256; i++) table[i] = new Uint8Array([i]);
-		table[256] = new Uint8Array(0);
-		table[257] = new Uint8Array(0);
+		tableBufUsed = 256;
 		nextCode = 258;
 		codeSize = 9;
 	}
-	resetTable();
-	const output = [];
-	let prevEntry = null;
+	let out = new Uint8Array(Math.max(data.length * 3, 4096));
+	let outPos = 0;
+	function ensureOut(needed) {
+		if (outPos + needed > out.length) {
+			const newBuf = new Uint8Array(Math.max(out.length * 2, outPos + needed));
+			newBuf.set(out.subarray(0, outPos));
+			out = newBuf;
+		}
+	}
+	function ensureTable(needed) {
+		if (tableBufUsed + needed > tableBuf.length) {
+			const newBuf = new Uint8Array(Math.max(tableBuf.length * 2, tableBufUsed + needed));
+			newBuf.set(tableBuf.subarray(0, tableBufUsed));
+			tableBuf = newBuf;
+		}
+	}
+	function writeEntry(code) {
+		const off = tableOff[code];
+		const len = tableLen[code];
+		ensureOut(len);
+		out.set(tableBuf.subarray(off, off + len), outPos);
+		outPos += len;
+	}
+	function addEntry(prevCode, firstByte) {
+		const prevOff = tableOff[prevCode];
+		const prevLen = tableLen[prevCode];
+		const newLen = prevLen + 1;
+		ensureTable(newLen);
+		tableBuf.set(tableBuf.subarray(prevOff, prevOff + prevLen), tableBufUsed);
+		tableBuf[tableBufUsed + prevLen] = firstByte;
+		tableOff[nextCode] = tableBufUsed;
+		tableLen[nextCode] = newLen;
+		tableBufUsed += newLen;
+		nextCode++;
+	}
 	let code = readBits(codeSize);
 	if (code === CLEAR_TABLE) {
 		resetTable();
 		code = readBits(codeSize);
 	}
-	if (code === EOD) return new Uint8Array(output);
-	let entry = table[code];
-	if (entry) {
-		for (const b of entry) output.push(b);
-		prevEntry = entry;
-	}
+	if (code === EOD) return new Uint8Array(0);
+	writeEntry(code);
+	let prevCode = code;
 	while (true) {
 		code = readBits(codeSize);
 		if (code === EOD) break;
 		if (code === CLEAR_TABLE) {
 			resetTable();
-			prevEntry = null;
 			code = readBits(codeSize);
 			if (code === EOD) break;
-			entry = table[code];
-			if (entry) {
-				for (const b of entry) output.push(b);
-				prevEntry = entry;
-			}
+			writeEntry(code);
+			prevCode = code;
 			continue;
 		}
-		if (code < nextCode && table[code]) {
-			entry = table[code];
-			for (const b of entry) output.push(b);
-			if (prevEntry) {
-				const newEntry = new Uint8Array(prevEntry.length + 1);
-				newEntry.set(prevEntry);
-				newEntry[prevEntry.length] = entry[0];
-				table[nextCode] = newEntry;
-				nextCode++;
-			}
+		if (code < nextCode) {
+			writeEntry(code);
+			addEntry(prevCode, tableBuf[tableOff[code]]);
 		} else {
-			if (!prevEntry) throw new Error("LZWDecode: invalid code sequence");
-			const newEntry = new Uint8Array(prevEntry.length + 1);
-			newEntry.set(prevEntry);
-			newEntry[prevEntry.length] = prevEntry[0];
-			for (const b of newEntry) output.push(b);
-			table[nextCode] = newEntry;
-			nextCode++;
-			entry = newEntry;
-		}
-		prevEntry = entry;
+			addEntry(prevCode, tableBuf[tableOff[prevCode]]);
+			writeEntry(nextCode - 1);
+		}
+		prevCode = code;
 		const threshold = (1 << codeSize) - earlyChange;
 		if (nextCode >= threshold && codeSize < 12) codeSize++;
 	}
-	return new Uint8Array(output);
+	return out.subarray(0, outPos);
 }
 /**
 * Decode a RunLengthDecode stream.
@@ -17882,7 +18006,6 @@ function embedPageAsFormXObject(page, sourceRegistry, targetRegistry, xObjectNam
 	const pageWidth = page.width;
 	const pageHeight = page.height;
 	const contentChunks = [];
-	new TextDecoder();
 	const originalRefs = page.getOriginalContentRefs();
 	for (const ref of originalRefs) {
 		const obj = sourceRegistry.resolve(ref);
@@ -18400,7 +18523,7 @@ var PdfDocument = class PdfDocument {
 	async embedTrueTypeFont(fontData, options) {
 		const embeddedFont = await embedFont(fontData);
 		const metrics = embeddedFont.metrics;
-		const psName = options?.customName || metrics.postScriptName || metrics.familyName || "CustomFont";
+		const psName = options?.customName ?? metrics.postScriptName ?? metrics.familyName ?? "CustomFont";
 		const existing = this.embeddedFonts.get(`__ttf__${psName}`);
 		if (existing) return existing;
 		this.fontCounter++;
@@ -18515,7 +18638,7 @@ var PdfDocument = class PdfDocument {
 	async embedCffFont(fontData, options) {
 		const embeddedFont = await embedFont(fontData);
 		const metrics = embeddedFont.metrics;
-		const psName = options?.customName || metrics.postScriptName || metrics.familyName || "CFFFont";
+		const psName = options?.customName ?? metrics.postScriptName ?? metrics.familyName ?? "CFFFont";
 		const existing = this.embeddedFonts.get(`__cff__${psName}`);
 		if (existing) return existing;
 		this.fontCounter++;
@@ -18805,7 +18928,7 @@ var PdfDocument = class PdfDocument {
 	* @param pages  Array of PdfPage instances to embed.
 	* @returns      Array of {@link EmbeddedPdfPage} handles, one per input page.
 	*/
-	async embedPages(pages) {
+	embedPages(pages) {
 		return pages.map((page) => this.embedPage(page));
 	}
 	/** Set the document title. */
@@ -20337,8 +20460,8 @@ function compressStream(stream, level) {
 * @returns              The incremental save result.
 */
 async function saveDocumentIncremental(originalBytes, doc, options) {
-	const { buildDocumentStructure } = await Promise.resolve().then(() => require("./pdfCatalog-y_XG8Hq1.cjs")).then((n) => n.pdfCatalog_exports);
-	const { PdfPage: _PdfPage } = await Promise.resolve().then(() => require("./pdfPage-BebMv6fN.cjs")).then((n) => n.pdfPage_exports);
+	const { buildDocumentStructure } = await Promise.resolve().then(() => require("./pdfCatalog-COKoYQ8C.cjs")).then((n) => n.pdfCatalog_exports);
+	const { PdfPage: _PdfPage } = await Promise.resolve().then(() => require("./pdfPage-DBfdinTR.cjs")).then((n) => n.pdfPage_exports);
 	const registry = doc.getRegistry();
 	const structure = buildDocumentStructure(doc.getInternalPages().map((p) => p.finalize()), {
 		producer: doc.getProducer(),
@@ -22445,6 +22568,19 @@ var TokenType = /* @__PURE__ */ function(TokenType) {
 	return TokenType;
 }(TokenType || {});
 /**
+* `hexVal[b]` is the numeric value (0-15) of a hex character, or -1 if
+* the byte is not a valid hex digit.
+*/
+const hexVal = /* @__PURE__ */ (() => {
+	const t = new Int8Array(256).fill(-1);
+	for (let i = 0; i <= 9; i++) t[48 + i] = i;
+	for (let i = 0; i < 6; i++) {
+		t[65 + i] = 10 + i;
+		t[97 + i] = 10 + i;
+	}
+	return t;
+})();
+/**
 * Combined lexer + parser for PDF content streams.
 *
 * Content streams are simpler than full PDF object syntax — there are no
@@ -22563,20 +22699,22 @@ var ContentStreamLexer = class {
 		}
 		const dataStart = this.pos;
 		let dataEnd = this.pos;
-		while (this.pos < this.data.length) {
-			if (this.isWhitespace(this.data[this.pos])) {
-				const wsPos = this.pos;
-				let probe = wsPos + 1;
-				if (probe + 1 < this.data.length && this.data[probe] === 69 && this.data[probe + 1] === 73) {
-					const afterEI = probe + 2;
-					if (afterEI >= this.data.length || this.isWhitespace(this.data[afterEI])) {
-						dataEnd = wsPos;
-						this.pos = afterEI;
-						break;
-					}
+		let searchFrom = this.pos;
+		while (searchFrom < this.data.length) {
+			const eIdx = this.data.indexOf(69, searchFrom);
+			if (eIdx === -1 || eIdx + 1 >= this.data.length) {
+				this.pos = this.data.length;
+				break;
+			}
+			if (eIdx > dataStart && this.isWhitespace(this.data[eIdx - 1]) && this.data[eIdx + 1] === 73) {
+				const afterEI = eIdx + 2;
+				if (afterEI >= this.data.length || this.isWhitespace(this.data[afterEI])) {
+					dataEnd = eIdx - 1;
+					this.pos = afterEI;
+					break;
 				}
 			}
-			this.pos++;
+			searchFrom = eIdx + 1;
 		}
 		return {
 			dict,
@@ -22644,7 +22782,7 @@ var ContentStreamLexer = class {
 	*/
 	readLiteralString() {
 		this.pos++;
-		let result = "";
+		const parts = [];
 		let depth = 1;
 		while (this.pos < this.data.length && depth > 0) {
 			const ch = this.data[this.pos];
@@ -22654,35 +22792,35 @@ var ContentStreamLexer = class {
 				const esc = this.data[this.pos];
 				switch (esc) {
 					case 110:
-						result += "\n";
+						parts.push("\n");
 						this.pos++;
 						break;
 					case 114:
-						result += "\r";
+						parts.push("\r");
 						this.pos++;
 						break;
 					case 116:
-						result += "	";
+						parts.push("	");
 						this.pos++;
 						break;
 					case 98:
-						result += "\b";
+						parts.push("\b");
 						this.pos++;
 						break;
 					case 102:
-						result += "\f";
+						parts.push("\f");
 						this.pos++;
 						break;
 					case 40:
-						result += "(";
+						parts.push("(");
 						this.pos++;
 						break;
 					case 41:
-						result += ")";
+						parts.push(")");
 						this.pos++;
 						break;
 					case 92:
-						result += "\\";
+						parts.push("\\");
 						this.pos++;
 						break;
 					case 10:
@@ -22710,29 +22848,29 @@ var ContentStreamLexer = class {
 									}
 								}
 							}
-							result += String.fromCharCode(octal & 255);
+							parts.push(String.fromCharCode(octal & 255));
 						} else {
-							result += String.fromCharCode(esc);
+							parts.push(String.fromCharCode(esc));
 							this.pos++;
 						}
 						break;
 				}
 			} else if (ch === 40) {
 				depth++;
-				result += "(";
+				parts.push("(");
 				this.pos++;
 			} else if (ch === 41) {
 				depth--;
-				if (depth > 0) result += ")";
+				if (depth > 0) parts.push(")");
 				this.pos++;
 			} else {
-				result += String.fromCharCode(ch);
+				parts.push(String.fromCharCode(ch));
 				this.pos++;
 			}
 		}
 		return {
 			type: TokenType.String,
-			value: result
+			value: parts.join("")
 		};
 	}
 	/**
@@ -22740,7 +22878,8 @@ var ContentStreamLexer = class {
 	*/
 	readHexString() {
 		this.pos++;
-		let hex = "";
+		const bytes = [];
+		let hi = -1;
 		while (this.pos < this.data.length) {
 			const ch = this.data[this.pos];
 			if (ch === 62) {
@@ -22751,18 +22890,22 @@ var ContentStreamLexer = class {
 				this.pos++;
 				continue;
 			}
-			hex += String.fromCharCode(ch);
+			const v = hexVal[ch];
+			if (v === -1) {
+				this.pos++;
+				continue;
+			}
+			if (hi === -1) hi = v;
+			else {
+				bytes.push(hi << 4 | v);
+				hi = -1;
+			}
 			this.pos++;
 		}
-		if (hex.length % 2 !== 0) hex += "0";
-		let result = "";
-		for (let i = 0; i < hex.length; i += 2) {
-			const byte = parseInt(hex.substring(i, i + 2), 16);
-			if (!isNaN(byte)) result += String.fromCharCode(byte);
-		}
+		if (hi !== -1) bytes.push(hi << 4);
 		return {
 			type: TokenType.HexString,
-			value: result
+			value: String.fromCharCode.apply(null, bytes)
 		};
 	}
 	/**
@@ -22770,27 +22913,25 @@ var ContentStreamLexer = class {
 	*/
 	readName() {
 		this.pos++;
-		let name = "/";
+		const parts = ["/"];
 		while (this.pos < this.data.length) {
 			const ch = this.data[this.pos];
 			if (this.isWhitespace(ch) || this.isDelimiter(ch)) break;
 			if (ch === 35 && this.pos + 2 < this.data.length) {
-				const hi = this.data[this.pos + 1];
-				const lo = this.data[this.pos + 2];
-				const hex = String.fromCharCode(hi) + String.fromCharCode(lo);
-				const code = parseInt(hex, 16);
-				if (!isNaN(code)) {
-					name += String.fromCharCode(code);
+				const hi = hexVal[this.data[this.pos + 1]];
+				const lo = hexVal[this.data[this.pos + 2]];
+				if (hi !== -1 && lo !== -1) {
+					parts.push(String.fromCharCode(hi << 4 | lo));
 					this.pos += 3;
 					continue;
 				}
 			}
-			name += String.fromCharCode(ch);
+			parts.push(String.fromCharCode(ch));
 			this.pos++;
 		}
 		return {
 			type: TokenType.Name,
-			value: require_pdfCatalog.PdfName.of(name)
+			value: require_pdfCatalog.PdfName.of(parts.join(""))
 		};
 	}
 	/**
@@ -22884,9 +23025,7 @@ var ContentStreamLexer = class {
 	* Decode a slice of the data as ASCII text.
 	*/
 	decodeAscii(start, end) {
-		let s = "";
-		for (let i = start; i < end; i++) s += String.fromCharCode(this.data[i]);
-		return s;
+		return String.fromCharCode.apply(null, this.data.subarray(start, end));
 	}
 };