@libpdf/core 0.2.7 → 0.2.8

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import { t as __exportAll } from "./chunk-15K8U1wQ.mjs";
+import { LRUCache } from "lru-cache";
 import pako, { deflate, inflate } from "pako";
 import { cbc, ecb } from "@noble/ciphers/aes.js";
 import { randomBytes } from "@noble/ciphers/utils.js";
@@ -10,7 +11,7 @@ import { createCMSECDSASignature } from "pkijs";
 import { base64 } from "@scure/base";
 
 //#region package.json
-var version = "0.2.7";
+var version = "0.2.8";
 
 //#endregion
 //#region src/objects/pdf-array.ts
@@ -112,6 +113,80 @@ var PdfArray = class PdfArray {
 	}
 };
 
+//#endregion
+//#region src/helpers/buffer.ts
+/**
+* Buffer utilities for working with ArrayBuffer and Uint8Array.
+*/
+/**
+* Ensure we have a proper ArrayBuffer (not SharedArrayBuffer or slice).
+*
+* Web Crypto APIs require a true ArrayBuffer, not a view into one.
+*
+* @param data - Uint8Array to convert
+* @returns ArrayBuffer containing the data
+*/
+function toArrayBuffer(data) {
+	if (data.buffer instanceof ArrayBuffer && data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) return data.buffer;
+	return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
+/**
+* Concatenate multiple Uint8Arrays into a single Uint8Array.
+*
+* @param arrays - Arrays to concatenate
+* @returns Single Uint8Array containing all data
+*/
+function concatBytes(arrays) {
+	const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+}
+/** Pre-computed hex lookup: byte value → "XX" uppercase string. */
+const HEX_TABLE = new Array(256);
+for (let i = 0; i < 256; i++) HEX_TABLE[i] = i.toString(16).toUpperCase().padStart(2, "0");
+/**
+* Convert bytes to uppercase hex string.
+*
+* @param bytes - Raw bytes
+* @returns Hex string (e.g., "48656C6C6F")
+*
+* @example
+* ```ts
+* bytesToHex(new Uint8Array([72, 101, 108, 108, 111])) // "48656C6C6F"
+* ```
+*/
+function bytesToHex(bytes) {
+	let hex = "";
+	for (const byte of bytes) hex += HEX_TABLE[byte];
+	return hex;
+}
+/**
+* Convert a hex string to bytes.
+*
+* Whitespace is ignored. Odd-length strings are padded with trailing 0.
+*
+* @param hex - Hex string (e.g., "48656C6C6F" or "48 65 6C 6C 6F")
+* @returns Decoded bytes
+*
+* @example
+* ```ts
+* hexToBytes("48656C6C6F") // Uint8Array([72, 101, 108, 108, 111])
+* hexToBytes("ABC") // Uint8Array([171, 192]) - padded to "ABC0"
+* ```
+*/
+function hexToBytes(hex) {
+	const clean = hex.replace(/\s/g, "");
+	const padded = clean.length % 2 === 1 ? `${clean}0` : clean;
+	const bytes = new Uint8Array(padded.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = Number.parseInt(padded.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+
 //#endregion
 //#region src/helpers/chars.ts
 /**
@@ -221,83 +296,6 @@ function hexValue(byte) {
 */
 const SINGLE_BYTE_MASK = 255;
 
-//#endregion
-//#region src/helpers/lru-cache.ts
-/**
-* Simple LRU (Least Recently Used) cache implementation.
-*
-* Used for interning frequently-used PDF objects (PdfName, PdfRef)
-* while preventing unbounded memory growth.
-*/
-/**
-* A bounded cache that evicts least-recently-used entries when full.
-*
-* @typeParam K - Key type
-* @typeParam V - Value type
-*/
-var LRUCache = class {
-	maxSize;
-	cache = /* @__PURE__ */ new Map();
-	/**
-	* Create a new LRU cache.
-	*
-	* @param maxSize - Maximum number of entries to retain (default: 10000)
-	*/
-	constructor(maxSize = 1e4) {
-		this.maxSize = maxSize;
-	}
-	/**
-	* Get a value from the cache, updating its recency.
-	*
-	* @returns The cached value, or undefined if not present
-	*/
-	get(key$1) {
-		const value = this.cache.get(key$1);
-		if (value !== void 0) {
-			this.cache.delete(key$1);
-			this.cache.set(key$1, value);
-		}
-		return value;
-	}
-	/**
-	* Check if a key exists in the cache (without updating recency).
-	*/
-	has(key$1) {
-		return this.cache.has(key$1);
-	}
-	/**
-	* Add or update a value in the cache.
-	*
-	* If the cache is at capacity, the least-recently-used entry is evicted.
-	*/
-	set(key$1, value) {
-		if (this.cache.has(key$1)) this.cache.delete(key$1);
-		else if (this.cache.size >= this.maxSize) {
-			const oldestKey = this.cache.keys().next().value;
-			if (oldestKey !== void 0) this.cache.delete(oldestKey);
-		}
-		this.cache.set(key$1, value);
-	}
-	/**
-	* Remove a value from the cache.
-	*/
-	delete(key$1) {
-		return this.cache.delete(key$1);
-	}
-	/**
-	* Clear all entries from the cache.
-	*/
-	clear() {
-		this.cache.clear();
-	}
-	/**
-	* Get the current number of entries in the cache.
-	*/
-	get size() {
-		return this.cache.size;
-	}
-};
-
 //#endregion
 //#region src/objects/pdf-name.ts
 const NAME_NEEDS_ESCAPE = new Set([
@@ -305,11 +303,20 @@ const NAME_NEEDS_ESCAPE = new Set([
 	...DELIMITERS,
 	CHAR_HASH
 ]);
+/** Module-level encoder — avoids constructing one per escapeName call. */
+const textEncoder = new TextEncoder();
 /**
-* Default cache size for PdfName interning.
-* Can be overridden via PdfName.setCacheSize().
+* Check whether a name is pure "safe" ASCII — every char is printable ASCII
+* (33–126) and not in the escape set. If so, no escaping is needed and we
+* can skip the TextEncoder entirely.
 */
-const DEFAULT_NAME_CACHE_SIZE = 1e4;
+function isSimpleAsciiName(name) {
+	for (let i = 0; i < name.length; i++) {
+		const c = name.charCodeAt(i);
+		if (c < 33 || c > 126 || NAME_NEEDS_ESCAPE.has(c)) return false;
+	}
+	return true;
+}
 /**
 * Escape a PDF name for serialization.
 *
@@ -319,13 +326,19 @@ const DEFAULT_NAME_CACHE_SIZE = 1e4;
 * - The # character itself
 */
 function escapeName$1(name) {
-	const bytes = new TextEncoder().encode(name);
+	if (isSimpleAsciiName(name)) return name;
+	const bytes = textEncoder.encode(name);
 	let result = "";
-	for (const byte of bytes) if (byte < 33 || byte > 126 || NAME_NEEDS_ESCAPE.has(byte)) result += `#${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+	for (const byte of bytes) if (byte < 33 || byte > 126 || NAME_NEEDS_ESCAPE.has(byte)) result += `#${HEX_TABLE[byte]}`;
 	else result += String.fromCharCode(byte);
 	return result;
 }
 /**
+* Default cache size for PdfName interning.
+* Can be overridden via PdfName.setCacheSize().
+*/
+const DEFAULT_NAME_CACHE_SIZE = 1e4;
+/**
 * PDF name object (interned).
 *
 * In PDF: `/Type`, `/Page`, `/Length`
@@ -340,7 +353,7 @@ var PdfName = class PdfName {
 	get type() {
 		return "name";
 	}
-	static cache = new LRUCache(DEFAULT_NAME_CACHE_SIZE);
+	static cache = new LRUCache({ max: DEFAULT_NAME_CACHE_SIZE });
 	/**
 	* Pre-cached common names that should never be evicted.
 	* These are stored separately from the LRU cache.
@@ -359,6 +372,8 @@ var PdfName = class PdfName {
 	static Length = PdfName.createPermanent("Length");
 	static Filter = PdfName.createPermanent("Filter");
 	static FlateDecode = PdfName.createPermanent("FlateDecode");
+	/** Cached serialized form (e.g. "/Type"). Computed lazily on first toBytes(). */
+	cachedBytes = null;
 	constructor(value) {
 		this.value = value;
 	}
@@ -394,7 +409,13 @@ var PdfName = class PdfName {
 		return PdfName.cache.size;
 	}
 	toBytes(writer) {
-		writer.writeAscii(`/${escapeName$1(this.value)}`);
+		let bytes = this.cachedBytes;
+		if (bytes === null) {
+			const escaped = escapeName$1(this.value);
+			bytes = textEncoder.encode(`/${escaped}`);
+			this.cachedBytes = bytes;
+		}
+		writer.writeBytes(bytes);
 	}
 	/**
 	* Create a permanent (non-evictable) name.
@@ -427,7 +448,7 @@ var PdfRef = class PdfRef {
 	get type() {
 		return "ref";
 	}
-	static cache = new LRUCache(DEFAULT_REF_CACHE_SIZE);
+	static cache = new LRUCache({ max: DEFAULT_REF_CACHE_SIZE });
 	constructor(objectNumber, generation) {
 		this.objectNumber = objectNumber;
 		this.generation = generation;
@@ -2044,77 +2065,6 @@ var PdfStream = class PdfStream extends PdfDict {
 	}
 };
 
-//#endregion
-//#region src/helpers/buffer.ts
-/**
-* Buffer utilities for working with ArrayBuffer and Uint8Array.
-*/
-/**
-* Ensure we have a proper ArrayBuffer (not SharedArrayBuffer or slice).
-*
-* Web Crypto APIs require a true ArrayBuffer, not a view into one.
-*
-* @param data - Uint8Array to convert
-* @returns ArrayBuffer containing the data
-*/
-function toArrayBuffer(data) {
-	if (data.buffer instanceof ArrayBuffer && data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) return data.buffer;
-	return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-}
-/**
-* Concatenate multiple Uint8Arrays into a single Uint8Array.
-*
-* @param arrays - Arrays to concatenate
-* @returns Single Uint8Array containing all data
-*/
-function concatBytes(arrays) {
-	const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-	const result = new Uint8Array(totalLength);
-	let offset = 0;
-	for (const arr of arrays) {
-		result.set(arr, offset);
-		offset += arr.length;
-	}
-	return result;
-}
-/**
-* Convert bytes to uppercase hex string.
-*
-* @param bytes - Raw bytes
-* @returns Hex string (e.g., "48656C6C6F")
-*
-* @example
-* ```ts
-* bytesToHex(new Uint8Array([72, 101, 108, 108, 111])) // "48656C6C6F"
-* ```
-*/
-function bytesToHex(bytes) {
-	let hex = "";
-	for (const byte of bytes) hex += byte.toString(16).toUpperCase().padStart(2, "0");
-	return hex;
-}
-/**
-* Convert a hex string to bytes.
-*
-* Whitespace is ignored. Odd-length strings are padded with trailing 0.
-*
-* @param hex - Hex string (e.g., "48656C6C6F" or "48 65 6C 6C 6F")
-* @returns Decoded bytes
-*
-* @example
-* ```ts
-* hexToBytes("48656C6C6F") // Uint8Array([72, 101, 108, 108, 111])
-* hexToBytes("ABC") // Uint8Array([171, 192]) - padded to "ABC0"
-* ```
-*/
-function hexToBytes(hex) {
-	const clean = hex.replace(/\s/g, "");
-	const padded = clean.length % 2 === 1 ? `${clean}0` : clean;
-	const bytes = new Uint8Array(padded.length / 2);
-	for (let i = 0; i < bytes.length; i++) bytes[i] = Number.parseInt(padded.slice(i * 2, i * 2 + 2), 16);
-	return bytes;
-}
-
 //#endregion
 //#region src/content/operators.ts
 /**
@@ -24410,6 +24360,14 @@ function mergeBboxes(boxes) {
 //#endregion
 //#region src/text/line-grouper.ts
 /**
+* Minimum fraction of consecutive char pairs with decreasing x-positions
+* (in stream order) to classify a line as "RTL-placed".
+*
+* Figma/Canva exports produce ~100% decreasing pairs within words.
+* 80% tolerates small forward jumps at word boundaries.
+*/
+const RTL_PLACED_THRESHOLD = .8;
+/**
 * Group extracted characters into lines and spans.
 *
 * @param chars - Array of extracted characters
@@ -24423,8 +24381,8 @@ function groupCharsIntoLines(chars, options = {}) {
 	const lineGroups = groupByBaseline(chars, baselineTolerance);
 	const lines = [];
 	for (const group of lineGroups) {
-		const sorted = [...group].sort((a, b) => a.bbox.x - b.bbox.x);
-		const spans = groupIntoSpans(sorted, spaceThreshold);
+		const { chars: sorted, rtlPlaced } = orderLineChars(group);
+		const spans = groupIntoSpans(sorted, spaceThreshold, rtlPlaced);
 		if (spans.length === 0) continue;
 		const lineText = spans.map((s) => s.text).join("");
 		const lineBbox = mergeBboxes(spans.map((s) => s.bbox));
@@ -24440,6 +24398,71 @@ function groupCharsIntoLines(chars, options = {}) {
 	return lines;
 }
 /**
+* Determine the correct character order for a line.
+*
+* Design tools like Figma and Canva export PDFs where LTR characters are placed
+* right-to-left via TJ positioning adjustments (positive values move the pen left).
+* The font has near-zero glyph widths, so all positioning comes from TJ. Characters
+* appear in correct reading order in the content stream, but their x-positions
+* decrease monotonically.
+*
+* When this pattern is detected, we preserve content stream order instead of sorting
+* by x-position, which would reverse the text.
+*
+* **Limitation**: Detection requires `sequenceIndex` on every character. If any
+* character in the group lacks a `sequenceIndex`, we fall back to x-position sorting
+* because stream order cannot be reliably reconstructed.
+*/
+function orderLineChars(group) {
+	if (group.length <= 1) return {
+		chars: [...group],
+		rtlPlaced: false
+	};
+	if (!group.every((c) => c.sequenceIndex != null)) return {
+		chars: [...group].sort((a, b) => a.bbox.x - b.bbox.x),
+		rtlPlaced: false
+	};
+	const streamOrder = [...group].sort((a, b) => a.sequenceIndex - b.sequenceIndex);
+	if (isRtlPlaced(streamOrder)) return {
+		chars: streamOrder,
+		rtlPlaced: true
+	};
+	return {
+		chars: [...group].sort((a, b) => a.bbox.x - b.bbox.x),
+		rtlPlaced: false
+	};
+}
+/**
+* Detect whether characters are placed right-to-left in user space while
+* content stream order represents the correct reading order.
+*
+* Returns true when x-positions in stream order are predominantly decreasing
+* (≥ 80% of consecutive pairs). In that case, position-based sorting would
+* reverse the reading order, so we preserve stream order instead.
+*
+* This covers two real-world scenarios:
+* - **Design-tool PDFs** (Figma, Canva): LTR text placed right-to-left via
+*   TJ positioning adjustments. Stream order = correct reading order.
+* - **Genuine RTL text** (Arabic, Hebrew): characters naturally placed
+*   right-to-left. PDF producers typically emit them in reading order, so
+*   stream order is again correct.
+*
+* In both cases, when x-positions decrease in stream order, preserving stream
+* order produces the correct reading order.
+*
+* **Known limitation**: mixed bidi text (e.g., Arabic with embedded English)
+* requires a full Unicode bidi algorithm, which is out of scope for this
+* heuristic. For mixed lines, neither stream order nor x-sort is fully
+* correct; a future bidi implementation should replace this heuristic.
+*/
+function isRtlPlaced(streamOrder) {
+	if (streamOrder.length < 2) return false;
+	let decreasingCount = 0;
+	for (let i = 1; i < streamOrder.length; i++) if (streamOrder[i].bbox.x < streamOrder[i - 1].bbox.x) decreasingCount++;
+	const totalPairs = streamOrder.length - 1;
+	return decreasingCount / totalPairs >= RTL_PLACED_THRESHOLD;
+}
+/**
 * Group characters by baseline Y coordinate.
 */
 function groupByBaseline(chars, tolerance) {
@@ -24461,7 +24484,7 @@ function groupByBaseline(chars, tolerance) {
 /**
 * Group characters into spans based on font/size and detect spaces.
 */
-function groupIntoSpans(chars, spaceThreshold) {
+function groupIntoSpans(chars, spaceThreshold, rtlPlaced) {
 	if (chars.length === 0) return [];
 	const spans = [];
 	let currentSpan = [chars[0]];
@@ -24471,14 +24494,14 @@ function groupIntoSpans(chars, spaceThreshold) {
 		const prevChar = chars[i - 1];
 		const char = chars[i];
 		const fontChanged = char.fontName !== currentFontName || Math.abs(char.fontSize - currentFontSize) > .5;
-		const needsSpace = char.bbox.x - (prevChar.bbox.x + prevChar.bbox.width) > (prevChar.fontSize + char.fontSize) / 2 * spaceThreshold;
+		const needsSpace = (rtlPlaced ? prevChar.bbox.x - (char.bbox.x + char.bbox.width) : char.bbox.x - (prevChar.bbox.x + prevChar.bbox.width)) > (prevChar.fontSize + char.fontSize) / 2 * spaceThreshold;
 		if (fontChanged) {
 			spans.push(buildSpan(currentSpan));
 			currentSpan = [char];
 			currentFontName = char.fontName;
 			currentFontSize = char.fontSize;
 		} else if (needsSpace) {
-			currentSpan.push(createSpaceChar(prevChar, char));
+			currentSpan.push(createSpaceChar(prevChar, char, rtlPlaced));
 			currentSpan.push(char);
 		} else currentSpan.push(char);
 	}
@@ -24503,9 +24526,9 @@ function buildSpan(chars) {
 /**
 * Create a synthetic space character between two characters.
 */
-function createSpaceChar(before, after) {
-	const x = before.bbox.x + before.bbox.width;
-	const width = after.bbox.x - x;
+function createSpaceChar(before, after, rtlPlaced) {
+	const x = rtlPlaced ? after.bbox.x + after.bbox.width : before.bbox.x + before.bbox.width;
+	const width = rtlPlaced ? before.bbox.x - x : after.bbox.x - x;
 	return {
 		char: " ",
 		bbox: {
@@ -24516,7 +24539,8 @@ function createSpaceChar(before, after) {
 		},
 		fontSize: (before.fontSize + after.fontSize) / 2,
 		fontName: before.fontName,
-		baseline: (before.baseline + after.baseline) / 2
+		baseline: (before.baseline + after.baseline) / 2,
+		sequenceIndex: before.sequenceIndex != null ? before.sequenceIndex + .5 : void 0
 	};
 }
 /**
@@ -26152,7 +26176,8 @@ var TextExtractor = class {
 				},
 				fontSize: this.state.effectiveFontSize,
 				fontName: font.baseFontName,
-				baseline: bbox.baseline
+				baseline: bbox.baseline,
+				sequenceIndex: this.chars.length
 			});
 			const isSpace = char === " " || char === "\xA0";
 			this.state.advanceChar(width, isSpace);
@@ -29131,7 +29156,7 @@ const INHERITABLE_PAGE_ATTRS = [
 * @example
 * ```typescript
 * const copier = new ObjectCopier(sourcePdf, destPdf);
-* const copiedPageRef = await copier.copyPage(sourcePageRef);
+* const copiedPageRef = copier.copyPage(sourcePageRef);
 * destPdf.insertPage(0, copiedPageRef);
 * ```
 */
@@ -29161,14 +29186,14 @@ var ObjectCopier = class {
 	* @param srcPageRef Reference to the page in source document
 	* @returns Reference to the copied page in destination document
 	*/
-	async copyPage(srcPageRef) {
+	copyPage(srcPageRef) {
 		const srcPage = this.source.getObject(srcPageRef);
 		if (!(srcPage instanceof PdfDict)) throw new Error(`Page object not found or not a dictionary: ${srcPageRef.objectNumber} ${srcPageRef.generation} R`);
 		const cloned = srcPage.clone();
 		for (const key$1 of INHERITABLE_PAGE_ATTRS) if (!cloned.has(key$1)) {
 			const inherited = this.getInheritedAttribute(srcPage, key$1);
 			if (inherited) {
-				const copied = await this.copyObject(inherited);
+				const copied = this.copyObject(inherited);
 				cloned.set(key$1, copied);
 			}
 		}
@@ -29177,17 +29202,17 @@ var ObjectCopier = class {
 		if (!this.options.includeThumbnails) cloned.delete("Thumb");
 		if (!this.options.includeStructure) cloned.delete("StructParents");
 		cloned.delete("Parent");
-		const copiedPage = await this.copyDictValues(cloned);
+		const copiedPage = this.copyDictValues(cloned);
 		return this.dest.register(copiedPage);
 	}
 	/**
 	* Deep copy any PDF object, remapping references to destination.
 	*/
-	async copyObject(obj) {
-		if (obj instanceof PdfRef) return await this.copyRef(obj);
-		if (obj instanceof PdfStream) return await this.copyStream(obj);
-		if (obj instanceof PdfDict) return await this.copyDict(obj);
-		if (obj instanceof PdfArray) return await this.copyArray(obj);
+	copyObject(obj) {
+		if (obj instanceof PdfRef) return this.copyRef(obj);
+		if (obj instanceof PdfStream) return this.copyStream(obj);
+		if (obj instanceof PdfDict) return this.copyDict(obj);
+		if (obj instanceof PdfArray) return this.copyArray(obj);
 		return obj;
 	}
 	/**
@@ -29196,7 +29221,7 @@ var ObjectCopier = class {
 	* Handles circular references by registering a placeholder before
 	* recursively copying the referenced object's contents.
 	*/
-	async copyRef(ref) {
+	copyRef(ref) {
 		const key$1 = `${ref.objectNumber}:${ref.generation}`;
 		const existing = this.refMap.get(key$1);
 		if (existing) return existing;
@@ -29210,7 +29235,7 @@ var ObjectCopier = class {
 		if (srcObj instanceof PdfDict) return this.copyDictRef(key$1, srcObj);
 		if (srcObj instanceof PdfArray) {
 			const items = [];
-			for (const item of srcObj) items.push(await this.copyObject(item));
+			for (const item of srcObj) items.push(this.copyObject(item));
 			const copiedArr = new PdfArray(items);
 			const destRef$1 = this.dest.register(copiedArr);
 			this.refMap.set(key$1, destRef$1);
@@ -29223,17 +29248,17 @@ var ObjectCopier = class {
 	/**
 	* Copy a dict reference, handling circular references.
 	*/
-	async copyDictRef(key$1, srcDict) {
+	copyDictRef(key$1, srcDict) {
 		const cloned = srcDict.clone();
 		const destRef = this.dest.register(cloned);
 		this.refMap.set(key$1, destRef);
-		await this.copyDictValues(cloned);
+		this.copyDictValues(cloned);
 		return destRef;
 	}
 	/**
 	* Copy a stream reference, handling circular references and encryption.
 	*/
-	async copyStreamRef(key$1, srcStream) {
+	copyStreamRef(key$1, srcStream) {
 		const sourceWasEncrypted = this.source.isEncrypted;
 		const clonedDict = srcStream.clone();
 		let streamData;
@@ -29268,7 +29293,7 @@ var ObjectCopier = class {
 		const destRef = this.dest.register(copiedStream);
 		this.refMap.set(key$1, destRef);
 		for (const [entryKey, value] of clonedDict) {
-			const copied = await this.copyObject(value);
+			const copied = this.copyObject(value);
 			copiedStream.set(entryKey.value, copied);
 		}
 		return destRef;
@@ -29276,7 +29301,7 @@ var ObjectCopier = class {
 	/**
 	* Copy a dictionary, remapping all reference values.
 	*/
-	async copyDict(dict) {
+	copyDict(dict) {
 		const cloned = dict.clone();
 		return this.copyDictValues(cloned);
 	}
@@ -29284,9 +29309,9 @@ var ObjectCopier = class {
 	* Copy all values in a dictionary, remapping references.
 	* Modifies the dict in place and returns it.
 	*/
-	async copyDictValues(dict) {
+	copyDictValues(dict) {
 		for (const [key$1, value] of dict) {
-			const copied = await this.copyObject(value);
+			const copied = this.copyObject(value);
 			dict.set(key$1.value, copied);
 		}
 		return dict;
@@ -29294,9 +29319,9 @@ var ObjectCopier = class {
 	/**
 	* Copy an array, remapping all reference elements.
 	*/
-	async copyArray(arr) {
+	copyArray(arr) {
 		const items = [];
-		for (const item of arr) items.push(await this.copyObject(item));
+		for (const item of arr) items.push(this.copyObject(item));
 		return new PdfArray(items);
 	}
 	/**
@@ -29305,10 +29330,10 @@ var ObjectCopier = class {
 	* If source wasn't encrypted, copies raw encoded bytes (fastest).
 	* If source was encrypted, decodes and re-encodes with same filters.
 	*/
-	async copyStream(stream) {
+	copyStream(stream) {
 		const sourceWasEncrypted = this.source.isEncrypted;
 		const clonedDict = stream.clone();
-		await this.copyDictValues(clonedDict);
+		this.copyDictValues(clonedDict);
 		if (!sourceWasEncrypted) return new PdfStream(clonedDict, stream.data);
 		try {
 			const decodedData = stream.getDecodedData();
@@ -30672,15 +30697,21 @@ function aesEncrypt(key$1, plaintext) {
 * @param key - 16 bytes (AES-128) or 32 bytes (AES-256)
 * @param data - IV (16 bytes) + ciphertext
 * @returns Decrypted plaintext
-* @throws {Error} if data is too short or padding is invalid
+* @throws {Error} if data is too short to contain an IV
 */
 function aesDecrypt(key$1, data) {
 	validateAesKey(key$1);
 	if (data.length < AES_BLOCK_SIZE) throw new Error(`AES ciphertext too short: expected at least ${AES_BLOCK_SIZE} bytes for IV`);
 	if (data.length === AES_BLOCK_SIZE) return new Uint8Array(0);
 	const iv = data.subarray(0, AES_BLOCK_SIZE);
-	const ciphertext = data.subarray(AES_BLOCK_SIZE);
-	if (ciphertext.length % AES_BLOCK_SIZE !== 0) throw new Error(`AES ciphertext length must be multiple of ${AES_BLOCK_SIZE}, got ${ciphertext.length}`);
+	let ciphertext = data.subarray(AES_BLOCK_SIZE);
+	if (ciphertext.length % AES_BLOCK_SIZE !== 0) {
+		const remainder = ciphertext.length % AES_BLOCK_SIZE;
+		const aligned = ciphertext.length - remainder;
+		console.warn(`AES ciphertext length (${ciphertext.length}) is not a multiple of ${AES_BLOCK_SIZE}, truncating ${remainder} trailing bytes`);
+		if (aligned === 0) return new Uint8Array(0);
+		ciphertext = ciphertext.subarray(0, aligned);
+	}
 	return cbc(key$1, iv).decrypt(ciphertext);
 }
 /**
@@ -33281,29 +33312,34 @@ var DocumentParser = class {
 		* Decrypt an object's strings and stream data.
 		*/
 		const decryptObject = (obj, objNum, genNum) => {
-			if (!securityHandler?.isAuthenticated) return obj;
-			if (obj instanceof PdfString) return new PdfString(securityHandler.decryptString(obj.bytes, objNum, genNum), obj.format);
-			if (obj instanceof PdfArray) {
-				const decryptedItems = [];
-				for (const item of obj) decryptedItems.push(decryptObject(item, objNum, genNum));
-				return new PdfArray(decryptedItems);
-			}
-			if (obj instanceof PdfStream) {
-				const streamType = obj.getName("Type")?.value;
-				if (!securityHandler.shouldEncryptStream(streamType)) return obj;
-				const newStream = new PdfStream(obj, securityHandler.decryptStream(obj.data, objNum, genNum));
-				for (const [key$1, value] of obj) {
-					const decryptedValue = decryptObject(value, objNum, genNum);
-					if (decryptedValue !== value) newStream.set(key$1.value, decryptedValue);
+			try {
+				if (!securityHandler?.isAuthenticated) return obj;
+				if (obj instanceof PdfString) return new PdfString(securityHandler.decryptString(obj.bytes, objNum, genNum), obj.format);
+				if (obj instanceof PdfArray) {
+					const decryptedItems = [];
+					for (const item of obj) decryptedItems.push(decryptObject(item, objNum, genNum));
+					return new PdfArray(decryptedItems);
 				}
-				return newStream;
-			}
-			if (obj instanceof PdfDict) {
-				const decryptedDict = new PdfDict();
-				for (const [key$1, value] of obj) decryptedDict.set(key$1.value, decryptObject(value, objNum, genNum));
-				return decryptedDict;
+				if (obj instanceof PdfStream) {
+					const streamType = obj.getName("Type")?.value;
+					if (!securityHandler.shouldEncryptStream(streamType)) return obj;
+					const newStream = new PdfStream(obj, securityHandler.decryptStream(obj.data, objNum, genNum));
+					for (const [key$1, value] of obj) {
+						const decryptedValue = decryptObject(value, objNum, genNum);
+						if (decryptedValue !== value) newStream.set(key$1.value, decryptedValue);
+					}
+					return newStream;
+				}
+				if (obj instanceof PdfDict) {
+					const decryptedDict = new PdfDict();
+					for (const [key$1, value] of obj) decryptedDict.set(key$1.value, decryptObject(value, objNum, genNum));
+					return decryptedDict;
+				}
+				return obj;
+			} catch (error) {
+				console.warn(`Failed to decrypt object ${objNum} ${genNum}:`, error);
+				return obj;
 			}
-			return obj;
 		};
 		const getObject = (ref) => {
 			const key$1 = `${ref.objectNumber} ${ref.generation}`;
@@ -33781,11 +33817,12 @@ function writeIndirectObject(writer, ref, obj) {
 * Streams that already have filters are returned unchanged - this includes
 * image formats (DCTDecode, JPXDecode, etc.) that are already compressed.
 */
-function prepareObjectForWrite(obj, compress) {
+const DEFAULT_COMPRESSION_THRESHOLD = 512;
+function prepareObjectForWrite(obj, compress, compressionThreshold) {
 	if (!(obj instanceof PdfStream)) return obj;
 	if (obj.has("Filter")) return obj;
 	if (!compress) return obj;
-	if (obj.data.length === 0) return obj;
+	if (obj.data.length < compressionThreshold) return obj;
 	const compressed = FilterPipeline.encode(obj.data, { name: "FlateDecode" });
 	if (compressed.length >= obj.data.length) return obj;
 	const compressedStream = new PdfStream(obj, compressed);
@@ -33886,6 +33923,7 @@ function collectReachableRefs(registry, root, info, encrypt) {
 function writeComplete(registry, options) {
 	const writer = new ByteWriter();
 	const compress = options.compressStreams ?? true;
+	const threshold = options.compressionThreshold ?? DEFAULT_COMPRESSION_THRESHOLD;
 	const version$1 = options.version ?? "1.7";
 	writer.writeAscii(`%PDF-${version$1}\n`);
 	writer.writeBytes(new Uint8Array([
@@ -33901,7 +33939,7 @@ function writeComplete(registry, options) {
 	for (const [ref, obj] of registry.entries()) {
 		const key$1 = `${ref.objectNumber} ${ref.generation}`;
 		if (!reachableKeys.has(key$1)) continue;
-		let prepared = prepareObjectForWrite(obj, compress);
+		let prepared = prepareObjectForWrite(obj, compress, threshold);
 		if (options.securityHandler && options.encrypt && ref !== options.encrypt) prepared = encryptObject(prepared, {
 			handler: options.securityHandler,
 			objectNumber: ref.objectNumber,
@@ -33986,12 +34024,13 @@ function writeIncremental(registry, options) {
 		xrefOffset: options.originalXRefOffset
 	};
 	const compress = options.compressStreams ?? true;
+	const threshold = options.compressionThreshold ?? DEFAULT_COMPRESSION_THRESHOLD;
 	const writer = new ByteWriter(options.originalBytes);
 	const lastByte = options.originalBytes[options.originalBytes.length - 1];
 	if (lastByte !== LF && lastByte !== CR) writer.writeByte(10);
 	const offsets = /* @__PURE__ */ new Map();
 	for (const [ref, obj] of changes.modified) {
-		let prepared = prepareObjectForWrite(obj, compress);
+		let prepared = prepareObjectForWrite(obj, compress, threshold);
 		if (options.securityHandler && options.encrypt && ref !== options.encrypt) prepared = encryptObject(prepared, {
 			handler: options.securityHandler,
 			objectNumber: ref.objectNumber,
@@ -34004,7 +34043,7 @@ function writeIncremental(registry, options) {
 		writeIndirectObject(writer, ref, prepared);
 	}
 	for (const [ref, obj] of changes.created) {
-		let prepared = prepareObjectForWrite(obj, compress);
+		let prepared = prepareObjectForWrite(obj, compress, threshold);
 		if (options.securityHandler && options.encrypt && ref !== options.encrypt) prepared = encryptObject(prepared, {
 			handler: options.securityHandler,
 			objectNumber: ref.objectNumber,
@@ -40849,7 +40888,7 @@ var PDF = class PDF {
 		for (const index of indices) {
 			const srcPage = source.getPage(index);
 			if (!srcPage) throw new Error(`Source page ${index} not found`);
-			const copiedPageRef = await copier.copyPage(srcPage.ref);
+			const copiedPageRef = copier.copyPage(srcPage.ref);
 			copiedRefs.push(copiedPageRef);
 		}
 		let insertIndex = options.insertAt ?? this.getPageCount();
@@ -40925,7 +40964,7 @@ var PDF = class PDF {
 		const srcResources = srcPage.dict.getDict("Resources", source.getObject.bind(source));
 		let resources;
 		if (srcResources) {
-			const copied = await copier.copyObject(srcResources);
+			const copied = copier.copyObject(srcResources);
 			resources = copied instanceof PdfDict ? copied : new PdfDict();
 		} else resources = new PdfDict();
 		const mediaBox = srcPage.getMediaBox();
@@ -41903,7 +41942,9 @@ var PDF = class PDF {
 				encrypt: encryptRef,
 				id: fileId,
 				useXRefStream,
-				securityHandler
+				securityHandler,
+				compressStreams: options.compressStreams,
+				compressionThreshold: options.compressionThreshold
 			});
 			this._pendingSecurity = { action: "none" };
 			return result$1;
@@ -41915,7 +41956,9 @@ var PDF = class PDF {
 			encrypt: encryptRef,
 			id: fileId,
 			useXRefStream,
-			securityHandler
+			securityHandler,
+			compressStreams: options.compressStreams,
+			compressionThreshold: options.compressionThreshold
 		});
 		this._pendingSecurity = { action: "none" };
 		return result;