av6-pdf-engine 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -0,0 +1,1940 @@
+// src/renderer-engine/index.ts
+import fs from "fs";
+import PDFDocument from "pdfkit";
+
+// src/renderer-engine/blocks/barcode.ts
+var processBarcodeBlock = (doc, ctx, block, y, env, ensureSpaceFor) => {
+  const imgSource = block.src;
+  const imgWidth = block.width ?? 120;
+  const imgHeight = block.height ?? 40;
+  const localLeft = block.marginLeft ?? 0;
+  const localRight = block.marginRight ?? 0;
+  const baseLeft = env.marginLeft + localLeft;
+  const availableWidth = Math.max(env.innerWidth - localLeft - localRight, 1);
+  const mt = block.marginTop ?? 0;
+  const mb = block.marginBottom ?? 0;
+  const baseY = y ?? ctx.currentY;
+  const startY = baseY + mt;
+  const heightNeeded = mt + imgHeight + mb;
+  if (y === null) {
+    ensureSpaceFor(heightNeeded, env);
+  }
+  let x = baseLeft;
+  if (block.align === "center") {
+    x = baseLeft + (availableWidth - imgWidth) / 2;
+  } else if (block.align === "right") {
+    x = baseLeft + availableWidth - imgWidth;
+  }
+  const rotation = typeof block.rotate === "number" ? block.rotate : block.orientation === "vertical" ? 90 : 0;
+  try {
+    drawRotatedImage(doc, imgSource, x, startY, imgWidth, imgHeight, rotation);
+  } catch (e) {
+    console.warn("Failed to load barcode image:", e);
+  }
+  const newY = startY + imgHeight + mb;
+  if (y === null) ctx.currentY = newY;
+  return newY;
+};
+
+// src/renderer-engine/blocks/columns.ts
+var processColumnsBlock = (ctx, block, y, env, computeColumnPixelWidths2, renderBlock, ensureSpaceFor, measureBlockHeight) => {
+  const blockLeft = block.marginLeft ?? 0;
+  const blockRight = block.marginRight ?? 0;
+  const baseLeft = env.marginLeft + blockLeft;
+  const totalWidth = Math.max(env.innerWidth - blockLeft - blockRight, 1);
+  const mt = block.marginTop ?? 0;
+  const mb = block.marginBottom ?? 0;
+  const cols = block.columns ?? [];
+  const n = cols.length;
+  if (!n) {
+    const baseY0 = y ?? ctx.currentY;
+    const endY = baseY0 + mt + mb;
+    if (y === null) ctx.currentY = endY;
+    return endY;
+  }
+  let colWidths;
+  const mode = block.mode ?? "fixedGap";
+  let gap;
+  if (mode === "spaceBetween" && n > 1) {
+    if (block.widths && block.widths.length === n) {
+      colWidths = computeColumnPixelWidths2(block.widths, totalWidth);
+    } else {
+      colWidths = Array(n).fill(totalWidth / n);
+    }
+    const totalColsWidth = colWidths.reduce((a, b) => a + b, 0);
+    const remaining = Math.max(totalWidth - totalColsWidth, 0);
+    gap = remaining / (n - 1);
+  } else {
+    gap = block.gap ?? 20;
+    const totalGapsWidth = gap * (n - 1);
+    const widthForCols = Math.max(totalWidth - totalGapsWidth, 1);
+    if (block.widths && block.widths.length === n) {
+      colWidths = computeColumnPixelWidths2(block.widths, widthForCols);
+    } else {
+      colWidths = Array(n).fill(widthForCols / n);
+    }
+  }
+  const xBases = [];
+  {
+    let x = baseLeft;
+    for (let i = 0; i < n; i++) {
+      xBases.push(x);
+      x += colWidths[i] + (i < n - 1 ? gap : 0);
+    }
+  }
+  const measureColHeights = [];
+  for (let colIndex = 0; colIndex < n; colIndex++) {
+    const colEnvMeasure = {
+      marginLeft: 0,
+      innerWidth: colWidths[colIndex],
+      allowPageBreak: false
+      // measure as keep-together
+    };
+    let h = 0;
+    for (const b of cols[colIndex]) {
+      if (b.visible === false) continue;
+      h += measureBlockHeight(b, colEnvMeasure);
+    }
+    measureColHeights.push(h);
+  }
+  const maxColHeight = Math.max(...measureColHeights, 0);
+  const totalHeightNeeded = mt + maxColHeight + mb;
+  if (y === null) {
+    ensureSpaceFor(totalHeightNeeded, env);
+  }
+  const baseY = y ?? ctx.currentY;
+  const startY = baseY + mt;
+  const heights = [];
+  for (let colIndex = 0; colIndex < n; colIndex++) {
+    const colEnv = {
+      marginLeft: xBases[colIndex],
+      innerWidth: colWidths[colIndex],
+      allowPageBreak: false
+      // keep whole column block intact on one page
+    };
+    let colY = startY;
+    for (const b of cols[colIndex]) {
+      if (b.visible === false) continue;
+      colY = renderBlock(b, colY, colEnv);
+    }
+    heights.push(colY - startY);
+  }
+  const maxHeight = Math.max(...heights, 0);
+  const newY = startY + maxHeight + mb;
+  if (y === null) ctx.currentY = newY;
+  return newY;
+};
+
+// src/renderer-engine/blocks/image.ts
+var drawRotatedImage = (doc, src, x, y, width, height, rotationDeg) => {
+  if (!rotationDeg) {
+    doc.image(src, x, y, { width, height });
+    return;
+  }
+  const cx = x + width / 2;
+  const cy = y + height / 2;
+  doc.save();
+  doc.rotate(rotationDeg, { origin: [cx, cy] });
+  doc.image(src, x, y, { width, height });
+  doc.restore();
+};
+var processImageBlock = (doc, ctx, block, y, env, ensureSpaceFor) => {
+  const imgSource = block.src;
+  const imgWidth = block.width ?? 80;
+  const imgHeight = block.height ?? 50;
+  const localLeft = block.marginLeft ?? 0;
+  const localRight = block.marginRight ?? 0;
+  const baseLeft = env.marginLeft + localLeft;
+  const availableWidth = Math.max(env.innerWidth - localLeft - localRight, 1);
+  const mt = block.marginTop ?? 0;
+  const mb = block.marginBottom ?? 0;
+  const baseY = y ?? ctx.currentY;
+  const startY = baseY + mt;
+  const heightNeeded = mt + imgHeight + mb;
+  if (y === null) {
+    ensureSpaceFor(heightNeeded, env);
+  }
+  let x = baseLeft;
+  if (block.align === "center") {
+    x = baseLeft + (availableWidth - imgWidth) / 2;
+  } else if (block.align === "right") {
+    x = baseLeft + availableWidth - imgWidth;
+  }
+  try {
+    doc.image(imgSource, x, startY, {
+      width: imgWidth,
+      height: imgHeight
+    });
+  } catch (e) {
+    console.warn("Failed to load image:", e);
+  }
+  const newY = startY + imgHeight + mb;
+  if (y === null) ctx.currentY = newY;
+  return newY;
+};
+
+// src/renderer-engine/blocks/key-value-grid.ts
+var processKeyValueGridBlock = (doc, ctx, styles, block, y, env, computeColumnPixelWidths2, ensureSpaceFor) => {
+  const mt = block.marginTop ?? 0;
+  const mb = block.marginBottom ?? 0;
+  const rowGap = block.rowGap ?? 4;
+  const orientation = block.orientation ?? "horizontal";
+  const cols = block.columns ?? [];
+  const colCount = cols.length;
+  if (!colCount) {
+    const baseY2 = y ?? ctx.currentY;
+    const endY2 = baseY2 + mt + mb;
+    if (y === null) ctx.currentY = endY2;
+    return endY2;
+  }
+  const blockLeft = block.marginLeft ?? 0;
+  const blockRight = block.marginRight ?? 0;
+  const baseLeft = env.marginLeft + blockLeft;
+  const totalWidth = Math.max(env.innerWidth - blockLeft - blockRight, 1);
+  const columnGap = block.columnGap ?? 30;
+  const totalGapWidth = columnGap * (colCount - 1);
+  const widthForCols = Math.max(totalWidth - totalGapWidth, 1);
+  let colWidths;
+  if (block.columnWidths && block.columnWidths.length === colCount) {
+    const safeWidths = block.columnWidths.map(
+      (w) => w === void 0 ? "*" : w
+    );
+    colWidths = computeColumnPixelWidths2(safeWidths, widthForCols);
+  } else {
+    const equal = widthForCols / colCount;
+    colWidths = Array(colCount).fill(equal);
+  }
+  const xBases = [];
+  {
+    let x = baseLeft;
+    for (let i = 0; i < colCount; i++) {
+      xBases.push(x);
+      x += colWidths[i] + columnGap;
+    }
+  }
+  const maxRows = Math.max(...cols.map((c) => c.length));
+  const separatorText = block.separator;
+  const sepBoxWidth = separatorText ? 10 : 0;
+  const baseKeyWidthRatio = 0.35;
+  const resolveStyled = (base, styleNames) => resolveTextBlock(styles, {
+    ...base,
+    style: styleNames
+  });
+  const measureTextHeight = (tb, width) => {
+    const fontName = getFontNameForText(tb);
+    doc.font(fontName);
+    doc.fontSize(tb.fontSize ?? 10);
+    return doc.heightOfString(tb.text ?? "", { width });
+  };
+  const buildKeyBlock = (item) => ({
+    type: "text",
+    text: item.key ?? "",
+    align: block.keyAlign ?? "left",
+    ...block.keyTextStyle ?? {},
+    ...item.keyTextStyle ?? {}
+  });
+  const buildValueBlock = (item) => ({
+    type: "text",
+    text: item.value ?? "",
+    align: block.valueAlign ?? "left",
+    ...block.valueTextStyle ?? {},
+    ...item.valueTextStyle ?? {}
+  });
+  let totalHeight = mt;
+  if (orientation === "vertical") {
+    const keyValueGap = block.verticalKeyValueGap ?? 2;
+    let maxColHeight = 0;
+    for (let colIndex = 0; colIndex < colCount; colIndex++) {
+      const col = cols[colIndex];
+      const colWidth = colWidths[colIndex];
+      let colHeight = 0;
+      for (const item of col) {
+        const keyStyleNames = item.keyStyle ?? block.keyStyle ?? void 0;
+        const valueStyleNames = item.valueStyle ?? block.valueStyle ?? void 0;
+        const keyBase = buildKeyBlock(item);
+        const keyResolved = resolveStyled(keyBase, keyStyleNames);
+        const keyHeight = measureTextHeight(keyResolved, colWidth);
+        const valueBase = buildValueBlock(item);
+        const valueResolved = resolveStyled(valueBase, valueStyleNames);
+        const valueHeight = measureTextHeight(valueResolved, colWidth);
+        const rowHeight = keyHeight + keyValueGap + valueHeight;
+        colHeight += rowHeight + rowGap;
+      }
+      if (colHeight > maxColHeight) maxColHeight = colHeight;
+    }
+    totalHeight += maxColHeight;
+  } else {
+    for (let rowIndex = 0; rowIndex < maxRows; rowIndex++) {
+      let rowHeight = 0;
+      for (let colIndex = 0; colIndex < colCount; colIndex++) {
+        const col = cols[colIndex];
+        const item = col[rowIndex];
+        if (!item) continue;
+        const colWidth = colWidths[colIndex];
+        const keyWidthPx = block.keyWidth === "*" ? Math.max(colWidth * baseKeyWidthRatio, 20) : block.keyWidth ?? 80;
+        const keyStyleNames = item.keyStyle ?? block.keyStyle ?? void 0;
+        const valueStyleNames = item.valueStyle ?? block.valueStyle ?? void 0;
+        const keyBase = buildKeyBlock(item);
+        const keyResolved = resolveStyled(keyBase, keyStyleNames);
+        const keyHeight = measureTextHeight(keyResolved, keyWidthPx);
+        const valueBase = buildValueBlock(item);
+        const valueResolved = resolveStyled(valueBase, valueStyleNames);
+        const valueXInsideCol = keyWidthPx + (separatorText ? sepBoxWidth + 4 : 4);
+        const valueWidth = Math.max(colWidth - valueXInsideCol, 1);
+        const valueHeight = measureTextHeight(valueResolved, valueWidth);
+        const cellHeight = Math.max(keyHeight, valueHeight);
+        if (cellHeight > rowHeight) rowHeight = cellHeight;
+      }
+      if (rowHeight > 0) {
+        totalHeight += rowHeight + rowGap;
+      }
+    }
+  }
+  totalHeight += mb;
+  if (y === null) {
+    ensureSpaceFor(totalHeight, env);
+  }
+  const baseY = y ?? ctx.currentY;
+  let rowY = baseY + mt;
+  if (orientation === "vertical") {
+    const keyValueGap = block.verticalKeyValueGap ?? 2;
+    let maxColBottom = rowY;
+    for (let colIndex = 0; colIndex < colCount; colIndex++) {
+      const col = cols[colIndex];
+      const colWidth = colWidths[colIndex];
+      const colX = xBases[colIndex];
+      let colY = rowY;
+      for (const item of col) {
+        const keyStyleNames = item.keyStyle ?? block.keyStyle ?? void 0;
+        const valueStyleNames = item.valueStyle ?? block.valueStyle ?? void 0;
+        const keyBlock = buildKeyBlock(item);
+        const keyResolved = resolveStyled(keyBlock, keyStyleNames);
+        const keyHeight = measureTextHeight(keyResolved, colWidth);
+        drawStyledText(doc, keyResolved, colX, colY, colWidth);
+        colY += keyHeight + keyValueGap;
+        const valueBlock = buildValueBlock(item);
+        const valueResolved = resolveStyled(valueBlock, valueStyleNames);
+        const valueHeight = measureTextHeight(valueResolved, colWidth);
+        drawStyledText(doc, valueResolved, colX, colY, colWidth);
+        colY += valueHeight + rowGap;
+      }
+      if (colY > maxColBottom) maxColBottom = colY;
+    }
+    rowY = maxColBottom;
+  } else {
+    for (let rowIndex = 0; rowIndex < maxRows; rowIndex++) {
+      let rowHeight = 0;
+      for (let colIndex = 0; colIndex < colCount; colIndex++) {
+        const col = cols[colIndex];
+        const item = col[rowIndex];
+        if (!item) continue;
+        const colWidth = colWidths[colIndex];
+        const keyWidthPx = block.keyWidth === "*" ? Math.max(colWidth * baseKeyWidthRatio, 20) : block.keyWidth ?? 80;
+        const keyStyleNames = item.keyStyle ?? block.keyStyle ?? void 0;
+        const valueStyleNames = item.valueStyle ?? block.valueStyle ?? void 0;
+        const keyBase = buildKeyBlock(item);
+        const keyResolved = resolveStyled(keyBase, keyStyleNames);
+        const keyHeight = measureTextHeight(keyResolved, keyWidthPx);
+        const valueBase = buildValueBlock(item);
+        const valueResolved = resolveStyled(valueBase, valueStyleNames);
+        const valueXInsideCol = keyWidthPx + (separatorText ? sepBoxWidth + 4 : 4);
+        const valueWidth = Math.max(colWidth - valueXInsideCol, 1);
+        const valueHeight = measureTextHeight(valueResolved, valueWidth);
+        const cellHeight = Math.max(keyHeight, valueHeight);
+        if (cellHeight > rowHeight) rowHeight = cellHeight;
+      }
+      if (rowHeight === 0) continue;
+      for (let colIndex = 0; colIndex < colCount; colIndex++) {
+        const col = cols[colIndex];
+        const item = col[rowIndex];
+        if (!item) continue;
+        const colX = xBases[colIndex];
+        const colWidth = colWidths[colIndex];
+        const keyWidthPx = block.keyWidth === "*" ? Math.max(colWidth * baseKeyWidthRatio, 20) : block.keyWidth ?? 80;
+        const keyStyleNames = item.keyStyle ?? block.keyStyle ?? void 0;
+        const valueStyleNames = item.valueStyle ?? block.valueStyle ?? void 0;
+        const keyBlock = buildKeyBlock(item);
+        const keyResolved = resolveStyled(keyBlock, keyStyleNames);
+        drawStyledText(doc, keyResolved, colX, rowY, keyWidthPx);
+        if (separatorText) {
+          const sepBlock = {
+            type: "text",
+            text: separatorText,
+            align: "left"
+          };
+          const sepResolved = resolveStyled(sepBlock, keyStyleNames);
+          const sepX = colX + keyWidthPx + 2;
+          drawStyledText(doc, sepResolved, sepX, rowY, sepBoxWidth);
+        }
+        const valueX = colX + keyWidthPx + (separatorText ? sepBoxWidth + 4 : 4);
+        const valueWidth = Math.max(colWidth - (valueX - colX), 1);
+        const valueBlock = buildValueBlock(item);
+        const valueResolved = resolveStyled(valueBlock, valueStyleNames);
+        drawStyledText(doc, valueResolved, valueX, rowY, valueWidth);
+      }
+      rowY += rowHeight + rowGap;
+    }
+  }
+  const endY = rowY + mb;
+  if (y === null) ctx.currentY = endY;
+  return endY;
+};
+
+// src/renderer-engine/blocks/line.ts
+var processLineBlock = (doc, ctx, block, y, env, ensureSpaceFor) => {
+  const localLeft = block.marginLeft ?? 0;
+  const localRight = block.marginRight ?? 0;
+  const xLeft = env.marginLeft + localLeft;
+  const width = Math.max(env.innerWidth - localLeft - localRight, 1);
+  const mt = block.marginTop ?? 0;
+  const mb = block.marginBottom ?? 0;
+  const baseY = y ?? ctx.currentY;
+  const startY = baseY + mt;
+  const lineWidth = block.lineWidth ?? 1;
+  const heightNeeded = mt + lineWidth + mb;
+  if (y === null) {
+    ensureSpaceFor(heightNeeded, env);
+  }
+  doc.save();
+  if (block.color) {
+    doc.strokeColor(block.color);
+  }
+  doc.lineWidth(lineWidth);
+  doc.moveTo(xLeft, startY).lineTo(xLeft + width, startY).stroke();
+  doc.restore();
+  const newY = startY + lineWidth + mb;
+  if (y === null) ctx.currentY = newY;
+  return newY;
+};
+
+// src/renderer-engine/blocks/table.ts
+var measureTableHeight = (doc, table, env, styles, computeColumnPixelWidths2) => {
+  const localLeft = table.marginLeft ?? 0;
+  const localRight = table.marginRight ?? 0;
+  const width = Math.max(env.innerWidth - localLeft - localRight, 1);
+  const colWidths = computeColumnPixelWidths2(table.widths, width);
+  let totalHeight = 0;
+  totalHeight += table.marginTop ?? 0;
+  table.body.forEach((row) => {
+    let rowHeight = 0;
+    row.forEach((rawCell, colIndex) => {
+      const cell = resolveTableCell(styles, rawCell);
+      const colW = colWidths[colIndex] ?? 50;
+      const fontSize = cell.fontSize ?? 10;
+      const isBold = !!cell.bold;
+      const isItalic = !!cell.italic;
+      const fontName = cell.font ? cell.font : isBold && isItalic ? "Helvetica-BoldOblique" : isBold ? "Helvetica-Bold" : isItalic ? "Helvetica-Oblique" : "Helvetica";
+      doc.font(fontName);
+      doc.fontSize(fontSize);
+      const h = doc.heightOfString(cell.text, { width: colW });
+      rowHeight = Math.max(rowHeight, h + 4);
+    });
+    totalHeight += rowHeight;
+  });
+  totalHeight += table.lineGap ?? 6;
+  totalHeight += table.marginBottom ?? 0;
+  return totalHeight;
+};
+var processTableBlock = (doc, ctx, styles, table, y, env, computeColumnPixelWidths2, bottomLimitForContent, finishPage2) => {
+  const localLeft = table.marginLeft ?? 0;
+  const localRight = table.marginRight ?? 0;
+  const baseLeft = env.marginLeft + localLeft;
+  const width = Math.max(env.innerWidth - localLeft - localRight, 1);
+  const mt = table.marginTop ?? 0;
+  const mb = table.marginBottom ?? 0;
+  const baseY = y ?? ctx.currentY;
+  const startY = baseY + mt;
+  const colWidths = computeColumnPixelWidths2(table.widths, width);
+  const layout = table.layout ?? {
+    border: "all",
+    hLineColor: "#ccc",
+    vLineColor: "#ccc"
+  };
+  const borderAll = layout.border !== "none";
+  const headerRows = table.headerRows ?? 0;
+  const measureRowHeight = (row) => {
+    let rowHeight = 0;
+    row.forEach((rawCell, colIndex) => {
+      const cell = resolveTableCell(styles, rawCell);
+      const colW = colWidths[colIndex] ?? 50;
+      const fontSize = cell.fontSize ?? 10;
+      const fontName = cell.font ? cell.font : cell.bold ? "Helvetica-Bold" : "Helvetica";
+      doc.font(fontName);
+      doc.fontSize(fontSize);
+      const textWidth = Math.max(colW - 4, 1);
+      const h = doc.heightOfString(cell.text, {
+        width: textWidth
+      }) + 4;
+      rowHeight = Math.max(rowHeight, h);
+    });
+    return rowHeight || 12;
+  };
+  const drawRow = (row, rowTop2, rowHeight, isHeaderRow, drawTopBorder) => {
+    row.forEach((rawCell, colIndex) => {
+      const cell = resolveTableCell(styles, rawCell);
+      const colW = colWidths[colIndex] ?? 50;
+      const x = baseLeft + colWidths.slice(0, colIndex).reduce((a, b) => a + b, 0);
+      const fontSize = cell.fontSize ?? 10;
+      doc.save();
+      if (cell.fillColor) {
+        doc.rect(x, rowTop2, colW, rowHeight).fillOpacity(1).fill(cell.fillColor);
+        doc.fillOpacity(1);
+      }
+      const isBold = !!cell.bold;
+      const isItalic = !!cell.italic;
+      const fontName = cell.font ? cell.font : isBold && isItalic ? "Helvetica-BoldOblique" : isBold ? "Helvetica-Bold" : isItalic ? "Helvetica-Oblique" : "Helvetica";
+      doc.font(fontName);
+      doc.fontSize(fontSize);
+      if (cell.color) {
+        doc.fillColor(cell.color);
+      } else {
+        doc.fillColor("black");
+      }
+      const align = cell.align ?? "left";
+      const textWidth = Math.max(colW - 4, 1);
+      const textHeight = doc.heightOfString(cell.text, {
+        width: textWidth
+      });
+      let textY = rowTop2 + 2;
+      if (isHeaderRow) {
+        const available = rowHeight - 4;
+        const offset = Math.max((available - textHeight) / 2, 0);
+        textY = rowTop2 + 2 + offset;
+      }
+      doc.text(cell.text, x + 2, textY, {
+        width: textWidth,
+        align,
+        underline: !!cell.underline,
+        strike: !!cell.strike,
+        link: cell.link
+      });
+      doc.restore();
+    });
+    if (borderAll) {
+      const bottomY = rowTop2 + rowHeight;
+      doc.save();
+      doc.lineWidth(0.5);
+      doc.strokeColor(layout.hLineColor ?? "#ccc");
+      if (drawTopBorder) {
+        doc.moveTo(baseLeft, rowTop2).lineTo(baseLeft + width, rowTop2).stroke();
+      }
+      doc.moveTo(baseLeft, bottomY).lineTo(baseLeft + width, bottomY).stroke();
+      doc.restore();
+      doc.save();
+      doc.lineWidth(0.5);
+      doc.strokeColor(layout.vLineColor ?? "#ccc");
+      let x = baseLeft;
+      colWidths.forEach((colW) => {
+        doc.moveTo(x, rowTop2).lineTo(x, bottomY).stroke();
+        x += colW;
+      });
+      doc.moveTo(baseLeft + width, rowTop2).lineTo(baseLeft + width, bottomY).stroke();
+      doc.restore();
+    }
+    return rowTop2 + rowHeight;
+  };
+  const drawHeaderRowsOnNewPage = () => {
+    if (!headerRows) return doc.page.margins.top + mt;
+    let rowTop2 = doc.page.margins.top + mt;
+    for (let i = 0; i < headerRows; i++) {
+      const headerRow = table.body[i];
+      const headerHeight = measureRowHeight(headerRow);
+      rowTop2 = drawRow(headerRow, rowTop2, headerHeight, true, true);
+    }
+    return rowTop2;
+  };
+  let rowTop = startY;
+  table.body.forEach((row, rowIndex) => {
+    const isHeaderRow = rowIndex < headerRows;
+    const rowHeight = measureRowHeight(row);
+    const bottomLimit = bottomLimitForContent();
+    if (rowTop + rowHeight > bottomLimit) {
+      finishPage2(true);
+      rowTop = headerRows ? drawHeaderRowsOnNewPage() : doc.page.margins.top + mt;
+    }
+    const drawTopBorder = true;
+    rowTop = drawRow(row, rowTop, rowHeight, isHeaderRow, drawTopBorder);
+  });
+  const newY = rowTop + (table.lineGap ?? 6) + mb;
+  if (y === null) ctx.currentY = newY;
+  return newY;
+};
+
+// src/renderer-engine/blocks/text.ts
+var processTextBlock = (doc, ctx, styles, block, y, env, ensureSpaceFor) => {
+  const tb = resolveTextBlock(styles, block);
+  const localLeft = tb.marginLeft ?? 0;
+  const localRight = tb.marginRight ?? 0;
+  const xLeft = env.marginLeft + localLeft;
+  const width = Math.max(env.innerWidth - localLeft - localRight, 1);
+  const baseY = y ?? ctx.currentY;
+  const startY = baseY;
+  doc.fontSize(tb.fontSize ?? 10);
+  const isBold = !!tb.bold;
+  const isItalic = !!tb.italic;
+  let fontName = tb.font;
+  if (!fontName) {
+    if (isBold && isItalic) fontName = "Helvetica-BoldOblique";
+    else if (isBold) fontName = "Helvetica-Bold";
+    else if (isItalic) fontName = "Helvetica-Oblique";
+    else fontName = "Helvetica";
+  }
+  doc.font(fontName);
+  if (tb.color) doc.fillColor(tb.color);
+  else doc.fillColor("black");
+  const textHeight = doc.heightOfString(tb.text, { width });
+  if (y === null) {
+    const gapCheck = tb.lineGap ?? 4;
+    ensureSpaceFor(textHeight + gapCheck, env);
+  }
+  doc.text(tb.text, xLeft, startY, {
+    width,
+    align: tb.align ?? "left",
+    underline: !!tb.underline,
+    strike: !!tb.strike,
+    link: tb.link
+  });
+  const gap = tb.lineGap ?? 4;
+  const newY = startY + textHeight + gap;
+  if (y === null) ctx.currentY = newY;
+  return newY;
+};
+
+// src/renderer-engine/utils/block-renderer.ts
+function createBlockRenderer(deps) {
+  const {
+    doc,
+    ctx,
+    styles,
+    computeColumnPixelWidths: computeColumnPixelWidths2,
+    finishPage: finishPage2,
+    processSignatureBlock
+  } = deps;
+  const bottomLimitForContent = createBottomLimitForContent(doc, ctx);
+  const ensureSpaceFor = createEnsureSpaceFor(
+    ctx,
+    bottomLimitForContent,
+    finishPage2
+  );
+  const measureBlockHeight = createMeasureBlockHeight({
+    doc,
+    styles,
+    computeColumnPixelWidths: computeColumnPixelWidths2
+  });
+  const renderBlock = (block, y, env) => {
+    if (block.visible === false) {
+      return y ?? ctx.currentY;
+    }
+    switch (block.type) {
+      case "text":
+        return processTextBlock(
+          doc,
+          ctx,
+          styles,
+          block,
+          y,
+          env,
+          ensureSpaceFor
+        );
+      case "image":
+        return processImageBlock(
+          doc,
+          ctx,
+          block,
+          y,
+          env,
+          ensureSpaceFor
+        );
+      case "qr": {
+        const qb = block;
+        const imageLike = {
+          type: "image",
+          src: qb.src,
+          width: qb.size,
+          height: qb.size,
+          align: qb.align,
+          marginTop: qb.marginTop,
+          marginBottom: qb.marginBottom,
+          marginLeft: qb.marginLeft,
+          marginRight: qb.marginRight
+        };
+        return processImageBlock(doc, ctx, imageLike, y, env, ensureSpaceFor);
+      }
+      case "barcode":
+        return processBarcodeBlock(doc, ctx, block, y, env, ensureSpaceFor);
+      case "line":
+        return processLineBlock(
+          doc,
+          ctx,
+          block,
+          y,
+          env,
+          ensureSpaceFor
+        );
+      case "table":
+        return processTableBlock(
+          doc,
+          ctx,
+          styles,
+          block,
+          y,
+          env,
+          computeColumnPixelWidths2,
+          bottomLimitForContent,
+          finishPage2
+        );
+      case "columns":
+        return processColumnsBlock(
+          ctx,
+          block,
+          y,
+          env,
+          computeColumnPixelWidths2,
+          renderBlock,
+          ensureSpaceFor,
+          measureBlockHeight
+        );
+      case "keyValueGrid":
+        return processKeyValueGridBlock(
+          doc,
+          ctx,
+          styles,
+          block,
+          y,
+          env,
+          computeColumnPixelWidths2,
+          ensureSpaceFor
+        );
+      case "signature":
+        if (!env.allowPageBreak) {
+          throw new Error(
+            "Signature block is only allowed in main content flow."
+          );
+        }
+        if (y !== null) {
+          throw new Error(
+            "Signature block must be part of main flow, not drawn at explicit Y."
+          );
+        }
+        processSignatureBlock(block);
+        return ctx.currentY;
+      case "pageBreak":
+        if (!env.allowPageBreak || ctx.inFooter) {
+          return y ?? ctx.currentY;
+        }
+        finishPage2(true);
+        return ctx.currentY;
+      default:
+        return ctx.currentY;
+    }
+  };
+  const renderBlockArray = (blocks, startY, env) => {
+    let localY = startY;
+    for (const block of blocks) {
+      if (block.visible === false) {
+        continue;
+      }
+      localY = renderBlock(block, localY, env);
+    }
+    return localY;
+  };
+  return {
+    renderBlock,
+    renderBlockArray
+  };
+}
+
+// src/renderer-engine/utils/context.ts
+function createInitialContext(doc) {
+  return {
+    pageNumber: 1,
+    currentY: doc.page.margins.top,
+    signatureBlock: null,
+    signatureTopY: null,
+    signatureHeight: 0,
+    signaturePlaced: false,
+    afterSignature: false,
+    inFooter: false
+  };
+}
+
+// src/renderer-engine/utils/ensure-space.ts
+function createEnsureSpaceFor(ctx, bottomLimitForContent, finishPage2) {
+  return (heightNeeded, env) => {
+    if (!env.allowPageBreak || ctx.inFooter) return;
+    const bottomLimit = bottomLimitForContent();
+    if (ctx.currentY + heightNeeded > bottomLimit) {
+      finishPage2(true);
+    }
+  };
+}
+
+// src/renderer-engine/utils/env.ts
+var contentEnv = (doc) => ({
+  marginLeft: doc.page.margins.left,
+  innerWidth: doc.page.width - doc.page.margins.left - doc.page.margins.right,
+  allowPageBreak: true
+});
+
+// src/renderer-engine/utils/finish-page.ts
+function finishPage({
+  addNewPage,
+  doc,
+  def,
+  ctx,
+  footerBandHeight,
+  renderBlockArray,
+  startNewPageLayout
+}) {
+  const mode = def.watermark?.mode;
+  if (def.watermark && watermarkUsesLast(mode)) {
+    const isLast = !addNewPage;
+    drawWatermarkForPage(doc, def.watermark, ctx.pageNumber, isLast);
+  }
+  if (ctx.signatureBlock && ctx.signatureTopY !== null) {
+    const env = contentEnv(doc);
+    drawSignatureBlock(
+      doc,
+      ctx.signatureBlock,
+      ctx.signatureTopY,
+      env,
+      renderBlockArray
+    );
+  }
+  drawFooter(doc, def, ctx, footerBandHeight, renderBlockArray);
+  if (addNewPage) {
+    doc.addPage();
+    ctx.pageNumber += 1;
+    startNewPageLayout();
+  }
+}
+
+// src/renderer-engine/utils/footer.ts
+function normalizeFooter(input, ctx, doc) {
+  if (!input) return null;
+  if (typeof input === "function") {
+    const result = input(ctx.pageNumber, {
+      width: doc.page.width,
+      height: doc.page.height
+    });
+    if (!result) return null;
+    return normalizeFooter(result, ctx, doc);
+  }
+  if (input.blocks && Array.isArray(input.blocks)) {
+    const f = input;
+    return {
+      visible: f.visible,
+      blocks: f.blocks,
+      marginTop: f.marginTop,
+      marginBottom: f.marginBottom,
+      marginLeft: f.marginLeft,
+      marginRight: f.marginRight,
+      backgroundColor: f.backgroundColor,
+      backgroundImage: f.backgroundImage
+    };
+  }
+  if (input.type) {
+    return { blocks: [input] };
+  }
+  if (Array.isArray(input)) {
+    return { blocks: input };
+  }
+  return null;
+}
+function drawFooter(doc, def, ctx, footerBandHeight, renderBlockArray) {
+  const footerConfig = def.footer;
+  if (!footerConfig) return;
+  const layout = normalizeFooter(footerConfig, ctx, doc);
+  if (!layout || !layout.blocks.length) return;
+  if (layout.visible === false) return;
+  const bandHeight = footerBandHeight;
+  if (!bandHeight) return;
+  const { marginTop = 4, backgroundColor, backgroundImage, blocks } = layout;
+  const footerMarginLeft = layout.marginLeft ?? 0;
+  const footerMarginRight = layout.marginRight ?? 0;
+  const contentWidth = doc.page.width - footerMarginLeft - footerMarginRight;
+  const footerEnv = {
+    marginLeft: footerMarginLeft,
+    innerWidth: contentWidth,
+    allowPageBreak: false
+  };
+  const pageHeight = doc.page.height;
+  const bandTop = pageHeight - bandHeight;
+  if (backgroundColor) {
+    doc.save();
+    doc.rect(0, bandTop, doc.page.width, bandHeight).fill(backgroundColor);
+    doc.restore();
+  }
+  if (backgroundImage) {
+    try {
+      doc.image(backgroundImage, 0, bandTop, {
+        width: doc.page.width,
+        height: bandHeight
+      });
+    } catch (e) {
+      console.warn("Failed to load footer background image:", e);
+    }
+  }
+  doc.save();
+  doc.rect(footerMarginLeft, bandTop, contentWidth, bandHeight).clip();
+  doc.translate(0, bandTop);
+  ctx.inFooter = true;
+  const localStartY = marginTop;
+  renderBlockArray(blocks, localStartY, footerEnv);
+  ctx.inFooter = false;
+  doc.restore();
+}
+
+// src/renderer-engine/utils/header.ts
+function drawHeader(doc, def, headerBandHeight, header, renderBlockArray) {
+  if (!header || !header.blocks.length) return;
+  if (header.visible === false) return;
+  if (!headerBandHeight) return;
+  const bandTop = 0;
+  const bandHeight = def.margins.top;
+  const headerMarginLeft = header.marginLeft ?? 0;
+  const headerMarginRight = header.marginRight ?? 0;
+  const contentWidth = doc.page.width - headerMarginLeft - headerMarginRight;
+  const headerEnv = {
+    marginLeft: headerMarginLeft,
+    innerWidth: contentWidth,
+    allowPageBreak: false
+  };
+  if (header.backgroundColor) {
+    doc.save();
+    doc.rect(0, bandTop, doc.page.width, bandHeight).fill(header.backgroundColor);
+    doc.restore();
+  }
+  if (header.backgroundImage) {
+    try {
+      doc.image(header.backgroundImage, 0, bandTop, {
+        width: doc.page.width,
+        height: bandHeight
+      });
+    } catch (e) {
+      console.warn("Failed to load header background image:", e);
+    }
+  }
+  doc.save();
+  doc.rect(headerMarginLeft, bandTop, contentWidth, bandHeight).clip();
+  const startY = bandTop + (header.marginTop ?? 0);
+  renderBlockArray(header.blocks, startY, headerEnv);
+  doc.restore();
+}
+
+// src/renderer-engine/utils/image-loader.ts
+import axios from "axios";
+async function normalizeImageSrc(src) {
+  if (!src) return src;
+  if (Buffer.isBuffer(src)) return src;
+  if (src.startsWith("http://") || src.startsWith("https://")) {
+    const res = await axios.get(src, {
+      responseType: "arraybuffer"
+    });
+    return Buffer.from(res.data);
+  }
+  return src;
+}
+async function materializeImagesInBlocks(blocks) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.type === "image") {
+      const img = { ...block };
+      img.src = await normalizeImageSrc(img.src);
+      out.push(img);
+    } else if (block.type === "columns") {
+      out.push({
+        ...block,
+        columns: await Promise.all(
+          block.columns.map((col) => materializeImagesInBlocks(col))
+        )
+      });
+    } else if (block.type === "signature" && block.blocks) {
+      out.push({
+        ...block,
+        blocks: await materializeImagesInBlocks(block.blocks)
+      });
+    } else {
+      out.push(block);
+    }
+  }
+  return out;
+}
+
+// src/renderer-engine/utils/layout.ts
+function computeColumnPixelWidths(widths, totalWidth) {
+  let fixedTotal = 0;
+  let starCount = 0;
+  widths.forEach((w) => {
+    if (w === "*") starCount++;
+    else fixedTotal += w;
+  });
+  const remaining = Math.max(totalWidth - fixedTotal, 0);
+  const starWidth = starCount > 0 ? remaining / starCount : 0;
+  return widths.map((w) => w === "*" ? starWidth : w);
+}
+
+// src/renderer-engine/utils/styles.ts
+function mergeStyleDefs(styles, names) {
+  const result = {};
+  if (!names || !styles) return result;
+  const arr = Array.isArray(names) ? names : [names];
+  for (const name of arr) {
+    const st = styles[name];
+    if (!st) continue;
+    if (st.fontSize !== void 0) result.fontSize = st.fontSize;
+    if (st.lineGap !== void 0) result.lineGap = st.lineGap;
+    if (st.align !== void 0) result.align = st.align;
+    if (st.bold !== void 0) result.bold = st.bold;
+    if (st.italic !== void 0) result.italic = st.italic;
+    if (st.underline !== void 0) result.underline = st.underline;
+    if (st.strike !== void 0) result.strike = st.strike;
+    if (st.link !== void 0) result.link = st.link;
+    if (st.color !== void 0) result.color = st.color;
+    if (st.fillColor !== void 0) result.fillColor = st.fillColor;
+    if (st.font !== void 0) result.font = st.font;
+  }
+  return result;
+}
+function resolveTextBlock(styles, block) {
+  const styleDef = mergeStyleDefs(styles, block.style);
+  return {
+    ...styleDef,
+    ...block,
+    fontSize: block.fontSize ?? styleDef.fontSize,
+    lineGap: block.lineGap ?? styleDef.lineGap,
+    align: block.align ?? styleDef.align,
+    bold: block.bold ?? styleDef.bold,
+    italic: block.italic ?? styleDef.italic,
+    underline: block.underline ?? styleDef.underline,
+    strike: block.strike ?? styleDef.strike,
+    link: block.link ?? styleDef.link,
+    color: block.color ?? styleDef.color,
+    // fillColor: block.fillColor ?? styleDef.fillColor,
+    font: block.font ?? styleDef.font
+  };
+}
+function resolveTableCell(styles, cell) {
+  const styleDef = mergeStyleDefs(styles, cell.style);
+  return {
+    ...styleDef,
+    ...cell,
+    fontSize: cell.fontSize ?? styleDef.fontSize,
+    align: cell.align ?? styleDef.align,
+    bold: cell.bold ?? styleDef.bold,
+    italic: cell.italic ?? styleDef.italic,
+    color: cell.color ?? styleDef.color,
+    fillColor: cell.fillColor ?? styleDef.fillColor,
+    font: cell.font ?? styleDef.font
+  };
+}
+var getFontNameForText = (tb) => {
+  if (tb.font) return tb.font;
+  const bold = tb.bold ?? false;
+  const italic = tb.italic ?? false;
+  if (bold && italic) return "Helvetica-BoldOblique";
+  if (bold) return "Helvetica-Bold";
+  if (italic) return "Helvetica-Oblique";
+  return "Helvetica";
+};
+var drawStyledText = (doc, tb, x, y, width) => {
+  doc.save();
+  doc.fontSize(tb.fontSize ?? 10);
+  doc.font(getFontNameForText(tb));
+  if (tb.color) doc.fillColor(tb.color);
+  else doc.fillColor("black");
+  const textHeight = doc.heightOfString(tb.text, { width });
+  doc.text(tb.text, x, y, {
+    width,
+    align: tb.align ?? "left"
+  });
+  const underline = tb.underline;
+  const strike = tb.strike;
+  if (underline) {
+    const lineY = y + textHeight;
+    doc.moveTo(x, lineY).lineTo(x + width, lineY).stroke();
+  }
+  if (strike) {
+    const lineY = y + textHeight / 2;
+    doc.moveTo(x, lineY).lineTo(x + width, lineY).stroke();
+  }
+  doc.restore();
+};
+
+// src/renderer-engine/utils/measure-block-height.ts
+function createMeasureBlockHeight(deps) {
+  const { doc, styles, computeColumnPixelWidths: computeColumnPixelWidths2 } = deps;
+  const measureText = (b, env) => {
+    const tb = resolveTextBlock(styles, b);
+    const width = Math.max(env.innerWidth, 1);
+    doc.font(getFontNameForText(tb));
+    doc.fontSize(tb.fontSize ?? 10);
+    const h = doc.heightOfString(tb.text ?? "", { width });
+    const gap = tb.lineGap ?? 4;
+    return h + gap;
+  };
+  const measureImageLike = (mt, mb, h) => (mt ?? 0) + h + (mb ?? 0);
+  const measureImage = (b) => {
+    const h = b.height ?? 50;
+    return measureImageLike(b.marginTop, b.marginBottom, h);
+  };
+  const measureQr = (b) => {
+    const size = b.size ?? 80;
+    return measureImageLike(b.marginTop, b.marginBottom, size);
+  };
+  const measureBarcode = (b) => {
+    const h = b.height ?? 40;
+    return measureImageLike(b.marginTop, b.marginBottom, h);
+  };
+  const measureLine = (b) => {
+    const lw = b.lineWidth ?? 1;
+    const mt = b.marginTop ?? 0;
+    const mb = b.marginBottom ?? 0;
+    return mt + lw + mb;
+  };
+  const measureTable = (b, env) => {
+    const mt = b.marginTop ?? 0;
+    const mb = b.marginBottom ?? 0;
+    const ml = b.marginLeft ?? 0;
+    const mr = b.marginRight ?? 0;
+    const innerWidth = Math.max(env.innerWidth - ml - mr, 1);
+    const fakeEnv = {
+      marginLeft: 0,
+      innerWidth,
+      allowPageBreak: false
+    };
+    const h = measureTableHeight(
+      doc,
+      b,
+      fakeEnv,
+      styles,
+      computeColumnPixelWidths2
+    );
+    return mt + h + mb;
+  };
+  const measureColumns = (b, env) => {
+    const mt = b.marginTop ?? 0;
+    const mb = b.marginBottom ?? 0;
+    const blockLeft = b.marginLeft ?? 0;
+    const blockRight = b.marginRight ?? 0;
+    const totalWidth = Math.max(env.innerWidth - blockLeft - blockRight, 1);
+    const cols = b.columns ?? [];
+    const n = cols.length;
+    if (!n) return mt + mb;
+    let colWidths;
+    const mode = b.mode ?? "fixedGap";
+    let gap;
+    if (mode === "spaceBetween" && n > 1) {
+      if (b.widths && b.widths.length === n) {
+        colWidths = computeColumnPixelWidths2(b.widths, totalWidth);
+      } else {
+        colWidths = Array(n).fill(totalWidth / n);
+      }
+      const totalColsWidth = colWidths.reduce((a, x) => a + x, 0);
+      const remaining = Math.max(totalWidth - totalColsWidth, 0);
+      gap = remaining / (n - 1);
+      void gap;
+    } else {
+      gap = b.gap ?? 20;
+      const totalGapsWidth = gap * (n - 1);
+      const widthForCols = Math.max(totalWidth - totalGapsWidth, 1);
+      if (b.widths && b.widths.length === n) {
+        colWidths = computeColumnPixelWidths2(b.widths, widthForCols);
+      } else {
+        colWidths = Array(n).fill(widthForCols / n);
+      }
+    }
+    const heights = [];
+    for (let i = 0; i < n; i++) {
+      const colBlocks = cols[i] ?? [];
+      const colEnv = {
+        marginLeft: 0,
+        innerWidth: colWidths[i],
+        allowPageBreak: false
+      };
+      let colH = 0;
+      for (const child of colBlocks) {
+        if (!child || child.visible === false) continue;
+        colH += measure(child, colEnv);
+      }
+      heights.push(colH);
+    }
+    const maxH = Math.max(...heights, 0);
+    return mt + maxH + mb;
+  };
+  const measureKeyValueGrid = (b, env) => {
+    const mt = b.marginTop ?? 0;
+    const mb = b.marginBottom ?? 0;
+    const rowGap = b.rowGap ?? 4;
+    const orientation = b.orientation ?? "horizontal";
+    const cols = b.columns ?? [];
+    const colCount = cols.length;
+    if (!colCount) return mt + mb;
+    const blockLeft = b.marginLeft ?? 0;
+    const blockRight = b.marginRight ?? 0;
+    const totalWidth = Math.max(env.innerWidth - blockLeft - blockRight, 1);
+    let colWidths;
+    if (b.columnWidths && b.columnWidths.length === colCount) {
+      const safe = b.columnWidths.map((w) => w === void 0 ? "*" : w);
+      colWidths = computeColumnPixelWidths2(safe, totalWidth);
+    } else {
+      colWidths = Array(colCount).fill(totalWidth / colCount);
+    }
+    const separatorText = b.separator;
+    const sepBoxWidth = separatorText ? 10 : 0;
+    const baseKeyWidthRatio = 0.35;
+    const measureKVText = (tb, width) => {
+      const r = resolveTextBlock(styles, tb);
+      const fontName = getFontNameForText(r);
+      doc.font(fontName);
+      doc.fontSize(r.fontSize ?? 10);
+      return doc.heightOfString(r.text ?? "", { width });
+    };
+    let totalHeight = mt;
+    if (orientation === "vertical") {
+      const keyValueGap = b.verticalKeyValueGap ?? 2;
+      let maxColHeight = 0;
+      for (let colIndex = 0; colIndex < colCount; colIndex++) {
+        const col = cols[colIndex] ?? [];
+        const colWidth = colWidths[colIndex];
+        let colHeight = 0;
+        for (const item of col) {
+          const keyH = measureKVText(
+            { type: "text", text: item.key ?? "" },
+            colWidth
+          );
+          const valH = measureKVText(
+            { type: "text", text: item.value ?? "" },
+            colWidth
+          );
+          colHeight += keyH + keyValueGap + valH + rowGap;
+        }
+        if (colHeight > maxColHeight) maxColHeight = colHeight;
+      }
+      totalHeight += maxColHeight;
+    } else {
+      const maxRows = Math.max(...cols.map((c) => c ? c.length : 0), 0);
+      for (let rowIndex = 0; rowIndex < maxRows; rowIndex++) {
+        let rowHeight = 0;
+        for (let colIndex = 0; colIndex < colCount; colIndex++) {
+          const item = cols[colIndex]?.[rowIndex];
+          if (!item) continue;
+          const colWidth = colWidths[colIndex];
+          const keyWidthPx = b.keyWidth === "*" ? Math.max(colWidth * baseKeyWidthRatio, 20) : b.keyWidth ?? 80;
+          const keyH = measureKVText(
+            { type: "text", text: item.key ?? "" },
+            keyWidthPx
+          );
+          const valueXInsideCol = keyWidthPx + (separatorText ? sepBoxWidth + 4 : 4);
+          const valueWidth = Math.max(colWidth - valueXInsideCol, 1);
+          const valH = measureKVText(
+            { type: "text", text: item.value ?? "" },
+            valueWidth
+          );
+          rowHeight = Math.max(rowHeight, Math.max(keyH, valH));
+        }
+        if (rowHeight > 0) totalHeight += rowHeight + rowGap;
+      }
+    }
+    totalHeight += mb;
+    return totalHeight;
+  };
+  const measure = (block, env) => {
+    if (!block || block.visible === false) return 0;
+    switch (block.type) {
+      case "text":
+        return measureText(block, env);
+      case "image":
+        return measureImage(block);
+      case "qr":
+        return measureQr(block);
+      case "barcode":
+        return measureBarcode(block);
+      case "line":
+        return measureLine(block);
+      case "table":
+        return measureTable(block, env);
+      case "columns":
+        return measureColumns(block, env);
+      case "keyValueGrid":
+        return measureKeyValueGrid(block, env);
+      case "signature":
+        return block.height ?? 0;
+      case "pageBreak":
+        return 0;
+      default:
+        return 0;
+    }
+  };
+  return (block, env) => measure(block, env);
+}
+
+// src/renderer-engine/utils/page-background.ts
+function drawPageBackground(doc, pageBackground) {
+  if (!pageBackground) return;
+  const { src, opacity = 1 } = pageBackground;
+  const pageWidth = doc.page.width;
+  const pageHeight = doc.page.height;
+  doc.save();
+  try {
+    if (opacity < 1) {
+      doc.opacity(opacity);
+    }
+    doc.image(src, 0, 0, {
+      width: pageWidth,
+      height: pageHeight
+    });
+  } catch (e) {
+    console.warn("Failed to load page background image:", e);
+  }
+  doc.restore();
+  doc.opacity(1);
+}
+
+// src/renderer-engine/utils/page-limit.ts
+function createBottomLimitForContent(doc, ctx) {
+  return () => {
+    const pageBottomForContent = doc.page.height - doc.page.margins.bottom;
+    return ctx.signatureTopY ?? pageBottomForContent;
+  };
+}
+
+// src/renderer-engine/utils/qr-bar-code.ts
+import bwipjs from "bwip-js";
+import QRCode from "qrcode";
+function generateQrBuffer(value, size, version, errorCorrectionLevel) {
+  const options = {
+    width: size,
+    margin: 0
+  };
+  if (version && version >= 1 && version <= 40) {
+    options.version = version;
+  }
+  options.errorCorrectionLevel = errorCorrectionLevel ?? "M";
+  return new Promise((resolve, reject) => {
+    QRCode.toBuffer(value, options, (err, buffer) => {
+      if (err) {
+        return reject(err);
+      }
+      resolve(buffer);
+    });
+  });
+}
+function mapBarcodeTypeToBcid(bcType) {
+  switch (bcType) {
+    case "EAN13":
+      return "ean13";
+    case "CODE39":
+      return "code39";
+    case "ITF":
+      return "interleaved2of5";
+    case "CODE93":
+      return "code93";
+    case "CODE128":
+    default:
+      return "code128";
+  }
+}
+function generateBarcodeBuffer(value, options = {}) {
+  const {
+    bcType,
+    scale = 3,
+    barHeight = 10,
+    includetext = false,
+    textalign = "center"
+  } = options;
+  const bcid = mapBarcodeTypeToBcid(bcType);
+  return new Promise((resolve, reject) => {
+    let textValue = value;
+    if (bcType === "EAN13") {
+      const digitsOnly = textValue.replace(/\D/g, "");
+      if (digitsOnly.length === 13) {
+        textValue = digitsOnly.slice(0, 12);
+      } else if (digitsOnly.length === 12) {
+        textValue = textValue;
+      } else {
+        return reject(
+          new Error(
+            `EAN13 barcode value must have 12 or 13 digits, got "${value}"`
+          )
+        );
+      }
+    }
+    const bwipOptions = {
+      bcid,
+      text: textValue,
+      scale,
+      height: barHeight,
+      includetext
+    };
+    bwipOptions.textxalign = textalign;
+    bwipjs.toBuffer(bwipOptions, (err, png) => {
+      if (err) {
+        return reject(err);
+      }
+      resolve(png);
+    });
+  });
+}
+async function materializeQrAndBarcodesInBlocks(blocks) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.type === "columns") {
+      const colBlock = block;
+      const newCols = [];
+      for (const col of colBlock.columns) {
+        newCols.push(await materializeQrAndBarcodesInBlocks(col));
+      }
+      out.push({
+        ...colBlock,
+        columns: newCols
+      });
+    } else if (block.type === "signature") {
+      const sig = block;
+      if (sig.blocks && sig.blocks.length) {
+        const newInner = await materializeQrAndBarcodesInBlocks(sig.blocks);
+        out.push({
+          ...sig,
+          blocks: newInner
+        });
+      } else {
+        out.push(block);
+      }
+    } else if (block.type === "qr") {
+      const qb = { ...block };
+      if (!qb.src && qb.value) {
+        const size = qb.size ?? 80;
+        const buf = await generateQrBuffer(
+          qb.value,
+          size,
+          qb.qrVersion,
+          qb.errorCorrectionLevel
+        );
+        qb.src = buf;
+      }
+      out.push(qb);
+    } else if (block.type === "barcode") {
+      const bb = { ...block };
+      if (!bb.src && bb.value) {
+        const buf = await generateBarcodeBuffer(bb.value, {
+          bcType: bb.bcType,
+          scale: bb.scale,
+          barHeight: bb.barHeight,
+          includetext: bb.includetext,
+          textalign: bb.textalign
+        });
+        bb.src = buf;
+      }
+      out.push(bb);
+    } else {
+      out.push(block);
+    }
+  }
+  return out;
+}
+
+// src/renderer-engine/utils/signature.ts
+function drawSignatureBlock(doc, block, y, env, renderBlockArray) {
+  const localLeft = block.marginLeft ?? 0;
+  const localRight = block.marginRight ?? 0;
+  const bandLeft = env.marginLeft + localLeft;
+  const bandWidth = Math.max(env.innerWidth - localLeft - localRight, 1);
+  const bandHeight = block.height;
+  doc.save();
+  doc.rect(bandLeft, y, bandWidth, bandHeight).clip();
+  if (block.blocks && block.blocks.length) {
+    const sigEnv = {
+      marginLeft: bandLeft,
+      innerWidth: bandWidth,
+      allowPageBreak: false
+    };
+    renderBlockArray(block.blocks, y, sigEnv);
+  } else {
+    const imgWidth = block.width ?? 120;
+    const xCenter = bandLeft + (bandWidth - imgWidth) / 2;
+    if (block.image) {
+      try {
+        doc.image(block.image, xCenter, y, { width: imgWidth });
+      } catch (e) {
+        console.warn("Failed to load signature image:", e);
+      }
+    }
+    const label = block.label ?? "Authorized Signatory";
+    const labelY = y + bandHeight - 14;
+    doc.fontSize(9).text(label, bandLeft, labelY, {
+      width: bandWidth,
+      align: "center"
+    });
+  }
+  doc.restore();
+}
+function createProcessSignatureBlock({
+  doc,
+  ctx,
+  styles,
+  finishPage: finishPage2,
+  contentEnvFn
+}) {
+  return (block) => {
+    if (ctx.signatureBlock) {
+      finishPage2(true);
+    }
+    const env = contentEnvFn(doc);
+    const localLeft = block.marginLeft ?? 0;
+    const localRight = block.marginRight ?? 0;
+    const bandWidth = Math.max(env.innerWidth - localLeft - localRight, 1);
+    let requiredHeight = block.height;
+    if (block.blocks && block.blocks.length) {
+      let required = 0;
+      const measureImageLike = (mt, mb, h) => {
+        return (mt ?? 0) + h + (mb ?? 0);
+      };
+      const measureColumns = (c) => {
+        const blockLeft = c.marginLeft ?? 0;
+        const blockRight = c.marginRight ?? 0;
+        const totalWidth = Math.max(bandWidth - blockLeft - blockRight, 1);
+        const cols = c.columns;
+        const n = cols.length;
+        if (!n) return (c.marginTop ?? 0) + (c.marginBottom ?? 0);
+        let colWidths;
+        let gap;
+        const mode = c.mode ?? "fixedGap";
+        if (mode === "spaceBetween" && n > 1) {
+          if (c.widths && c.widths.length === n) {
+            colWidths = computeColumnPixelWidths(c.widths, totalWidth);
+          } else {
+            const equal = totalWidth / n;
+            colWidths = Array(n).fill(equal);
+          }
+          const totalColsWidth = colWidths.reduce((a, b) => a + b, 0);
+          const remaining = Math.max(totalWidth - totalColsWidth, 0);
+          gap = remaining / (n - 1);
+        } else {
+          gap = c.gap ?? 20;
+          const totalGapsWidth = gap * (n - 1);
+          const widthForCols = Math.max(totalWidth - totalGapsWidth, 1);
+          if (c.widths && c.widths.length === n) {
+            colWidths = computeColumnPixelWidths(c.widths, widthForCols);
+          } else {
+            const equal = widthForCols / n;
+            colWidths = Array(n).fill(equal);
+          }
+        }
+        const mt = c.marginTop ?? 0;
+        const mb = c.marginBottom ?? 0;
+        const colHeights = [];
+        cols.forEach((colBlocks, idx) => {
+          const colEnv = {
+            marginLeft: 0,
+            innerWidth: colWidths[idx],
+            allowPageBreak: false
+          };
+          let colY = 0;
+          for (const b of colBlocks) {
+            colY += measureInnerBlock(b, colEnv);
+          }
+          colHeights.push(colY);
+        });
+        const maxColHeight = Math.max(...colHeights, 0);
+        return mt + maxColHeight + mb;
+      };
+      const innerEnv = {
+        marginLeft: 0,
+        innerWidth: bandWidth,
+        allowPageBreak: false
+      };
+      const measureInnerBlock = (b, envForColumns) => {
+        switch (b.type) {
+          case "text": {
+            const tb = resolveTextBlock(styles, b);
+            const localLeft2 = tb.marginLeft ?? 0;
+            const localRight2 = tb.marginRight ?? 0;
+            const width = Math.max(
+              envForColumns.innerWidth - localLeft2 - localRight2,
+              1
+            );
+            doc.fontSize(tb.fontSize ?? 10);
+            const isBold = !!tb.bold;
+            const isItalic = !!tb.italic;
+            let fontName = tb.font;
+            if (!fontName) {
+              if (isBold && isItalic) fontName = "Helvetica-BoldOblique";
+              else if (isBold) fontName = "Helvetica-Bold";
+              else if (isItalic) fontName = "Helvetica-Oblique";
+              else fontName = "Helvetica";
+            }
+            doc.font(fontName);
+            const h = doc.heightOfString(tb.text, { width });
+            const gap = tb.lineGap ?? 4;
+            return h + gap;
+          }
+          case "image": {
+            const ib = b;
+            const h = ib.height ?? 50;
+            return measureImageLike(ib.marginTop, ib.marginBottom, h);
+          }
+          case "qr": {
+            const qb = b;
+            const size = qb.size ?? 80;
+            return measureImageLike(qb.marginTop, qb.marginBottom, size);
+          }
+          case "barcode": {
+            const bb = b;
+            const h = bb.height ?? 40;
+            return measureImageLike(bb.marginTop, bb.marginBottom, h);
+          }
+          case "line": {
+            const lb = b;
+            const lw = lb.lineWidth ?? 1;
+            const mt = lb.marginTop ?? 0;
+            const mb = lb.marginBottom ?? 0;
+            return mt + lw + mb;
+          }
+          case "table": {
+            const t = b;
+            const fakeEnv = {
+              marginLeft: t.marginLeft ?? 0,
+              innerWidth: bandWidth - (t.marginLeft ?? 0) - (t.marginRight ?? 0),
+              allowPageBreak: false
+            };
+            return measureTableHeight(
+              doc,
+              t,
+              fakeEnv,
+              styles,
+              computeColumnPixelWidths
+            );
+          }
+          case "columns":
+            return measureColumns(b);
+          case "signature":
+            return b.height;
+          default:
+            return 0;
+        }
+      };
+      for (const inner of block.blocks) {
+        required += measureInnerBlock(inner, innerEnv);
+      }
+      requiredHeight = Math.max(requiredHeight, required);
+    }
+    const sigHeight = requiredHeight;
+    const pageHeight = doc.page.height;
+    const candidateTop = pageHeight - doc.page.margins.bottom - sigHeight;
+    if (ctx.currentY > candidateTop) {
+      finishPage2(true);
+    }
+    const newPageHeight = doc.page.height;
+    const newCandidateTop = newPageHeight - doc.page.margins.bottom - sigHeight;
+    ctx.signatureBlock = { ...block, height: sigHeight };
+    ctx.signatureTopY = newCandidateTop;
+    ctx.signatureHeight = sigHeight;
+    ctx.signaturePlaced = true;
+    ctx.afterSignature = true;
+  };
+}
+
+// src/renderer-engine/utils/start-page-layout.ts
+function createStartNewPageLayout({
+  doc,
+  def,
+  ctx,
+  headerBandHeight,
+  renderBlockArray
+}) {
+  return () => {
+    drawPageBackground(doc, def.pageBackground);
+    drawHeader(
+      doc,
+      def,
+      headerBandHeight,
+      def.header ?? void 0,
+      renderBlockArray
+    );
+    const mode = def.watermark?.mode;
+    if (def.watermark && !watermarkUsesLast(mode)) {
+      drawWatermarkForPage(doc, def.watermark, ctx.pageNumber, false);
+    }
+    ctx.currentY = doc.page.margins.top;
+    ctx.signatureBlock = null;
+    ctx.signatureTopY = null;
+    ctx.signatureHeight = 0;
+    ctx.signaturePlaced = false;
+    ctx.afterSignature = false;
+  };
+}
+
+// src/renderer-engine/utils/watermark.ts
+function watermarkUsesLast(mode) {
+  return mode === "last" || mode === "firstLast" || mode === "exceptLast" || mode === "exceptFirstLast";
+}
+function drawWatermarkForPage(doc, watermark, pageNumber, isLast) {
+  const {
+    text,
+    opacity = 0.06,
+    fontSize = 60,
+    color = "gray",
+    angle = 45,
+    mode = "all"
+  } = watermark;
+  const shouldDraw = (() => {
+    switch (mode) {
+      case "all":
+        return true;
+      case "first":
+        return pageNumber === 1;
+      case "last":
+        return isLast;
+      case "firstLast":
+        return pageNumber === 1 || isLast;
+      case "exceptFirstLast":
+        return pageNumber !== 1 && !isLast;
+      case "exceptFirst":
+        return pageNumber !== 1;
+      case "exceptLast":
+        return !isLast;
+      default:
+        return true;
+    }
+  })();
+  if (!shouldDraw) return;
+  const centerX = doc.page.width / 2;
+  const centerY = doc.page.height / 2;
+  doc.save();
+  doc.fillColor(color);
+  doc.opacity(opacity);
+  doc.fontSize(fontSize);
+  const textWidth = doc.widthOfString(text);
+  const textHeight = doc.currentLineHeight();
+  const x = centerX - textWidth / 2;
+  const y = centerY - textHeight / 2;
+  doc.rotate(angle, { origin: [centerX, centerY] });
+  doc.text(text, x, y);
+  doc.restore();
+  doc.opacity(1);
+}
+
+// src/renderer-engine/index.ts
+async function renderCustomPdf(def, outputPath) {
+  if (def.header) {
+    def.header.blocks = await materializeQrAndBarcodesInBlocks(
+      def.header.blocks
+    );
+    def.header.blocks = await materializeImagesInBlocks(def.header.blocks);
+  }
+  def.content = await materializeQrAndBarcodesInBlocks(def.content);
+  def.content = await materializeImagesInBlocks(def.content);
+  if (def.pageBackground?.src) {
+    def.pageBackground.src = await normalizeImageSrc(def.pageBackground.src);
+  }
+  if (def.header?.backgroundImage) {
+    def.header.backgroundImage = await normalizeImageSrc(
+      def.header.backgroundImage
+    );
+  }
+  if (def.footer && typeof def.footer !== "function") {
+    const footer = def.footer;
+    if (footer.backgroundImage) {
+      footer.backgroundImage = await normalizeImageSrc(footer.backgroundImage);
+    }
+  }
+  return new Promise((resolve, reject) => {
+    const headerBandHeight = def.margins.top ?? 0;
+    const footerBandHeight = def.margins.bottom ?? 0;
+    const doc = new PDFDocument({
+      size: def.pageSize || "A4",
+      margins: {
+        top: headerBandHeight,
+        bottom: footerBandHeight,
+        left: def.margins.left,
+        right: def.margins.right
+      }
+    });
+    if (def.fonts && def.fonts.length) {
+      for (const f of def.fonts) {
+        try {
+          doc.registerFont(f.name, f.src);
+        } catch (e) {
+          console.warn("Failed to register font:", f.name, e);
+        }
+      }
+    }
+    const stream = fs.createWriteStream(outputPath);
+    doc.pipe(stream);
+    const ctx = createInitialContext(doc);
+    const styles = def.styles ?? {};
+    const finishPage2 = (addNewPage) => finishPage({
+      addNewPage,
+      doc,
+      def,
+      ctx,
+      footerBandHeight,
+      renderBlockArray,
+      startNewPageLayout
+    });
+    const processSignatureBlock = createProcessSignatureBlock({
+      doc,
+      ctx,
+      styles,
+      finishPage: finishPage2,
+      contentEnvFn: contentEnv
+    });
+    const { renderBlock, renderBlockArray } = createBlockRenderer({
+      doc,
+      ctx,
+      styles,
+      computeColumnPixelWidths,
+      finishPage: finishPage2,
+      processSignatureBlock
+    });
+    const startNewPageLayout = createStartNewPageLayout({
+      doc,
+      def,
+      ctx,
+      headerBandHeight,
+      renderBlockArray
+    });
+    startNewPageLayout();
+    for (const block of def.content) {
+      if (block.type === "signature") {
+        processSignatureBlock(block);
+        continue;
+      }
+      if (ctx.afterSignature) {
+        finishPage2(true);
+        ctx.afterSignature = false;
+      }
+      renderBlock(block, null, contentEnv(doc));
+    }
+    finishPage2(false);
+    doc.end();
+    stream.on("finish", () => resolve());
+    stream.on("error", (err) => reject(err));
+  });
+}
+async function renderCustomPdfToBuffer(def) {
+  if (def.header) {
+    def.header.blocks = await materializeQrAndBarcodesInBlocks(
+      def.header.blocks
+    );
+    def.header.blocks = await materializeImagesInBlocks(def.header.blocks);
+  }
+  def.content = await materializeQrAndBarcodesInBlocks(def.content);
+  def.content = await materializeImagesInBlocks(def.content);
+  if (def.pageBackground?.src) {
+    def.pageBackground.src = await normalizeImageSrc(def.pageBackground.src);
+  }
+  if (def.header?.backgroundImage) {
+    def.header.backgroundImage = await normalizeImageSrc(
+      def.header.backgroundImage
+    );
+  }
+  if (def.footer && typeof def.footer !== "function") {
+    const footer = def.footer;
+    if (footer.backgroundImage) {
+      footer.backgroundImage = await normalizeImageSrc(footer.backgroundImage);
+    }
+  }
+  return new Promise((resolve, reject) => {
+    const headerBandHeight = def.margins.top ?? 0;
+    const footerBandHeight = def.margins.bottom ?? 0;
+    const doc = new PDFDocument({
+      size: def.pageSize || "A4",
+      margins: {
+        top: headerBandHeight,
+        bottom: footerBandHeight,
+        left: def.margins.left,
+        right: def.margins.right
+      }
+    });
+    const chunks = [];
+    doc.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    doc.on("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+    doc.on("error", (err) => {
+      reject(err);
+    });
+    if (def.fonts && def.fonts.length) {
+      for (const f of def.fonts) {
+        try {
+          doc.registerFont(f.name, f.src);
+        } catch (e) {
+          console.warn("Failed to register font:", f.name, e);
+        }
+      }
+    }
+    const ctx = createInitialContext(doc);
+    const styles = def.styles ?? {};
+    const finishPage2 = (addNewPage) => finishPage({
+      addNewPage,
+      doc,
+      def,
+      ctx,
+      footerBandHeight,
+      renderBlockArray,
+      startNewPageLayout
+    });
+    const processSignatureBlock = createProcessSignatureBlock({
+      doc,
+      ctx,
+      styles,
+      finishPage: finishPage2,
+      contentEnvFn: contentEnv
+    });
+    const { renderBlock, renderBlockArray } = createBlockRenderer({
+      doc,
+      ctx,
+      styles,
+      computeColumnPixelWidths,
+      finishPage: finishPage2,
+      processSignatureBlock
+    });
+    const startNewPageLayout = createStartNewPageLayout({
+      doc,
+      def,
+      ctx,
+      headerBandHeight,
+      renderBlockArray
+    });
+    startNewPageLayout();
+    for (const block of def.content) {
+      if (block.type === "signature") {
+        processSignatureBlock(block);
+        continue;
+      }
+      if (ctx.afterSignature) {
+        finishPage2(true);
+        ctx.afterSignature = false;
+      }
+      renderBlock(block, null, contentEnv(doc));
+    }
+    finishPage2(false);
+    doc.end();
+  });
+}
+
+// src/types/barcode.ts
+var BARCODE_TYPES = {
+  CODE128: "CODE128",
+  EAN13: "EAN13",
+  CODE39: "CODE39",
+  ITF: "ITF",
+  CODE93: "CODE93"
+};
+
+// src/types/qr.ts
+var QR_ERROR_LEVEL = {
+  LOW: "L",
+  MEDIUM: "M",
+  QUARTILE: "Q",
+  HIGH: "H"
+};
+export {
+  BARCODE_TYPES,
+  QR_ERROR_LEVEL,
+  renderCustomPdf,
+  renderCustomPdfToBuffer
+};