@f-o-t/pdf 0.3.9 → 0.4.0

package/dist/index-35skpe4f.js

@@ -0,0 +1,920 @@
+// @bun
+// src/plugins/editing/parser.ts
+function findStartXref(pdfStr) {
+  const idx = pdfStr.lastIndexOf("startxref");
+  if (idx === -1)
+    throw new Error("Cannot find startxref in PDF");
+  const after = pdfStr.slice(idx + 9).trim().split(/[\r\n\s]/)[0];
+  return parseInt(after, 10);
+}
+function parseTrailer(pdfStr) {
+  const startxrefIdx = pdfStr.lastIndexOf("startxref");
+  const trailerIdx = pdfStr.lastIndexOf("trailer");
+  let dictStr;
+  if (trailerIdx !== -1 && trailerIdx < startxrefIdx) {
+    dictStr = pdfStr.slice(trailerIdx, startxrefIdx);
+  } else {
+    const xrefOffset = findStartXref(pdfStr);
+    const xrefObjStr = pdfStr.slice(xrefOffset, xrefOffset + 4096);
+    const dictStart = xrefObjStr.indexOf("<<");
+    if (dictStart === -1) {
+      throw new Error("Cannot find trailer or xref stream dictionary in PDF");
+    }
+    const dictEnd = findMatchingDictEnd(xrefObjStr, dictStart);
+    if (dictEnd === -1) {
+      throw new Error("Cannot find end of xref stream dictionary");
+    }
+    dictStr = xrefObjStr.slice(dictStart, dictEnd + 2);
+  }
+  const rootMatch = dictStr.match(/\/Root\s+(\d+)\s+\d+\s+R/);
+  if (!rootMatch)
+    throw new Error("Cannot find Root ref in trailer");
+  const sizeMatch = dictStr.match(/\/Size\s+(\d+)/);
+  if (!sizeMatch)
+    throw new Error("Cannot find Size in trailer");
+  const infoMatch = dictStr.match(/\/Info\s+(\d+)\s+\d+\s+R/);
+  const prevMatch = dictStr.match(/\/Prev\s+(\d+)/);
+  return {
+    root: parseInt(rootMatch[1], 10),
+    size: parseInt(sizeMatch[1], 10),
+    info: infoMatch ? parseInt(infoMatch[1], 10) : null,
+    prevXref: prevMatch ? parseInt(prevMatch[1], 10) : findStartXref(pdfStr)
+  };
+}
+function extractObjectDictContent(pdfStr, objNum) {
+  const objRegex = new RegExp(`(?:^|\\s)${objNum}\\s+0\\s+obj`, "m");
+  const match = pdfStr.match(objRegex);
+  if (!match || match.index === undefined) {
+    throw new Error(`Cannot find object ${objNum} in PDF`);
+  }
+  const searchStart = match.index + match[0].length;
+  const dictStart = pdfStr.indexOf("<<", searchStart);
+  if (dictStart === -1 || dictStart > searchStart + 200) {
+    throw new Error(`Cannot find dictionary start for object ${objNum}`);
+  }
+  const dictEnd = findMatchingDictEnd(pdfStr, dictStart);
+  if (dictEnd === -1) {
+    throw new Error(`Cannot find dictionary end for object ${objNum}`);
+  }
+  return pdfStr.slice(dictStart + 2, dictEnd);
+}
+function findPageObjects(pdfStr, rootNum) {
+  const rootContent = extractObjectDictContent(pdfStr, rootNum);
+  const pagesMatch = rootContent.match(/\/Pages\s+(\d+)\s+\d+\s+R/);
+  if (!pagesMatch)
+    throw new Error("Cannot find Pages ref in Root catalog");
+  const pagesNum = parseInt(pagesMatch[1], 10);
+  return collectPageLeafs(pdfStr, pagesNum, new Set);
+}
+function collectPageLeafs(pdfStr, objNum, visited) {
+  if (visited.has(objNum))
+    return [];
+  visited.add(objNum);
+  const content = extractObjectDictContent(pdfStr, objNum);
+  const typeMatch = content.match(/\/Type\s+\/(\w+)/);
+  if (typeMatch?.[1] === "Page") {
+    return [objNum];
+  }
+  const kidsMatch = content.match(/\/Kids\s*\[([^\]]+)\]/);
+  if (!kidsMatch) {
+    return [objNum];
+  }
+  const refs = [];
+  const refRegex = /(\d+)\s+\d+\s+R/g;
+  let m;
+  while ((m = refRegex.exec(kidsMatch[1])) !== null) {
+    refs.push(parseInt(m[1], 10));
+  }
+  const pages = [];
+  for (const ref of refs) {
+    pages.push(...collectPageLeafs(pdfStr, ref, visited));
+  }
+  return pages;
+}
+function getMediaBox(pdfStr, pageObjNum) {
+  const visited = new Set;
+  let objNum = pageObjNum;
+  while (objNum !== null && !visited.has(objNum)) {
+    visited.add(objNum);
+    const content = extractObjectDictContent(pdfStr, objNum);
+    const mediaBoxMatch = content.match(/\/MediaBox\s*\[\s*([\d.]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)\s*\]/);
+    if (mediaBoxMatch) {
+      return [
+        parseFloat(mediaBoxMatch[1]),
+        parseFloat(mediaBoxMatch[2]),
+        parseFloat(mediaBoxMatch[3]),
+        parseFloat(mediaBoxMatch[4])
+      ];
+    }
+    const parentMatch = content.match(/\/Parent\s+(\d+)\s+\d+\s+R/);
+    objNum = parentMatch ? parseInt(parentMatch[1], 10) : null;
+  }
+  throw new Error(`Cannot find MediaBox for page object ${pageObjNum}`);
+}
+function parsePdfStructure(pdfStr) {
+  const xrefOffset = findStartXref(pdfStr);
+  const trailer = parseTrailer(pdfStr);
+  const rootContent = extractObjectDictContent(pdfStr, trailer.root);
+  const pagesMatch = rootContent.match(/\/Pages\s+(\d+)\s+\d+\s+R/);
+  if (!pagesMatch)
+    throw new Error("Cannot find Pages ref in Root catalog");
+  const pagesNum = parseInt(pagesMatch[1], 10);
+  const pageNums = findPageObjects(pdfStr, trailer.root);
+  const pageDictContents = pageNums.map((pn) => extractObjectDictContent(pdfStr, pn));
+  return {
+    xrefOffset,
+    rootNum: trailer.root,
+    infoNum: trailer.info,
+    size: trailer.size,
+    pagesNum,
+    pageNums,
+    rootDictContent: rootContent,
+    pageDictContents
+  };
+}
+function findMatchingDictEnd(str, startPos) {
+  let depth = 0;
+  let i = startPos;
+  while (i < str.length - 1) {
+    if (str[i] === "(") {
+      i++;
+      while (i < str.length && str[i] !== ")") {
+        if (str[i] === "\\")
+          i++;
+        i++;
+      }
+      i++;
+    } else if (str[i] === "<" && str[i + 1] === "<") {
+      depth++;
+      i += 2;
+    } else if (str[i] === ">" && str[i + 1] === ">") {
+      depth--;
+      if (depth === 0)
+        return i;
+      i += 2;
+    } else {
+      i++;
+    }
+  }
+  return -1;
+}
+function findMatchingArrayEnd(str, startPos) {
+  let depth = 0;
+  let i = startPos;
+  while (i < str.length) {
+    if (str[i] === "(") {
+      i++;
+      while (i < str.length && str[i] !== ")") {
+        if (str[i] === "\\")
+          i++;
+        i++;
+      }
+      i++;
+    } else if (str[i] === "[") {
+      depth++;
+      i++;
+    } else if (str[i] === "]") {
+      depth--;
+      if (depth === 0)
+        return i;
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return -1;
+}
+function parseResourcesDict(pageContent, pdfStr) {
+  const result = {};
+  const inlineMatch = pageContent.match(/\/Resources\s*<</);
+  if (inlineMatch) {
+    const resIdx = pageContent.indexOf("/Resources");
+    const resStart = pageContent.indexOf("<<", resIdx);
+    const resEnd = findMatchingDictEnd(pageContent, resStart);
+    if (resEnd === -1) {
+      throw new Error("Cannot find end of Resources dictionary");
+    }
+    const resContent = pageContent.slice(resStart + 2, resEnd);
+    return parseResourceEntries(resContent);
+  }
+  const refMatch = pageContent.match(/\/Resources\s+(\d+)\s+\d+\s+R/);
+  if (refMatch) {
+    const objNum = parseInt(refMatch[1], 10);
+    const objContent = extractObjectDictContent(pdfStr, objNum);
+    return parseResourceEntries(objContent);
+  }
+  return result;
+}
+function mergeResourcesDicts(existing, additions) {
+  const result = { ...existing };
+  for (const [resType, addValue] of Object.entries(additions)) {
+    if (!result[resType]) {
+      result[resType] = addValue;
+      continue;
+    }
+    const existingValue = result[resType];
+    if (existingValue.startsWith("[")) {
+      continue;
+    }
+    if (existingValue.startsWith("<<")) {
+      result[resType] = mergeDictEntries(existingValue, addValue);
+    } else {
+      throw new Error(`Unexpected resource format for ${resType}: ${existingValue}`);
+    }
+  }
+  return result;
+}
+function mergeDictEntries(existing, additions) {
+  const existingEntries = extractDictEntries(existing);
+  const additionEntries = extractDictEntries(additions);
+  const merged = { ...existingEntries, ...additionEntries };
+  const entries = Object.entries(merged).map(([name, ref]) => `${name} ${ref}`).join(" ");
+  return `<< ${entries} >>`;
+}
+function extractDictEntries(dict) {
+  const entries = {};
+  const inner = dict.replace(/^<<\s*/, "").replace(/\s*>>$/, "");
+  const regex = /(\/[^\s<>\[\]()\/]+)\s+(\d+\s+\d+\s+R)/g;
+  let match;
+  while ((match = regex.exec(inner)) !== null) {
+    entries[match[1]] = match[2];
+  }
+  return entries;
+}
+function parseResourceEntries(content) {
+  const result = {};
+  const resourceTypes = [
+    "/Font",
+    "/XObject",
+    "/ExtGState",
+    "/ColorSpace",
+    "/Pattern",
+    "/Shading",
+    "/ProcSet"
+  ];
+  for (const resType of resourceTypes) {
+    const pattern = new RegExp(`${resType.replace(/\//g, "\\/")}\\s+([<\\[])`);
+    const match = content.match(pattern);
+    if (!match)
+      continue;
+    const idx = match.index;
+    let valueStart = idx + resType.length;
+    while (valueStart < content.length && /\s/.test(content[valueStart])) {
+      valueStart++;
+    }
+    if (content[valueStart] === "<" && content[valueStart + 1] === "<") {
+      const dictEnd = findMatchingDictEnd(content, valueStart);
+      if (dictEnd === -1) {
+        throw new Error(`Cannot find end of ${resType} dictionary`);
+      }
+      result[resType] = content.slice(valueStart, dictEnd + 2);
+    } else if (content[valueStart] === "[") {
+      const arrayEnd = findMatchingArrayEnd(content, valueStart);
+      if (arrayEnd === -1) {
+        throw new Error(`Cannot find end of ${resType} array`);
+      }
+      result[resType] = content.slice(valueStart, arrayEnd + 1);
+    }
+  }
+  return result;
+}
+
+// src/plugins/editing/page.ts
+function parseHexColor(hex) {
+  if (!hex)
+    return null;
+  const m = hex.match(/^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/);
+  if (!m)
+    return null;
+  return [
+    parseInt(m[1], 16) / 255,
+    parseInt(m[2], 16) / 255,
+    parseInt(m[3], 16) / 255
+  ];
+}
+
+class PdfPageImpl {
+  width;
+  height;
+  pageObjNum;
+  originalDictContent;
+  operators = [];
+  imageRefs = new Map;
+  fontObjNum = 0;
+  get dirty() {
+    return this.operators.length > 0;
+  }
+  constructor(pageObjNum, width, height, originalDictContent) {
+    this.pageObjNum = pageObjNum;
+    this.width = width;
+    this.height = height;
+    this.originalDictContent = originalDictContent;
+  }
+  drawText(text, options) {
+    const { x, y, size = 12, color } = options;
+    const rgb = parseHexColor(color);
+    if (rgb) {
+      this.operators.push(`${rgb[0].toFixed(3)} ${rgb[1].toFixed(3)} ${rgb[2].toFixed(3)} rg`);
+    }
+    const escaped = text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+    this.operators.push("BT");
+    this.operators.push(`/F1 ${size} Tf`);
+    this.operators.push(`${x} ${y} Td`);
+    this.operators.push(`(${escaped}) Tj`);
+    this.operators.push("ET");
+  }
+  drawRectangle(options) {
+    const { x, y, width, height, color, borderColor, borderWidth } = options;
+    const fillRgb = parseHexColor(color);
+    const strokeRgb = parseHexColor(borderColor);
+    if (fillRgb) {
+      this.operators.push(`${fillRgb[0].toFixed(3)} ${fillRgb[1].toFixed(3)} ${fillRgb[2].toFixed(3)} rg`);
+    }
+    if (strokeRgb) {
+      this.operators.push(`${strokeRgb[0].toFixed(3)} ${strokeRgb[1].toFixed(3)} ${strokeRgb[2].toFixed(3)} RG`);
+    }
+    if (borderWidth !== undefined) {
+      this.operators.push(`${borderWidth} w`);
+    }
+    this.operators.push(`${x} ${y} ${width} ${height} re`);
+    if (fillRgb && strokeRgb) {
+      this.operators.push("B");
+    } else if (fillRgb) {
+      this.operators.push("f");
+    } else if (strokeRgb) {
+      this.operators.push("S");
+    } else {
+      this.operators.push("f");
+    }
+  }
+  drawImage(image, options) {
+    const { x, y, width, height } = options;
+    const imgName = `Im${image.objectNumber}`;
+    this.imageRefs.set(imgName, image.objectNumber);
+    this.operators.push("q");
+    this.operators.push(`${width} 0 0 ${height} ${x} ${y} cm`);
+    this.operators.push(`/${imgName} Do`);
+    this.operators.push("Q");
+  }
+  buildContentStream() {
+    const content = this.operators.join(`
+`);
+    return new TextEncoder().encode(content);
+  }
+  getImageRefs() {
+    return new Map(this.imageRefs);
+  }
+}
+
+// src/plugins/editing/document.ts
+var BYTE_RANGE_PLACEHOLDER = "0 0000000000 0000000000 0000000000";
+var DEFAULT_SIGNATURE_LENGTH = 16384;
+var latin1Encoder = new TextEncoder;
+var latin1Decoder = new TextDecoder("latin1");
+var CONTENTS_MARKER = latin1Encoder.encode("/Contents <");
+var BYTE_RANGE_MARKER = latin1Encoder.encode("/ByteRange [");
+function findLastBytes(data, pattern) {
+  outer:
+    for (let i = data.length - pattern.length;i >= 0; i--) {
+      for (let j = 0;j < pattern.length; j++) {
+        if (data[i + j] !== pattern[j])
+          continue outer;
+      }
+      return i;
+    }
+  return -1;
+}
+function parsePngIhdr(data) {
+  const sig = [137, 80, 78, 71, 13, 10, 26, 10];
+  for (let i = 0;i < sig.length; i++) {
+    if (data[i] !== sig[i])
+      throw new Error("Not a valid PNG file");
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const chunkType = latin1Decoder.decode(data.slice(12, 16));
+  if (chunkType !== "IHDR")
+    throw new Error("First PNG chunk is not IHDR");
+  return {
+    width: view.getUint32(16),
+    height: view.getUint32(20),
+    bitDepth: data[24],
+    colorType: data[25]
+  };
+}
+function extractIdatData(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const chunks = [];
+  let offset = 8;
+  while (offset < data.length) {
+    const chunkLen = view.getUint32(offset);
+    const chunkType = latin1Decoder.decode(data.slice(offset + 4, offset + 8));
+    if (chunkType === "IDAT") {
+      chunks.push(data.slice(offset + 8, offset + 8 + chunkLen));
+    }
+    offset += 12 + chunkLen;
+  }
+  if (chunks.length === 0)
+    throw new Error("No IDAT chunks found in PNG");
+  const totalLen = chunks.reduce((s, c) => s + c.length, 0);
+  const result = new Uint8Array(totalLen);
+  let pos = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, pos);
+    pos += chunk.length;
+  }
+  return result;
+}
+
+class PdfDocumentImpl {
+  originalData;
+  pdfStr;
+  structure;
+  pages = [];
+  nextObjNum;
+  fontObjNum;
+  embeddedImages = [];
+  constructor(data) {
+    this.originalData = data;
+    this.pdfStr = latin1Decoder.decode(data);
+    this.structure = parsePdfStructure(this.pdfStr);
+    this.nextObjNum = this.structure.size;
+    this.fontObjNum = this.nextObjNum++;
+    for (let i = 0;i < this.structure.pageNums.length; i++) {
+      const pageNum = this.structure.pageNums[i];
+      const mediaBox = getMediaBox(this.pdfStr, pageNum);
+      const width = mediaBox[2] - mediaBox[0];
+      const height = mediaBox[3] - mediaBox[1];
+      const dictContent = this.structure.pageDictContents[i];
+      const page = new PdfPageImpl(pageNum, width, height, dictContent);
+      page.fontObjNum = this.fontObjNum;
+      this.pages.push(page);
+    }
+  }
+  get pageCount() {
+    return this.pages.length;
+  }
+  getPage(index) {
+    if (index < 0 || index >= this.pages.length) {
+      throw new Error(`Page index ${index} out of range (0-${this.pages.length - 1})`);
+    }
+    return this.pages[index];
+  }
+  embedPng(data) {
+    const ihdr = parsePngIhdr(data);
+    const idatData = extractIdatData(data);
+    const objNum = this.nextObjNum++;
+    this.embeddedImages.push({
+      objNum,
+      width: ihdr.width,
+      height: ihdr.height,
+      idatData,
+      colorType: ihdr.colorType,
+      bitDepth: ihdr.bitDepth
+    });
+    return {
+      objectNumber: objNum,
+      width: ihdr.width,
+      height: ihdr.height
+    };
+  }
+  save() {
+    return this.buildIncrementalUpdate(false).pdf;
+  }
+  saveWithPlaceholder(options) {
+    return this.buildIncrementalUpdate(true, options);
+  }
+  buildIncrementalUpdate(withSignature, sigOptions) {
+    const objects = [];
+    let currentNextObj = this.nextObjNum;
+    const anyDirty = this.pages.some((p) => p.dirty);
+    if (anyDirty || this.embeddedImages.length > 0) {
+      objects.push({
+        objNum: this.fontObjNum,
+        content: "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"
+      });
+    }
+    for (const img of this.embeddedImages) {
+      const colorSpace = img.colorType === 2 ? "/DeviceRGB" : img.colorType === 0 ? "/DeviceGray" : "/DeviceRGB";
+      const colors = img.colorType === 2 ? 3 : 1;
+      const bpc = img.bitDepth;
+      objects.push({
+        objNum: img.objNum,
+        content: [
+          "<< /Type /XObject",
+          "/Subtype /Image",
+          `/Width ${img.width}`,
+          `/Height ${img.height}`,
+          `/ColorSpace ${colorSpace}`,
+          `/BitsPerComponent ${bpc}`,
+          "/Filter /FlateDecode",
+          `/DecodeParms << /Predictor 15 /Colors ${colors} /BitsPerComponent ${bpc} /Columns ${img.width} >>`,
+          `/Length ${img.idatData.length}`,
+          ">>"
+        ].join(`
+`),
+        streamData: img.idatData
+      });
+    }
+    const wrapperStreamMap = new Map;
+    const contentStreamMap = new Map;
+    for (const page of this.pages) {
+      if (!page.dirty)
+        continue;
+      const wrapperObjNum = currentNextObj++;
+      wrapperStreamMap.set(page.pageObjNum, wrapperObjNum);
+      const wrapperData = latin1Encoder.encode("q");
+      objects.push({
+        objNum: wrapperObjNum,
+        content: `<< /Length ${wrapperData.length} >>`,
+        streamData: wrapperData
+      });
+      const contentObjNum = currentNextObj++;
+      contentStreamMap.set(page.pageObjNum, contentObjNum);
+      const pageStreamData = page.buildContentStream();
+      const prefixedData = new Uint8Array(2 + pageStreamData.length);
+      prefixedData[0] = 81;
+      prefixedData[1] = 10;
+      prefixedData.set(pageStreamData, 2);
+      objects.push({
+        objNum: contentObjNum,
+        content: `<< /Length ${prefixedData.length} >>`,
+        streamData: prefixedData
+      });
+    }
+    for (const page of this.pages) {
+      if (!page.dirty && !this.hasImagesForPage(page))
+        continue;
+      let pageContent = page.originalDictContent;
+      if (page.dirty) {
+        const contentObjNum = contentStreamMap.get(page.pageObjNum);
+        const wrapperObjNum = wrapperStreamMap.get(page.pageObjNum);
+        if (pageContent.match(/\/Contents\s/)) {
+          pageContent = pageContent.replace(/\/Contents\s+(\d+\s+\d+\s+R)/, `/Contents [${wrapperObjNum} 0 R $1 ${contentObjNum} 0 R]`);
+          pageContent = pageContent.replace(/\/Contents\s*\[([^\]]+)\]/, (match, inner) => {
+            if (inner.includes(`${contentObjNum} 0 R`))
+              return match;
+            return `/Contents [${wrapperObjNum} 0 R ${inner.trim()} ${contentObjNum} 0 R]`;
+          });
+        } else {
+          pageContent += `
+/Contents ${contentObjNum} 0 R`;
+        }
+      }
+      const newResourceParts = [];
+      newResourceParts.push(`/Font << /F1 ${this.fontObjNum} 0 R >>`);
+      const imageRefs = page.dirty ? page.getImageRefs() : new Map;
+      if (imageRefs.size > 0) {
+        const xobjEntries = Array.from(imageRefs.entries()).map(([name, objNum]) => `/${name} ${objNum} 0 R`).join(" ");
+        newResourceParts.push(`/XObject << ${xobjEntries} >>`);
+      }
+      const newResources = {};
+      for (const part of newResourceParts) {
+        const [resType, ...rest] = part.split(/\s+/);
+        if (resType) {
+          newResources[resType] = rest.join(" ");
+        }
+      }
+      const existingResources = parseResourcesDict(pageContent, this.pdfStr);
+      const mergedResources = mergeResourcesDicts(existingResources, newResources);
+      const resourceEntries = Object.entries(mergedResources).map(([name, value]) => `${name} ${value}`).join(`
+`);
+      if (pageContent.match(/\/Resources\s*<</)) {
+        const resIdx = pageContent.indexOf("/Resources");
+        const resStart = pageContent.indexOf("<<", resIdx);
+        if (resStart !== -1) {
+          const resEnd = findMatchingDictEndInContent(pageContent, resStart);
+          if (resEnd !== -1) {
+            pageContent = pageContent.slice(0, resStart) + `<< ${resourceEntries} >>` + pageContent.slice(resEnd + 2);
+          }
+        }
+      } else if (pageContent.match(/\/Resources\s+\d+\s+\d+\s+R/)) {
+        pageContent = pageContent.replace(/\/Resources\s+\d+\s+\d+\s+R/, `/Resources << ${resourceEntries} >>`);
+      } else {
+        pageContent += `
+/Resources << ${resourceEntries} >>`;
+      }
+      objects.push({
+        objNum: page.pageObjNum,
+        content: `<<${pageContent}
+>>`
+      });
+    }
+    let sigObjNum = 0;
+    let widgetObjNum = 0;
+    let acroFormObjNum = 0;
+    if (withSignature && sigOptions) {
+      sigObjNum = currentNextObj++;
+      widgetObjNum = currentNextObj++;
+      acroFormObjNum = currentNextObj++;
+      const signatureLength = sigOptions.signatureLength ?? DEFAULT_SIGNATURE_LENGTH;
+      const reason = sigOptions.reason ?? "Digitally signed";
+      const name = sigOptions.name ?? "Digital Signature";
+      const location = sigOptions.location ?? "";
+      const contactInfo = sigOptions.contactInfo ?? "";
+      const signingTime = formatPdfDate(new Date);
+      const contentsPlaceholder = "0".repeat(signatureLength * 2);
+      const sigParts = [
+        "<< /Type /Sig",
+        "/Filter /Adobe.PPKLite",
+        "/SubFilter /adbe.pkcs7.detached",
+        `/ByteRange [${BYTE_RANGE_PLACEHOLDER}]`,
+        `/Contents <${contentsPlaceholder}>`,
+        `/Reason ${pdfString(reason)}`,
+        `/M ${pdfString(signingTime)}`,
+        `/Name ${pdfString(name)}`
+      ];
+      if (location)
+        sigParts.push(`/Location ${pdfString(location)}`);
+      if (contactInfo)
+        sigParts.push(`/ContactInfo ${pdfString(contactInfo)}`);
+      sigParts.push(">>");
+      objects.push({ objNum: sigObjNum, content: sigParts.join(`
+`) });
+      const sigPageIdx = Math.min(Math.max(sigOptions.appearancePage ?? 0, 0), this.pages.length - 1);
+      const sigPageNum = this.structure.pageNums[sigPageIdx];
+      objects.push({
+        objNum: widgetObjNum,
+        content: [
+          "<< /Type /Annot",
+          "/Subtype /Widget",
+          "/FT /Sig",
+          "/Rect [0 0 0 0]",
+          `/V ${sigObjNum} 0 R`,
+          `/T ${pdfString("Signature1")}`,
+          "/F 4",
+          `/P ${sigPageNum} 0 R`,
+          ">>"
+        ].join(`
+`)
+      });
+      objects.push({
+        objNum: acroFormObjNum,
+        content: [
+          "<< /Type /AcroForm",
+          "/SigFlags 3",
+          `/Fields [${widgetObjNum} 0 R]`,
+          ">>"
+        ].join(`
+`)
+      });
+      let rootContent = this.structure.rootDictContent;
+      rootContent = rootContent.replace(/\/AcroForm\s+\d+\s+\d+\s+R/g, "");
+      rootContent = rootContent.replace(/\/Perms\s*<<[^>]*>>/g, "");
+      rootContent = rootContent.replace(/\/Perms\s+\d+\s+\d+\s+R/g, "");
+      objects.push({
+        objNum: this.structure.rootNum,
+        content: `<<${rootContent}
+/AcroForm ${acroFormObjNum} 0 R
+>>`
+      });
+      const sigPage = this.pages[sigPageIdx];
+      let pageContent;
+      const existingPageObj = objects.find((o) => o.objNum === sigPage.pageObjNum);
+      if (existingPageObj) {
+        pageContent = existingPageObj.content.slice(2, existingPageObj.content.length - 2);
+      } else {
+        pageContent = sigPage.originalDictContent;
+      }
+      if (pageContent.includes("/Annots")) {
+        const bracketEnd = pageContent.indexOf("]", pageContent.indexOf("/Annots"));
+        pageContent = pageContent.slice(0, bracketEnd) + ` ${widgetObjNum} 0 R` + pageContent.slice(bracketEnd);
+      } else {
+        pageContent += `
+/Annots [${widgetObjNum} 0 R]`;
+      }
+      if (existingPageObj) {
+        existingPageObj.content = `<<${pageContent}
+>>`;
+      } else {
+        objects.push({
+          objNum: sigPage.pageObjNum,
+          content: `<<${pageContent}
+>>`
+        });
+      }
+    }
+    const newSize = currentNextObj;
+    const appendParts = [];
+    const objectOffsets = [];
+    let currentOffset = this.originalData.length;
+    for (const obj of objects) {
+      const sep = latin1Encoder.encode(`
+`);
+      appendParts.push(sep);
+      currentOffset += sep.length;
+      objectOffsets.push({ objNum: obj.objNum, offset: currentOffset });
+      if (obj.streamData) {
+        const header = latin1Encoder.encode(`${obj.objNum} 0 obj
+${obj.content}
+stream
+`);
+        appendParts.push(header);
+        currentOffset += header.length;
+        appendParts.push(obj.streamData);
+        currentOffset += obj.streamData.length;
+        const footer = latin1Encoder.encode(`
+endstream
+endobj
+`);
+        appendParts.push(footer);
+        currentOffset += footer.length;
+      } else {
+        const objBytes = latin1Encoder.encode(`${obj.objNum} 0 obj
+${obj.content}
+endobj
+`);
+        appendParts.push(objBytes);
+        currentOffset += objBytes.length;
+      }
+    }
+    const xrefOffset = currentOffset;
+    const xrefStr = buildXrefTable(objectOffsets);
+    const xrefBytes = latin1Encoder.encode(xrefStr);
+    appendParts.push(xrefBytes);
+    currentOffset += xrefBytes.length;
+    const trailerLines = ["<<", `/Size ${newSize}`, `/Root ${this.structure.rootNum} 0 R`];
+    if (this.structure.infoNum !== null) {
+      trailerLines.push(`/Info ${this.structure.infoNum} 0 R`);
+    }
+    trailerLines.push(`/Prev ${this.structure.xrefOffset}`, ">>");
+    const trailerStr = `trailer
+${trailerLines.join(`
+`)}
+startxref
+${xrefOffset}
+%%EOF`;
+    const trailerBytes = latin1Encoder.encode(trailerStr);
+    appendParts.push(trailerBytes);
+    const totalAppendLength = appendParts.reduce((s, p) => s + p.length, 0);
+    const result = new Uint8Array(this.originalData.length + totalAppendLength);
+    result.set(this.originalData, 0);
+    let pos = this.originalData.length;
+    for (const part of appendParts) {
+      result.set(part, pos);
+      pos += part.length;
+    }
+    let byteRange = [0, 0, 0, 0];
+    if (withSignature) {
+      const br = updateByteRangeInPlace(result);
+      return { pdf: result, byteRange: br };
+    }
+    return { pdf: result, byteRange };
+  }
+  hasImagesForPage(page) {
+    return page.dirty && page.getImageRefs().size > 0;
+  }
+}
+function buildXrefTable(entries) {
+  const sorted = [...entries].sort((a, b) => a.objNum - b.objNum);
+  const subsections = [];
+  for (const entry of sorted) {
+    const last = subsections[subsections.length - 1];
+    if (last && entry.objNum === last.start + last.offsets.length) {
+      last.offsets.push(entry.offset);
+    } else {
+      subsections.push({ start: entry.objNum, offsets: [entry.offset] });
+    }
+  }
+  let result = `xref
+`;
+  for (const sub of subsections) {
+    result += `${sub.start} ${sub.offsets.length}
+`;
+    for (const offset of sub.offsets) {
+      result += `${String(offset).padStart(10, "0")} 00000 n 
+`;
+    }
+  }
+  return result;
+}
+function formatPdfDate(date) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  const h = String(date.getUTCHours()).padStart(2, "0");
+  const min = String(date.getUTCMinutes()).padStart(2, "0");
+  const s = String(date.getUTCSeconds()).padStart(2, "0");
+  return `D:${y}${m}${d}${h}${min}${s}Z`;
+}
+function pdfString(str) {
+  const escaped = str.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+  return `(${escaped})`;
+}
+function updateByteRangeInPlace(pdf) {
+  const contentsIdx = findLastBytes(pdf, CONTENTS_MARKER);
+  if (contentsIdx === -1)
+    throw new Error("Cannot find Contents in signature");
+  const contentsStart = contentsIdx + CONTENTS_MARKER.length;
+  let contentsEnd = contentsStart;
+  while (contentsEnd < pdf.length && pdf[contentsEnd] !== 62)
+    contentsEnd++;
+  if (contentsEnd >= pdf.length)
+    throw new Error("Cannot find end of Contents hex");
+  const br = [
+    0,
+    contentsStart - 1,
+    contentsEnd + 1,
+    pdf.length - (contentsEnd + 1)
+  ];
+  const brIdx = findLastBytes(pdf, BYTE_RANGE_MARKER);
+  if (brIdx === -1)
+    throw new Error("Cannot find ByteRange in PDF");
+  const brStart = brIdx + BYTE_RANGE_MARKER.length;
+  let brEnd = brStart;
+  while (brEnd < pdf.length && pdf[brEnd] !== 93)
+    brEnd++;
+  if (brEnd >= pdf.length)
+    throw new Error("Cannot find end of ByteRange");
+  const placeholderLen = brEnd - brStart;
+  const brValueStr = `${br[0]} ${br[1]} ${br[2]} ${br[3]}`.padEnd(placeholderLen, " ");
+  pdf.set(latin1Encoder.encode(brValueStr), brStart);
+  return br;
+}
+function findMatchingDictEndInContent(str, startPos) {
+  let depth = 0;
+  let i = startPos;
+  while (i < str.length - 1) {
+    if (str[i] === "(") {
+      i++;
+      while (i < str.length && str[i] !== ")") {
+        if (str[i] === "\\")
+          i++;
+        i++;
+      }
+      i++;
+    } else if (str[i] === "<" && str[i + 1] === "<") {
+      depth++;
+      i += 2;
+    } else if (str[i] === ">" && str[i + 1] === ">") {
+      depth--;
+      if (depth === 0)
+        return i;
+      i += 2;
+    } else {
+      i++;
+    }
+  }
+  return -1;
+}
+function findByteRange(pdfData) {
+  const contentsIdx = findLastBytes(pdfData, CONTENTS_MARKER);
+  if (contentsIdx === -1)
+    throw new Error("Could not find Contents in PDF");
+  const contentsStart = contentsIdx + CONTENTS_MARKER.length;
+  let contentsEnd = contentsStart;
+  while (contentsEnd < pdfData.length && pdfData[contentsEnd] !== 62)
+    contentsEnd++;
+  if (contentsEnd >= pdfData.length)
+    throw new Error("Could not find end of Contents field");
+  const placeholderLength = contentsEnd - contentsStart;
+  const byteRange = [
+    0,
+    contentsStart - 1,
+    contentsEnd + 1,
+    pdfData.length - (contentsEnd + 1)
+  ];
+  return { byteRange, contentsStart, contentsEnd, placeholderLength };
+}
+function extractBytesToSign(pdfData, byteRange) {
+  const [offset1, length1, offset2, length2] = byteRange;
+  if (offset1 < 0 || length1 <= 0 || offset2 <= 0 || length2 <= 0) {
+    throw new Error(`Invalid ByteRange values: [${byteRange.join(", ")}]`);
+  }
+  if (offset1 + length1 > pdfData.length || offset2 + length2 > pdfData.length) {
+    throw new Error("ByteRange exceeds PDF data size");
+  }
+  const chunk1 = pdfData.subarray(offset1, offset1 + length1);
+  const chunk2 = pdfData.subarray(offset2, offset2 + length2);
+  const result = new Uint8Array(chunk1.length + chunk2.length);
+  result.set(chunk1, 0);
+  result.set(chunk2, chunk1.length);
+  return result;
+}
+function embedSignature(pdfData, signature) {
+  const { contentsStart, placeholderLength } = findByteRange(pdfData);
+  const hexChars = [];
+  for (let i = 0;i < signature.length; i++) {
+    hexChars.push(signature[i].toString(16).padStart(2, "0"));
+  }
+  const signatureHex = hexChars.join("");
+  if (signatureHex.length > placeholderLength) {
+    throw new Error(`Signature too large: ${signatureHex.length} hex chars, placeholder is ${placeholderLength}`);
+  }
+  const paddedHex = signatureHex.padEnd(placeholderLength, "0");
+  const hexBytes = new TextEncoder().encode(paddedHex);
+  pdfData.set(hexBytes, contentsStart);
+  return pdfData;
+}
+// src/plugins/editing/index.ts
+function loadPdf(data) {
+  return new PdfDocumentImpl(data);
+}
+function countPdfPages(data) {
+  const pdfStr = new TextDecoder("latin1").decode(data);
+  const structure = parsePdfStructure(pdfStr);
+  return structure.pageNums.length;
+}
+
+export { PdfDocumentImpl, findByteRange, extractBytesToSign, embedSignature, loadPdf, countPdfPages };
+
+//# debugId=C149D920AE5494F964756E2164756E21