@signiphi/page-assembly 0.2.0-beta.7 → 0.2.0-beta.9

package/dist/index.js

@@ -43,7 +43,9 @@ var DropdownMenuPrimitive__namespace = /*#__PURE__*/_interopNamespace(DropdownMe
 var TooltipPrimitive__namespace = /*#__PURE__*/_interopNamespace(TooltipPrimitive);
 var pdfjsLib__namespace = /*#__PURE__*/_interopNamespace(pdfjsLib);
 
-// src/components/PageAssembler.tsx
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 function cn(...inputs) {
   return tailwindMerge.twMerge(clsx.clsx(inputs));
 }
@@ -574,6 +576,528 @@ var TooltipContent = React7__namespace.forwardRef(({ className, sideOffset = 4,
   }
 ));
 TooltipContent.displayName = TooltipPrimitive__namespace.Content.displayName;
+var PdfPasswordRequiredError = class extends Error {
+  constructor() {
+    const message = "This PDF is password-protected. Please remove the password and upload it again.";
+    super(message);
+    __publicField(this, "code", "PDF_PASSWORD_REQUIRED");
+    __publicField(this, "recoverable", true);
+    __publicField(this, "userMessage");
+    this.name = "PdfPasswordRequiredError";
+    this.userMessage = message;
+  }
+};
+var UnsupportedPdfEncryptionError = class extends Error {
+  constructor(detail) {
+    super(`This PDF uses an unsupported encryption scheme (${detail}).`);
+    this.name = "UnsupportedPdfEncryptionError";
+  }
+};
+function concatBytes(...parts) {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
+}
+var MD5_S = [
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21
+];
+var MD5_K = (() => {
+  const k = new Uint32Array(64);
+  for (let i = 0; i < 64; i++) k[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296);
+  return k;
+})();
+function md5(input) {
+  const bitLen = input.length * 8;
+  const paddedLen = (input.length + 8 >> 6) + 1 << 6;
+  const buf = new Uint8Array(paddedLen);
+  buf.set(input);
+  buf[input.length] = 128;
+  const dv = new DataView(buf.buffer);
+  dv.setUint32(paddedLen - 8, bitLen >>> 0, true);
+  dv.setUint32(paddedLen - 4, Math.floor(bitLen / 4294967296), true);
+  let a0 = 1732584193;
+  let b0 = 4023233417;
+  let c0 = 2562383102;
+  let d0 = 271733878;
+  const M = new Uint32Array(16);
+  for (let offset = 0; offset < paddedLen; offset += 64) {
+    for (let i = 0; i < 16; i++) M[i] = dv.getUint32(offset + i * 4, true);
+    let A = a0;
+    let B = b0;
+    let C = c0;
+    let D = d0;
+    for (let i = 0; i < 64; i++) {
+      let F;
+      let g;
+      if (i < 16) {
+        F = B & C | ~B & D;
+        g = i;
+      } else if (i < 32) {
+        F = D & B | ~D & C;
+        g = 5 * i + 1 & 15;
+      } else if (i < 48) {
+        F = B ^ C ^ D;
+        g = 3 * i + 5 & 15;
+      } else {
+        F = C ^ (B | ~D);
+        g = 7 * i & 15;
+      }
+      const tmp = D;
+      D = C;
+      C = B;
+      const x = A + F + MD5_K[i] + M[g] | 0;
+      const s = MD5_S[i];
+      B = B + (x << s | x >>> 32 - s) | 0;
+      A = tmp;
+    }
+    a0 = a0 + A | 0;
+    b0 = b0 + B | 0;
+    c0 = c0 + C | 0;
+    d0 = d0 + D | 0;
+  }
+  const out = new Uint8Array(16);
+  const ov = new DataView(out.buffer);
+  ov.setUint32(0, a0 >>> 0, true);
+  ov.setUint32(4, b0 >>> 0, true);
+  ov.setUint32(8, c0 >>> 0, true);
+  ov.setUint32(12, d0 >>> 0, true);
+  return out;
+}
+function rc4(key, data) {
+  const S = new Uint8Array(256);
+  for (let i2 = 0; i2 < 256; i2++) S[i2] = i2;
+  let j = 0;
+  for (let i2 = 0; i2 < 256; i2++) {
+    j = j + S[i2] + key[i2 % key.length] & 255;
+    const t = S[i2];
+    S[i2] = S[j];
+    S[j] = t;
+  }
+  const out = new Uint8Array(data.length);
+  let i = 0;
+  j = 0;
+  for (let k = 0; k < data.length; k++) {
+    i = i + 1 & 255;
+    j = j + S[i] & 255;
+    const t = S[i];
+    S[i] = S[j];
+    S[j] = t;
+    out[k] = data[k] ^ S[S[i] + S[j] & 255];
+  }
+  return out;
+}
+function getSubtle() {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new UnsupportedPdfEncryptionError("WebCrypto is unavailable in this environment");
+  return subtle;
+}
+async function sha2(algorithm, data) {
+  return new Uint8Array(await getSubtle().digest(algorithm, data));
+}
+async function importAesKey(rawKey, usages) {
+  return getSubtle().importKey("raw", rawKey, "AES-CBC", false, usages);
+}
+async function aesCbcEncryptNoPad(rawKey, iv, data) {
+  const key = await importAesKey(rawKey, ["encrypt"]);
+  const out = new Uint8Array(await getSubtle().encrypt({ name: "AES-CBC", iv }, key, data));
+  return out.slice(0, data.length);
+}
+async function aesCbcDecryptNoPad(rawKey, iv, data) {
+  const key = await importAesKey(rawKey, ["encrypt", "decrypt"]);
+  const lastBlock = data.slice(data.length - 16);
+  const padBlock = new Uint8Array(
+    await getSubtle().encrypt({ name: "AES-CBC", iv: lastBlock }, key, new Uint8Array(0))
+  );
+  const joined = concatBytes(data, padBlock);
+  return new Uint8Array(await getSubtle().decrypt({ name: "AES-CBC", iv }, key, joined));
+}
+async function aesDecryptPdfData(rawKey, data) {
+  if (data.length < 32) return new Uint8Array(0);
+  const iv = data.slice(0, 16);
+  let ct = data.slice(16);
+  if (ct.length % 16 !== 0) ct = ct.slice(0, ct.length - ct.length % 16);
+  try {
+    const key = await importAesKey(rawKey, ["decrypt"]);
+    return new Uint8Array(await getSubtle().decrypt({ name: "AES-CBC", iv }, key, ct));
+  } catch {
+    const plain = await aesCbcDecryptNoPad(rawKey, iv, ct);
+    const padLen = plain[plain.length - 1];
+    return padLen >= 1 && padLen <= 16 ? plain.slice(0, plain.length - padLen) : plain;
+  }
+}
+var PAD = new Uint8Array([
+  40,
+  191,
+  78,
+  94,
+  78,
+  117,
+  138,
+  65,
+  100,
+  0,
+  78,
+  86,
+  255,
+  250,
+  1,
+  8,
+  46,
+  46,
+  0,
+  182,
+  208,
+  104,
+  62,
+  128,
+  47,
+  12,
+  169,
+  254,
+  100,
+  83,
+  105,
+  122
+]);
+var bytesEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+function legacyFileKey(paddedPwd, params) {
+  const { revision, keyLen, O, P, id0, encryptMetadata } = params;
+  const pBytes = new Uint8Array(4);
+  new DataView(pBytes.buffer).setInt32(0, P | 0, true);
+  const parts = [paddedPwd, O.slice(0, 32), pBytes, id0];
+  if (revision >= 4 && !encryptMetadata) parts.push(new Uint8Array([255, 255, 255, 255]));
+  let h = md5(concatBytes(...parts));
+  if (revision >= 3) for (let i = 0; i < 50; i++) h = md5(h.slice(0, keyLen));
+  return h.slice(0, keyLen);
+}
+function legacyComputeU(fileKey, revision, id0) {
+  if (revision === 2) return rc4(fileKey, PAD);
+  let d = md5(concatBytes(PAD, id0));
+  d = rc4(fileKey, d);
+  for (let i = 1; i <= 19; i++) d = rc4(fileKey.map((b) => b ^ i), d);
+  return d;
+}
+function legacyUMatches(fileKey, params) {
+  const computed = legacyComputeU(fileKey, params.revision, params.id0);
+  return params.revision === 2 ? bytesEqual(computed, params.U.slice(0, 32)) : bytesEqual(computed.slice(0, 16), params.U.slice(0, 16));
+}
+function legacyAuthenticateEmptyPassword(params) {
+  const userKey = legacyFileKey(PAD, params);
+  if (legacyUMatches(userKey, params)) return userKey;
+  const { revision, keyLen } = params;
+  let h = md5(PAD);
+  if (revision >= 3) for (let i = 0; i < 50; i++) h = md5(h);
+  const ownerKey = h.slice(0, keyLen);
+  let recovered = params.O.slice(0, 32);
+  if (revision === 2) {
+    recovered = rc4(ownerKey, recovered);
+  } else {
+    for (let i = 19; i >= 0; i--) recovered = rc4(ownerKey.map((b) => b ^ i), recovered);
+  }
+  const viaOwner = legacyFileKey(recovered, params);
+  if (legacyUMatches(viaOwner, params)) return viaOwner;
+  throw new PdfPasswordRequiredError();
+}
+async function hash2B(password, salt, udata) {
+  let k = await sha2("SHA-256", concatBytes(password, salt, udata));
+  let e = new Uint8Array(0);
+  let i = 0;
+  do {
+    const block = concatBytes(password, k, udata);
+    const k1 = new Uint8Array(block.length * 64);
+    for (let rep = 0; rep < 64; rep++) k1.set(block, rep * block.length);
+    e = await aesCbcEncryptNoPad(k.slice(0, 16), k.slice(16, 32), k1);
+    let sum = 0;
+    for (let b = 0; b < 16; b++) sum += e[b];
+    const mod = sum % 3;
+    k = await sha2(mod === 0 ? "SHA-256" : mod === 1 ? "SHA-384" : "SHA-512", e);
+    i++;
+  } while (i < 64 || e[e.length - 1] > i - 32);
+  return k.slice(0, 32);
+}
+async function v5AuthenticateEmptyPassword(revision, U, O, UE, OE) {
+  const pwd = new Uint8Array(0);
+  const zeroIv = new Uint8Array(16);
+  const hash = async (salt, udata) => revision === 5 ? sha2("SHA-256", concatBytes(pwd, salt, udata)) : hash2B(pwd, salt, udata);
+  const userHash = await hash(U.slice(32, 40), new Uint8Array(0));
+  if (bytesEqual(userHash, U.slice(0, 32))) {
+    const intermediate = await hash(U.slice(40, 48), new Uint8Array(0));
+    return aesCbcDecryptNoPad(intermediate, zeroIv, UE.slice(0, 32));
+  }
+  const u48 = U.slice(0, 48);
+  const ownerHash = await hash(O.slice(32, 40), u48);
+  if (bytesEqual(ownerHash, O.slice(0, 32))) {
+    const intermediate = await hash(O.slice(40, 48), u48);
+    return aesCbcDecryptNoPad(intermediate, zeroIv, OE.slice(0, 32));
+  }
+  throw new PdfPasswordRequiredError();
+}
+var identityCipher = async (data) => data;
+function rc4ObjectCipher(fileKey) {
+  return async (data, ref) => {
+    const ext = new Uint8Array([
+      ref.objectNumber & 255,
+      ref.objectNumber >> 8 & 255,
+      ref.objectNumber >> 16 & 255,
+      ref.generationNumber & 255,
+      ref.generationNumber >> 8 & 255
+    ]);
+    const key = md5(concatBytes(fileKey, ext)).slice(0, Math.min(fileKey.length + 5, 16));
+    return rc4(key, data);
+  };
+}
+var AES_SALT = new Uint8Array([115, 65, 108, 84]);
+function aes128ObjectCipher(fileKey) {
+  return async (data, ref) => {
+    const ext = new Uint8Array([
+      ref.objectNumber & 255,
+      ref.objectNumber >> 8 & 255,
+      ref.objectNumber >> 16 & 255,
+      ref.generationNumber & 255,
+      ref.generationNumber >> 8 & 255
+    ]);
+    const key = md5(concatBytes(fileKey, ext, AES_SALT)).slice(0, 16);
+    return aesDecryptPdfData(key, data);
+  };
+}
+function aes256ObjectCipher(fileKey) {
+  return async (data) => aesDecryptPdfData(fileKey, data);
+}
+function dictNumber(dict, key) {
+  const value = dict.lookup(pdfLib.PDFName.of(key));
+  return value instanceof pdfLib.PDFNumber ? value.asNumber() : void 0;
+}
+function dictBytes(dict, key) {
+  const value = dict.lookup(pdfLib.PDFName.of(key));
+  return value instanceof pdfLib.PDFString || value instanceof pdfLib.PDFHexString ? value.asBytes() : void 0;
+}
+async function buildDocumentCiphers(encDict, id0) {
+  const filter = encDict.lookup(pdfLib.PDFName.of("Filter"));
+  if (filter !== pdfLib.PDFName.of("Standard")) {
+    throw new UnsupportedPdfEncryptionError(`security handler ${String(filter)}`);
+  }
+  const V = dictNumber(encDict, "V") ?? 0;
+  const R = dictNumber(encDict, "R") ?? 0;
+  const O = dictBytes(encDict, "O");
+  const U = dictBytes(encDict, "U");
+  const P = dictNumber(encDict, "P") ?? -1;
+  const metadataValue = encDict.lookup(pdfLib.PDFName.of("EncryptMetadata"));
+  const encryptMetadata = metadataValue instanceof pdfLib.PDFBool ? metadataValue.asBoolean() : true;
+  if (!O || !U) throw new UnsupportedPdfEncryptionError("missing /O or /U");
+  if (V === 1 || V === 2) {
+    const keyLen = V === 1 ? 5 : (dictNumber(encDict, "Length") ?? 40) / 8;
+    const fileKey = legacyAuthenticateEmptyPassword({ revision: R, keyLen, O, U, P, id0, encryptMetadata });
+    const cipher = rc4ObjectCipher(fileKey);
+    return { stringCipher: cipher, streamCipher: cipher, encryptMetadata };
+  }
+  if (V === 4 || V === 5) {
+    const cf = encDict.lookup(pdfLib.PDFName.of("CF"));
+    const cfmOf = (filterKey) => {
+      const streamFilter = encDict.lookup(pdfLib.PDFName.of(filterKey));
+      if (!(streamFilter instanceof pdfLib.PDFName) || streamFilter === pdfLib.PDFName.of("Identity")) return void 0;
+      if (!(cf instanceof pdfLib.PDFDict)) throw new UnsupportedPdfEncryptionError("missing /CF");
+      const cfDict = cf.lookup(streamFilter);
+      if (!(cfDict instanceof pdfLib.PDFDict)) throw new UnsupportedPdfEncryptionError(`missing crypt filter ${streamFilter.toString()}`);
+      const cfm = cfDict.lookup(pdfLib.PDFName.of("CFM"));
+      return cfm instanceof pdfLib.PDFName ? cfm : void 0;
+    };
+    let fileKey;
+    if (V === 5) {
+      const UE = dictBytes(encDict, "UE");
+      const OE = dictBytes(encDict, "OE");
+      if (!UE || !OE) throw new UnsupportedPdfEncryptionError("missing /UE or /OE");
+      fileKey = await v5AuthenticateEmptyPassword(R, U, O, UE, OE);
+    } else {
+      const keyLen = (dictNumber(encDict, "Length") ?? 40) / 8;
+      fileKey = legacyAuthenticateEmptyPassword({ revision: R, keyLen, O, U, P, id0, encryptMetadata });
+    }
+    const cipherFor = (cfm) => {
+      if (!cfm || cfm === pdfLib.PDFName.of("Identity")) return identityCipher;
+      if (cfm === pdfLib.PDFName.of("V2")) return rc4ObjectCipher(fileKey);
+      if (cfm === pdfLib.PDFName.of("AESV2")) return aes128ObjectCipher(fileKey);
+      if (cfm === pdfLib.PDFName.of("AESV3")) return aes256ObjectCipher(fileKey);
+      throw new UnsupportedPdfEncryptionError(`crypt filter method ${cfm.toString()}`);
+    };
+    return {
+      streamCipher: cipherFor(cfmOf("StmF")),
+      stringCipher: cipherFor(cfmOf("StrF")),
+      encryptMetadata
+    };
+  }
+  throw new UnsupportedPdfEncryptionError(`/V ${V}`);
+}
+var toHexString = (bytes) => {
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, "0");
+  return new pdfLib.PDFHexString(hex.toUpperCase());
+};
+function filterIncludesCrypt(dict) {
+  const filter = dict.lookup(pdfLib.PDFName.of("Filter"));
+  if (filter === pdfLib.PDFName.of("Crypt")) return true;
+  if (filter instanceof pdfLib.PDFArray) {
+    for (let i = 0; i < filter.size(); i++) {
+      if (filter.get(i) === pdfLib.PDFName.of("Crypt")) return true;
+    }
+  }
+  return false;
+}
+async function decryptStringsWithin(obj, ref, stringCipher) {
+  if (obj instanceof pdfLib.PDFDict) {
+    const isSignature = obj.lookup(pdfLib.PDFName.of("Type")) === pdfLib.PDFName.of("Sig");
+    for (const [key, value] of obj.entries()) {
+      if (value instanceof pdfLib.PDFString || value instanceof pdfLib.PDFHexString) {
+        if (isSignature && key === pdfLib.PDFName.of("Contents")) continue;
+        obj.set(key, toHexString(await stringCipher(value.asBytes(), ref)));
+      } else {
+        await decryptStringsWithin(value, ref, stringCipher);
+      }
+    }
+  } else if (obj instanceof pdfLib.PDFArray) {
+    for (let i = 0; i < obj.size(); i++) {
+      const value = obj.get(i);
+      if (value instanceof pdfLib.PDFString || value instanceof pdfLib.PDFHexString) {
+        obj.set(i, toHexString(await stringCipher(value.asBytes(), ref)));
+      } else {
+        await decryptStringsWithin(value, ref, stringCipher);
+      }
+    }
+  }
+}
+async function decryptLoadedDocument(doc) {
+  const context = doc.context;
+  const encryptRef = context.trailerInfo.Encrypt;
+  const encDict = context.lookup(encryptRef);
+  if (!(encDict instanceof pdfLib.PDFDict)) {
+    throw new UnsupportedPdfEncryptionError("malformed /Encrypt dictionary");
+  }
+  const idArray = context.lookup(context.trailerInfo.ID);
+  const idFirst = idArray instanceof pdfLib.PDFArray ? idArray.get(0) : void 0;
+  const id0 = idFirst instanceof pdfLib.PDFString || idFirst instanceof pdfLib.PDFHexString ? idFirst.asBytes() : new Uint8Array(0);
+  const { stringCipher, streamCipher, encryptMetadata } = await buildDocumentCiphers(encDict, id0);
+  for (const [ref, obj] of context.enumerateIndirectObjects()) {
+    if (ref === encryptRef || obj === encDict) continue;
+    if (obj instanceof pdfLib.PDFRawStream) {
+      const type = obj.dict.lookup(pdfLib.PDFName.of("Type"));
+      const isXrefStream = type === pdfLib.PDFName.of("XRef");
+      const isSkippedMetadata = !encryptMetadata && type === pdfLib.PDFName.of("Metadata");
+      if (!isXrefStream && !isSkippedMetadata && !filterIncludesCrypt(obj.dict)) {
+        const decrypted = await streamCipher(obj.contents, ref);
+        context.assign(ref, pdfLib.PDFRawStream.of(obj.dict, decrypted));
+      }
+      await decryptStringsWithin(obj.dict, ref, stringCipher);
+    } else if (obj instanceof pdfLib.PDFString || obj instanceof pdfLib.PDFHexString) {
+      context.assign(ref, toHexString(await stringCipher(obj.asBytes(), ref)));
+    } else {
+      await decryptStringsWithin(obj, ref, stringCipher);
+    }
+  }
+  delete context.trailerInfo.Encrypt;
+  if (encryptRef instanceof pdfLib.PDFRef) context.delete(encryptRef);
+  return doc.save({ useObjectStreams: false });
+}
+async function decryptPdf(pdfBytes) {
+  const doc = await pdfLib.PDFDocument.load(pdfBytes.slice(), {
+    ignoreEncryption: true,
+    updateMetadata: false
+  });
+  if (!doc.isEncrypted) return pdfBytes;
+  return decryptLoadedDocument(doc);
+}
+var ENCRYPT_MARKER = new Uint8Array([47, 69, 110, 99, 114, 121, 112, 116]);
+function containsEncryptMarker(bytes) {
+  const last = bytes.length - ENCRYPT_MARKER.length;
+  outer: for (let i = 0; i <= last; i++) {
+    for (let j = 0; j < ENCRYPT_MARKER.length; j++) {
+      if (bytes[i + j] !== ENCRYPT_MARKER[j]) continue outer;
+    }
+    return true;
+  }
+  return false;
+}
+function isEncryptedPdfError(error) {
+  return error instanceof pdfLib.EncryptedPDFError || error instanceof Error && error.message.includes("is encrypted");
+}
+async function normalizePdfEncryption(pdfBytes) {
+  if (!containsEncryptMarker(pdfBytes)) return pdfBytes;
+  const doc = await pdfLib.PDFDocument.load(pdfBytes.slice(), {
+    ignoreEncryption: true,
+    updateMetadata: false
+  });
+  if (!doc.isEncrypted) return pdfBytes;
+  console.info("[PageAssembler] Encrypted PDF detected during ingestion; decrypting");
+  return decryptLoadedDocument(doc);
+}
+
+// src/utils/pdf-helpers.ts
 if (typeof window !== "undefined") {
   pdfjsLib__namespace.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
 }
@@ -645,6 +1169,53 @@ async function pdfToImages(pdfBytes, options) {
     throw error;
   }
 }
+async function rasterizePdfToPdf(pdfBytes) {
+  if (typeof window !== "undefined") {
+    pdfjsLib__namespace.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
+  }
+  let sourceDoc;
+  try {
+    sourceDoc = await pdfjsLib__namespace.getDocument({ data: pdfBytes.slice(0), verbosity: 0 }).promise;
+  } catch (error) {
+    if (error?.name === "PasswordException") {
+      throw new PdfPasswordRequiredError();
+    }
+    throw error;
+  }
+  try {
+    const outDoc = await pdfLib.PDFDocument.create();
+    for (let pageNum = 1; pageNum <= sourceDoc.numPages; pageNum++) {
+      const page = await sourceDoc.getPage(pageNum);
+      const viewport = page.getViewport({ scale: 2 });
+      const canvas = document.createElement("canvas");
+      canvas.width = viewport.width;
+      canvas.height = viewport.height;
+      const context = canvas.getContext("2d");
+      await page.render({ canvasContext: context, viewport }).promise;
+      const png = await outDoc.embedPng(canvas.toDataURL("image/png"));
+      const pageWidth = viewport.width / 2;
+      const pageHeight = viewport.height / 2;
+      const outPage = outDoc.addPage([pageWidth, pageHeight]);
+      outPage.drawImage(png, { x: 0, y: 0, width: pageWidth, height: pageHeight });
+    }
+    return new Uint8Array(await outDoc.save({ useObjectStreams: false }));
+  } finally {
+    await sourceDoc.destroy();
+  }
+}
+async function normalizeUploadedPdfBytes(pdfBytes) {
+  try {
+    const normalized = await normalizePdfEncryption(pdfBytes);
+    return normalized === pdfBytes ? pdfBytes : new Uint8Array(normalized);
+  } catch (error) {
+    if (error instanceof PdfPasswordRequiredError) throw error;
+    console.warn(
+      "[PageAssembler] Structural decryption failed; rebuilding document from rendered pages:",
+      error
+    );
+    return rasterizePdfToPdf(pdfBytes);
+  }
+}
 async function imageToPdf(imageFile) {
   return new Promise((resolve, reject) => {
     const img = new Image();
@@ -1928,6 +2499,7 @@ var PageAssembler = React7.forwardRef(
     );
     const [isLoading, setIsLoading] = React7.useState(false);
     const [processingStatus, setProcessingStatus] = React7.useState("");
+    const [uploadError, setUploadError] = React7.useState(null);
     const [showDeleteConfirm, setShowDeleteConfirm] = React7.useState(false);
     const [showRemoveFileConfirm, setShowRemoveFileConfirm] = React7.useState(false);
     const [fileToRemove, setFileToRemove] = React7.useState(null);
@@ -1969,6 +2541,7 @@ var PageAssembler = React7.forwardRef(
         } else {
           pdfBytes = new Uint8Array(pdf);
         }
+        pdfBytes = await normalizeUploadedPdfBytes(pdfBytes);
         const defensiveCopy = new Uint8Array(pdfBytes);
         const pages = await pdfToImages(defensiveCopy, { hideFormFields: true });
         if (pages.length === 0) {
@@ -2014,8 +2587,9 @@ var PageAssembler = React7.forwardRef(
         setProcessingStatus("");
       }
     }, []);
+    const hasRestorableState = !!initialState && initialState.files.length > 0;
     React7.useEffect(() => {
-      if (initialPdf && !initialState) {
+      if (initialPdf && state.files.length === 0 && !hasRestorableState) {
         const pdfIdentifier = initialPdf instanceof Uint8Array ? `uint8array-${initialPdf.length}-${initialPdf[0]}-${initialPdf[initialPdf.length - 1]}` : `${initialPdf.constructor.name}-${initialPdf.size || initialPdf.byteLength}`;
         if (processedInitialPdfRef.current === pdfIdentifier) {
           return;
@@ -2023,15 +2597,16 @@ var PageAssembler = React7.forwardRef(
         processedInitialPdfRef.current = pdfIdentifier;
         processInitialPdf(initialPdf);
       }
-    }, [initialPdf, initialState, processInitialPdf]);
+    }, [initialPdf, state.files.length, hasRestorableState, processInitialPdf]);
     React7.useEffect(() => {
-      if (initialState) {
+      if (initialState && initialState.files.length > 0) {
         dispatch({ type: "RESET", payload: initialState });
       }
     }, [initialState]);
     const processFiles = React7.useCallback(async (files) => {
       const fileArray = Array.from(files);
       const maxFileSize = (limits?.maxFileSizeMB || 10) * 1024 * 1024;
+      setUploadError(null);
       setIsLoading(true);
       setProcessingStatus(`Processing ${fileArray.length} file${fileArray.length !== 1 ? "s" : ""}...`);
       for (const file of fileArray) {
@@ -2056,7 +2631,7 @@ var PageAssembler = React7.forwardRef(
           if (file.type === "application/pdf") {
             setProcessingStatus(`Processing PDF: ${file.name}`);
             const arrayBuffer = await file.arrayBuffer();
-            const pdfBytes = new Uint8Array(arrayBuffer);
+            const pdfBytes = await normalizeUploadedPdfBytes(new Uint8Array(arrayBuffer));
             fileInfo.originalBytes = new Uint8Array(pdfBytes);
             originalBytesCache.current.set(fileInfo.id, fileInfo.originalBytes);
             const defensiveCopy = new Uint8Array(pdfBytes);
@@ -2106,6 +2681,11 @@ var PageAssembler = React7.forwardRef(
           dispatch({ type: "ADD_FILE", payload: fileInfo });
         } catch (error) {
           console.error(`Error processing file ${file.name}:`, error);
+          if (error instanceof PdfPasswordRequiredError) {
+            setUploadError(`${file.name}: ${error.userMessage}`);
+          } else {
+            setUploadError(`Failed to process "${file.name}". The file may be corrupted or unsupported.`);
+          }
         }
       }
       setIsLoading(false);
@@ -2203,7 +2783,7 @@ var PageAssembler = React7.forwardRef(
         setIsLoading(true);
         setProcessingStatus("Assembling PDF...");
         try {
-          const { PDFDocument: PDFDocument4, PDFName: PDFName3, PDFString: PDFString3 } = await import('pdf-lib');
+          const { PDFDocument: PDFDocument5, PDFName: PDFName4, PDFString: PDFString4 } = await import('pdf-lib');
           const loadedPdfs = /* @__PURE__ */ new Map();
           const fileMap = /* @__PURE__ */ new Map();
           const pdfFiles = state.files.filter((f) => f.type === "pdf" && f.originalBytes?.length > 0);
@@ -2213,7 +2793,7 @@ var PageAssembler = React7.forwardRef(
             fileMap.set(file.id, file);
             if (file.type === "pdf" && file.originalBytes && file.originalBytes.length > 0) {
               try {
-                const sourcePdf = await PDFDocument4.load(file.originalBytes);
+                const sourcePdf = await PDFDocument5.load(file.originalBytes);
                 loadedPdfs.set(file.id, sourcePdf);
               } catch (error) {
                 console.error(`Error loading PDF for file ${file.id}:`, error);
@@ -2234,7 +2814,7 @@ var PageAssembler = React7.forwardRef(
             if (cachedBytes && cachedBytes.length > 0) {
               try {
                 console.log(`[PageAssembler] Loading PDF from cache for deleted file ${fileId}`);
-                const sourcePdf = await PDFDocument4.load(cachedBytes);
+                const sourcePdf = await PDFDocument5.load(cachedBytes);
                 loadedPdfs.set(fileId, sourcePdf);
               } catch (error) {
                 console.error(`Error loading cached PDF for file ${fileId}:`, error);
@@ -2318,7 +2898,7 @@ var PageAssembler = React7.forwardRef(
                 if (sourceInfoRef) {
                   const sourceInfoDict = sourcePdf.context.lookup(sourceInfoRef);
                   if (sourceInfoDict && typeof sourceInfoDict.get === "function") {
-                    const metadataObj = sourceInfoDict.get(PDFName3.of("SigniphiMetadata"));
+                    const metadataObj = sourceInfoDict.get(PDFName4.of("SigniphiMetadata"));
                     if (metadataObj) {
                       const metadataStr = metadataObj.toString();
                       let jsonStr = metadataStr;
@@ -2401,7 +2981,7 @@ var PageAssembler = React7.forwardRef(
           }
           console.log(`[PageAssembler] Total extracted fields: ${allExtractedFields.length}`);
           console.log(`[PageAssembler] Field names:`, allExtractedFields.map((f) => `${f.name} (page ${f.position.page})`));
-          const combinedDoc = await PDFDocument4.create();
+          const combinedDoc = await PDFDocument5.create();
           for (const file of state.files) {
             if (file.pages.length === 0) continue;
             for (const page of file.pages) {
@@ -2423,9 +3003,9 @@ var PageAssembler = React7.forwardRef(
                     const copiedPages = await combinedDoc.copyPages(sourcePdf, [page.srcIndex]);
                     copiedPages.forEach((copiedPage) => {
                       try {
-                        const annotsRef = copiedPage.node.get(PDFName3.of("Annots"));
+                        const annotsRef = copiedPage.node.get(PDFName4.of("Annots"));
                         if (annotsRef) {
-                          copiedPage.node.delete(PDFName3.of("Annots"));
+                          copiedPage.node.delete(PDFName4.of("Annots"));
                         }
                       } catch (annotError) {
                         console.warn("Could not remove annotations from copied page:", annotError);
@@ -2440,7 +3020,7 @@ var PageAssembler = React7.forwardRef(
               } else if (sourceFile.type === "image" && sourceFile.originalFile) {
                 try {
                   const imagePdfBytes = await imageToPdf(sourceFile.originalFile);
-                  const imagePdf = await PDFDocument4.load(imagePdfBytes);
+                  const imagePdf = await PDFDocument5.load(imagePdfBytes);
                   const copiedPages = await combinedDoc.copyPages(imagePdf, [0]);
                   copiedPages.forEach((copiedPage) => combinedDoc.addPage(copiedPage));
                 } catch (imageError) {
@@ -2457,8 +3037,8 @@ var PageAssembler = React7.forwardRef(
                 const newInfoDict = combinedDoc.context.lookup(newInfoRef);
                 if (newInfoDict && typeof newInfoDict.set === "function") {
                   newInfoDict.set(
-                    PDFName3.of("SigniphiMetadata"),
-                    PDFString3.of(JSON.stringify(mergedMetadata))
+                    PDFName4.of("SigniphiMetadata"),
+                    PDFString4.of(JSON.stringify(mergedMetadata))
                   );
                 }
               }
@@ -2544,6 +3124,10 @@ var PageAssembler = React7.forwardRef(
         /* @__PURE__ */ jsxRuntime.jsx("div", { className: "animate-spin rounded-full h-4 w-4 border-b-2 border-primary" }),
         /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm", children: processingStatus })
       ] }) }),
+      uploadError && !isLoading && /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4 border-destructive/50 bg-destructive/5", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "h-4 w-4 text-destructive flex-shrink-0" }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-destructive", children: uploadError })
+      ] }) }),
       /* @__PURE__ */ jsxRuntime.jsx(
         BulkActionBar,
         {
@@ -2682,14 +3266,21 @@ function debounce(func, wait) {
 exports.Button = Button;
 exports.FormFieldType = FormFieldType;
 exports.PageAssembler = PageAssembler;
+exports.PdfPasswordRequiredError = PdfPasswordRequiredError;
+exports.UnsupportedPdfEncryptionError = UnsupportedPdfEncryptionError;
 exports.addFormFieldsToPdf = addFormFieldsToPdf;
 exports.createPdfBlobUrl = createPdfBlobUrl;
+exports.decryptPdf = decryptPdf;
 exports.downloadPdf = downloadPdf;
 exports.extractFieldsFromPdf = extractFieldsFromPdf;
 exports.getSigniphiMetadata = getSigniphiMetadata;
 exports.imageToPdf = imageToPdf;
+exports.isEncryptedPdfError = isEncryptedPdfError;
 exports.mapFieldPositionsAfterAssembly = mapFieldPositionsAfterAssembly;
+exports.normalizePdfEncryption = normalizePdfEncryption;
+exports.normalizeUploadedPdfBytes = normalizeUploadedPdfBytes;
 exports.pdfToImages = pdfToImages;
+exports.rasterizePdfToPdf = rasterizePdfToPdf;
 exports.setSigniphiMetadata = setSigniphiMetadata;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map