@web-ts-toolkit/pdf-reader 0.37.0

package/index.mjs

@@ -0,0 +1,760 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/errors.ts
+var PdfReaderError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "PdfReaderError";
+    this.code = code;
+  }
+};
+
+// src/PDFReader.ts
+import { getDocument } from "pdfjs-dist";
+
+// src/embeddedImages.ts
+import { OPS, Util } from "pdfjs-dist";
+
+// src/geometry.ts
+function getTransformedUnitBounds(transform) {
+  const [a, b, c, d, e, f] = transform;
+  const points = [
+    [e, f],
+    [a + e, b + f],
+    [c + e, d + f],
+    [a + c + e, b + d + f]
+  ];
+  const xs = points.map(([x]) => x);
+  const ys = points.map(([, y]) => y);
+  const left = Math.min(...xs);
+  const right = Math.max(...xs);
+  const bottom = Math.min(...ys);
+  const top = Math.max(...ys);
+  return { left, right, top, bottom, width: right - left, height: top - bottom };
+}
+
+// src/embeddedImages.ts
+var identityTransform = [1, 0, 0, 1, 0, 0];
+var propagatedErrorCodes = /* @__PURE__ */ new Set(["ABORTED", "DESTROYED", "IMAGE_LIMIT_EXCEEDED"]);
+async function extractEmbeddedImages(page, viewport, options) {
+  const operators = await page.getOperatorList();
+  const images = [];
+  const stack = [];
+  let transform = identityTransform;
+  for (let index = 0; index < operators.fnArray.length; index += 1) {
+    options.throwIfDestroyed();
+    options.throwIfAborted(options.signal);
+    const operation = operators.fnArray[index];
+    if (operation === OPS.save) {
+      stack.push([...transform]);
+      continue;
+    }
+    if (operation === OPS.restore || operation === OPS.paintFormXObjectEnd) {
+      transform = stack.pop() ?? identityTransform;
+      continue;
+    }
+    if (operation === OPS.transform) {
+      const next = readTransformArgs(operators.argsArray[index]);
+      if (next) transform = Util.transform(transform, next);
+      continue;
+    }
+    if (operation === OPS.paintFormXObjectBegin) {
+      stack.push([...transform]);
+      const next = readTransformMatrix(operators.argsArray[index]?.[0]);
+      if (next) transform = Util.transform(transform, next);
+      continue;
+    }
+    if (operation === OPS.paintImageMaskXObject) {
+      warn(options.logger, "Skipped embedded image operator paintImageMaskXObject: image masks are not supported.");
+      continue;
+    }
+    if (operation !== OPS.paintXObject && operation !== OPS.paintImageXObject && operation !== OPS.paintInlineImageXObject) {
+      continue;
+    }
+    try {
+      const paintedImage = await resolvePaintedImage(page, operation, operators.argsArray[index], index);
+      if (!paintedImage) continue;
+      const dataUrl = imageToDataUrl(paintedImage.image, options);
+      if (!dataUrl) {
+        warn(
+          options.logger,
+          `Skipped embedded image ${paintedImage.label}: unsupported PDF.js image shape or data layout.`
+        );
+        continue;
+      }
+      const bounds = getTransformedUnitBounds(transform);
+      images.push({
+        dataUrl,
+        x: bounds.left,
+        y: bounds.top,
+        width: bounds.width,
+        height: bounds.height,
+        size: imageByteLength(paintedImage.image),
+        mimeType: "image/png",
+        pageWidth: viewport.width / viewport.scale,
+        pageHeight: viewport.height / viewport.scale,
+        transform: [...transform]
+      });
+    } catch (error) {
+      options.throwIfDestroyed();
+      options.throwIfAborted(options.signal);
+      if (shouldPropagateEmbeddedImageError(error)) throw error;
+      const label = readOperationLabel(operation, operators.argsArray[index], index);
+      warn(options.logger, `Failed to extract embedded image ${label}.`, error);
+    }
+  }
+  return images;
+}
+async function resolvePaintedImage(page, operation, args, index) {
+  if (operation === OPS.paintInlineImageXObject) {
+    const inlineImage = Array.isArray(args) ? args[0] : void 0;
+    if (!inlineImage || typeof inlineImage !== "object") return void 0;
+    return { image: inlineImage, label: `inline@${index}` };
+  }
+  const reference = Array.isArray(args) ? args[0] : void 0;
+  if (typeof reference !== "string") return void 0;
+  const image = await page.objs.get(reference);
+  return { image, label: reference };
+}
+function imageToDataUrl(image, options) {
+  const width = image.width;
+  const height = image.height;
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0) {
+    return void 0;
+  }
+  const canvas = allocateCanvas(width, 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 (!ArrayBuffer.isView(image.data)) return void 0;
+    const source = new Uint8ClampedArray(image.data.buffer, image.data.byteOffset, image.data.byteLength);
+    const rgba = toRgba(source, width, height);
+    if (!rgba) return void 0;
+    const pixels = context.createImageData(width, height);
+    pixels.data.set(rgba);
+    context.putImageData(pixels, 0, 0);
+    return canvas.toDataURL("image/png");
+  } finally {
+    releaseCanvas(canvas);
+  }
+}
+function toRgba(data, width, height) {
+  const pixels = width * height;
+  if (data.length === pixels * 4) return data;
+  if (data.length !== pixels && data.length !== pixels * 3) return void 0;
+  const channels = data.length / pixels;
+  const rgba = new Uint8ClampedArray(pixels * 4);
+  for (let pixel = 0; pixel < pixels; pixel += 1) {
+    const input = pixel * channels;
+    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;
+  }
+  return rgba;
+}
+function allocateCanvas(width, height, limit, createCanvas) {
+  const pixelWidth = Math.ceil(width);
+  const pixelHeight = Math.ceil(height);
+  const pixels = pixelWidth * pixelHeight;
+  if (!Number.isSafeInteger(pixels) || pixels > limit) {
+    throw new PdfReaderError("IMAGE_LIMIT_EXCEEDED", `embedded image requires ${pixels} pixels; limit is ${limit}.`);
+  }
+  const canvas = createCanvas();
+  canvas.width = pixelWidth;
+  canvas.height = pixelHeight;
+  return canvas;
+}
+function imageByteLength(image) {
+  if (typeof image.dataLen === "number" && Number.isFinite(image.dataLen)) return image.dataLen;
+  return ArrayBuffer.isView(image.data) ? image.data.byteLength : 0;
+}
+function releaseCanvas(canvas) {
+  canvas.width = 0;
+  canvas.height = 0;
+}
+function readTransformMatrix(value) {
+  const values = readNumericTuple(value, 6);
+  if (!values) return void 0;
+  return values;
+}
+function readTransformArgs(value) {
+  return readTransformMatrix(value) ?? readTransformMatrix(Array.isArray(value) ? value[0] : void 0);
+}
+function readNumericTuple(value, length) {
+  if (Array.isArray(value)) {
+    if (value.length !== length) return void 0;
+    if (value.some((entry) => typeof entry !== "number" || !Number.isFinite(entry))) return void 0;
+    return [...value];
+  }
+  if (!value || typeof value !== "object") return void 0;
+  const entries = [];
+  for (let index = 0; index < length; index += 1) {
+    const entry = value[index];
+    if (typeof entry !== "number" || !Number.isFinite(entry)) return void 0;
+    entries.push(entry);
+  }
+  return entries;
+}
+function readOperationLabel(operation, args, index) {
+  if (operation === OPS.paintInlineImageXObject) return `inline@${index}`;
+  const reference = Array.isArray(args) ? args[0] : void 0;
+  return typeof reference === "string" ? reference : `operator@${index}`;
+}
+function shouldPropagateEmbeddedImageError(error) {
+  return error instanceof PdfReaderError && propagatedErrorCodes.has(error.code);
+}
+function warn(logger, message, error) {
+  logger?.warn(message, error);
+}
+
+// src/options.ts
+function resolveConvertOptions(options) {
+  const resolved = {
+    pageRange: options.pageRange,
+    viewportScale: options.viewportScale ?? 1.5,
+    imageFormat: options.imageFormat ?? "image/png",
+    jpegQuality: options.jpegQuality ?? 0.92,
+    includePageImage: options.includePageImage ?? true,
+    pageImageOutput: options.pageImageOutput ?? "data-url",
+    includeText: options.includeText ?? true,
+    includeEmbeddedImages: options.includeEmbeddedImages ?? false,
+    signal: options.signal
+  };
+  if (typeof resolved.viewportScale === "number") {
+    assertPositiveFinite(resolved.viewportScale, "viewportScale");
+  }
+  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.");
+  }
+  if (resolved.pageImageOutput !== "data-url" && resolved.pageImageOutput !== "blob") {
+    throw new PdfReaderError("INVALID_OPTION", 'pageImageOutput must be either "data-url" or "blob".');
+  }
+  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)];
+}
+function assertPositiveFinite(value, option) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new PdfReaderError("INVALID_OPTION", `${option} must be a positive finite number.`);
+  }
+}
+function validatePageRange(pageRange) {
+  if (pageRange === void 0) return;
+  const values = typeof pageRange === "number" ? [pageRange] : pageRange;
+  if (values.some((value) => !Number.isSafeInteger(value) || value < 1)) {
+    throw new PdfReaderError("INVALID_OPTION", "pageRange values must be positive safe integers.");
+  }
+}
+
+// src/PDFReader.ts
+var defaultLimits = {
+  maxDocumentPages: 1e3,
+  maxCanvasPixels: 4e7,
+  maxEmbeddedImagePixels: 25e6
+};
+var _source, _createCanvas, _logger, _limits, _sourcePolicy, _loadingState, _document, _destroyPromise, _activeRenderTasks, _activePageWorkCount, _destroyed, _lastLoadFailed, _PDFReader_instances, load_fn, processPage_fn, encodePageImage_fn, resolveViewport_fn, encodeCanvasToBlob_fn, allocateCanvas_fn, waitForRender_fn, releaseCanvas_fn, getOrCreateLoadState_fn, awaitWithSignal_fn, createAbortedError_fn, createDestroyedError_fn, createDeadlineExceededError_fn, createUnsupportedEnvironmentError_fn, rethrowLifecycleError_fn, throwIfDestroyed_fn, throwIfAborted_fn, resolveLoadOptions_fn, isAbortSignal_fn, enforceSourcePolicy_fn, isPromiseLike_fn, inspectSource_fn, knownByteLength_fn, readUrl_fn, readHttpHeaders_fn, validateLimits_fn;
+var PDFReader = class {
+  constructor(source, options = {}) {
+    __privateAdd(this, _PDFReader_instances);
+    __privateAdd(this, _source);
+    __privateAdd(this, _createCanvas);
+    __privateAdd(this, _logger);
+    __privateAdd(this, _limits);
+    __privateAdd(this, _sourcePolicy);
+    __privateAdd(this, _loadingState);
+    __privateAdd(this, _document);
+    __privateAdd(this, _destroyPromise);
+    __privateAdd(this, _activeRenderTasks, /* @__PURE__ */ new Set());
+    __privateAdd(this, _activePageWorkCount, 0);
+    __privateAdd(this, _destroyed, false);
+    __privateAdd(this, _lastLoadFailed, false);
+    __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, _sourcePolicy, options.sourcePolicy);
+    __privateMethod(this, _PDFReader_instances, validateLimits_fn).call(this);
+  }
+  get numPages() {
+    return __privateGet(this, _document)?.numPages;
+  }
+  /** Current lifecycle state for load, iteration/rendering, retry, and teardown boundaries. */
+  get state() {
+    if (__privateGet(this, _destroyed)) return "destroyed";
+    if (__privateGet(this, _activePageWorkCount) > 0) return "iterating";
+    if (__privateGet(this, _document)) return "loaded";
+    if (__privateGet(this, _loadingState)) return "loading";
+    if (__privateGet(this, _lastLoadFailed)) return "failed";
+    return "new";
+  }
+  load(options) {
+    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. */
+  async *pages(options = {}) {
+    __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+    const documentProxy = __privateGet(this, _document);
+    if (!documentProxy) {
+      throw new PdfReaderError("DOCUMENT_NOT_LOADED", "Document not loaded. Call load() first.");
+    }
+    const resolved = resolveConvertOptions(options);
+    const [start, end] = resolvePageNumbers(resolved.pageRange, documentProxy.numPages);
+    if (start > documentProxy.numPages) {
+      throw new PdfReaderError("INVALID_OPTION", `pageRange starts after the last page (${documentProxy.numPages}).`);
+    }
+    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;
+      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;
+        __privateSet(this, _activePageWorkCount, __privateGet(this, _activePageWorkCount) - 1);
+        ownsActivePageWork = false;
+        yield result;
+      } catch (error) {
+        __privateMethod(this, _PDFReader_instances, rethrowLifecycleError_fn).call(this, error, resolved.signal);
+      } finally {
+        if (ownsActivePageWork) __privateSet(this, _activePageWorkCount, __privateGet(this, _activePageWorkCount) - 1);
+        page?.cleanup();
+      }
+    }
+  }
+  /** Collects `pages()` into an array. Prefer `pages()` for large documents. */
+  async convert(options = {}) {
+    const results = [];
+    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() {
+    if (__privateGet(this, _destroyPromise)) return __privateGet(this, _destroyPromise);
+    __privateSet(this, _destroyed, true);
+    const documentProxy = __privateGet(this, _document);
+    const loadingState = __privateGet(this, _loadingState);
+    __privateSet(this, _document, void 0);
+    __privateSet(this, _loadingState, void 0);
+    __privateSet(this, _destroyPromise, (async () => {
+      for (const renderTask of __privateGet(this, _activeRenderTasks)) renderTask.cancel();
+      if (documentProxy) {
+        await documentProxy.destroy();
+        return;
+      }
+      if (!loadingState) return;
+      loadingState.destroyed = true;
+      loadingState.destroyPromise ?? (loadingState.destroyPromise = loadingState.task ? loadingState.task.destroy() : Promise.resolve());
+      await loadingState.destroyPromise;
+    })());
+    await __privateGet(this, _destroyPromise);
+  }
+};
+_source = new WeakMap();
+_createCanvas = new WeakMap();
+_logger = new WeakMap();
+_limits = new WeakMap();
+_sourcePolicy = new WeakMap();
+_loadingState = new WeakMap();
+_document = new WeakMap();
+_destroyPromise = new WeakMap();
+_activeRenderTasks = new WeakMap();
+_activePageWorkCount = new WeakMap();
+_destroyed = new WeakMap();
+_lastLoadFailed = new WeakMap();
+_PDFReader_instances = new WeakSet();
+load_fn = async function(options) {
+  const state = __privateMethod(this, _PDFReader_instances, getOrCreateLoadState_fn).call(this);
+  try {
+    const documentProxy = await __privateMethod(this, _PDFReader_instances, awaitWithSignal_fn).call(this, state.promise, options.signal, options.deadlineMs);
+    __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+    __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, options.signal);
+    return documentProxy;
+  } catch (error) {
+    __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+    __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, options.signal);
+    throw error;
+  }
+};
+processPage_fn = async function(page, pageNumber, numPages, options) {
+  const viewport = __privateMethod(this, _PDFReader_instances, resolveViewport_fn).call(this, page, options.viewportScale);
+  const result = {
+    numPages,
+    pageNumber,
+    pageIndex: pageNumber - 1,
+    viewport,
+    images: []
+  };
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, options.signal);
+  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+  if (options.includeText) {
+    try {
+      result.text = await page.getTextContent();
+    } catch (error) {
+      __privateMethod(this, _PDFReader_instances, rethrowLifecycleError_fn).call(this, error, options.signal);
+    }
+  }
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, options.signal);
+  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+  if (options.includeEmbeddedImages) {
+    try {
+      result.images = await extractEmbeddedImages(page, viewport, {
+        signal: options.signal,
+        createCanvas: __privateGet(this, _createCanvas),
+        maxPixels: __privateGet(this, _limits).maxEmbeddedImagePixels,
+        logger: __privateGet(this, _logger),
+        throwIfAborted: (signal) => __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal),
+        throwIfDestroyed: () => __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this)
+      });
+    } catch (error) {
+      __privateMethod(this, _PDFReader_instances, rethrowLifecycleError_fn).call(this, error, options.signal);
+    }
+  }
+  __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");
+    try {
+      const context = canvas.getContext("2d");
+      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);
+      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);
+    }
+  }
+  return result;
+};
+encodePageImage_fn = async function(canvas, mimeType, output, jpegQuality, signal) {
+  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
+  const quality = mimeType === "image/jpeg" ? jpegQuality : void 0;
+  if (output === "data-url") {
+    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);
+    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);
+  return { kind: "blob", mimeType, blob };
+};
+resolveViewport_fn = function(page, viewportScale) {
+  if (typeof viewportScale === "number") return page.getViewport({ scale: viewportScale });
+  const base = page.getViewport({ scale: 1 });
+  const scale = viewportScale(base.width, base.height);
+  assertPositiveFinite(scale, "viewportScale callback result");
+  return page.getViewport({ scale });
+};
+encodeCanvasToBlob_fn = async function(canvas, mimeType, quality, signal) {
+  if (typeof canvas.toBlob !== "function") {
+    throw __privateMethod(this, _PDFReader_instances, createUnsupportedEnvironmentError_fn).call(this, "Canvas Blob encoding is not supported by this canvas implementation.");
+  }
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => settle(() => reject(__privateMethod(this, _PDFReader_instances, createAbortedError_fn).call(this)));
+    const cleanup = () => signal?.removeEventListener("abort", onAbort);
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      callback();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      const resolveBlob = (blob) => {
+        if (!blob) {
+          settle(
+            () => reject(__privateMethod(this, _PDFReader_instances, createUnsupportedEnvironmentError_fn).call(this, `Canvas Blob encoding returned null for ${mimeType}.`))
+          );
+          return;
+        }
+        settle(() => resolve(blob));
+      };
+      if (quality === void 0) {
+        canvas.toBlob(resolveBlob, mimeType);
+      } else {
+        canvas.toBlob(resolveBlob, mimeType, quality);
+      }
+    } catch (error) {
+      settle(() => reject(error));
+    }
+  });
+};
+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}.`);
+  }
+  const canvas = __privateGet(this, _createCanvas).call(this);
+  canvas.width = pixelWidth;
+  canvas.height = pixelHeight;
+  return canvas;
+};
+waitForRender_fn = async function(renderTask, signal) {
+  const abort = () => renderTask.cancel();
+  __privateGet(this, _activeRenderTasks).add(renderTask);
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    await renderTask.promise;
+    __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);
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    __privateGet(this, _activeRenderTasks).delete(renderTask);
+  }
+};
+releaseCanvas_fn = function(canvas) {
+  canvas.width = 0;
+  canvas.height = 0;
+};
+getOrCreateLoadState_fn = function() {
+  const existing = __privateGet(this, _loadingState);
+  if (existing) return existing;
+  __privateSet(this, _lastLoadFailed, false);
+  const state = { destroyed: false };
+  state.promise = (async () => {
+    try {
+      const policyResult = __privateMethod(this, _PDFReader_instances, enforceSourcePolicy_fn).call(this);
+      if (__privateMethod(this, _PDFReader_instances, isPromiseLike_fn).call(this, policyResult)) await policyResult;
+      if (state.destroyed || __privateGet(this, _destroyed)) {
+        throw __privateMethod(this, _PDFReader_instances, createDestroyedError_fn).call(this);
+      }
+      const task = getDocument(__privateGet(this, _source));
+      state.task = task;
+      const documentProxy = await task.promise;
+      if (state.destroyed || state.destroyPromise) {
+        await state.destroyPromise?.catch(() => void 0);
+        throw __privateMethod(this, _PDFReader_instances, createDestroyedError_fn).call(this);
+      }
+      if (documentProxy.numPages > __privateGet(this, _limits).maxDocumentPages) {
+        await documentProxy.destroy();
+        throw new PdfReaderError(
+          "PAGE_LIMIT_EXCEEDED",
+          `PDF has ${documentProxy.numPages} pages; limit is ${__privateGet(this, _limits).maxDocumentPages}.`
+        );
+      }
+      __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+      __privateSet(this, _document, documentProxy);
+      __privateSet(this, _lastLoadFailed, false);
+      return documentProxy;
+    } catch (error) {
+      if (state.destroyed || state.destroyPromise || __privateGet(this, _destroyed)) {
+        await state.destroyPromise?.catch(() => void 0);
+        throw __privateMethod(this, _PDFReader_instances, createDestroyedError_fn).call(this);
+      }
+      __privateSet(this, _lastLoadFailed, true);
+      throw error;
+    } finally {
+      if (__privateGet(this, _loadingState) === state) __privateSet(this, _loadingState, void 0);
+    }
+  })();
+  state.promise.catch(() => void 0);
+  __privateSet(this, _loadingState, state);
+  return state;
+};
+awaitWithSignal_fn = async function(promise, signal, deadlineMs) {
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
+  if (!signal && deadlineMs === void 0) return promise;
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => settle(() => reject(__privateMethod(this, _PDFReader_instances, createAbortedError_fn).call(this)));
+    const cleanup = () => {
+      signal?.removeEventListener("abort", onAbort);
+      if (timer !== void 0) clearTimeout(timer);
+    };
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      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 });
+    promise.then(
+      (value) => settle(() => resolve(value)),
+      (error) => settle(() => reject(error))
+    ).catch(() => void 0);
+  });
+};
+createAbortedError_fn = function() {
+  return new PdfReaderError("ABORTED", "PDF operation was aborted.");
+};
+createDestroyedError_fn = function() {
+  return new PdfReaderError("DESTROYED", "PDFReader has been destroyed.");
+};
+createDeadlineExceededError_fn = function() {
+  return new PdfReaderError("DEADLINE_EXCEEDED", "PDF load exceeded the configured deadline.");
+};
+createUnsupportedEnvironmentError_fn = function(message) {
+  return new PdfReaderError("UNSUPPORTED_ENVIRONMENT", message);
+};
+rethrowLifecycleError_fn = function(error, signal) {
+  __privateMethod(this, _PDFReader_instances, throwIfDestroyed_fn).call(this);
+  __privateMethod(this, _PDFReader_instances, throwIfAborted_fn).call(this, signal);
+  throw error;
+};
+throwIfDestroyed_fn = function() {
+  if (__privateGet(this, _destroyed)) throw __privateMethod(this, _PDFReader_instances, createDestroyedError_fn).call(this);
+};
+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.");
+  }
+  return options;
+};
+isAbortSignal_fn = function(value) {
+  return "aborted" in value && "addEventListener" in value && "removeEventListener" in value;
+};
+enforceSourcePolicy_fn = function() {
+  const source = __privateMethod(this, _PDFReader_instances, inspectSource_fn).call(this, __privateGet(this, _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}.`
+    );
+  }
+  if (!__privateGet(this, _sourcePolicy)) return;
+  try {
+    const result = __privateGet(this, _sourcePolicy).call(this, source);
+    if (!__privateMethod(this, _PDFReader_instances, isPromiseLike_fn).call(this, result)) return;
+    return result.catch((error) => {
+      if (error instanceof PdfReaderError) throw error;
+      throw new PdfReaderError("SOURCE_POLICY_VIOLATION", "PDF source rejected by sourcePolicy.");
+    });
+  } catch (error) {
+    if (error instanceof PdfReaderError) throw error;
+    throw new PdfReaderError("SOURCE_POLICY_VIOLATION", "PDF source rejected by sourcePolicy.");
+  }
+};
+isPromiseLike_fn = function(value) {
+  return value instanceof Promise;
+};
+inspectSource_fn = function(source) {
+  if (typeof source === "string") {
+    return {
+      rawSource: source,
+      kind: "url",
+      url: source,
+      hasHttpHeaders: false,
+      withCredentials: false
+    };
+  }
+  if (typeof URL !== "undefined" && source instanceof URL) {
+    return {
+      rawSource: source,
+      kind: "url",
+      url: source.toString(),
+      hasHttpHeaders: false,
+      withCredentials: false
+    };
+  }
+  const byteLength = __privateMethod(this, _PDFReader_instances, knownByteLength_fn).call(this, source);
+  if (byteLength !== void 0) {
+    return {
+      rawSource: source,
+      kind: "bytes",
+      byteLength,
+      hasHttpHeaders: false,
+      withCredentials: false
+    };
+  }
+  const candidate = source;
+  const headers = __privateMethod(this, _PDFReader_instances, readHttpHeaders_fn).call(this, candidate.httpHeaders);
+  return {
+    rawSource: source,
+    kind: "document-init-parameters",
+    url: __privateMethod(this, _PDFReader_instances, readUrl_fn).call(this, candidate.url),
+    byteLength: __privateMethod(this, _PDFReader_instances, knownByteLength_fn).call(this, candidate.data),
+    hasHttpHeaders: headers !== void 0,
+    httpHeaders: headers,
+    withCredentials: candidate.withCredentials === true
+  };
+};
+knownByteLength_fn = function(value) {
+  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;
+  return void 0;
+};
+readUrl_fn = function(value) {
+  if (typeof value === "string") return value;
+  if (typeof URL !== "undefined" && value instanceof URL) return value.toString();
+  return void 0;
+};
+readHttpHeaders_fn = function(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+  if (entries.length === 0) return void 0;
+  return Object.freeze(Object.fromEntries(entries));
+};
+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/source.ts
+function pdfUrlSource(url, options = {}) {
+  return { ...options, url };
+}
+
+// src/worker.ts
+import { GlobalWorkerOptions } from "pdfjs-dist";
+function configurePdfWorker(worker) {
+  if (typeof worker === "string") {
+    GlobalWorkerOptions.workerPort = null;
+    GlobalWorkerOptions.workerSrc = worker;
+  } else {
+    GlobalWorkerOptions.workerSrc = "";
+    GlobalWorkerOptions.workerPort = worker;
+  }
+}
+export {
+  PDFReader,
+  PdfReaderError,
+  configurePdfWorker,
+  pdfUrlSource
+};