@ganttloom/gantt-export 0.2.0

package/dist/pdf.cjs

@@ -0,0 +1,671 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pdf.ts
+var pdf_exports = {};
+__export(pdf_exports, {
+  computePagination: () => computePagination,
+  renderToPDF: () => renderToPDF
+});
+module.exports = __toCommonJS(pdf_exports);
+
+// src/paginate.ts
+var PAGE_SIZES_PT = {
+  // Values are the portrait (short-edge width x long-edge height) dimensions
+  // in PDF/typographic points (72pt = 1in).
+  A4: { width: 595.28, height: 841.89 },
+  Letter: { width: 612, height: 792 },
+  A3: { width: 841.89, height: 1190.55 }
+};
+var DEFAULT_MARGIN_PT = 36;
+var DEFAULT_SCALE = 0.75;
+var MIN_TIMELINE_WIDTH_PT = 50;
+var MIN_ROWS_HEIGHT_PT = 20;
+function resolvePageSize(opt) {
+  if (opt?.custom) {
+    return { width: opt.custom.widthPt, height: opt.custom.heightPt };
+  }
+  const name = opt?.name ?? "A4";
+  const base = PAGE_SIZES_PT[name];
+  const orientation = opt?.orientation ?? "landscape";
+  const short = Math.min(base.width, base.height);
+  const long = Math.max(base.width, base.height);
+  return orientation === "landscape" ? { width: long, height: short } : { width: short, height: long };
+}
+function defaultGridPanelWidthPx(model) {
+  const cols = model.columns ?? [];
+  if (cols.length === 0) return 160;
+  return cols.reduce((sum, c) => sum + (c.width ?? 120), 0);
+}
+function computePagination(model, options = {}) {
+  const { width: pageWidthPt, height: pageHeightPt } = resolvePageSize(options.pageSize);
+  const margins = {
+    top: options.margins?.top ?? DEFAULT_MARGIN_PT,
+    right: options.margins?.right ?? DEFAULT_MARGIN_PT,
+    bottom: options.margins?.bottom ?? DEFAULT_MARGIN_PT,
+    left: options.margins?.left ?? DEFAULT_MARGIN_PT
+  };
+  const scale = options.scale ?? DEFAULT_SCALE;
+  const gridPanelWidthPx = options.gridPanelWidthPx ?? defaultGridPanelWidthPx(model);
+  const gridPanelWidthPt = gridPanelWidthPx * scale;
+  const headerHeightPx = model.headerHeight;
+  const headerHeightPt = headerHeightPx * scale;
+  const contentWidthPt = pageWidthPt - margins.left - margins.right;
+  const contentHeightPt = pageHeightPt - margins.top - margins.bottom;
+  const timelineWidthPtPerPage = Math.max(contentWidthPt - gridPanelWidthPt, MIN_TIMELINE_WIDTH_PT);
+  const rowsHeightPtPerPage = Math.max(contentHeightPt - headerHeightPt, MIN_ROWS_HEIGHT_PT);
+  const timelineWidthPxPerPage = timelineWidthPtPerPage / scale;
+  const rowsHeightPxPerPage = rowsHeightPtPerPage / scale;
+  const totalHeightPx = Math.max(model.height, 1);
+  const totalWidthPx = Math.max(model.width, 1);
+  const rowCount = Math.max(1, Math.ceil(totalHeightPx / rowsHeightPxPerPage));
+  const colCount = Math.max(1, Math.ceil(totalWidthPx / timelineWidthPxPerPage));
+  const rowBands = [];
+  for (let i = 0; i < rowCount; i++) {
+    rowBands.push({
+      start: i * rowsHeightPxPerPage,
+      end: Math.min(totalHeightPx, (i + 1) * rowsHeightPxPerPage)
+    });
+  }
+  const colBands = [];
+  for (let i = 0; i < colCount; i++) {
+    colBands.push({
+      start: i * timelineWidthPxPerPage,
+      end: Math.min(totalWidthPx, (i + 1) * timelineWidthPxPerPage)
+    });
+  }
+  const pages = [];
+  for (let r = 0; r < rowCount; r++) {
+    const rowBand = rowBands[r];
+    for (let c = 0; c < colCount; c++) {
+      const colBand = colBands[c];
+      pages.push({
+        rowBand: r,
+        colBand: c,
+        rowStartY: rowBand.start,
+        rowEndY: rowBand.end,
+        colStartX: colBand.start,
+        colEndX: colBand.end
+      });
+    }
+  }
+  return {
+    pageWidthPt,
+    pageHeightPt,
+    margins,
+    scale,
+    gridPanelWidthPx,
+    gridPanelWidthPt,
+    headerHeightPx,
+    headerHeightPt,
+    timelineWidthPxPerPage,
+    rowsHeightPxPerPage,
+    rowBands,
+    colBands,
+    pages,
+    rowCount,
+    colCount
+  };
+}
+function clipSegment(x0, y0, x1, y1, rect) {
+  let t0 = 0;
+  let t1 = 1;
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const checks = [
+    [-dx, x0 - rect.x0],
+    [dx, rect.x1 - x0],
+    [-dy, y0 - rect.y0],
+    [dy, rect.y1 - y0]
+  ];
+  for (const [p, q] of checks) {
+    if (p === 0) {
+      if (q < 0) return null;
+    } else {
+      const r = q / p;
+      if (p < 0) {
+        if (r > t1) return null;
+        if (r > t0) t0 = r;
+      } else {
+        if (r < t0) return null;
+        if (r < t1) t1 = r;
+      }
+    }
+  }
+  return { x0: x0 + t0 * dx, y0: y0 + t0 * dy, x1: x0 + t1 * dx, y1: y0 + t1 * dy };
+}
+function clipRect(x, y, w, h, rect) {
+  const x0 = Math.max(x, rect.x0);
+  const y0 = Math.max(y, rect.y0);
+  const x1 = Math.min(x + w, rect.x1);
+  const y1 = Math.min(y + h, rect.y1);
+  if (x1 <= x0 || y1 <= y0) return null;
+  return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+
+// src/geom.ts
+function computeLinkPolyline(fromBar, toBar) {
+  const x0 = fromBar.x + fromBar.width;
+  const y0 = fromBar.y + fromBar.height / 2;
+  const x1 = toBar.x;
+  const y1 = toBar.y + toBar.height / 2;
+  if (Math.abs(y1 - y0) < 0.01) {
+    return [{ x: x0, y: y0 }, { x: x1, y: y1 }];
+  }
+  const midX = x0 + (x1 - x0) / 2;
+  return [
+    { x: x0, y: y0 },
+    { x: midX, y: y0 },
+    { x: midX, y: y1 },
+    { x: x1, y: y1 }
+  ];
+}
+function clipPolylineToRect(points, rect) {
+  const segments = [];
+  let current = [];
+  for (let i = 0; i < points.length - 1; i++) {
+    const a = points[i];
+    const b = points[i + 1];
+    const clipped = clipSegment(a.x, a.y, b.x, b.y, rect);
+    if (!clipped) {
+      if (current.length > 1) segments.push(current);
+      current = [];
+      continue;
+    }
+    if (current.length === 0) {
+      current.push({ x: clipped.x0, y: clipped.y0 });
+    } else {
+      const last = current[current.length - 1];
+      if (Math.abs(last.x - clipped.x0) > 0.01 || Math.abs(last.y - clipped.y0) > 0.01) {
+        if (current.length > 1) segments.push(current);
+        current = [{ x: clipped.x0, y: clipped.y0 }];
+      }
+    }
+    current.push({ x: clipped.x1, y: clipped.y1 });
+  }
+  if (current.length > 1) segments.push(current);
+  return segments;
+}
+
+// src/layout.ts
+function columnWidthsPt(model, layout) {
+  const columns = model.columns.length > 0 ? model.columns : [{ id: "name", title: "Task" }];
+  const naturalTotal = columns.reduce((sum, c) => sum + (c.width ?? 120), 0) || 1;
+  return columns.map((column) => ({
+    column,
+    widthPt: (column.width ?? 120) / naturalTotal * layout.gridPanelWidthPt
+  }));
+}
+function cellText(column, task, depth) {
+  if (!task) return "";
+  if (column.accessor) {
+    const v = column.accessor(task);
+    return v === null || v === void 0 ? "" : String(v);
+  }
+  const indent = "  ".repeat(Math.max(0, depth));
+  return `${indent}${task.name}`;
+}
+function buildPageContent(model, tasks, layout, page) {
+  const { scale, gridPanelWidthPt, headerHeightPt, pageWidthPt, pageHeightPt, margins } = layout;
+  const theme = model.theme;
+  const tasksById = new Map(tasks.map((t) => [t.id, t]));
+  const barsByTaskId = new Map(model.bars.map((b) => [b.taskId, b]));
+  const rowsByTaskId = new Map(model.rows.map((r) => [r.taskId, r]));
+  const commands = [];
+  const contentX0 = margins.left;
+  const contentY0 = margins.top;
+  const timelineRect = {
+    x0: page.colStartX,
+    y0: page.rowStartY,
+    x1: page.colEndX,
+    y1: page.rowEndY
+  };
+  commands.push({ kind: "rect", x: 0, y: 0, w: pageWidthPt, h: pageHeightPt, fill: theme.backgroundColor });
+  const cols = columnWidthsPt(model, layout);
+  let colCursor = contentX0;
+  for (const { column, widthPt } of cols) {
+    commands.push({
+      kind: "text",
+      x: colCursor + 4,
+      y: contentY0 + headerHeightPt / 2 - 5,
+      w: widthPt - 8,
+      text: column.title,
+      size: 9,
+      color: theme.textColor,
+      bold: true,
+      align: column.align ?? "left"
+    });
+    colCursor += widthPt;
+  }
+  commands.push({
+    kind: "rect",
+    x: contentX0,
+    y: contentY0,
+    w: gridPanelWidthPt + (page.colEndX - page.colStartX) * scale,
+    h: headerHeightPt,
+    stroke: theme.gridColor
+  });
+  const timelineOriginX = contentX0 + gridPanelWidthPt;
+  for (const tick of model.ticks) {
+    if (tick.x < page.colStartX || tick.x > page.colEndX) continue;
+    const px = timelineOriginX + (tick.x - page.colStartX) * scale;
+    if (tick.isWeekend) {
+    }
+    commands.push({
+      kind: "line",
+      points: [
+        { x: px, y: contentY0 },
+        { x: px, y: pageHeightPt - margins.bottom }
+      ],
+      stroke: tick.isToday ? theme.todayColor : theme.gridColor
+    });
+    commands.push({
+      kind: "text",
+      x: px + 2,
+      y: contentY0 + headerHeightPt / 2 - 5,
+      text: tick.label,
+      size: 7,
+      color: theme.textColor,
+      align: "left"
+    });
+  }
+  const rowTop = (y) => contentY0 + headerHeightPt + (y - page.rowStartY) * scale;
+  for (const row of model.rows) {
+    if (row.y + row.height <= page.rowStartY || row.y >= page.rowEndY) continue;
+    const clippedRowY0 = Math.max(row.y, page.rowStartY);
+    const clippedRowY1 = Math.min(row.y + row.height, page.rowEndY);
+    const rowYTop = rowTop(clippedRowY0);
+    const rowHPt = (clippedRowY1 - clippedRowY0) * scale;
+    const task = tasksById.get(row.taskId);
+    let cx = contentX0;
+    for (const { column, widthPt } of cols) {
+      commands.push({
+        kind: "text",
+        x: cx + 4,
+        y: rowYTop + rowHPt / 2 - 4,
+        w: widthPt - 8,
+        text: cellText(column, task, row.depth),
+        size: 8,
+        color: theme.textColor,
+        align: column.align ?? "left"
+      });
+      cx += widthPt;
+    }
+    commands.push({
+      kind: "rect",
+      x: contentX0,
+      y: rowYTop,
+      w: gridPanelWidthPt + (page.colEndX - page.colStartX) * scale,
+      h: rowHPt,
+      stroke: theme.gridColor
+    });
+    const bar = barsByTaskId.get(row.taskId);
+    if (bar) {
+      const clippedBar = clipRect(bar.x, bar.y, bar.width, bar.height, timelineRect);
+      if (clippedBar) {
+        const bx = timelineOriginX + (clippedBar.x - page.colStartX) * scale;
+        const by = rowTop(clippedBar.y);
+        const bw = clippedBar.w * scale;
+        const bh = clippedBar.h * scale;
+        if (bar.baseline) {
+          const clippedBaseline = clipRect(bar.baseline.x, bar.y, bar.baseline.width, bar.height, timelineRect);
+          if (clippedBaseline) {
+            commands.push({
+              kind: "rect",
+              x: timelineOriginX + (clippedBaseline.x - page.colStartX) * scale,
+              y: rowTop(clippedBaseline.y),
+              w: clippedBaseline.w * scale,
+              h: clippedBaseline.h * scale,
+              fill: theme.baselineColor
+            });
+          }
+        }
+        if (bar.isMilestone) {
+          const r = bh / 2;
+          commands.push({
+            kind: "diamond",
+            cx: bx + r,
+            cy: by + r,
+            r,
+            fill: bar.isCritical ? theme.criticalColor : bar.color,
+            stroke: theme.textColor
+          });
+          if (bar.label) {
+            commands.push({
+              kind: "text",
+              x: bx + bh + 4,
+              y: by + bh / 2 - 4,
+              text: bar.label,
+              size: 8,
+              color: theme.textColor
+            });
+          }
+        } else {
+          commands.push({
+            kind: "rect",
+            x: bx,
+            y: by,
+            w: bw,
+            h: bh,
+            fill: bar.isCritical ? theme.criticalColor : bar.color
+          });
+          if (bar.progressWidth > 0) {
+            const clippedProgress = clipRect(bar.x, bar.y, bar.progressWidth, bar.height, timelineRect);
+            if (clippedProgress) {
+              commands.push({
+                kind: "rect",
+                x: timelineOriginX + (clippedProgress.x - page.colStartX) * scale,
+                y: rowTop(clippedProgress.y),
+                w: clippedProgress.w * scale,
+                h: clippedProgress.h * scale,
+                fill: bar.progressColor
+              });
+            }
+          }
+          commands.push({
+            kind: "text",
+            x: bx + 3,
+            y: by + bh / 2 - 4,
+            text: bar.label,
+            size: 8,
+            color: theme.textColor
+          });
+        }
+      }
+    }
+  }
+  for (const link of model.links) {
+    const fromBar = barsByTaskId.get(link.fromId);
+    const toBar = barsByTaskId.get(link.toId);
+    if (!fromBar || !toBar) continue;
+    const fromRow = rowsByTaskId.get(link.fromId);
+    const toRow = rowsByTaskId.get(link.toId);
+    if (!fromRow || !toRow) continue;
+    const polyline = computeLinkPolyline(fromBar, toBar);
+    const pieces = clipPolylineToRect(polyline, timelineRect);
+    for (const piece of pieces) {
+      commands.push({
+        kind: "line",
+        points: piece.map((p) => ({
+          x: timelineOriginX + (p.x - page.colStartX) * scale,
+          y: rowTop(p.y)
+        })),
+        stroke: link.isCritical ? theme.criticalColor : theme.linkColor
+      });
+    }
+  }
+  return { widthPt: pageWidthPt, heightPt: pageHeightPt, commands };
+}
+
+// src/pdf/writer.ts
+var encoder = new TextEncoder();
+function encodeLatin1(str) {
+  const out = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    out[i] = code <= 255 ? code : 63;
+  }
+  return out;
+}
+function escapePdfText(str) {
+  return str.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+}
+function xrefLine(offset, generation, type) {
+  const line = `${String(offset).padStart(10, "0")} ${String(generation).padStart(5, "0")} ${type} 
+`;
+  return line;
+}
+var PdfBuilder = class {
+  constructor() {
+    this.parts = [];
+    this.length = 0;
+    this.offsetsById = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+  }
+  reserveId() {
+    return this.nextId++;
+  }
+  raw(bytes) {
+    this.parts.push(bytes);
+    this.length += bytes.length;
+  }
+  text(s) {
+    this.raw(encoder.encode(s));
+  }
+  writeHeader() {
+    this.text("%PDF-1.4\n");
+    this.raw(new Uint8Array([37, 226, 227, 207, 211, 10]));
+  }
+  /** Append a simple (non-stream) indirect object, e.g. a dictionary or array. */
+  addObject(id, body) {
+    this.offsetsById.set(id, this.length);
+    this.text(`${id} 0 obj
+${body}
+endobj
+`);
+  }
+  /** Append a stream object; `dictExtra` is the dictionary content besides `/Length`. */
+  addStreamObject(id, dictExtra, data) {
+    this.offsetsById.set(id, this.length);
+    this.text(`${id} 0 obj
+<< ${dictExtra} /Length ${data.length} >>
+stream
+`);
+    this.raw(data);
+    this.text("\nendstream\nendobj\n");
+  }
+  /** Finalize the file: write the xref table, trailer, and startxref/%%EOF footer. */
+  build(rootId) {
+    const xrefOffset = this.length;
+    const maxId = this.nextId - 1;
+    let xref = `xref
+0 ${maxId + 1}
+`;
+    xref += xrefLine(0, 65535, "f");
+    for (let id = 1; id <= maxId; id++) {
+      const off = this.offsetsById.get(id);
+      if (off === void 0) {
+        throw new Error(`PdfBuilder: object ${id} was reserved but never written`);
+      }
+      xref += xrefLine(off, 0, "n");
+    }
+    this.text(xref);
+    this.text(`trailer
+<< /Size ${maxId + 1} /Root ${rootId} 0 R >>
+startxref
+${xrefOffset}
+%%EOF`);
+    const total = new Uint8Array(this.length);
+    let o = 0;
+    for (const p of this.parts) {
+      total.set(p, o);
+      o += p.length;
+    }
+    return total;
+  }
+  /** Byte offset an object was (or will be) written at — exposed for tests. */
+  getOffset(id) {
+    return this.offsetsById.get(id);
+  }
+};
+
+// src/color.ts
+function parseColor(input) {
+  if (!input) return [0, 0, 0];
+  const s = input.trim();
+  const hex = s.match(/^#?([0-9a-fA-F]{6})$/) ?? s.match(/^#?([0-9a-fA-F]{3})$/);
+  if (hex) {
+    let h = hex[1];
+    if (h.length === 3) {
+      h = h.split("").map((c) => c + c).join("");
+    }
+    const r = parseInt(h.slice(0, 2), 16) / 255;
+    const g = parseInt(h.slice(2, 4), 16) / 255;
+    const b = parseInt(h.slice(4, 6), 16) / 255;
+    return [r, g, b];
+  }
+  const rgb = s.match(/^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)/i);
+  if (rgb) {
+    return [Number(rgb[1]) / 255, Number(rgb[2]) / 255, Number(rgb[3]) / 255];
+  }
+  const named = {
+    black: [0, 0, 0],
+    white: [1, 1, 1],
+    red: [1, 0, 0],
+    green: [0, 0.5, 0],
+    blue: [0, 0, 1],
+    gray: [0.5, 0.5, 0.5],
+    grey: [0.5, 0.5, 0.5],
+    transparent: [1, 1, 1]
+  };
+  return named[s.toLowerCase()] ?? [0, 0, 0];
+}
+
+// src/pdf/content.ts
+function num(n) {
+  const r = Math.round(n * 1e3) / 1e3;
+  return Object.is(r, -0) ? "0" : String(r);
+}
+function colorOp(color, op) {
+  const [r, g, b] = parseColor(color);
+  return `${num(r)} ${num(g)} ${num(b)} ${op}
+`;
+}
+function buildContentStream(commands, pageHeightPt) {
+  let s = "q\n";
+  for (const cmd of commands) {
+    switch (cmd.kind) {
+      case "rect": {
+        const x = cmd.x;
+        const yTop = pageHeightPt - (cmd.y + cmd.h);
+        if (cmd.fill) s += colorOp(cmd.fill, "rg");
+        if (cmd.stroke) s += colorOp(cmd.stroke, "RG");
+        s += `${num(x)} ${num(yTop)} ${num(cmd.w)} ${num(cmd.h)} re
+`;
+        if (cmd.fill && cmd.stroke) s += "B\n";
+        else if (cmd.fill) s += "f\n";
+        else if (cmd.stroke) s += "S\n";
+        break;
+      }
+      case "diamond": {
+        const pts = [
+          { x: cmd.cx, y: cmd.cy - cmd.r },
+          { x: cmd.cx + cmd.r, y: cmd.cy },
+          { x: cmd.cx, y: cmd.cy + cmd.r },
+          { x: cmd.cx - cmd.r, y: cmd.cy }
+        ].map((p) => ({ x: p.x, y: pageHeightPt - p.y }));
+        if (cmd.fill) s += colorOp(cmd.fill, "rg");
+        if (cmd.stroke) s += colorOp(cmd.stroke, "RG");
+        s += `${num(pts[0].x)} ${num(pts[0].y)} m
+`;
+        for (let i = 1; i < pts.length; i++) s += `${num(pts[i].x)} ${num(pts[i].y)} l
+`;
+        s += "h\n";
+        if (cmd.fill && cmd.stroke) s += "B\n";
+        else if (cmd.fill) s += "f\n";
+        else if (cmd.stroke) s += "S\n";
+        break;
+      }
+      case "line": {
+        if (cmd.points.length < 2) break;
+        s += colorOp(cmd.stroke, "RG");
+        const p0 = cmd.points[0];
+        s += `${num(p0.x)} ${num(pageHeightPt - p0.y)} m
+`;
+        for (let i = 1; i < cmd.points.length; i++) {
+          const p = cmd.points[i];
+          s += `${num(p.x)} ${num(pageHeightPt - p.y)} l
+`;
+        }
+        s += "S\n";
+        break;
+      }
+      case "text": {
+        if (!cmd.text) break;
+        const font = cmd.bold ? "/F2" : "/F1";
+        const baselineY = pageHeightPt - (cmd.y + cmd.size * 0.8);
+        s += colorOp(cmd.color, "rg");
+        s += "BT\n";
+        s += `${font} ${num(cmd.size)} Tf
+`;
+        s += `${num(cmd.x)} ${num(baselineY)} Td
+`;
+        s += `(${escapePdfText(latin1Safe(cmd.text))}) Tj
+`;
+        s += "ET\n";
+        break;
+      }
+    }
+  }
+  s += "Q\n";
+  return encodeLatin1(s);
+}
+function latin1Safe(s) {
+  let out = "";
+  for (const ch of s) {
+    const code = ch.codePointAt(0);
+    out += code <= 255 ? ch : "?";
+  }
+  return out;
+}
+
+// src/pdf/index.ts
+function renderToPDF(model, tasks, options = {}) {
+  const layout = computePagination(model, options);
+  const pdf = new PdfBuilder();
+  pdf.writeHeader();
+  const catalogId = pdf.reserveId();
+  const pagesId = pdf.reserveId();
+  const helveticaId = pdf.reserveId();
+  const helveticaBoldId = pdf.reserveId();
+  pdf.addObject(helveticaId, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>");
+  pdf.addObject(
+    helveticaBoldId,
+    "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >>"
+  );
+  const pageIds = [];
+  for (const page of layout.pages) {
+    const content = buildPageContent(model, tasks, layout, page);
+    const streamBytes = buildContentStream(content.commands, layout.pageHeightPt);
+    const pageId = pdf.reserveId();
+    const contentId = pdf.reserveId();
+    pdf.addStreamObject(contentId, "", streamBytes);
+    pdf.addObject(
+      pageId,
+      `<< /Type /Page /Parent ${pagesId} 0 R /MediaBox [0 0 ${num2(layout.pageWidthPt)} ${num2(layout.pageHeightPt)}] /Resources << /Font << /F1 ${helveticaId} 0 R /F2 ${helveticaBoldId} 0 R >> >> /Contents ${contentId} 0 R >>`
+    );
+    pageIds.push(pageId);
+  }
+  pdf.addObject(
+    pagesId,
+    `<< /Type /Pages /Kids [${pageIds.map((id) => `${id} 0 R`).join(" ")}] /Count ${pageIds.length} >>`
+  );
+  pdf.addObject(catalogId, `<< /Type /Catalog /Pages ${pagesId} 0 R >>`);
+  return pdf.build(catalogId);
+}
+function num2(n) {
+  const r = Math.round(n * 1e3) / 1e3;
+  return Object.is(r, -0) ? "0" : String(r);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computePagination,
+  renderToPDF
+});
+//# sourceMappingURL=pdf.cjs.map