@broadpaper/forme 0.2.1 → 0.4.0

package/dist/{chunk-2PT5WRKQ.js → chunk-QA4APTWM.js}

@@ -892,7 +892,7 @@ var FormeMeasurer = class {
       defaultPage: { size: "A4", margin: { top: 54, right: 54, bottom: 54, left: 54 }, wrap: true },
       defaultStyle: {}
     };
-    if (this.opts.fonts?.length) doc.fonts = this.opts.fonts;
+    if (this.opts.fonts?.length) doc.fonts = this.opts.fonts.map((f) => ({ ...f }));
     const result = await this.opts.render(doc);
     const pages = result.layout?.pages ?? [];
     const toPx = 96 / 72;
@@ -902,6 +902,146 @@ var FormeMeasurer = class {
   }
 };
 
+// src/fonts.ts
+var localReader = null;
+function setFontFileReader(reader) {
+  localReader = reader;
+}
+var MAX_FONT_BYTES = 32 * 1024 * 1024;
+var FETCH_TIMEOUT_MS = 15e3;
+var MAX_CACHED = 64;
+var cache = /* @__PURE__ */ new Map();
+async function resolveFonts(input) {
+  const fonts = [];
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (font) => {
+    const weight = font.weight ?? 400;
+    const style = font.style ?? "normal";
+    const key = `${font.family.trim().toLowerCase()}|${weight}|${style}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    fonts.push({ family: font.family, src: font.src, weight, style });
+  };
+  for (const font of input.fonts ?? []) add(font);
+  const faces = await Promise.all((input.theme?.fonts ?? []).map((face) => themeFace(face, input.sources ?? {})));
+  for (const face of faces) {
+    warnings.push(...face.warnings);
+    if (face.font) add(face.font);
+  }
+  return { fonts, warnings };
+}
+async function themeFace(face, policy) {
+  const { weight, range } = weightOf(face.weight);
+  const style = face.style === "italic" ? "italic" : "normal";
+  const name = `"${face.family}" (${weight}${style === "italic" ? " italic" : ""})`;
+  const sources = (Array.isArray(face.src) ? face.src : [face.src]).filter((s) => typeof s === "string" && s.trim() !== "");
+  const reasons = [];
+  for (const src of sources) {
+    const loaded = await load(src.trim(), policy);
+    if ("reason" in loaded) {
+      reasons.push(loaded.reason);
+      continue;
+    }
+    const warnings = range ? [`The font "${face.family}" declares the weights ${String(face.weight)} from one file; the PDF engine is given it at ${weight} only. Declare a file per weight for the others to be embedded.`] : [];
+    return { font: { family: face.family, src: loaded.src, weight, style }, warnings };
+  }
+  return {
+    warnings: [
+      `The font ${name} has no TrueType or OpenType source the PDF engine can read, so the PDF draws that text in a standard face and breaks its lines differently from the screen. Add a .ttf or .otf to its src${reasons.length ? ` (${reasons.join("; ")})` : ""}.`
+    ]
+  };
+}
+function weightOf(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return { weight: Math.round(value), range: false };
+  const text = String(value ?? "").trim().toLowerCase();
+  if (text === "bold") return { weight: 700, range: false };
+  const numbers = text.split(/\s+/).map(Number).filter((n) => Number.isFinite(n) && n > 0);
+  if (!numbers.length) return { weight: 400, range: false };
+  return { weight: Math.round(numbers[0]), range: numbers.length > 1 && numbers[1] !== numbers[0] };
+}
+async function load(src, policy) {
+  if (/^data:(font|application)\/(x-)?woff2?[;,]/i.test(src) || /\.woff2?([?#]|$)/i.test(src.startsWith("data:") ? "" : src)) {
+    return { reason: `${describe(src)} is WOFF, which only a browser reads` };
+  }
+  if (src.startsWith("data:")) return fromDataUri(src);
+  const remote = /^https?:\/\//i.test(src);
+  if (remote) {
+    let host;
+    try {
+      host = new URL(src).hostname;
+    } catch {
+      return { reason: `${describe(src)} is not a valid address` };
+    }
+    const allowed = policy.allowedHosts;
+    if (allowed && !allowed.includes("*") && !allowed.includes(host)) return { reason: `${host} is not an allowed host` };
+  } else if (policy.local === false) {
+    return { reason: `${describe(src)} is neither a data: URI nor a web address, and files are not read here` };
+  } else if (!localReader) {
+    return { src };
+  }
+  const key = src;
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const pending = (async () => {
+    const bytes = remote ? await download(src, Boolean(policy.allowedHosts && !policy.allowedHosts.includes("*"))) : await localReader(src);
+    if (bytes.byteLength > MAX_FONT_BYTES) return { reason: `${describe(src)} is larger than ${MAX_FONT_BYTES / 1024 / 1024} MB` };
+    const problem = notEmbeddable(bytes, src);
+    return problem ? { reason: problem } : { src: `data:font/ttf;base64,${toBase64(bytes)}` };
+  })().catch((e) => {
+    cache.delete(key);
+    return { reason: `${describe(src)} could not be read (${e.message || String(e)})` };
+  });
+  cache.set(key, pending);
+  while (cache.size > MAX_CACHED) cache.delete(cache.keys().next().value);
+  return pending;
+}
+async function download(src, restricted) {
+  const signal = typeof AbortSignal !== "undefined" && "timeout" in AbortSignal ? AbortSignal.timeout(FETCH_TIMEOUT_MS) : void 0;
+  const response = await fetch(src, { redirect: restricted ? "error" : "follow", ...signal ? { signal } : {} });
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  const length2 = Number(response.headers.get("content-length"));
+  if (length2 > MAX_FONT_BYTES) throw new Error(`larger than ${MAX_FONT_BYTES / 1024 / 1024} MB`);
+  return new Uint8Array(await response.arrayBuffer());
+}
+function fromDataUri(src) {
+  const match = /^data:([^,]*),(.*)$/s.exec(src);
+  if (!match) return { reason: "a data: URI with no data" };
+  const base64 = /;base64$/i.test(match[1]);
+  let head;
+  try {
+    head = base64 ? fromBase64(match[2].slice(0, 8)) : Uint8Array.from(decodeURIComponent(match[2].slice(0, 64)), (c) => c.charCodeAt(0) & 255);
+  } catch {
+    return { reason: "a data: URI that does not decode" };
+  }
+  const problem = notEmbeddable(head, "a data: URI");
+  if (problem) return { reason: problem };
+  if (base64) return { src };
+  const bytes = Uint8Array.from(decodeURIComponent(match[2]), (c) => c.charCodeAt(0) & 255);
+  return { src: `data:font/ttf;base64,${toBase64(bytes)}` };
+}
+function notEmbeddable(bytes, src) {
+  if (bytes.length < 4) return `${describe(src)} is not a font file`;
+  const tag = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3]);
+  if (bytes[0] === 0 && bytes[1] === 1 && bytes[2] === 0 && bytes[3] === 0 || tag === "OTTO" || tag === "true") return null;
+  if (tag === "wOFF" || tag === "wOF2") return `${describe(src)} is WOFF, which only a browser reads`;
+  if (tag === "ttcf") return `${describe(src)} is a font collection; give the single face instead`;
+  return `${describe(src)} is not a TrueType or OpenType file`;
+}
+function describe(src) {
+  return src.startsWith("data:") ? "a data: URI" : src.length > 80 ? `${src.slice(0, 77)}\u2026` : src;
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(binary);
+}
+function fromBase64(text) {
+  const clean = text.replace(/[^A-Za-z0-9+/]/g, "");
+  const binary = atob(clean.slice(0, clean.length - clean.length % 4));
+  return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}
+
 // src/editor.ts
 function hash(s) {
   let h = 2166136261;
@@ -928,8 +1068,8 @@ var FormeEditorMeasurer = class {
   destroy() {
     this.cache.clear();
   }
-  key(section, width, mode) {
-    return hash(JSON.stringify(section)) + ":" + Math.round(width * 100) + ":" + mode;
+  key(section, width, mode, faces) {
+    return hash(JSON.stringify(section)) + ":" + Math.round(width * 100) + ":" + mode + ":" + faces;
   }
   async measure(sections, width) {
     const opts = this.opts;
@@ -937,8 +1077,9 @@ var FormeEditorMeasurer = class {
     const out = {};
     const pending = [];
     const keys = /* @__PURE__ */ new Map();
+    const faces = facesKey(opts.theme.fonts);
     for (const section of sections) {
-      const k = this.key(section, width, opts.mode);
+      const k = this.key(section, width, opts.mode, faces);
       const hit = this.cache.get(k);
       if (hit) out[section.key] = hit;
       else {
@@ -947,6 +1088,9 @@ var FormeEditorMeasurer = class {
       }
     }
     if (!pending.length) return out;
+    const given = await this.config.fonts;
+    const { fonts, warnings } = await resolveFonts({ fonts: given, theme: opts.theme });
+    for (const w of warnings) this.warn(w);
     const measurer = new FormeMeasurer({
       registry: opts.registry,
       theme: opts.theme,
@@ -955,7 +1099,7 @@ var FormeEditorMeasurer = class {
       mode: opts.mode,
       pageWidth: width,
       margins: { top: 0, right: 0, bottom: 0, left: 0 },
-      fonts: this.config.fonts,
+      fonts,
       render: this.config.render
     });
     const measured = await measurer.measure(pending, width);
@@ -964,14 +1108,21 @@ var FormeEditorMeasurer = class {
       const k = keys.get(sectionKey);
       if (k) this.cache.set(k, geometry);
     }
-    for (const w of measurer.warnings) {
-      if (this.seen.has(w)) continue;
-      this.seen.add(w);
-      this.config.onWarning?.(w);
-    }
+    for (const w of measurer.warnings) this.warn(w);
     return out;
   }
+  warn(message) {
+    if (this.seen.has(message)) return;
+    this.seen.add(message);
+    this.config.onWarning?.(message);
+  }
 };
+function facesKey(faces) {
+  if (!faces?.length) return "";
+  return hash(
+    faces.map((f) => [f.family, f.weight, f.style, ...(Array.isArray(f.src) ? f.src : [f.src]).map((s) => `${s.length}:${s.slice(0, 64)}${s.slice(-64)}`)].join("|")).join(";")
+  );
+}
 
 // src/api.ts
 import {
@@ -983,47 +1134,261 @@ import {
 } from "@broadpaper/core";
 import { mapStyle as mapStyle4 } from "@formepdf/shared";
 import { producerString, resolveLicenseStatus, watermarkFor } from "@broadpaper/license";
+
+// src/credit.ts
+function creditNode(spec, width, ctx) {
+  const size = spec.fontSize;
+  const children = [];
+  if (spec.mark) {
+    children.push({
+      tag: "img",
+      props: { src: spec.mark, alt: "", style: { width: `${size}px`, height: `${size}px`, opacity: String(spec.opacity) } },
+      children: []
+    });
+  }
+  children.push({
+    tag: "span",
+    props: { style: { "font-size": `${size}px`, color: spec.color, opacity: String(spec.opacity), "line-height": "1.2" } },
+    children: [spec.text]
+  });
+  const line = {
+    tag: "div",
+    props: {
+      style: {
+        display: "flex",
+        "align-items": "center",
+        gap: `${Math.max(2, Math.round(size * 0.5))}px`,
+        width: `${width}px`,
+        "justify-content": "center"
+      }
+    },
+    children
+  };
+  return translate(line, ctx)?.node ?? null;
+}
+
+// src/api.ts
 import { BroadPaper, configure, resolveLicenseStatus as resolveLicenseStatus2, verifyLicense, parseLicense } from "@broadpaper/license";
 import { computePageGeometry as pageGeometry, paginate, resolveValue } from "@broadpaper/core";
 
+// src/long-tables.ts
+var EPS = 0.5;
+function round3(n) {
+  return Math.round(n * 100) / 100;
+}
+function isRow(c) {
+  return typeof c !== "string" && c.tag === "tr";
+}
+function bodyRowCount(table) {
+  let n = 0;
+  for (const c of table.children) {
+    if (typeof c === "string") continue;
+    if (c.tag === "tbody") n += c.children.filter(isRow).length;
+    else if (c.tag === "tr") n++;
+  }
+  return n;
+}
+function longTables(tree, limit) {
+  const out = [];
+  const visit = (v, key) => {
+    const own = typeof v.props["data-key"] === "string" ? v.props["data-key"] : key;
+    if (v.tag === "table") {
+      const rows = bodyRowCount(v);
+      if (rows > limit && own) out.push({ table: v, key: own, bodyRows: rows });
+      return;
+    }
+    for (const c of v.children) if (typeof c !== "string") visit(c, own);
+  };
+  visit(tree, void 0);
+  return out;
+}
+function sliceTables(tree, tables, start, count) {
+  const targets = new Set(tables.map((t) => t.table));
+  const visit = (v) => {
+    if (targets.has(v)) return sliceRows(v, start, count);
+    let changed = false;
+    const children = v.children.map((c) => {
+      if (typeof c === "string") return c;
+      const next = visit(c);
+      if (next !== c) changed = true;
+      return next;
+    });
+    return changed ? { ...v, children } : v;
+  };
+  return visit(tree);
+}
+function sliceRows(table, start, count) {
+  let index = 0;
+  const keep = () => {
+    const i = index++;
+    return i >= start && i < start + count;
+  };
+  const children = [];
+  for (const c of table.children) {
+    if (typeof c === "string") children.push(c);
+    else if (c.tag === "tbody") children.push({ ...c, children: c.children.filter((r) => !isRow(r) || keep()) });
+    else if (c.tag === "tr") {
+      if (keep()) children.push(c);
+    } else children.push(c);
+  }
+  return { ...table, children };
+}
+function sameRows(a, b) {
+  return !!a && a.length === b.length && a[0]?.top === b[0]?.top && a[a.length - 1]?.top === b[b.length - 1]?.top;
+}
+function stitchTables(first, tables, batches) {
+  const g = {
+    ...first,
+    nodes: Object.fromEntries(Object.entries(first.nodes).map(([k, n]) => [k, { ...n }]))
+  };
+  const bottomOf = (rows) => Math.max(...rows.map((r) => r.top + r.height));
+  const order = tables.map((t) => ({ t, rows: first.nodes[t.key]?.rows })).filter((x) => !!x.rows && x.rows.some((r) => r.kind === "body")).sort((a, b) => bottomOf(b.rows) - bottomOf(a.rows));
+  for (const { t } of order) {
+    const main = g.nodes[t.key].rows;
+    const body = main.filter((r) => r.kind === "body");
+    const last = body[body.length - 1];
+    const bodyEnd = last.top + last.height;
+    const gap = body.length > 1 ? Math.max(0, body[1].top - (body[0].top + body[0].height)) : 0;
+    const extra = [];
+    let cursor = bodyEnd + gap;
+    for (const batch of batches) {
+      const rows = batch.nodes[t.key]?.rows?.filter((r) => r.kind === "body") ?? [];
+      if (!rows.length) continue;
+      const base = rows[0].top;
+      for (const r of rows) extra.push({ top: round3(cursor + r.top - base), height: r.height, kind: "body" });
+      const end = rows[rows.length - 1];
+      cursor += end.top + end.height - base + gap;
+    }
+    if (!extra.length) continue;
+    const tail = extra[extra.length - 1];
+    const delta = round3(tail.top + tail.height - bodyEnd);
+    const merged = [
+      ...main.filter((r) => r.kind === "header"),
+      ...body,
+      ...extra,
+      ...main.filter((r) => r.kind === "footer").map((r) => ({ ...r, top: round3(r.top + delta) }))
+    ];
+    for (const n of Object.values(g.nodes)) {
+      const holdsThisTable = sameRows(n.rows, main);
+      if (n.top >= bodyEnd - EPS) {
+        n.top = round3(n.top + delta);
+        if (n.lines) n.lines = n.lines.map((y) => round3(y + delta));
+        if (n.rows && !holdsThisTable) n.rows = n.rows.map((r) => ({ ...r, top: round3(r.top + delta) }));
+      } else if (n.top + n.height > bodyEnd - EPS) {
+        n.height = round3(n.height + delta);
+      }
+      if (holdsThisTable) n.rows = merged;
+    }
+    g.height = round3(g.height + delta);
+  }
+  return g;
+}
+
 // src/paged.ts
 import {
-  renderNode as renderNode2,
-  walkVNodes as walkVNodes2
+  renderNode as renderNode2
 } from "@broadpaper/core";
 import { mapStyle as mapStyle3 } from "@formepdf/shared";
 
 // src/clip.ts
 import { styleString as styleString2 } from "@broadpaper/core";
-var EPS = 0.01;
+var EPS2 = 0.01;
 function cropToWindow(root, geom, from, to) {
   const w = { geom, from, to, dropped: 0 };
-  const node = crop(root, w, void 0);
+  const node = crop(root, w, void 0, true);
   return { node, offset: w.dropped };
 }
 function outside(w, top, height) {
-  return top + height <= w.from + EPS || top >= w.to - EPS;
+  return top + height <= w.from + EPS2 || top >= w.to - EPS2;
 }
-function crop(v, w, rows) {
-  const key = typeof v.props["data-key"] === "string" ? v.props["data-key"] : void 0;
-  const g = key ? w.geom.nodes[key] : void 0;
+function crop(v, w, rows, stacked) {
+  const g = geometryOf(v, w.geom);
   if (g) {
     if (outside(w, g.top, g.height)) return blank(v, g.height);
     if (g.rows) rows = g.rows;
   }
   if (v.tag === "table" && rows) return cropTable(v, w, rows);
-  let changed = false;
-  const children = v.children.map((c) => {
+  const childrenStacked = stacked && !sideBySide(v.children, w.geom);
+  const removed = childrenStacked ? removeAbove(v.children, w) : 0;
+  let changed = removed > 0;
+  const children = v.children.slice(removed).map((c) => {
     if (typeof c === "string") return c;
-    const next = crop(c, w, rows);
+    const next = crop(c, w, rows, childrenStacked);
     if (next !== c) changed = true;
     return next;
   });
   return changed ? { ...v, children } : v;
 }
+function geometryOf(v, geom) {
+  const key = typeof v.props["data-key"] === "string" ? v.props["data-key"] : void 0;
+  return key ? geom.nodes[key] : void 0;
+}
+function extent(v, geom) {
+  const g = geometryOf(v, geom);
+  if (g) return g.height > EPS2 ? [g.top, g.top + g.height] : null;
+  let span = null;
+  for (const c of v.children) {
+    if (typeof c === "string") continue;
+    const e = extent(c, geom);
+    if (e) span = span ? [Math.min(span[0], e[0]), Math.max(span[1], e[1])] : e;
+  }
+  return span;
+}
+function sideBySide(children, geom) {
+  const spans = children.filter((c) => typeof c !== "string").map((c) => extent(c, geom)).filter((e) => e !== null).sort((a, b) => a[0] - b[0]);
+  let bottom = Number.NEGATIVE_INFINITY;
+  for (const [top, end] of spans) {
+    if (top < bottom - EPS2) return true;
+    bottom = Math.max(bottom, end);
+  }
+  return false;
+}
+function removeAbove(children, w) {
+  let start = null;
+  let end = 0;
+  let count = 0;
+  for (let i = 0; i < children.length; i++) {
+    const c = children[i];
+    if (typeof c === "string") {
+      if (c.trim()) return 0;
+      continue;
+    }
+    const g = geometryOf(c, w.geom);
+    if (!g) return 0;
+    if (g.top + g.height > w.from + EPS2) {
+      if (start === null) return 0;
+      w.dropped += g.top - margin(c, "top") - start;
+      return i;
+    }
+    start ??= g.top - margin(c, "top");
+    end = g.top + g.height + margin(c, "bottom");
+    count = i + 1;
+  }
+  if (start === null) return 0;
+  w.dropped += end - start;
+  return count;
+}
+function margin(v, side) {
+  let value = 0;
+  for (const declaration of styleString2(v.props.style).split(";")) {
+    const m = /^\s*margin(?:-(top|bottom|left|right))?\s*:\s*(.+?)\s*$/i.exec(declaration);
+    if (!m) continue;
+    if (m[1]) {
+      if (m[1].toLowerCase() === side) value = pixels(m[2]);
+    } else {
+      const parts = m[2].split(/\s+/);
+      value = pixels(side === "top" ? parts[0] : parts.length >= 3 ? parts[2] : parts[0]);
+    }
+  }
+  return value;
+}
+function pixels(length2) {
+  const m = /^(-?\d*\.?\d+)(px)?$/i.exec(length2.trim());
+  return m && (m[2] || Number(m[1]) === 0) ? Number(m[1]) : 0;
+}
 function blank(v, height) {
   const kept = styleString2(v.props.style).split(";").map((d) => d.trim()).filter((d) => d && !/^height\s*:/i.test(d));
-  kept.push(`height:${round3(height)}px`);
+  kept.push(`height:${round4(height)}px`);
   return { ...v, props: { ...v.props, style: kept.join(";") }, children: [] };
 }
 function cropTable(table, w, rows) {
@@ -1050,7 +1415,7 @@ function cropTable(table, w, rows) {
   };
   return rewrite(table);
 }
-function round3(n) {
+function round4(n) {
   return Math.round(n * 100) / 100;
 }
 
@@ -1067,15 +1432,17 @@ function box(left, top, width, height, children, clip = true, bleed = 0) {
   return { kind: { type: "View" }, style, children };
 }
 function headerOnly(v) {
-  const clone = structuredClone(v);
-  walkVNodes2(clone, (n) => {
-    if (n.tag === "table") {
-      n.children = n.children.filter((c) => typeof c !== "string" && (c.tag === "colgroup" || c.tag === "thead"));
-      return false;
-    }
-    return true;
+  if (v.tag === "table") {
+    return { ...v, children: v.children.filter((c) => typeof c !== "string" && (c.tag === "colgroup" || c.tag === "thead")) };
+  }
+  let changed = false;
+  const children = v.children.map((c) => {
+    if (typeof c === "string") return c;
+    const next = headerOnly(c);
+    if (next !== c) changed = true;
+    return next;
   });
-  return clone;
+  return changed ? { ...v, children } : v;
 }
 function sectionsByKey(doc) {
   const map = /* @__PURE__ */ new Map();
@@ -1096,20 +1463,36 @@ function emitPages(input) {
   const width = page.contentWidth;
   const bleed = page.margins.right;
   const bodyDependsOnPage = isPageDependent(resolved.body);
-  const cache = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map();
+  const rendered = /* @__PURE__ */ new Map();
+  const treeOf = (section, opts) => {
+    if (bodyDependsOnPage) return renderNode2(section, opts, width);
+    if (!rendered.has(section.key)) rendered.set(section.key, renderNode2(section, opts, width));
+    return rendered.get(section.key);
+  };
   const translateSection = (section, opts, from, to) => {
     const cacheKey = `${section.key}|${from}|${to}`;
-    if (!bodyDependsOnPage && cache.has(cacheKey)) return cache.get(cacheKey);
-    const v = renderNode2(section, opts, width);
+    if (!bodyDependsOnPage && cache2.has(cacheKey)) return cache2.get(cacheKey);
+    const v = treeOf(section, opts);
     if (!v) return null;
     const geom = geometry[section.key];
     const cropped = geom ? cropToWindow(v, geom, from, to) : { node: v, offset: 0 };
     const t = translate(cropped.node, ctx);
     if (!t) return null;
     const out = { node: t.node, offset: cropped.offset };
-    if (!bodyDependsOnPage) cache.set(cacheKey, out);
+    if (!bodyDependsOnPage) cache2.set(cacheKey, out);
     return out;
   };
+  const headers = /* @__PURE__ */ new Map();
+  const repeatedHeader = (tableKey, table, opts, headerWidth) => {
+    const key = `${tableKey}|${headerWidth}`;
+    if (!bodyDependsOnPage && headers.has(key)) return headers.get(key);
+    const v = renderNode2(table, opts, headerWidth);
+    const t = v ? translate(headerOnly(v), ctx) : null;
+    const node = t ? t.node : null;
+    if (!bodyDependsOnPage) headers.set(key, node);
+    return node;
+  };
   const region = (sections, opts) => {
     const out = [];
     for (const s of sections) {
@@ -1123,7 +1506,7 @@ function emitPages(input) {
   return paged.pages.map((p) => {
     const opts = { ...renderOpts, page: { number: p.number, total: paged.totalPages } };
     const children = [];
-    if (input.watermark) children.push(watermarkNode(input.watermark));
+    for (const mark of input.watermarks ?? []) if (mark && (mark.placement ?? "center") === "center") children.push(watermarkNode(mark));
     const headerSections = p.first && resolved.header.firstPage ? resolved.header.firstPage : resolved.header.default;
     if (headerSections.length && page.headerHeight > 0) {
       children.push(box(page.margins.left, page.headerTop, width, page.headerHeight, region(headerSections, opts)));
@@ -1137,10 +1520,8 @@ function emitPages(input) {
       for (const r of f.repeatHeaders) {
         const table = byKey.get(r.tableKey);
         if (!table) continue;
-        const v = renderNode2(table, opts, r.width);
-        if (!v) continue;
-        const t = translate(headerOnly(v), ctx);
-        if (t) inner.push(box(r.left, 0, r.width, r.height, [t.node]));
+        const header = repeatedHeader(r.tableKey, table, opts, r.width);
+        if (header) inner.push(box(r.left, 0, r.width, r.height, [header]));
       }
       const content = translateSection(section, opts, f.from, f.to);
       if (content) {
@@ -1158,6 +1539,14 @@ function emitPages(input) {
     if (footerSections.length && page.footerHeight > 0) {
       children.push(box(page.margins.left, page.footerTop, width, page.footerHeight, region(footerSections, opts)));
     }
+    for (const mark of input.watermarks ?? []) {
+      if (!mark || (mark.placement ?? "center") !== "bottom") continue;
+      const node = creditNode(mark, width, ctx);
+      if (!node) continue;
+      const h = mark.fontSize * 1.6;
+      const top = Math.max(page.height - h, page.height - page.margins.bottom + Math.max(0, (page.margins.bottom - h) / 2));
+      children.push(box(page.margins.left, top, width, h, [node]));
+    }
     return {
       kind: {
         type: "Page",
@@ -1220,12 +1609,15 @@ async function buildFormeDocument(opts) {
     return out;
   };
   const children = [];
-  const mark = watermarkFor(license);
-  if (mark) children.push(watermarkNode(mark));
+  const marks = [watermarkFor(license), opts.watermark].filter((m) => Boolean(m));
+  for (const mark of marks) if ((mark.placement ?? "center") === "center") children.push(watermarkNode(mark));
   const header = translate2(resolved.header.default);
   if (header.length) children.push({ kind: { type: "Fixed", position: "Header" }, style: {}, children: header });
   const footer = translate2(resolved.footer.default);
-  if (footer.length) children.push({ kind: { type: "Fixed", position: "Footer" }, style: {}, children: footer });
+  const credits = marks.filter((m) => (m.placement ?? "center") === "bottom").map((m) => creditNode(m, geom.contentWidth, ctx)).filter((n) => Boolean(n));
+  if (footer.length || credits.length) {
+    children.push({ kind: { type: "Fixed", position: "Footer" }, style: {}, children: [...footer, ...credits] });
+  }
   children.push(...translate2(resolved.body));
   const page = {
     kind: {
@@ -1245,11 +1637,12 @@ async function buildFormeDocument(opts) {
     defaultPage: { size: "A4", margin: { top: 54, right: 54, bottom: 54, left: 54 }, wrap: true },
     defaultStyle: mapStyle4({ fontSize: pxToPt(theme.typography.baseFontSize ?? 11), fontFamily: theme.typography.bodyFont.split(",")[0].trim().replace(/^['"]|['"]$/g, "") })
   };
-  if (opts.fonts?.length) doc.fonts = opts.fonts.map((f) => ({ family: f.family, src: f.src, weight: f.weight ?? 400, style: f.style ?? "normal" }));
+  const fonts = await resolveFonts({ fonts: opts.fonts, theme, sources: opts.fontSources });
+  if (fonts.fonts.length) doc.fonts = fontEntries(fonts.fonts);
   if (opts.tagged) doc.tagged = true;
   if (opts.pdfUa) doc.pdfUa = true;
   if (opts.pdfA) doc.pdfa = opts.pdfA;
-  const warnings = [...ctx.warnings, ...resolved.warnings.map((w) => w.message)];
+  const warnings = [...ctx.warnings, ...resolved.warnings.map((w) => w.message), ...fonts.warnings];
   return { doc, warnings, license };
 }
 var engineLoader = null;
@@ -1282,6 +1675,20 @@ async function renderPdf(opts) {
 }
 async function renderPdfPaginated(opts) {
   const started = Date.now();
+  const layout = await layoutPaginated(opts);
+  const drawn = await layout.draw();
+  return {
+    pdf: drawn.pdf,
+    pages: drawn.pages,
+    layout: drawn.layout,
+    paged: layout.paged,
+    geometry: layout.geometry,
+    warnings: drawn.warnings,
+    durationMs: Date.now() - started
+  };
+}
+var MEASURE_BATCH_ROWS = 1e3;
+async function layoutPaginated(opts) {
   const license = await resolveLicenseStatus(opts.license !== void 0 ? { license: opts.license } : {});
   const { template } = migrateTemplate(opts.template);
   const theme = mergeTheme(opts.theme);
@@ -1316,17 +1723,16 @@ async function renderPdfPaginated(opts) {
   };
   const ctx = { warnings: /* @__PURE__ */ new Set(), suppressPageBreaks: true };
   const render = opts.renderer ?? defaultRenderer;
-  const measure = async (sections) => {
-    if (!sections.length) return {};
+  const fonts = await resolveFonts({ fonts: opts.fonts, theme, sources: opts.fontSources });
+  const layoutSections = async (list) => {
+    if (!list.length) return {};
     const measured = [];
-    for (const section of sections) {
-      const v = renderNode3(section, renderOpts, geom.contentWidth);
-      if (!v) continue;
-      const t = translate(v, ctx);
+    for (const { section, tree } of list) {
+      const t = translate(tree, ctx);
       if (t) measured.push({ section, node: t.node, ann: t.ann });
     }
     if (!measured.length) return {};
-    const doc2 = {
+    const doc = {
       children: [
         {
           kind: {
@@ -1345,53 +1751,86 @@ async function renderPdfPaginated(opts) {
       defaultPage: { size: "A4", margin: { top: 54, right: 54, bottom: 54, left: 54 }, wrap: true },
       defaultStyle: baseStyle(theme)
     };
-    if (opts.fonts?.length) doc2.fonts = fontEntries(opts.fonts);
-    const result2 = await render(doc2);
-    const pages2 = result2.layout?.pages ?? [];
+    if (fonts.fonts.length) doc.fonts = fontEntries(fonts.fonts);
+    const result = await render(doc);
+    const pages = result.layout?.pages ?? [];
     const scale2 = 1 / PX_TO_PT_LOCAL;
-    const scaled = pages2[0]?.elements.map((e) => scaleElement(e, scale2)) ?? [];
+    const scaled = pages[0]?.elements.map((e) => scaleElement(e, scale2)) ?? [];
     return geometryFromLayout(measured, scaled, geom.contentWidth);
   };
+  const batchRows = Math.max(1, opts.measureBatchRows ?? MEASURE_BATCH_ROWS);
+  const measure = async (sections) => {
+    const parts = [];
+    for (const section of sections) {
+      const tree = renderNode3(section, renderOpts, geom.contentWidth);
+      if (tree) parts.push({ section, tree, long: longTables(tree, batchRows) });
+    }
+    const out = await layoutSections(parts.map((p) => ({ section: p.section, tree: p.long.length ? sliceTables(p.tree, p.long, 0, batchRows) : p.tree })));
+    for (const p of parts) {
+      const first = out[p.section.key];
+      if (!p.long.length || !first) continue;
+      const most = Math.max(...p.long.map((t) => t.bodyRows));
+      const batches = [];
+      for (let start = batchRows; start < most; start += batchRows) {
+        batches.push({ section: { ...p.section, key: `${p.section.key}#rows-${start}` }, tree: sliceTables(p.tree, p.long, start, batchRows) });
+      }
+      const measured = [];
+      for (let i = 0; i < batches.length; i += BATCHES_PER_PASS) {
+        const chunk = batches.slice(i, i + BATCHES_PER_PASS);
+        const got = await layoutSections(chunk);
+        for (const b of chunk) {
+          const g = got[b.section.key];
+          if (g) measured.push(g);
+        }
+      }
+      out[p.section.key] = stitchTables(first, p.long, measured);
+    }
+    return out;
+  };
   const geometry = await measure(resolved.body);
   const regionGeometry = await measure([...resolved.header.default, ...resolved.header.firstPage ?? [], ...resolved.footer.default, ...resolved.footer.firstPage ?? []]);
   const paged = paginate({ document: resolved, geometry, page: geom, minPages: 1, regionGeometry });
-  const pages = emitPages({
-    resolved,
-    paged,
-    page: geom,
-    renderOpts,
-    ctx,
-    geometry,
-    background: template.page.background ? resolveValue(template.page.background, theme, "#ffffff") : void 0,
-    watermark: watermarkFor(license)
-  });
-  const doc = {
-    children: pages,
-    metadata: { title: template.name, creator: producerString(license), ...opts.metadata ?? {} },
-    defaultPage: { size: "A4", margin: { top: 54, right: 54, bottom: 54, left: 54 }, wrap: true },
-    defaultStyle: baseStyle(theme)
-  };
-  if (opts.fonts?.length) doc.fonts = fontEntries(opts.fonts);
-  if (opts.tagged) doc.tagged = true;
-  if (opts.pdfUa) doc.pdfUa = true;
-  if (opts.pdfA) doc.pdfa = opts.pdfA;
-  const result = await render(doc);
-  const layout = result.layout ?? null;
+  const background = template.page.background ? resolveValue(template.page.background, theme, "#ffffff") : void 0;
   return {
-    pdf: result.pdf,
-    pages: layout?.pages.length ?? paged.totalPages,
-    layout,
     paged,
     geometry,
-    warnings: [
-      ...ctx.warnings,
-      ...resolved.warnings.map((w) => w.message),
-      ...paged.warnings.map((w) => w.message),
-      ...result.warnings ?? []
-    ],
-    durationMs: Date.now() - started
+    async draw(range) {
+      const from = Math.max(0, range?.from ?? 0);
+      const to = Math.min(paged.pages.length, range?.to ?? paged.pages.length);
+      const pages = emitPages({
+        resolved,
+        // `totalPages` stays the whole document's, so a later file still counts
+        // its pages as part of the whole.
+        paged: { ...paged, pages: paged.pages.slice(from, to) },
+        page: geom,
+        renderOpts,
+        ctx,
+        geometry,
+        background,
+        watermarks: [watermarkFor(license), opts.watermark]
+      });
+      const doc = {
+        children: pages,
+        metadata: { title: template.name, creator: producerString(license), ...opts.metadata ?? {} },
+        defaultPage: { size: "A4", margin: { top: 54, right: 54, bottom: 54, left: 54 }, wrap: true },
+        defaultStyle: baseStyle(theme)
+      };
+      if (fonts.fonts.length) doc.fonts = fontEntries(fonts.fonts);
+      if (opts.tagged) doc.tagged = true;
+      if (opts.pdfUa) doc.pdfUa = true;
+      if (opts.pdfA) doc.pdfa = opts.pdfA;
+      const result = await render(doc);
+      const layout = result.layout ?? null;
+      return {
+        pdf: result.pdf,
+        pages: layout?.pages.length ?? to - from,
+        layout,
+        warnings: [...ctx.warnings, ...resolved.warnings.map((w) => w.message), ...paged.warnings.map((w) => w.message), ...fonts.warnings, ...result.warnings ?? []]
+      };
+    }
   };
 }
+var BATCHES_PER_PASS = 2;
 var PX_TO_PT_LOCAL = 72 / 96;
 function scaleElement(el, scale2) {
   return {
@@ -1424,15 +1863,19 @@ export {
   UNBOUNDED_PAGE_HEIGHT,
   geometryFromLayout,
   FormeMeasurer,
+  setFontFileReader,
+  resolveFonts,
   FormeEditorMeasurer,
   buildFormeDocument,
   setEngineLoader,
   renderPdf,
   renderPdfPaginated,
+  MEASURE_BATCH_ROWS,
+  layoutPaginated,
   BroadPaper,
   configure,
   resolveLicenseStatus2 as resolveLicenseStatus,
   verifyLicense,
   parseLicense
 };
-//# sourceMappingURL=chunk-2PT5WRKQ.js.map
+//# sourceMappingURL=chunk-QA4APTWM.js.map