@web-ts-toolkit/pdf-reader 0.43.0 → 0.48.0

package/index.mjs

@@ -22,6 +22,41 @@ import { getDocument } from "pdfjs-dist";
 // src/embeddedImages.ts
 import { OPS, Util } from "pdfjs-dist";
 
+// src/canvasGuards.ts
+var MAX_TIMER_MS = 2147483647;
+function resolveSafeCanvasDimensions(width, height, limit, code, subject) {
+  const pixelWidth = typeof width === "number" ? Math.ceil(width) : Number.NaN;
+  const pixelHeight = typeof height === "number" ? Math.ceil(height) : Number.NaN;
+  if (!Number.isSafeInteger(pixelWidth) || pixelWidth <= 0 || !Number.isSafeInteger(pixelHeight) || pixelHeight <= 0) {
+    throw new PdfReaderError(code, `${subject} has invalid canvas dimensions.`);
+  }
+  const pixels = pixelWidth * pixelHeight;
+  if (!Number.isSafeInteger(pixels) || pixels <= 0 || pixels > limit) {
+    const detail = Number.isSafeInteger(pixels) ? `${pixels}` : "unsafe";
+    throw new PdfReaderError(code, `${subject} requires ${detail} pixels; limit is ${limit}.`);
+  }
+  return { pixelWidth, pixelHeight, pixels };
+}
+function isValidDataUrlForMime(dataUrl, mimeType) {
+  if (typeof dataUrl !== "string") return false;
+  if (dataUrl === "data:,") return false;
+  if (!dataUrl.startsWith(`data:${mimeType}`)) return false;
+  const comma = dataUrl.indexOf(",");
+  if (comma === -1) return false;
+  if (comma === dataUrl.length - 1) return false;
+  const prefix = `data:${mimeType}`;
+  if (dataUrl.length <= prefix.length + 1) return false;
+  return true;
+}
+function isValidBlobForMime(blob, mimeType) {
+  if (blob === null || typeof blob !== "object") return false;
+  const candidate = blob;
+  if (typeof candidate.size !== "number" || typeof candidate.type !== "string") return false;
+  if (candidate.size <= 0) return false;
+  if (candidate.type !== mimeType) return false;
+  return true;
+}
+
 // src/geometry.ts
 function getTransformedUnitBounds(transform) {
   const [a, b, c, d, e, f] = transform;
@@ -50,8 +85,13 @@ var propagatedErrorCodes = /* @__PURE__ */ new Set([
   "IMAGE_TOTAL_PIXELS_LIMIT_EXCEEDED",
   "OPERATOR_LIMIT_EXCEEDED"
 ]);
+var ImageKind = {
+  GRAYSCALE_1BPP: 1,
+  RGB_24BPP: 2,
+  RGBA_32BPP: 3
+};
 async function extractEmbeddedImages(page, viewport, options) {
-  const operators = await page.getOperatorList();
+  const operators = await options.awaitWithCancellation(page.getOperatorList());
   enforceOperatorLimit(operators.fnArray.length, options.maxOperators);
   const images = [];
   const stack = [];
@@ -96,12 +136,12 @@ async function extractEmbeddedImages(page, viewport, options) {
         if (encoded) {
           enforceNextImageLimits(images.length, totalPixels, encoded.dimensions.pixels, options);
         } else {
-          const paintedImage = await resolvePaintedImage(page, operation, args, index);
+          const paintedImage = await resolvePaintedImage(page, operation, args, index, options);
           options.throwIfDestroyed();
           options.throwIfAborted(options.signal);
           if (!paintedImage) continue;
           const dimensions = readImageDimensions(paintedImage.image, options.maxPixels);
-          if (!dimensions || !isSupportedImageSource(paintedImage.image)) {
+          if (!dimensions) {
             warn(
               options.logger,
               `Skipped embedded image ${paintedImage.label}: unsupported PDF.js image shape or data layout.`
@@ -109,7 +149,15 @@ async function extractEmbeddedImages(page, viewport, options) {
             continue;
           }
           enforceNextImageLimits(images.length, totalPixels, dimensions.pixels, options);
-          const dataUrl = imageToDataUrl(paintedImage.image, dimensions, options);
+          const normalized = normalizeImageSource(paintedImage.image, dimensions);
+          if (!normalized) {
+            warn(
+              options.logger,
+              `Skipped embedded image ${paintedImage.label}: unsupported PDF.js image shape or data layout.`
+            );
+            continue;
+          }
+          const dataUrl = imageToDataUrl(normalized, dimensions, options);
           if (!dataUrl) {
             warn(
               options.logger,
@@ -151,7 +199,7 @@ function readImageReference(args) {
   const reference = Array.isArray(args) ? args[0] : void 0;
   return typeof reference === "string" ? reference : void 0;
 }
-async function resolvePaintedImage(page, operation, args, index) {
+async function resolvePaintedImage(page, operation, args, index, options) {
   if (operation === OPS.paintInlineImageXObject) {
     const inlineImage = Array.isArray(args) ? args[0] : void 0;
     if (!inlineImage || typeof inlineImage !== "object") return void 0;
@@ -159,47 +207,126 @@ async function resolvePaintedImage(page, operation, args, index) {
   }
   const reference = readImageReference(args);
   if (!reference) return void 0;
-  const image = await page.objs.get(reference);
+  const image = await awaitResolvedImageObject(selectImageStore(page, reference), reference, options);
+  if (!image || typeof image !== "object") return void 0;
   return { image, label: reference, reference };
 }
-function imageToDataUrl(image, dimensions, options) {
+function selectImageStore(page, reference) {
+  if (reference.startsWith("g_") && page.commonObjs) return page.commonObjs;
+  return page.objs;
+}
+async function awaitResolvedImageObject(store, reference, options) {
+  if (typeof store?.has === "function" && store.has(reference)) {
+    return store.get(reference);
+  }
+  if (typeof store?.has !== "function") {
+    return store.get(reference);
+  }
+  return options.awaitWithCancellation(
+    new Promise((resolve, reject) => {
+      try {
+        store.get(reference, (data) => resolve(data));
+      } catch (error) {
+        reject(error);
+      }
+    })
+  );
+}
+function imageToDataUrl(normalized, dimensions, options) {
   const canvas = allocateCanvas(dimensions.width, dimensions.height, options.maxPixels, options.createCanvas);
   try {
     const context = canvas.getContext("2d");
     if (!context) return void 0;
-    if (typeof ImageBitmap !== "undefined" && image.bitmap instanceof ImageBitmap) {
-      context.drawImage(image.bitmap, 0, 0);
-      return canvas.toDataURL("image/png");
+    if (normalized.format === "bitmap") {
+      context.drawImage(normalized.bitmap, 0, 0);
+      const dataUrl2 = canvas.toDataURL("image/png");
+      return isValidDataUrlForMime(dataUrl2, "image/png") ? dataUrl2 : void 0;
     }
-    if (!ArrayBuffer.isView(image.data)) return void 0;
-    const source = new Uint8ClampedArray(image.data.buffer, image.data.byteOffset, image.data.byteLength);
-    const rgba = toRgba(source, dimensions);
-    if (!rgba) return void 0;
     const pixels = context.createImageData(dimensions.width, dimensions.height);
-    pixels.data.set(rgba);
+    pixels.data.set(normalized.rgba);
     context.putImageData(pixels, 0, 0);
-    return canvas.toDataURL("image/png");
+    const dataUrl = canvas.toDataURL("image/png");
+    return isValidDataUrlForMime(dataUrl, "image/png") ? dataUrl : void 0;
   } finally {
     releaseCanvas(canvas);
   }
 }
-function toRgba(data, dimensions) {
+function normalizeImageSource(image, dimensions) {
+  if (typeof ImageBitmap !== "undefined" && image.bitmap instanceof ImageBitmap) {
+    return { format: "bitmap", bitmap: image.bitmap };
+  }
+  if (!ArrayBuffer.isView(image.data)) return void 0;
+  const source = new Uint8ClampedArray(image.data.buffer, image.data.byteOffset, image.data.byteLength);
+  const kind = typeof image.kind === "number" ? image.kind : void 0;
+  if (kind === ImageKind.RGBA_32BPP) {
+    const rgbaLength2 = multiplySafe(dimensions.pixels, 4);
+    if (rgbaLength2 === void 0 || source.length !== rgbaLength2) return void 0;
+    return { format: "rgba", rgba: source };
+  }
+  if (kind === ImageKind.RGB_24BPP) {
+    const rgbLength2 = multiplySafe(dimensions.pixels, 3);
+    const rgbaLength2 = multiplySafe(dimensions.pixels, 4);
+    if (rgbLength2 === void 0 || rgbaLength2 === void 0 || source.length !== rgbLength2) return void 0;
+    return { format: "rgba", rgba: expandRgbToRgba(source, dimensions.pixels, rgbaLength2) };
+  }
+  if (kind === ImageKind.GRAYSCALE_1BPP) {
+    const rowBytes = Math.ceil(dimensions.width / 8);
+    const packedLength = multiplySafe(rowBytes, dimensions.height);
+    const rgbaLength2 = multiplySafe(dimensions.pixels, 4);
+    if (packedLength === void 0 || rgbaLength2 === void 0 || source.length !== packedLength) return void 0;
+    return { format: "rgba", rgba: unpackOneBitToRgba(source, dimensions, rowBytes, rgbaLength2) };
+  }
+  if (kind !== void 0) return void 0;
   const rgbaLength = multiplySafe(dimensions.pixels, 4);
   const rgbLength = multiplySafe(dimensions.pixels, 3);
   if (rgbaLength === void 0 || rgbLength === void 0) {
     throw new PdfReaderError("IMAGE_LIMIT_EXCEEDED", "embedded image has unsafe decoded pixel dimensions.");
   }
-  if (data.length === rgbaLength) return data;
-  if (data.length !== dimensions.pixels && data.length !== rgbLength) return void 0;
-  const channels = data.length / dimensions.pixels;
+  if (source.length === rgbaLength) return { format: "rgba", rgba: source };
+  if (source.length === rgbLength)
+    return { format: "rgba", rgba: expandRgbToRgba(source, dimensions.pixels, rgbaLength) };
+  if (source.length === dimensions.pixels) {
+    return { format: "rgba", rgba: expandGray8ToRgba(source, dimensions.pixels, rgbaLength) };
+  }
+  return void 0;
+}
+function expandRgbToRgba(source, pixels, rgbaLength) {
+  const rgba = new Uint8ClampedArray(rgbaLength);
+  for (let pixel = 0; pixel < pixels; pixel += 1) {
+    const input = pixel * 3;
+    const output = pixel * 4;
+    rgba[output] = source[input] ?? 0;
+    rgba[output + 1] = source[input + 1] ?? 0;
+    rgba[output + 2] = source[input + 2] ?? 0;
+    rgba[output + 3] = 255;
+  }
+  return rgba;
+}
+function expandGray8ToRgba(source, pixels, rgbaLength) {
   const rgba = new Uint8ClampedArray(rgbaLength);
-  for (let pixel = 0; pixel < dimensions.pixels; pixel += 1) {
-    const input = pixel * channels;
+  for (let pixel = 0; pixel < pixels; pixel += 1) {
     const output = pixel * 4;
-    rgba[output] = data[input];
-    rgba[output + 1] = channels === 1 ? data[input] : data[input + 1];
-    rgba[output + 2] = channels === 1 ? data[input] : data[input + 2];
-    rgba[output + 3] = channels === 4 ? data[input + 3] : 255;
+    const gray = source[pixel] ?? 0;
+    rgba[output] = gray;
+    rgba[output + 1] = gray;
+    rgba[output + 2] = gray;
+    rgba[output + 3] = 255;
+  }
+  return rgba;
+}
+function unpackOneBitToRgba(packed, dimensions, rowBytes, rgbaLength) {
+  const rgba = new Uint8ClampedArray(rgbaLength);
+  for (let row = 0; row < dimensions.height; row += 1) {
+    for (let column = 0; column < dimensions.width; column += 1) {
+      const byte = packed[row * rowBytes + (column >> 3)] ?? 0;
+      const bit = byte >> 7 - (column & 7) & 1;
+      const value = bit === 1 ? 255 : 0;
+      const output = (row * dimensions.width + column) * 4;
+      rgba[output] = value;
+      rgba[output + 1] = value;
+      rgba[output + 2] = value;
+      rgba[output + 3] = 255;
+    }
   }
   return rgba;
 }
@@ -228,32 +355,39 @@ function readImageDimensions(image, limit) {
   const { width, height } = image;
   if (width === void 0 || height === void 0) return void 0;
   if (typeof width !== "number" || typeof height !== "number") return void 0;
-  const pixelWidth = Math.ceil(width);
-  const pixelHeight = Math.ceil(height);
-  const pixels = multiplySafe(pixelWidth, pixelHeight);
-  if (pixelWidth <= 0 || pixelHeight <= 0 || pixels === void 0 || pixels > limit) {
-    throw new PdfReaderError("IMAGE_LIMIT_EXCEEDED", `embedded image requires ${pixels} pixels; limit is ${limit}.`);
-  }
+  const { pixelWidth, pixelHeight, pixels } = resolveSafeCanvasDimensions(
+    width,
+    height,
+    limit,
+    "IMAGE_LIMIT_EXCEEDED",
+    "embedded image"
+  );
   return { width: pixelWidth, height: pixelHeight, pixels };
 }
-function isSupportedImageSource(image) {
-  return typeof ImageBitmap !== "undefined" && image.bitmap instanceof ImageBitmap || ArrayBuffer.isView(image.data);
-}
 function multiplySafe(left, right) {
   if (!Number.isSafeInteger(left) || !Number.isSafeInteger(right)) return void 0;
   const product = left * right;
   return Number.isSafeInteger(product) ? product : void 0;
 }
 function allocateCanvas(width, height, limit, createCanvas) {
-  const pixelWidth = Math.ceil(width);
-  const pixelHeight = Math.ceil(height);
-  const pixels = multiplySafe(pixelWidth, pixelHeight);
-  if (pixels === void 0 || pixels > limit) {
-    throw new PdfReaderError("IMAGE_LIMIT_EXCEEDED", `embedded image requires ${pixels} pixels; limit is ${limit}.`);
-  }
+  const { pixelWidth, pixelHeight } = resolveSafeCanvasDimensions(
+    width,
+    height,
+    limit,
+    "IMAGE_LIMIT_EXCEEDED",
+    "embedded image"
+  );
   const canvas = createCanvas();
-  canvas.width = pixelWidth;
-  canvas.height = pixelHeight;
+  try {
+    canvas.width = pixelWidth;
+    canvas.height = pixelHeight;
+  } catch (error) {
+    try {
+      releaseCanvas(canvas);
+    } catch {
+    }
+    throw error;
+  }
   return canvas;
 }
 function imageByteLength(image) {
@@ -299,8 +433,34 @@ function warn(logger, message, error) {
   logger?.warn(message, error);
 }
 
+// src/signal.ts
+function resolveSignal(value) {
+  if (value === void 0) return void 0;
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const candidate = value;
+    if (typeof candidate.aborted === "boolean" && typeof candidate.addEventListener === "function" && typeof candidate.removeEventListener === "function") {
+      return candidate;
+    }
+  }
+  throw new PdfReaderError(
+    "INVALID_OPTION",
+    "signal must have a boolean aborted and callable addEventListener/removeEventListener methods; omit it or use undefined for no signal."
+  );
+}
+
 // src/options.ts
 function resolveConvertOptions(options) {
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new PdfReaderError("INVALID_OPTION", "Convert options must be an object.");
+  }
+  const raw = options;
+  if (raw.pageRange !== void 0) validatePageRange(raw.pageRange);
+  if (raw.viewportScale !== void 0) validateViewportScaleShape(raw.viewportScale);
+  if (raw.imageFormat !== void 0) validateImageFormat(raw.imageFormat);
+  if (raw.pageImageOutput !== void 0) validatePageImageOutput(raw.pageImageOutput);
+  validateBooleanFlag(raw.includePageImage, "includePageImage");
+  validateBooleanFlag(raw.includeText, "includeText");
+  validateBooleanFlag(raw.includeEmbeddedImages, "includeEmbeddedImages");
   const resolved = {
     pageRange: options.pageRange,
     viewportScale: options.viewportScale ?? 1.5,
@@ -310,10 +470,12 @@ function resolveConvertOptions(options) {
     pageImageOutput: options.pageImageOutput ?? "data-url",
     includeText: options.includeText ?? true,
     includeEmbeddedImages: options.includeEmbeddedImages ?? false,
-    signal: options.signal
+    signal: resolveSignal(raw.signal)
   };
   if (typeof resolved.viewportScale === "number") {
     assertPositiveFinite(resolved.viewportScale, "viewportScale");
+  } else if (typeof resolved.viewportScale !== "function") {
+    throw new PdfReaderError("INVALID_OPTION", "viewportScale must be a positive finite number or a function.");
   }
   if (!Number.isFinite(resolved.jpegQuality) || resolved.jpegQuality < 0 || resolved.jpegQuality > 1) {
     throw new PdfReaderError("INVALID_OPTION", "jpegQuality must be a finite number from 0 through 1.");
@@ -321,13 +483,22 @@ function resolveConvertOptions(options) {
   if (resolved.pageImageOutput !== "data-url" && resolved.pageImageOutput !== "blob") {
     throw new PdfReaderError("INVALID_OPTION", 'pageImageOutput must be either "data-url" or "blob".');
   }
+  if (resolved.imageFormat !== "image/png" && resolved.imageFormat !== "image/jpeg") {
+    throw new PdfReaderError("INVALID_OPTION", 'imageFormat must be either "image/png" or "image/jpeg".');
+  }
   validatePageRange(resolved.pageRange);
   return resolved;
 }
 function resolvePageNumbers(pageRange, numPages) {
   if (pageRange === void 0) return [1, numPages];
   if (typeof pageRange === "number") return [pageRange, pageRange];
-  return [Math.min(...pageRange), Math.max(...pageRange)];
+  if (!Array.isArray(pageRange) || pageRange.length !== 2) {
+    throw new PdfReaderError("INVALID_OPTION", "pageRange tuple must have exactly two page numbers.");
+  }
+  return [
+    Math.min(pageRange[0], pageRange[1]),
+    Math.max(pageRange[0], pageRange[1])
+  ];
 }
 function assertPositiveFinite(value, option) {
   if (!Number.isFinite(value) || value <= 0) {
@@ -336,11 +507,130 @@ function assertPositiveFinite(value, option) {
 }
 function validatePageRange(pageRange) {
   if (pageRange === void 0) return;
-  const values = typeof pageRange === "number" ? [pageRange] : pageRange;
-  if (values.some((value) => !Number.isSafeInteger(value) || value < 1)) {
+  if (typeof pageRange === "number") {
+    if (!Number.isSafeInteger(pageRange) || pageRange < 1) {
+      throw new PdfReaderError("INVALID_OPTION", "pageRange values must be positive safe integers.");
+    }
+    return;
+  }
+  if (!Array.isArray(pageRange)) {
+    throw new PdfReaderError("INVALID_OPTION", "pageRange must be a page number or a two-element tuple.");
+  }
+  if (pageRange.length !== 2) {
+    throw new PdfReaderError("INVALID_OPTION", "pageRange tuple must have exactly two page numbers.");
+  }
+  if (!(0 in pageRange) || !(1 in pageRange)) {
+    throw new PdfReaderError("INVALID_OPTION", "pageRange tuple must not be sparse.");
+  }
+  if (pageRange.some((value) => !Number.isSafeInteger(value) || value < 1)) {
     throw new PdfReaderError("INVALID_OPTION", "pageRange values must be positive safe integers.");
   }
 }
+function validateViewportScaleShape(value) {
+  if (typeof value === "number" || typeof value === "function") return;
+  throw new PdfReaderError("INVALID_OPTION", "viewportScale must be a positive finite number or a function.");
+}
+function validateImageFormat(value) {
+  if (value === "image/png" || value === "image/jpeg") return;
+  throw new PdfReaderError("INVALID_OPTION", 'imageFormat must be either "image/png" or "image/jpeg".');
+}
+function validatePageImageOutput(value) {
+  if (value === "data-url" || value === "blob") return;
+  throw new PdfReaderError("INVALID_OPTION", 'pageImageOutput must be either "data-url" or "blob".');
+}
+function validateBooleanFlag(value, option) {
+  if (value === void 0) return;
+  if (typeof value !== "boolean") {
+    throw new PdfReaderError("INVALID_OPTION", `${option} must be a boolean.`);
+  }
+}
+
+// src/pageResources.ts
+var _owners, _closed, _pages, _cleanedAfterClose, _PageLifetime_instances, cleanup_fn;
+var PageLifetime = class {
+  constructor(onIdle) {
+    this.onIdle = onIdle;
+    __privateAdd(this, _PageLifetime_instances);
+    __privateAdd(this, _owners, 0);
+    __privateAdd(this, _closed, false);
+    __privateAdd(this, _pages, /* @__PURE__ */ new Set());
+    __privateAdd(this, _cleanedAfterClose, /* @__PURE__ */ new WeakSet());
+  }
+  retain() {
+    __privateSet(this, _owners, __privateGet(this, _owners) + 1);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      __privateSet(this, _owners, __privateGet(this, _owners) - 1);
+      if (__privateGet(this, _owners) === 0 && !__privateGet(this, _closed)) {
+        this.onIdle();
+        this.close();
+      }
+    };
+  }
+  /** Observe the original promise, not the caller's cancellation race. */
+  track(pending, accept) {
+    const release = this.retain();
+    pending.then((value) => {
+      try {
+        accept?.(value);
+      } finally {
+        release();
+      }
+    }, release).catch(() => void 0);
+    return pending;
+  }
+  acquire(start) {
+    return this.track(start(), (page) => {
+      if (__privateGet(this, _closed)) __privateMethod(this, _PageLifetime_instances, cleanup_fn).call(this, page);
+      else __privateGet(this, _pages).add(page);
+    });
+  }
+  close() {
+    __privateSet(this, _closed, true);
+    for (const page of __privateGet(this, _pages)) __privateMethod(this, _PageLifetime_instances, cleanup_fn).call(this, page);
+    __privateGet(this, _pages).clear();
+  }
+};
+_owners = new WeakMap();
+_closed = new WeakMap();
+_pages = new WeakMap();
+_cleanedAfterClose = new WeakMap();
+_PageLifetime_instances = new WeakSet();
+cleanup_fn = function(page) {
+  if (__privateGet(this, _cleanedAfterClose).has(page)) return;
+  __privateGet(this, _cleanedAfterClose).add(page);
+  try {
+    page.cleanup();
+  } catch {
+  }
+};
+var _pages2;
+var PageResources = class {
+  constructor() {
+    __privateAdd(this, _pages2, /* @__PURE__ */ new Map());
+  }
+  acquire(pageNumber) {
+    let lifetime = __privateGet(this, _pages2).get(pageNumber);
+    if (!lifetime) {
+      lifetime = new PageLifetime(() => __privateGet(this, _pages2).delete(pageNumber));
+      __privateGet(this, _pages2).set(pageNumber, lifetime);
+    }
+    const release = lifetime.retain();
+    return {
+      acquire: (start) => lifetime.acquire(start),
+      track: (pending) => lifetime.track(pending),
+      release
+    };
+  }
+  /** Document destruction is authoritative; do not await orphaned promises. */
+  destroy() {
+    for (const lifetime of __privateGet(this, _pages2).values()) lifetime.close();
+    __privateGet(this, _pages2).clear();
+  }
+};
+_pages2 = new WeakMap();
 
 // src/PDFReader.ts
 var defaultLimits = {
@@ -353,7 +643,31 @@ var defaultLimits = {
   maxEmbeddedImages: 1e3,
   maxEmbeddedImagePixelsTotal: 1e8
 };
-var _source, _createCanvas, _logger, _limits, _sourcePolicy, _loadingState, _loadingTask, _document, _destroyPromise, _destroyController, _activeRenderTasks, _activePageOperation, _activePageWorkCount, _destroyed, _lastLoadFailed, _PDFReader_instances, load_fn, processPage_fn, enforceTextLimits_fn, encodePageImage_fn, resolveViewport_fn, encodeCanvasToBlob_fn, allocateCanvas_fn, waitForRender_fn, releaseCanvas_fn, acquirePageOperation_fn, releasePageOperation_fn, getOrCreateLoadState_fn, destroyLoadStateTask_fn, awaitWithSignal_fn, awaitWithDestroy_fn, createAbortedError_fn, createDestroyedError_fn, createDeadlineExceededError_fn, createUnsupportedEnvironmentError_fn, rethrowLifecycleError_fn, throwIfDestroyed_fn, throwIfAborted_fn, resolveLoadOptions_fn, isAbortSignal_fn, enforceSourcePolicy_fn, createSourceSnapshot_fn, inspectSource_fn, sourceKind_fn, toPdfJsSource_fn, freezeSource_fn, isPdfTypedArray_fn, knownByteLength_fn, readUrl_fn, readHttpHeaders_fn, validateLimits_fn;
+function resolveLimits(limits) {
+  const resolved = { ...defaultLimits };
+  if (limits === void 0 || limits === null) return resolved;
+  for (const name of Object.keys(defaultLimits)) {
+    const supplied = limits[name];
+    if (supplied === void 0) continue;
+    if (!Number.isSafeInteger(supplied) || supplied <= 0) {
+      throw new PdfReaderError("INVALID_OPTION", `${name} must be a positive safe integer.`);
+    }
+    resolved[name] = supplied;
+  }
+  const maxSourceBytes = limits.maxSourceBytes;
+  if (maxSourceBytes === void 0) return resolved;
+  if (!Number.isSafeInteger(maxSourceBytes) || maxSourceBytes <= 0) {
+    throw new PdfReaderError("INVALID_OPTION", "maxSourceBytes must be a positive safe integer.");
+  }
+  resolved.maxSourceBytes = maxSourceBytes;
+  return resolved;
+}
+var InterruptedRender = class {
+  constructor(reason) {
+    this.reason = reason;
+  }
+};
+var _source, _createCanvas, _logger, _limits, _sourcePolicy, _loadingState, _loadingTask, _document, _destroyPromise, _destroyController, _activeRenderTasks, _pageResources, _activePageOperation, _activePageWorkCount, _destroyed, _lastLoadFailed, _PDFReader_instances, load_fn, processPage_fn, enforceTextLimits_fn, encodePageImage_fn, resolveViewport_fn, encodeCanvasToBlob_fn, createCanvasWithSignal_fn, allocateCanvas_fn, waitForRender_fn, releaseCanvas_fn, acquirePageOperation_fn, releasePageOperation_fn, getOrCreateLoadState_fn, destroyLoadStateTask_fn, awaitWithSignal_fn, awaitWithDestroy_fn, createAbortedError_fn, createDestroyedError_fn, createDeadlineExceededError_fn, createUnsupportedEnvironmentError_fn, rethrowLifecycleError_fn, throwIfDestroyed_fn, throwIfAborted_fn, resolveLoadOptions_fn, enforceSourcePolicy_fn, throwIfOverSourceLimit_fn, createSourceSnapshot_fn, inspectSource_fn, sourceKind_fn, toPdfJsSource_fn, freezeSource_fn, isFetchHeaders_fn, isPdfTypedArray_fn, knownByteLength_fn, readUrl_fn, readRawHttpHeaders_fn, snapshotHttpHeaders_fn;
 var PDFReader = class {
   constructor(source, options = {}) {
     __privateAdd(this, _PDFReader_instances);
@@ -368,6 +682,7 @@ var PDFReader = class {
     __privateAdd(this, _destroyPromise);
     __privateAdd(this, _destroyController, new AbortController());
     __privateAdd(this, _activeRenderTasks, /* @__PURE__ */ new Set());
+    __privateAdd(this, _pageResources, new PageResources());
     __privateAdd(this, _activePageOperation, false);
     __privateAdd(this, _activePageWorkCount, 0);
     __privateAdd(this, _destroyed, false);
@@ -375,9 +690,8 @@ var PDFReader = class {
     __privateSet(this, _source, source);
     __privateSet(this, _createCanvas, options.canvasFactory ?? (() => document.createElement("canvas")));
     __privateSet(this, _logger, options.logger);
-    __privateSet(this, _limits, { ...defaultLimits, ...options.limits });
+    __privateSet(this, _limits, resolveLimits(options.limits));
     __privateSet(this, _sourcePolicy, options.sourcePolicy);
-    __privateMethod(this, _PDFReader_instances, validateLimits_fn).call(this);
   }
   get numPages() {
     return __privateGet(this, _document)?.numPages;
@@ -392,13 +706,37 @@ var PDFReader = class {
     return "new";
   }
   load(options) {
+    __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
     const resolved = __privateMethod(this, _PDFReader_instances, resolveLoadOptions_fn).call(this, options);
     __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, resolved.signal);
-    __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
     if (__privateGet(this, _document)) return Promise.resolve(__privateGet(this, _document));
     return __privateMethod(this, _PDFReader_instances, load_fn).call(this, resolved);
   }
-  /** Streams page results so callers do not need to retain the entire document conversion in memory. */
+  /**
+   * Streams page results so callers do not need to retain the entire document conversion in memory.
+   *
+   * Page-stage waits (`getPage`, text, operator list, render, encoding) settle
+   * promptly with `ABORTED`/`DESTROYED` via the shared cancellation/wait
+   * contract. Active renders are cancelled; racing other PDF.js work does not
+   * stop it. Already-started promises remain observed even if a synchronous
+   * callback aborts/destroys before wait registration. Late `getPage()` values
+   * are never processed; late text/operator values are dropped. Page cleanup
+   * is deferred until package-owned acquisitions, processing, and upstream
+   * stage promises for that cached page are idle, including safe retries.
+   * Canvas factories and viewport callbacks are followed by lifecycle checks
+   * before subsequent allocation/rendering. Caller settlement releases the
+   * operation lock, but does not imply upstream work has finished.
+   * Cancellation/failure of an already-created render permanently closes the
+   * reader and starts public PDF.js teardown. The initiating call retains
+   * `ABORTED` or the native error; later operations reject `DESTROYED`. Retry
+   * with a fresh reader and fresh bytes (PDF.js may have transferred the input).
+   * Pre-render and non-render failures, and encoding cancellation/failure after
+   * successful rendering, do not automatically close the reader.
+   * A suspended generator only observes abort/destroy on the next
+   * `next()`/`return()`; destruction cannot force suspended consumer code to run.
+   * Malformed signals (including `null`) reject with `INVALID_OPTION` before
+   * page acquisition. Omitted/`undefined` signals are accepted.
+   */
   async *pages(options = {}) {
     let ownsPageOperation = false;
     try {
@@ -416,23 +754,27 @@ var PDFReader = class {
       for (let pageNumber = start; pageNumber <= Math.min(end, documentProxy.numPages); pageNumber += 1) {
         __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
         __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, resolved.signal);
-        let page;
+        const lease = __privateGet(this, _pageResources).acquire(pageNumber);
         let ownsActivePageWork = false;
         try {
           __privateSet(this, _activePageWorkCount, __privateGet(this, _activePageWorkCount) + 1);
           ownsActivePageWork = true;
-          page = await documentProxy.getPage(pageNumber);
-          const result = await __privateMethod(this, _PDFReader_instances, processPage_fn).call(this, page, pageNumber, documentProxy.numPages, resolved);
-          page.cleanup();
-          page = void 0;
+          const page = await __privateMethod(this, _PDFReader_instances, awaitWithSignal_fn).call(this, lease.acquire(() => documentProxy.getPage(pageNumber)), resolved.signal);
+          const result = await __privateMethod(this, _PDFReader_instances, processPage_fn).call(this, page, pageNumber, documentProxy.numPages, resolved, lease);
+          lease.release();
           __privateSet(this, _activePageWorkCount, __privateGet(this, _activePageWorkCount) - 1);
           ownsActivePageWork = false;
           yield result;
         } catch (error) {
+          if (error instanceof InterruptedRender) {
+            const reason = __privateGet(this, _destroyed) ? __privateMethod(this, _PDFReader_instances, createDestroyedError_fn).call(this) : resolved.signal?.aborted ? __privateMethod(this, _PDFReader_instances, createAbortedError_fn).call(this) : error.reason;
+            void this.destroy().catch(() => void 0);
+            throw reason;
+          }
           __privateMethod(this, _PDFReader_instances, rethrowLifecycleError_fn).call(this, error, resolved.signal);
         } finally {
           if (ownsActivePageWork) __privateSet(this, _activePageWorkCount, __privateGet(this, _activePageWorkCount) - 1);
-          page?.cleanup();
+          lease.release();
         }
       }
     } finally {
@@ -445,17 +787,45 @@ var PDFReader = class {
     for await (const page of this.pages(options)) results.push(page);
     return results;
   }
-  /** Terminates the loading task and document resources. The reader cannot be reused afterwards. */
-  async destroy() {
+  /**
+   * Terminates the loading task and document resources. The reader cannot be reused afterwards.
+   *
+   * A caller-created PDF.js `PDFWorker` passed on the source stays
+   * caller-owned: neither `destroy()` nor PDF.js task teardown destroys it.
+   * Destroy it explicitly in your own `finally` block, even if this method
+   * rejects.
+   *
+   * In-flight page-stage waiters settle promptly with `DESTROYED`, but their
+   * uncancellable getPage/text/operator work stays observed in the background.
+   * Active renders are cancelled. This method waits for PDF.js loading/document
+   * destruction, not for orphaned `getPage`/text/operator/image-object
+   * continuations, which never start later processing. It clears retained
+   * page ownership; late acquisitions receive best-effort cleanup. Await
+   * active operations to observe their temporary canvas release. It cannot
+   * force a suspended `pages()` consumer to resume; that consumer observes
+   * destruction on next resume.
+   * Render cancellation/failure also starts this teardown automatically without
+   * awaiting it or replacing the initiating error. This method always returns
+   * the same teardown promise, including its rejection; call it to observe that
+   * outcome. Automatic teardown rejection is observed even if you never do.
+   */
+  destroy() {
     if (__privateGet(this, _destroyPromise)) return __privateGet(this, _destroyPromise);
+    let resolveDestroy;
+    let rejectDestroy;
+    __privateSet(this, _destroyPromise, new Promise((resolve, reject) => {
+      resolveDestroy = resolve;
+      rejectDestroy = reject;
+    }));
     __privateSet(this, _destroyed, true);
-    __privateGet(this, _destroyController).abort();
     const loadingTask = __privateGet(this, _loadingTask);
     const loadingState = __privateGet(this, _loadingState);
     __privateSet(this, _loadingTask, void 0);
     __privateSet(this, _document, void 0);
     __privateSet(this, _loadingState, void 0);
-    __privateSet(this, _destroyPromise, (async () => {
+    void (async () => {
+      __privateGet(this, _destroyController).abort();
+      __privateGet(this, _pageResources).destroy();
       for (const renderTask of __privateGet(this, _activeRenderTasks)) renderTask.cancel();
       if (loadingTask) {
         await loadingTask.destroy();
@@ -464,8 +834,8 @@ var PDFReader = class {
       if (!loadingState) return;
       loadingState.destroyed = true;
       await __privateMethod(this, _PDFReader_instances, destroyLoadStateTask_fn).call(this, loadingState);
-    })());
-    await __privateGet(this, _destroyPromise);
+    })().then(resolveDestroy, rejectDestroy);
+    return __privateGet(this, _destroyPromise);
   }
 };
 _source = new WeakMap();
@@ -479,6 +849,7 @@ _document = new WeakMap();
 _destroyPromise = new WeakMap();
 _destroyController = new WeakMap();
 _activeRenderTasks = new WeakMap();
+_pageResources = new WeakMap();
 _activePageOperation = new WeakMap();
 _activePageWorkCount = new WeakMap();
 _destroyed = new WeakMap();
@@ -497,8 +868,10 @@ load_fn = async function(options) {
     throw error;
   }
 };
-processPage_fn = async function(page, pageNumber, numPages, options) {
-  const viewport = __privateMethod(this, _PDFReader_instances, resolveViewport_fn).call(this, page, options.viewportScale);
+processPage_fn = async function(page, pageNumber, numPages, options, lease) {
+  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, options.signal);
+  const viewport = __privateMethod(this, _PDFReader_instances, resolveViewport_fn).call(this, page, options.viewportScale, options.signal);
   const result = {
     numPages,
     pageNumber,
@@ -510,7 +883,7 @@ processPage_fn = async function(page, pageNumber, numPages, options) {
   __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
   if (options.includeText) {
     try {
-      const text = await page.getTextContent();
+      const text = await __privateMethod(this, _PDFReader_instances, awaitWithSignal_fn).call(this, lease.track(page.getTextContent()), options.signal);
       __privateMethod(this, _PDFReader_instances, enforceTextLimits_fn).call(this, text);
       result.text = text;
     } catch (error) {
@@ -523,14 +896,17 @@ processPage_fn = async function(page, pageNumber, numPages, options) {
     try {
       result.images = await extractEmbeddedImages(page, viewport, {
         signal: options.signal,
-        createCanvas: __privateGet(this, _createCanvas),
+        createCanvas: () => __privateMethod(this, _PDFReader_instances, createCanvasWithSignal_fn).call(this, options.signal),
         maxPixels: __privateGet(this, _limits).maxEmbeddedImagePixels,
         maxImages: __privateGet(this, _limits).maxEmbeddedImages,
         maxTotalPixels: __privateGet(this, _limits).maxEmbeddedImagePixelsTotal,
         maxOperators: __privateGet(this, _limits).maxOperatorCount,
         logger: __privateGet(this, _logger),
         throwIfAborted: (signal) => __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal),
-        throwIfDestroyed: () => __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this)
+        throwIfDestroyed: () => __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this),
+        // Reuses the reader's single cancellation/wait contract so operator
+        // retrieval settles promptly without cancelling upstream PDF.js work.
+        awaitWithCancellation: (pending) => __privateMethod(this, _PDFReader_instances, awaitWithSignal_fn).call(this, lease.track(pending), options.signal)
       });
     } catch (error) {
       __privateMethod(this, _PDFReader_instances, rethrowLifecycleError_fn).call(this, error, options.signal);
@@ -539,14 +915,18 @@ processPage_fn = async function(page, pageNumber, numPages, options) {
   __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, options.signal);
   __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
   if (options.includePageImage) {
-    const canvas = __privateMethod(this, _PDFReader_instances, allocateCanvas_fn).call(this, viewport.width, viewport.height, __privateGet(this, _limits).maxCanvasPixels, "page");
+    const canvas = __privateMethod(this, _PDFReader_instances, allocateCanvas_fn).call(this, viewport.width, viewport.height, __privateGet(this, _limits).maxCanvasPixels, "page", options.signal);
     try {
+      __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+      __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, options.signal);
       const context = canvas.getContext("2d");
+      __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+      __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, options.signal);
       if (!context) {
         throw __privateMethod(this, _PDFReader_instances, createUnsupportedEnvironmentError_fn).call(this, `Failed to create a 2D canvas context for page ${pageNumber}.`);
       }
       const renderTask = page.render({ canvas, canvasContext: context, viewport });
-      await __privateMethod(this, _PDFReader_instances, waitForRender_fn).call(this, renderTask, options.signal);
+      await __privateMethod(this, _PDFReader_instances, waitForRender_fn).call(this, renderTask, lease, options.signal);
       result.pageImage = await __privateMethod(this, _PDFReader_instances, encodePageImage_fn).call(this, canvas, options.imageFormat, options.pageImageOutput, options.jpegQuality, options.signal);
     } finally {
       __privateMethod(this, _PDFReader_instances, releaseCanvas_fn).call(this, canvas);
@@ -586,17 +966,27 @@ encodePageImage_fn = async function(canvas, mimeType, output, jpegQuality, signa
     const dataUrl = quality === void 0 ? canvas.toDataURL(mimeType) : canvas.toDataURL(mimeType, quality);
     __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
     __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
+    if (!isValidDataUrlForMime(dataUrl, mimeType)) {
+      throw __privateMethod(this, _PDFReader_instances, createUnsupportedEnvironmentError_fn).call(this, `Canvas encoding produced an empty or mismatched result for ${mimeType}.`);
+    }
     return { kind: "data-url", mimeType, dataUrl };
   }
   const blob = await __privateMethod(this, _PDFReader_instances, encodeCanvasToBlob_fn).call(this, canvas, mimeType, quality, signal);
   __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
   __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
+  if (!isValidBlobForMime(blob, mimeType)) {
+    throw __privateMethod(this, _PDFReader_instances, createUnsupportedEnvironmentError_fn).call(this, `Canvas Blob encoding produced an empty or mismatched result for ${mimeType}.`);
+  }
   return { kind: "blob", mimeType, blob };
 };
-resolveViewport_fn = function(page, viewportScale) {
+resolveViewport_fn = function(page, viewportScale, signal) {
   if (typeof viewportScale === "number") return page.getViewport({ scale: viewportScale });
   const base = page.getViewport({ scale: 1 });
+  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
   const scale = viewportScale(base.width, base.height);
+  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
   assertPositiveFinite(scale, "viewportScale callback result");
   return page.getViewport({ scale });
 };
@@ -642,29 +1032,58 @@ encodeCanvasToBlob_fn = async function(canvas, mimeType, quality, signal) {
     }
   });
 };
-allocateCanvas_fn = function(width, height, limit, subject) {
-  const pixelWidth = Math.ceil(width);
-  const pixelHeight = Math.ceil(height);
-  const pixels = pixelWidth * pixelHeight;
-  if (!Number.isSafeInteger(pixels) || pixels > limit) {
-    const code = subject === "page" ? "CANVAS_LIMIT_EXCEEDED" : "IMAGE_LIMIT_EXCEEDED";
-    throw new PdfReaderError(code, `${subject} requires ${pixels} pixels; limit is ${limit}.`);
-  }
+createCanvasWithSignal_fn = function(signal) {
+  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
   const canvas = __privateGet(this, _createCanvas).call(this);
-  canvas.width = pixelWidth;
-  canvas.height = pixelHeight;
+  try {
+    __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+    __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
+  } catch (error) {
+    try {
+      __privateMethod(this, _PDFReader_instances, releaseCanvas_fn).call(this, canvas);
+    } catch {
+    }
+    throw error;
+  }
   return canvas;
 };
-waitForRender_fn = async function(renderTask, signal) {
+allocateCanvas_fn = function(width, height, limit, subject, signal) {
+  const { pixelWidth, pixelHeight } = resolveSafeCanvasDimensions(
+    width,
+    height,
+    limit,
+    "CANVAS_LIMIT_EXCEEDED",
+    subject
+  );
+  const canvas = __privateMethod(this, _PDFReader_instances, createCanvasWithSignal_fn).call(this, signal);
+  try {
+    canvas.width = pixelWidth;
+    canvas.height = pixelHeight;
+  } catch (error) {
+    try {
+      __privateMethod(this, _PDFReader_instances, releaseCanvas_fn).call(this, canvas);
+    } catch {
+    }
+    throw error;
+  }
+  return canvas;
+};
+waitForRender_fn = async function(renderTask, lease, signal) {
   const abort = () => renderTask.cancel();
   __privateGet(this, _activeRenderTasks).add(renderTask);
   signal?.addEventListener("abort", abort, { once: true });
   try {
-    await __privateMethod(this, _PDFReader_instances, awaitWithSignal_fn).call(this, renderTask.promise, signal);
+    const waiting = __privateMethod(this, _PDFReader_instances, awaitWithSignal_fn).call(this, lease.track(renderTask.promise), signal);
+    try {
+      if (signal?.aborted || __privateGet(this, _destroyed)) abort();
+    } finally {
+      await waiting;
+    }
     __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
     __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
   } catch (error) {
-    __privateMethod(this, _PDFReader_instances, rethrowLifecycleError_fn).call(this, error, signal);
+    throw new InterruptedRender(error);
   } finally {
     signal?.removeEventListener("abort", abort);
     __privateGet(this, _activeRenderTasks).delete(renderTask);
@@ -692,11 +1111,20 @@ getOrCreateLoadState_fn = function() {
   if (existing) return existing;
   __privateSet(this, _lastLoadFailed, false);
   const state = { destroyed: false };
-  state.promise = (async () => {
+  let resolveLoad;
+  let rejectLoad;
+  state.promise = new Promise((resolve, reject) => {
+    resolveLoad = resolve;
+    rejectLoad = reject;
+  });
+  state.promise.catch(() => void 0);
+  __privateSet(this, _loadingState, state);
+  const taskPromise = (async () => {
     try {
       const source = __privateMethod(this, _PDFReader_instances, createSourceSnapshot_fn).call(this);
       const policyResult = __privateMethod(this, _PDFReader_instances, enforceSourcePolicy_fn).call(this, source.info);
       if (policyResult) await __privateMethod(this, _PDFReader_instances, awaitWithDestroy_fn).call(this, policyResult);
+      __privateMethod(this, _PDFReader_instances, throwIfOverSourceLimit_fn).call(this, source.pdfJsSource.data);
       if (state.destroyed || __privateGet(this, _destroyed)) {
         throw __privateMethod(this, _PDFReader_instances, createDestroyedError_fn).call(this);
       }
@@ -742,8 +1170,7 @@ getOrCreateLoadState_fn = function() {
       if (__privateGet(this, _loadingState) === state) __privateSet(this, _loadingState, void 0);
     }
   })();
-  state.promise.catch(() => void 0);
-  __privateSet(this, _loadingState, state);
+  taskPromise.then(resolveLoad, rejectLoad);
   return state;
 };
 destroyLoadStateTask_fn = function(state) {
@@ -754,10 +1181,9 @@ destroyLoadStateTask_fn = function(state) {
   return state.destroyPromise;
 };
 awaitWithSignal_fn = async function(promise, signal, deadlineMs) {
-  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
-  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
   return await new Promise((resolve, reject) => {
     let settled = false;
+    let timer;
     const onAbort = () => settle(() => reject(__privateMethod(this, _PDFReader_instances, createAbortedError_fn).call(this)));
     const onDestroy = () => settle(() => reject(__privateMethod(this, _PDFReader_instances, createDestroyedError_fn).call(this)));
     const cleanup = () => {
@@ -771,33 +1197,27 @@ awaitWithSignal_fn = async function(promise, signal, deadlineMs) {
       cleanup();
       callback();
     };
-    const timer = deadlineMs === void 0 ? void 0 : setTimeout(() => settle(() => reject(__privateMethod(this, _PDFReader_instances, createDeadlineExceededError_fn).call(this))), deadlineMs);
-    signal?.addEventListener("abort", onAbort, { once: true });
-    __privateGet(this, _destroyController).signal.addEventListener("abort", onDestroy, { once: true });
     promise.then(
-      (value) => settle(() => resolve(value)),
-      (error) => settle(() => reject(error))
+      (value) => {
+        if (settled) return;
+        settle(() => resolve(value));
+      },
+      (error) => {
+        if (settled) return;
+        settle(() => reject(error));
+      }
     ).catch(() => void 0);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    __privateGet(this, _destroyController).signal.addEventListener("abort", onDestroy, { once: true });
+    if (signal?.aborted) onAbort();
+    else if (__privateGet(this, _destroyed)) onDestroy();
+    if (!settled && deadlineMs !== void 0) {
+      timer = setTimeout(() => settle(() => reject(__privateMethod(this, _PDFReader_instances, createDeadlineExceededError_fn).call(this))), deadlineMs);
+    }
   });
 };
 awaitWithDestroy_fn = async function(promise) {
-  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
-  return await new Promise((resolve, reject) => {
-    let settled = false;
-    const onDestroy = () => settle(() => reject(__privateMethod(this, _PDFReader_instances, createDestroyedError_fn).call(this)));
-    const cleanup = () => __privateGet(this, _destroyController).signal.removeEventListener("abort", onDestroy);
-    const settle = (callback) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      callback();
-    };
-    __privateGet(this, _destroyController).signal.addEventListener("abort", onDestroy, { once: true });
-    Promise.resolve(promise).then(
-      (value) => settle(() => resolve(value)),
-      (error) => settle(() => reject(error))
-    );
-  });
+  return __privateMethod(this, _PDFReader_instances, awaitWithSignal_fn).call(this, Promise.resolve(promise));
 };
 createAbortedError_fn = function() {
   return new PdfReaderError("ABORTED", "PDF operation was aborted.");
@@ -823,23 +1243,28 @@ throwIfAborted_fn = function(signal) {
   if (signal?.aborted) throw __privateMethod(this, _PDFReader_instances, createAbortedError_fn).call(this);
 };
 resolveLoadOptions_fn = function(options) {
-  if (!options) return {};
-  if (__privateMethod(this, _PDFReader_instances, isAbortSignal_fn).call(this, options)) return { signal: options };
-  if (options.deadlineMs !== void 0 && (!Number.isFinite(options.deadlineMs) || options.deadlineMs <= 0)) {
-    throw new PdfReaderError("INVALID_OPTION", "deadlineMs must be a positive finite number.");
+  if (options === void 0) return {};
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new PdfReaderError("INVALID_OPTION", "Load options must be an object or an AbortSignal.");
   }
-  return options;
-};
-isAbortSignal_fn = function(value) {
-  return "aborted" in value && "addEventListener" in value && "removeEventListener" in value;
+  if ("aborted" in options || "addEventListener" in options || "removeEventListener" in options) {
+    return { signal: resolveSignal(options) };
+  }
+  const candidate = options;
+  const signal = resolveSignal(candidate.signal);
+  const deadlineMs = candidate.deadlineMs;
+  if (deadlineMs !== void 0) {
+    if (!Number.isFinite(deadlineMs) || deadlineMs <= 0 || deadlineMs > MAX_TIMER_MS) {
+      throw new PdfReaderError(
+        "INVALID_OPTION",
+        `deadlineMs must be a positive finite number not exceeding ${MAX_TIMER_MS}.`
+      );
+    }
+  }
+  return { signal, deadlineMs };
 };
 enforceSourcePolicy_fn = function(source) {
-  if (source.byteLength !== void 0 && __privateGet(this, _limits).maxSourceBytes !== void 0 && source.byteLength > __privateGet(this, _limits).maxSourceBytes) {
-    throw new PdfReaderError(
-      "SOURCE_LIMIT_EXCEEDED",
-      `PDF source is ${source.byteLength} bytes; limit is ${__privateGet(this, _limits).maxSourceBytes}.`
-    );
-  }
+  __privateMethod(this, _PDFReader_instances, throwIfOverSourceLimit_fn).call(this, source.rawSource.data);
   if (!__privateGet(this, _sourcePolicy)) return;
   try {
     const result = __privateGet(this, _sourcePolicy).call(this, source);
@@ -853,14 +1278,30 @@ enforceSourcePolicy_fn = function(source) {
     throw new PdfReaderError("SOURCE_POLICY_VIOLATION", "PDF source rejected by sourcePolicy.");
   }
 };
+/**
+ * Rejects a synchronously measurable over-limit byte source.
+ *
+ * Length is read without scanning or copying element content, so an
+ * oversized array fails on its `length` before any entry is visited.
+ */
+throwIfOverSourceLimit_fn = function(data) {
+  if (__privateGet(this, _limits).maxSourceBytes === void 0) return;
+  const byteLength = __privateMethod(this, _PDFReader_instances, knownByteLength_fn).call(this, data);
+  if (byteLength !== void 0 && byteLength > __privateGet(this, _limits).maxSourceBytes) {
+    throw new PdfReaderError(
+      "SOURCE_LIMIT_EXCEEDED",
+      `PDF source is ${byteLength} bytes; limit is ${__privateGet(this, _limits).maxSourceBytes}.`
+    );
+  }
+};
 createSourceSnapshot_fn = function() {
   const kind = __privateMethod(this, _PDFReader_instances, sourceKind_fn).call(this, __privateGet(this, _source));
-  const pdfJsSource = __privateMethod(this, _PDFReader_instances, toPdfJsSource_fn).call(this, __privateGet(this, _source));
-  const info = __privateMethod(this, _PDFReader_instances, inspectSource_fn).call(this, pdfJsSource, kind);
+  const headers = __privateMethod(this, _PDFReader_instances, snapshotHttpHeaders_fn).call(this, __privateMethod(this, _PDFReader_instances, readRawHttpHeaders_fn).call(this, __privateGet(this, _source)));
+  const pdfJsSource = __privateMethod(this, _PDFReader_instances, toPdfJsSource_fn).call(this, __privateGet(this, _source), headers);
+  const info = __privateMethod(this, _PDFReader_instances, inspectSource_fn).call(this, pdfJsSource, kind, headers);
   return { pdfJsSource, info };
 };
-inspectSource_fn = function(source, kind) {
-  const headers = __privateMethod(this, _PDFReader_instances, readHttpHeaders_fn).call(this, source.httpHeaders);
+inspectSource_fn = function(source, kind, headers) {
   const info = {
     rawSource: source,
     kind,
@@ -878,7 +1319,7 @@ sourceKind_fn = function(source) {
   if (source instanceof ArrayBuffer || __privateMethod(this, _PDFReader_instances, isPdfTypedArray_fn).call(this, source) || Array.isArray(source)) return "bytes";
   return "document-init-parameters";
 };
-toPdfJsSource_fn = function(source) {
+toPdfJsSource_fn = function(source, headers) {
   if (typeof source === "string") {
     return __privateMethod(this, _PDFReader_instances, freezeSource_fn).call(this, { url: source });
   }
@@ -890,23 +1331,47 @@ toPdfJsSource_fn = function(source) {
   }
   const snapshot = {};
   for (const key of Reflect.ownKeys(source)) {
+    if (key === "httpHeaders") continue;
     const descriptor = Object.getOwnPropertyDescriptor(source, key);
     if (!descriptor?.enumerable) continue;
-    snapshot[key] = source[key];
+    const value = source[key];
+    Object.defineProperty(snapshot, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
   }
   if (typeof URL !== "undefined" && snapshot.url instanceof URL) snapshot.url = snapshot.url.toString();
+  if (headers.httpHeaders !== void 0) {
+    Object.defineProperty(snapshot, "httpHeaders", {
+      value: headers.httpHeaders,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+  }
   return __privateMethod(this, _PDFReader_instances, freezeSource_fn).call(this, snapshot);
 };
 freezeSource_fn = function(source) {
   return Object.freeze(source);
 };
+isFetchHeaders_fn = function(value) {
+  if (typeof Headers !== "undefined" && value instanceof Headers) return true;
+  try {
+    if (Object.prototype.toString.call(value) === "[object Headers]") return true;
+  } catch {
+  }
+  return false;
+};
 isPdfTypedArray_fn = function(source) {
   return ArrayBuffer.isView(source) && !(source instanceof DataView);
 };
 knownByteLength_fn = function(value) {
+  if (typeof value === "string") return value.length;
   if (value instanceof ArrayBuffer) return value.byteLength;
   if (ArrayBuffer.isView(value)) return value.byteLength;
-  if (Array.isArray(value) && value.every((entry) => Number.isFinite(entry))) return value.length;
+  if (Array.isArray(value)) return value.length;
   return void 0;
 };
 readUrl_fn = function(value) {
@@ -914,34 +1379,57 @@ readUrl_fn = function(value) {
   if (typeof URL !== "undefined" && value instanceof URL) return value.toString();
   return void 0;
 };
-readHttpHeaders_fn = function(value) {
-  if (!value || typeof value !== "object") return { hasHttpHeaders: false };
-  const entries = [];
-  try {
-    for (const [name, headerValue] of Object.entries(value)) {
-      if (typeof headerValue === "string") entries.push([name, headerValue]);
-    }
-    if ("forEach" in value && typeof value.forEach === "function") {
-      value.forEach((headerValue, name) => {
-        if (typeof name === "string" && typeof headerValue === "string") entries.push([name, headerValue]);
-      });
-    }
-  } catch {
+readRawHttpHeaders_fn = function(source) {
+  if (typeof source !== "object" || source === null) return void 0;
+  if (source instanceof ArrayBuffer || ArrayBuffer.isView(source) || Array.isArray(source)) return void 0;
+  return source.httpHeaders;
+};
+/**
+ * Stabilizes effective HTTP headers into one owned, frozen record.
+ *
+ * Enumeration mirrors the installed PDF.js `createHeaders` transport
+ * (`for...in`, inherited enumerable string keys, `undefined` skipped) so
+ * the approved diagnostic and the value handed to `getDocument()` agree.
+ * Remaining values are coerced with `String()` as `Headers.append` would.
+ * Non-plain containers (`Headers`, `Map`, class instances) intentionally
+ * yield no value entries — matching what PDF.js `for...in` consumption
+ * observes — while `hasHttpHeaders` stays `true` so policies gating only
+ * on header presence keep blocking. A throwing getter propagates so the
+ * load fails closed before policy approval. The caller's container is
+ * never frozen or mutated.
+ */
+snapshotHttpHeaders_fn = function(value) {
+  if (value === null || value === void 0) return { hasHttpHeaders: false };
+  if (typeof value !== "object" && typeof value !== "function") return { hasHttpHeaders: false };
+  if (__privateMethod(this, _PDFReader_instances, isFetchHeaders_fn).call(this, value)) {
     return { hasHttpHeaders: true };
   }
+  const entries = [];
+  for (const name in value) {
+    const headerValue = value[name];
+    if (headerValue === void 0) continue;
+    entries.push([name, String(headerValue)]);
+  }
   return {
     hasHttpHeaders: true,
+    // Object.fromEntries installs `__proto__` as an own data property
+    // (no prototype mutation); the frozen record is shared by policy info
+    // and PDF.js loading params. Opaque worker/factory fields elsewhere in
+    // the snapshot stay borrowed by reference — only headers stabilize.
     httpHeaders: entries.length > 0 ? Object.freeze(Object.fromEntries(entries)) : void 0
   };
 };
-validateLimits_fn = function() {
-  for (const [name, value] of Object.entries(__privateGet(this, _limits))) {
-    if (value === void 0) continue;
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new PdfReaderError("INVALID_OPTION", `${name} must be a positive safe integer.`);
-    }
+
+// src/pdfTextToString.ts
+function pdfTextToString(content) {
+  const fragments = [];
+  for (const item of content.items) {
+    if (!("str" in item)) continue;
+    fragments.push(item.str);
+    if (item.hasEOL === true) fragments.push("\n");
   }
-};
+  return fragments.join("");
+}
 
 // src/source.ts
 function pdfUrlSource(url, options = {}) {
@@ -963,5 +1451,6 @@ export {
   PDFReader,
   PdfReaderError,
   configurePdfWorker,
+  pdfTextToString,
   pdfUrlSource
 };