@broadpaper/forme 0.1.1

package/dist/chunk-KE7FFMY2.js

@@ -0,0 +1,1438 @@
+// src/style.ts
+var PX_TO_PT = 72 / 96;
+function pxToPt(px) {
+  return Math.round(px * PX_TO_PT * 1e3) / 1e3;
+}
+function parseDeclarations(style) {
+  const out = {};
+  if (!style) return out;
+  if (typeof style === "object") {
+    for (const [k, v] of Object.entries(style)) {
+      if (v === void 0 || v === null || v === "") continue;
+      out[kebab(k)] = String(v);
+    }
+    return out;
+  }
+  for (const decl of String(style).split(";")) {
+    const i = decl.indexOf(":");
+    if (i < 0) continue;
+    const k = decl.slice(0, i).trim();
+    const v = decl.slice(i + 1).trim();
+    if (k && v) out[k] = v;
+  }
+  return out;
+}
+function kebab(s) {
+  return s.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+}
+function length(value) {
+  const v = value.trim();
+  if (v === "auto" || v === "none" || v === "inherit") return void 0;
+  if (v.endsWith("%")) return v;
+  const n = Number.parseFloat(v);
+  if (!Number.isFinite(n)) return void 0;
+  if (v.endsWith("em")) return void 0;
+  return pxToPt(n);
+}
+function num(value) {
+  const n = Number.parseFloat(value);
+  return Number.isFinite(n) ? n : void 0;
+}
+function colour(value) {
+  const v = value.trim().toLowerCase();
+  if (!v || v === "transparent" || v === "none" || v === "inherit" || v === "currentcolor") return void 0;
+  return v;
+}
+function edges(value) {
+  const parts = value.trim().split(/\s+/).map((p) => length(p));
+  if (parts.some((p) => typeof p !== "number")) return void 0;
+  const n = parts;
+  const [t, r, b, l] = n.length === 1 ? [n[0], n[0], n[0], n[0]] : n.length === 2 ? [n[0], n[1], n[0], n[1]] : n.length === 3 ? [n[0], n[1], n[2], n[1]] : [n[0], n[1], n[2], n[3]];
+  return { top: t, right: r, bottom: b, left: l };
+}
+function border(value) {
+  const v = value.trim();
+  if (!v || v === "none" || v.startsWith("0 ") || v === "0") return void 0;
+  const widthMatch = /(-?[\d.]+)px/.exec(v);
+  const colourMatch = /(#[0-9a-f]{3,8}|rgba?\([^)]+\))/i.exec(v);
+  const width = widthMatch ? pxToPt(Number(widthMatch[1])) : 0.75;
+  if (/\bnone\b/.test(v)) return void 0;
+  return { width, colour: colourMatch ? colourMatch[0] : void 0 };
+}
+var FLEX_DIRECTION = { row: "row", column: "column", "row-reverse": "row-reverse", "column-reverse": "column-reverse" };
+var JUSTIFY = { "flex-start": "flex-start", start: "flex-start", "flex-end": "flex-end", end: "flex-end", center: "center", "space-between": "space-between", "space-around": "space-around", "space-evenly": "space-evenly" };
+var ALIGN = { "flex-start": "flex-start", start: "flex-start", "flex-end": "flex-end", end: "flex-end", center: "center", stretch: "stretch", baseline: "baseline" };
+var TEXT_ALIGN = { left: "left", right: "right", center: "center", justify: "justify" };
+var IGNORED = /* @__PURE__ */ new Set([
+  "box-sizing",
+  "-webkit-font-smoothing",
+  "text-rendering",
+  "font-variant-numeric",
+  "pointer-events",
+  "user-select",
+  "cursor",
+  "text-overflow",
+  "white-space",
+  "word-wrap",
+  "overflow-wrap",
+  "box-decoration-break",
+  "-webkit-box-decoration-break",
+  "text-underline-offset",
+  "text-decoration-thickness",
+  "outline",
+  "transition",
+  "list-style",
+  "border-collapse",
+  "border-spacing",
+  "table-layout",
+  "vertical-align",
+  "min-width",
+  "max-width",
+  "-webkit-line-clamp",
+  "-webkit-box-orient",
+  "object-fit",
+  "content",
+  "zoom",
+  "transform-origin"
+]);
+function translateStyle(css) {
+  const s = {};
+  const unsupported = [];
+  const set = (k, v) => {
+    if (v !== void 0) s[k] = v;
+  };
+  for (const [prop, raw] of Object.entries(css)) {
+    const value = raw.trim();
+    if (IGNORED.has(prop)) continue;
+    switch (prop) {
+      case "display":
+        if (value === "flex" || value === "inline-flex") set("display", "flex");
+        else if (value === "grid") {
+          set("display", "flex");
+          set("flexDirection", "row");
+        } else if (value === "none") set("display", "none");
+        break;
+      case "flex-direction":
+        set("flexDirection", FLEX_DIRECTION[value]);
+        break;
+      case "justify-content":
+        set("justifyContent", JUSTIFY[value]);
+        break;
+      case "align-items":
+        set("alignItems", ALIGN[value]);
+        break;
+      case "align-self":
+        set("alignSelf", ALIGN[value]);
+        break;
+      case "flex-wrap":
+        set("flexWrap", value === "wrap" ? "wrap" : "nowrap");
+        break;
+      case "flex":
+        set("flexGrow", num(value.split(/\s+/)[0] ?? "0"));
+        break;
+      case "flex-grow":
+        set("flexGrow", num(value));
+        break;
+      case "flex-shrink":
+        set("flexShrink", num(value));
+        break;
+      case "gap":
+      case "row-gap":
+      case "column-gap": {
+        const parts = value.split(/\s+/).map((p) => length(p));
+        const first = typeof parts[0] === "number" ? parts[0] : void 0;
+        const second = parts.length > 1 && typeof parts[1] === "number" ? parts[1] : first;
+        if (prop === "gap") {
+          set("rowGap", first);
+          set("columnGap", second);
+        } else set(prop === "row-gap" ? "rowGap" : "columnGap", first);
+        break;
+      }
+      case "grid-template-columns":
+        break;
+      case "grid-column": {
+        const span = /^span\s+(\d+)$/.exec(value);
+        if (span) {
+          set("flexGrow", Number(span[1]));
+          set("flexBasis", 0);
+        }
+        break;
+      }
+      case "width":
+        set("width", length(value));
+        break;
+      case "height": {
+        const h = length(value);
+        if (typeof h === "number") set("height", h);
+        break;
+      }
+      case "padding":
+        set("padding", edges(value));
+        break;
+      case "padding-top":
+      case "padding-right":
+      case "padding-bottom":
+      case "padding-left":
+        set(`padding${cap(prop.slice(8))}`, length(value));
+        break;
+      case "margin":
+        set("margin", edges(value));
+        break;
+      case "margin-top":
+      case "margin-right":
+      case "margin-bottom":
+      case "margin-left":
+        set(`margin${cap(prop.slice(7))}`, length(value));
+        break;
+      case "background":
+      case "background-color":
+        set("backgroundColor", colour(value));
+        break;
+      case "color":
+        set("color", colour(value));
+        break;
+      case "font-family":
+        set("fontFamily", value.split(",")[0].trim().replace(/^['"]|['"]$/g, ""));
+        break;
+      case "font-size":
+        set("fontSize", length(value));
+        break;
+      case "font-weight":
+        set("fontWeight", value === "bold" ? 700 : value === "normal" ? 400 : num(value));
+        break;
+      case "font-style":
+        if (value === "italic") set("fontStyle", "italic");
+        break;
+      case "line-height":
+        set("lineHeight", num(value));
+        break;
+      case "letter-spacing":
+        if (value.endsWith("px")) set("letterSpacing", length(value));
+        break;
+      case "text-align":
+        set("textAlign", TEXT_ALIGN[value]);
+        break;
+      case "text-transform":
+        if (value !== "none") set("textTransform", value);
+        break;
+      case "text-decoration":
+        if (value.includes("underline")) set("textDecoration", "underline");
+        else if (value.includes("line-through")) set("textDecoration", "line-through");
+        break;
+      case "opacity":
+        set("opacity", num(value));
+        break;
+      case "overflow":
+        if (value === "hidden") set("overflow", "hidden");
+        break;
+      case "border-radius": {
+        const r = length(value.split(/\s+/)[0] ?? "0");
+        set("borderRadius", typeof r === "number" ? r : void 0);
+        break;
+      }
+      case "border": {
+        const b = border(value);
+        if (b) {
+          set("borderWidth", b.width);
+          set("borderColor", b.colour);
+        }
+        break;
+      }
+      case "border-top":
+      case "border-right":
+      case "border-bottom":
+      case "border-left": {
+        const side = cap(prop.slice(7));
+        const b = border(value);
+        if (b) {
+          set(`border${side}Width`, b.width);
+          set(`border${side}Color`, b.colour);
+        }
+        break;
+      }
+      case "position":
+        if (value === "absolute" || value === "relative") set("position", value);
+        break;
+      case "top":
+      case "left":
+      case "right":
+      case "bottom":
+        set(prop, length(value));
+        break;
+      default:
+        unsupported.push(prop);
+    }
+  }
+  if (s.display === "flex" && s.flexDirection === void 0) s.flexDirection = "row";
+  return { style: s, unsupported };
+}
+function cap(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/vnode.ts
+import { classNames, styleString, walkVNodes } from "@broadpaper/core";
+import { mapStyle, mapColumnWidth } from "@formepdf/shared";
+
+// src/svg.ts
+import { toHtml } from "@broadpaper/core";
+var COORDS = {
+  rect: [["x", 0], ["y", 1]],
+  circle: [["cx", 0], ["cy", 1]],
+  ellipse: [["cx", 0], ["cy", 1]],
+  line: [["x1", 0], ["y1", 1], ["x2", 0], ["y2", 1]],
+  text: [["x", 0], ["y", 1]],
+  tspan: [["x", 0], ["y", 1]],
+  image: [["x", 0], ["y", 1]],
+  use: [["x", 0], ["y", 1]]
+};
+var TRANSLATE = /^\s*translate\(\s*(-?[\d.eE+]+)\s*(?:[, ]\s*(-?[\d.eE+]+))?\s*\)\s*$/;
+function translationOf(value) {
+  if (typeof value !== "string" || !value.trim()) return null;
+  const m = TRANSLATE.exec(value);
+  if (!m) return "unsupported";
+  return [Number(m[1]), m[2] === void 0 ? 0 : Number(m[2])];
+}
+var PATH_COMMANDS = {
+  m: { size: 2, coords: [0, 1] },
+  l: { size: 2, coords: [0, 1] },
+  t: { size: 2, coords: [0, 1] },
+  h: { size: 1, coords: [0] },
+  v: { size: 1, coords: [1] },
+  c: { size: 6, coords: [0, 1, 0, 1, 0, 1] },
+  s: { size: 4, coords: [0, 1, 0, 1] },
+  q: { size: 4, coords: [0, 1, 0, 1] },
+  // rx ry rotation large-arc sweep x y — only the final pair is a position.
+  a: { size: 7, coords: [-1, -1, -1, -1, -1, 0, 1] },
+  z: { size: 0, coords: [] }
+};
+function translatePathData(d, dx, dy) {
+  if (!dx && !dy) return d;
+  const tokens = d.match(/[a-zA-Z]|-?(?:\d*\.\d+|\d+)(?:[eE][-+]?\d+)?/g);
+  if (!tokens) return d;
+  const out = [];
+  let command = "";
+  let i = 0;
+  let first = true;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (/[a-zA-Z]/.test(token)) {
+      command = token;
+      out.push(token);
+      i++;
+      if (command.toLowerCase() === "z") {
+        first = false;
+        continue;
+      }
+    }
+    const spec = PATH_COMMANDS[command.toLowerCase()];
+    if (!spec || spec.size === 0) {
+      while (i < tokens.length) out.push(tokens[i++]);
+      break;
+    }
+    const absolute = command === command.toUpperCase() || first && command === "m";
+    for (let p = 0; p < spec.size && i < tokens.length; p++) {
+      const axis = spec.coords[p];
+      const value = Number(tokens[i]);
+      out.push(absolute && axis >= 0 ? String(round(value + (axis === 0 ? dx : dy))) : tokens[i]);
+      i++;
+    }
+    if (first) {
+      first = false;
+      if (command === "m") command = "l";
+      else if (command === "M") command = "L";
+    }
+  }
+  return out.join(" ");
+}
+function round(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+function translatePoints(points, dx, dy) {
+  const nums = points.match(/-?(?:\d*\.\d+|\d+)(?:[eE][-+]?\d+)?/g);
+  if (!nums) return points;
+  return nums.map((n, i) => round(Number(n) + (i % 2 === 0 ? dx : dy))).join(" ");
+}
+function shift(v, dx, dy, warn) {
+  const own = translationOf(v.props.transform);
+  let tx = dx;
+  let ty = dy;
+  const props = { ...v.props };
+  if (own === "unsupported") {
+    warn(`SVG transform "${String(v.props.transform)}" is not translate() and was left to the engine, which ignores it`);
+  } else if (own) {
+    tx += own[0];
+    ty += own[1];
+    delete props.transform;
+  }
+  if (tx || ty) {
+    for (const [attr, axis] of COORDS[v.tag] ?? []) {
+      const current = props[attr];
+      const base = current === void 0 || current === null || current === "" ? 0 : Number(current);
+      if (Number.isFinite(base)) props[attr] = round(base + (axis === 0 ? tx : ty));
+    }
+    if (v.tag === "path" && typeof props.d === "string") props.d = translatePathData(props.d, tx, ty);
+    if ((v.tag === "polyline" || v.tag === "polygon") && typeof props.points === "string") props.points = translatePoints(props.points, tx, ty);
+  }
+  const children = v.children.map((c) => typeof c === "string" ? c : shift(c, tx, ty, warn));
+  return { ...v, props, children };
+}
+function textContent(v) {
+  if (typeof v === "string") return v;
+  return v.children.map(textContent).join("");
+}
+function numeric(value, fallback) {
+  const n = typeof value === "number" ? value : Number.parseFloat(String(value ?? ""));
+  return Number.isFinite(n) ? n : fallback;
+}
+var SCREEN_ONLY = /^data-bp-/;
+function splitSvg(v, warn) {
+  const flat = shift(v, 0, 0, warn);
+  const labels = [];
+  const strip = (node, inherited) => {
+    const own = {
+      fontFamily: node.props["font-family"] ?? inherited.fontFamily,
+      fill: node.props.fill ?? inherited.fill
+    };
+    if (node.tag === "text") {
+      const text = textContent(node).trim();
+      if (text) {
+        const anchor = String(node.props["text-anchor"] ?? "start");
+        labels.push({
+          x: numeric(node.props.x, 0),
+          y: numeric(node.props.y, 0),
+          text,
+          anchor: anchor === "middle" || anchor === "end" ? anchor : "start",
+          fontSize: numeric(node.props["font-size"], 10),
+          fontFamily: own.fontFamily,
+          fontWeight: node.props["font-weight"] ? numeric(node.props["font-weight"], 400) : void 0,
+          fill: own.fill
+        });
+      }
+      return null;
+    }
+    const children = [];
+    for (const c of node.children) {
+      if (typeof c === "string") {
+        children.push(c);
+        continue;
+      }
+      const kept2 = strip(c, own);
+      if (kept2) children.push(kept2);
+    }
+    const props = {};
+    for (const [k, value] of Object.entries(node.props)) if (!SCREEN_ONLY.test(k)) props[k] = value;
+    return { ...node, props, children };
+  };
+  const kept = strip(flat, {});
+  return { markup: kept.children.map((c) => typeof c === "string" ? c : toHtml(c)).join(""), labels };
+}
+var ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\xA0" };
+function decodeEntities(s) {
+  return s.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (whole, body) => {
+    if (body.startsWith("#x") || body.startsWith("#X")) return String.fromCodePoint(Number.parseInt(body.slice(2), 16));
+    if (body.startsWith("#")) return String.fromCodePoint(Number.parseInt(body.slice(1), 10));
+    return ENTITIES[body] ?? whole;
+  });
+}
+var TAG = /<\s*(\/)?\s*([a-zA-Z][\w:.-]*)((?:\s+[\w:.-]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s">]+))*)\s*(\/)?\s*>/g;
+var ATTR = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s">]+))/g;
+var SKIP = /<\?[\s\S]*?\?>|<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<![\s\S]*?>/g;
+function parseSvgMarkup(source) {
+  const text = source.replace(SKIP, "");
+  const root = { tag: "#root", props: {}, children: [] };
+  const stack = [root];
+  let cursor = 0;
+  TAG.lastIndex = 0;
+  for (let m = TAG.exec(text); m; m = TAG.exec(text)) {
+    const between = text.slice(cursor, m.index);
+    if (between.trim()) stack[stack.length - 1].children.push(decodeEntities(between));
+    cursor = TAG.lastIndex;
+    const [, closing, tag, rawAttrs, selfClosing] = m;
+    if (closing) {
+      if (stack.length > 1) stack.pop();
+      continue;
+    }
+    const props = {};
+    ATTR.lastIndex = 0;
+    for (let a = ATTR.exec(rawAttrs ?? ""); a; a = ATTR.exec(rawAttrs ?? "")) {
+      props[a[1]] = decodeEntities(a[2] ?? a[3] ?? a[4] ?? "");
+    }
+    const node = { tag, props, children: [] };
+    stack[stack.length - 1].children.push(node);
+    if (!selfClosing) stack.push(node);
+  }
+  const svg = root.children.find((c) => typeof c !== "string" && c.tag.toLowerCase() === "svg");
+  return svg ?? null;
+}
+function svgFromDataUri(src) {
+  const match = /^data:image\/svg\+xml(;[^,]*)?,(.*)$/is.exec(src.trim());
+  if (!match) return null;
+  const isBase64 = (match[1] ?? "").toLowerCase().includes("base64");
+  try {
+    const body = match[2] ?? "";
+    const markup = isBase64 ? new TextDecoder().decode(Uint8Array.from(atob(body), (c) => c.charCodeAt(0))) : decodeURIComponent(body);
+    return parseSvgMarkup(markup);
+  } catch {
+    return null;
+  }
+}
+
+// src/vnode.ts
+var INLINE_TAGS = /* @__PURE__ */ new Set(["span", "strong", "b", "em", "i", "u", "s", "code", "a", "small"]);
+var TEXT_BLOCK_TAGS = /* @__PURE__ */ new Set(["p", "h1", "h2", "h3", "h4", "h5", "h6", "li", "blockquote", "figcaption", "label", "td", "th", "div"]);
+function declarationsOf(v) {
+  return parseDeclarations(typeof v.props.style === "string" ? v.props.style : styleString(v.props.style));
+}
+function styleOf(v, ctx) {
+  const decls = declarationsOf(v);
+  const { style, unsupported } = translateStyle(decls);
+  for (const u of unsupported) ctx.warnings.add(`unsupported CSS property "${u}" (ignored)`);
+  return mapStyle(style);
+}
+function textOf(v) {
+  if (typeof v === "string") return v;
+  if (v.tag === "br") return "\n";
+  return v.children.map(textOf).join("");
+}
+function hasBlockChild(v) {
+  return v.children.some((c) => typeof c !== "string" && !INLINE_TAGS.has(c.tag) && c.tag !== "br");
+}
+function holdsWrappedText(v) {
+  let found = false;
+  walkVNodes(v, (n) => {
+    if (n.props["data-part"] === "text") found = true;
+    return !found;
+  });
+  return found;
+}
+function leaf(node, ann = { children: [] }) {
+  return { node, ann };
+}
+function svgNode(v, ctx) {
+  const width = Number(v.props.width) || 0;
+  const height = Number(v.props.height) || 0;
+  const { markup, labels } = splitSvg(v, (message) => ctx.warnings.add(message));
+  const viewBox = typeof v.props.viewBox === "string" ? v.props.viewBox : `0 0 ${width} ${height}`;
+  const box2 = mapStyle({ width: pxToPt(width), height: pxToPt(height) });
+  const shapes = {
+    kind: { type: "Svg", width: pxToPt(width), height: pxToPt(height), view_box: viewBox, content: markup },
+    style: { ...box2, ...styleOf(v, ctx) },
+    children: []
+  };
+  if (!labels.length) return leaf(shapes);
+  const vb = viewBox.trim().split(/[\s,]+/).map(Number);
+  const sx = vb.length === 4 && vb[2] ? width / vb[2] : 1;
+  const sy = vb.length === 4 && vb[3] ? height / vb[3] : 1;
+  const children = [shapes, ...labels.map((l) => labelNode(l, sx, sy))];
+  return {
+    node: {
+      kind: { type: "View" },
+      // Relative, so the labels are placed against this box rather than the page.
+      style: mapStyle({ position: "relative", width: pxToPt(width), height: pxToPt(height) }),
+      children
+    },
+    ann: { children: children.map(() => ({ children: [] })) }
+  };
+}
+function labelNode(l, sx, sy) {
+  const x = l.x * sx;
+  const size = l.fontSize * Math.min(sx, sy);
+  const estimate = Math.max(size, l.text.length * size * 0.55);
+  const width = estimate * 1.5;
+  const left = l.anchor === "middle" ? x - estimate / 2 : l.anchor === "end" ? x - estimate : x;
+  const style = {
+    position: "absolute",
+    left: pxToPt(left),
+    // `y` is a baseline; a box starts roughly one ascender higher.
+    top: pxToPt(l.y * sy - size * 0.8),
+    width: pxToPt(width),
+    fontSize: pxToPt(size),
+    textAlign: "left"
+  };
+  if (l.fill) style.color = l.fill;
+  if (l.fontFamily) style.fontFamily = l.fontFamily.split(",")[0].trim().replace(/^['"]|['"]$/g, "");
+  if (l.fontWeight) style.fontWeight = l.fontWeight;
+  return { kind: { type: "Text", content: l.text }, style: mapStyle(style), children: [] };
+}
+function sizeFrom(img, svg) {
+  const own = { width: Number(svg.props.width) || 0, height: Number(svg.props.height) || 0 };
+  const box2 = String(svg.props.viewBox ?? "").trim().split(/[\s,]+/).map(Number);
+  const natural = {
+    width: own.width || (box2.length === 4 ? box2[2] : 0),
+    height: own.height || (box2.length === 4 ? box2[3] : 0)
+  };
+  const css = parseDeclarations(typeof img.props.style === "string" ? img.props.style : styleString(img.props.style));
+  const asked = { width: Number.parseFloat(css.width ?? ""), height: Number.parseFloat(css.height ?? "") };
+  const ratio = natural.width && natural.height ? natural.width / natural.height : 0;
+  let width = Number.isFinite(asked.width) ? asked.width : 0;
+  let height = Number.isFinite(asked.height) ? asked.height : 0;
+  if (!width && height && ratio) width = height * ratio;
+  if (!height && width && ratio) height = width / ratio;
+  return { width: width || natural.width, height: height || natural.height };
+}
+function tableNode(v, ctx) {
+  const columns = [];
+  const rows = [];
+  const rowAnns = [];
+  const rowKinds = [];
+  const visit = (node, kind) => {
+    for (const child of node.children) {
+      if (typeof child === "string") continue;
+      if (child.tag === "colgroup") {
+        for (const col of child.children) {
+          if (typeof col === "string") continue;
+          const w = parseDeclarations(typeof col.props.style === "string" ? col.props.style : styleString(col.props.style)).width;
+          const parsed = w ? length(w) : void 0;
+          columns.push({
+            width: mapColumnWidth(
+              typeof parsed === "string" ? { fraction: Number.parseFloat(parsed) / 100 } : typeof parsed === "number" ? { fixed: parsed } : "auto"
+            )
+          });
+        }
+      } else if (child.tag === "thead") visit(child, "header");
+      else if (child.tag === "tbody") visit(child, "body");
+      else if (child.tag === "tfoot") visit(child, "footer");
+      else if (child.tag === "tr") {
+        const cells = [];
+        const cellAnns = [];
+        for (const cell of child.children) {
+          if (typeof cell === "string") continue;
+          const inner = childNodes(cell, ctx);
+          cells.push({
+            kind: { type: "TableCell", col_span: Number(cell.props.colspan) || 1, row_span: Number(cell.props.rowspan) || 1 },
+            style: styleOf(cell, ctx),
+            children: inner.nodes
+          });
+          cellAnns.push({ children: inner.anns });
+        }
+        rows.push({ kind: { type: "TableRow", is_header: kind === "header" }, style: styleOf(child, ctx), children: cells });
+        rowAnns.push({ children: cellAnns });
+        rowKinds.push(kind);
+      }
+    }
+  };
+  visit(v, "body");
+  return {
+    node: { kind: { type: "Table", columns }, style: styleOf(v, ctx), children: rows },
+    ann: { rowKinds, children: rowAnns }
+  };
+}
+function childNodes(v, ctx, inherited = {}) {
+  const nodes = [];
+  const anns = [];
+  for (const child of v.children) {
+    if (typeof child === "string") {
+      if (!child.trim()) continue;
+      nodes.push({ kind: { type: "Text", content: child }, style: inherited, children: [] });
+      anns.push({ children: [] });
+      continue;
+    }
+    const t = translate(child, ctx);
+    if (!t) continue;
+    nodes.push(t.node);
+    anns.push(t.ann);
+  }
+  return { nodes, anns };
+}
+function translate(v, ctx) {
+  const cls = classNames(v.props.class);
+  if (!ctx.design && /bp-(placeholder|empty-section|empty-column)\b/.test(cls)) return null;
+  if (/bp-page-break\b/.test(cls) && !ctx.suppressPageBreaks) return leaf({ kind: { type: "PageBreak" }, style: {}, children: [] });
+  let result;
+  switch (v.tag) {
+    case "svg":
+      result = svgNode(v, ctx);
+      break;
+    case "table":
+      result = tableNode(v, ctx);
+      break;
+    case "img": {
+      const src = typeof v.props.src === "string" ? v.props.src : "";
+      if (!src) return null;
+      const vector = svgFromDataUri(src);
+      if (vector) {
+        const sized = { ...vector, props: { ...vector.props, ...sizeFrom(v, vector) } };
+        result = svgNode(sized, ctx);
+        break;
+      }
+      const node = { kind: { type: "Image", src }, style: styleOf(v, ctx), children: [] };
+      if (typeof v.props.alt === "string" && v.props.alt) node.alt = v.props.alt;
+      result = leaf(node);
+      break;
+    }
+    case "br":
+      result = leaf({ kind: { type: "Text", content: "\n" }, style: {}, children: [] });
+      break;
+    case "ul":
+    case "ol": {
+      const items = [];
+      const itemAnns = [];
+      for (const li of v.children) {
+        if (typeof li === "string") continue;
+        const inner = childNodes(li, ctx);
+        items.push({ kind: { type: "ListItem" }, style: styleOf(li, ctx), children: inner.nodes });
+        itemAnns.push({ children: inner.anns });
+      }
+      result = {
+        // Marker names are the CSS `list-style-type` spellings, not capitalised
+        // variant names: the engine rejects the whole document over one wrong
+        // enum, so a single bullet list used to mean no PDF at all.
+        node: { kind: { type: "List", ordered: v.tag === "ol", marker_type: v.tag === "ol" ? "decimal" : "disc", start: 1 }, style: styleOf(v, ctx), children: items },
+        ann: { children: itemAnns }
+      };
+      break;
+    }
+    case "colgroup":
+    case "col":
+      return null;
+    default:
+      result = null;
+  }
+  if (!result) {
+    const style = styleOf(v, ctx);
+    const heading = /^h([1-6])$/.exec(v.tag);
+    const content = textOf(v);
+    const blank2 = !content.trim();
+    if (blank2 && !Object.keys(style).length && !v.children.length) return null;
+    const decls = declarationsOf(v);
+    const laysOut = decls.display === "flex" || decls.display === "inline-flex" || decls.display === "grid";
+    const textual = (TEXT_BLOCK_TAGS.has(v.tag) || INLINE_TAGS.has(v.tag) || heading) && !hasBlockChild(v) && !laysOut;
+    if (textual && (!blank2 || /bp-p--empty/.test(cls))) {
+      const kind = heading ? { type: "Heading", level: Number(heading[1]), content } : { type: "Text", content };
+      const node = { kind, style, children: [] };
+      if (v.tag === "a" && typeof v.props.href === "string") node.href = v.props.href;
+      result = leaf(node);
+    } else {
+      const inner = childNodes(v, ctx);
+      const draws = Object.keys(style).some((k) => /^border[A-Za-z]*Width$/.test(k)) || style.backgroundColor !== void 0 || style.height !== void 0;
+      if (inner.nodes.length === 0 && !draws) return null;
+      if (decls.display === "grid") applyGridAsFlex(style, inner.nodes, decls);
+      const node = { kind: { type: "View" }, style, children: inner.nodes };
+      if (v.tag === "a" && typeof v.props.href === "string") node.href = v.props.href;
+      result = { node, ann: { children: inner.anns } };
+    }
+  }
+  const key = v.props["data-key"];
+  if (typeof key === "string") {
+    result.ann.key = key;
+    if (holdsWrappedText(v)) result.ann.text = true;
+    if (!result.ann.rowKinds) {
+      const rows = findRowKinds(result.ann);
+      if (rows) result.ann.rowKinds = rows;
+    }
+  }
+  return result;
+}
+function applyGridAsFlex(style, children, decls) {
+  const tracks = /repeat\(\s*(\d+)/.exec(decls["grid-template-columns"] ?? "");
+  const spanned = children.filter((c) => typeof c.style.flexGrow === "number" && c.style.flexGrow > 0).length;
+  const perRow = tracks && spanned === 0 ? Number(tracks[1]) : children.length;
+  const wraps = children.length > perRow;
+  style.flexWrap = wraps ? "Wrap" : "NoWrap";
+  for (const child of children) {
+    if (child.style.flexGrow === void 0) {
+      child.style.flexGrow = 1;
+      child.style.flexBasis = wraps ? { Percent: 100 / Math.max(1, perRow) } : { Pt: 0 };
+    }
+    if (child.style.flexShrink === void 0) child.style.flexShrink = 1;
+    if (child.style.minWidth === void 0) child.style.minWidth = { Pt: 0 };
+  }
+}
+function findRowKinds(ann) {
+  if (ann.rowKinds) return ann.rowKinds;
+  for (const c of ann.children) {
+    const found = findRowKinds(c);
+    if (found) return found;
+  }
+  return void 0;
+}
+function vnodeToForme(v, ctx) {
+  return translate(v, ctx)?.node ?? null;
+}
+
+// src/watermark.ts
+import { mapStyle as mapStyle2 } from "@formepdf/shared";
+function watermarkNode(spec) {
+  return {
+    kind: { type: "Watermark", text: spec.text, font_size: spec.fontSize, angle: spec.angle },
+    style: mapStyle2({ color: spec.color, opacity: spec.opacity }),
+    children: []
+  };
+}
+
+// src/measure.ts
+import { renderNode } from "@broadpaper/core";
+var UNBOUNDED_PAGE_HEIGHT = 2e5;
+function descendants(el, nodeType, out = []) {
+  for (const c of el.children ?? []) {
+    if (c.nodeType === nodeType) out.push(c);
+    descendants(c, nodeType, out);
+  }
+  return out;
+}
+function collect(ann, el, origin, out) {
+  if (ann.key) {
+    const g = {
+      top: round2(el.y - origin.y),
+      height: round2(el.height),
+      // Both coordinates are relative to the section, which is what the
+      // paginator hands back as a repeated header’s offset inside the page
+      // content box. Leaving x absolute pushed every repeated table header one
+      // page margin to the right and its last column off the page.
+      left: round2(el.x - origin.x),
+      width: round2(el.width)
+    };
+    if (ann.text) {
+      const lines = descendants(el, "TextLine");
+      if (lines.length) {
+        const sorted = [...lines].sort((a, b) => a.y - b.y);
+        const bounds = [];
+        for (let i = 0; i < sorted.length - 1; i++) {
+          const bottom = sorted[i].y + sorted[i].height;
+          bounds.push(round2((bottom + sorted[i + 1].y) / 2 - origin.y));
+        }
+        bounds.push(round2(el.y + el.height - origin.y));
+        g.lines = bounds;
+      }
+    }
+    if (ann.rowKinds) {
+      const rows = descendants(el, "TableRow").sort((a, b) => a.y - b.y);
+      g.rows = rows.map((r, i) => ({ top: round2(r.y - origin.y), height: round2(r.height), kind: ann.rowKinds[i] ?? "body" }));
+    }
+    out[ann.key] = g;
+  }
+  const kids = el.children ?? [];
+  for (let i = 0; i < ann.children.length; i++) {
+    const childEl = kids[i];
+    if (!childEl) continue;
+    collect(ann.children[i], childEl, origin, out);
+  }
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function geometryFromLayout(sections, pageElements, width) {
+  const out = {};
+  for (let i = 0; i < sections.length; i++) {
+    const el = pageElements[i];
+    const { section, ann } = sections[i];
+    if (!el) {
+      out[section.key] = { height: 0, width, nodes: {} };
+      continue;
+    }
+    const nodes = {};
+    collect(ann, el, { x: el.x, y: el.y }, nodes);
+    const geom = { height: round2(el.height), width, nodes };
+    nodes[section.key] = { top: 0, height: geom.height, left: 0, width: round2(el.width) };
+    out[section.key] = geom;
+  }
+  return out;
+}
+function scale(el, factor) {
+  return {
+    ...el,
+    x: el.x * factor,
+    y: el.y * factor,
+    width: el.width * factor,
+    height: el.height * factor,
+    children: (el.children ?? []).map((c) => scale(c, factor))
+  };
+}
+var FormeMeasurer = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  warnings = /* @__PURE__ */ new Set();
+  renderOptions() {
+    return {
+      registry: this.opts.registry,
+      theme: this.opts.theme,
+      styles: this.opts.styles,
+      mode: this.opts.mode ?? "preview",
+      page: { number: 1, total: 1 },
+      format: this.opts.format,
+      width: this.contentWidth
+    };
+  }
+  get contentWidth() {
+    return Math.max(0, this.opts.pageWidth - this.opts.margins.left - this.opts.margins.right);
+  }
+  async measure(sections, width = this.contentWidth) {
+    if (!sections.length) return {};
+    const ctx = { warnings: this.warnings, design: (this.opts.mode ?? "preview") === "design", suppressPageBreaks: true };
+    const renderOpts = { ...this.renderOptions(), width };
+    const measured = [];
+    for (const section of sections) {
+      const v = renderNode(section, renderOpts, width);
+      if (!v) continue;
+      const t = translate(v, ctx);
+      if (t) measured.push({ section, node: t.node, ann: t.ann });
+    }
+    if (!measured.length) return {};
+    const m = this.opts.margins;
+    const doc = {
+      children: [
+        {
+          kind: {
+            type: "Page",
+            config: {
+              // Tall enough that nothing can paginate: this is a measuring page.
+              size: { Custom: { width: pxToPt(this.opts.pageWidth), height: UNBOUNDED_PAGE_HEIGHT } },
+              margin: { top: pxToPt(m.top), right: pxToPt(m.right), bottom: pxToPt(m.bottom), left: pxToPt(m.left) },
+              wrap: true
+            }
+          },
+          style: {},
+          children: measured.map((x) => x.node)
+        }
+      ],
+      metadata: {},
+      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;
+    const result = await this.opts.render(doc);
+    const pages = result.layout?.pages ?? [];
+    const toPx = 96 / 72;
+    const elements = (pages[0]?.elements ?? []).map((e) => scale(e, toPx));
+    for (const w of result.warnings ?? []) this.warnings.add(w);
+    return geometryFromLayout(measured, elements, width);
+  }
+};
+
+// src/editor.ts
+function hash(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36) + s.length.toString(36);
+}
+var FormeEditorMeasurer = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  opts = null;
+  cache = /* @__PURE__ */ new Map();
+  seen = /* @__PURE__ */ new Set();
+  setOptions(opts) {
+    this.opts = opts;
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  destroy() {
+    this.cache.clear();
+  }
+  key(section, width, mode) {
+    return hash(JSON.stringify(section)) + ":" + Math.round(width * 100) + ":" + mode;
+  }
+  async measure(sections, width) {
+    const opts = this.opts;
+    if (!opts) throw new Error("FormeEditorMeasurer.setOptions() must be called before measure()");
+    const out = {};
+    const pending = [];
+    const keys = /* @__PURE__ */ new Map();
+    for (const section of sections) {
+      const k = this.key(section, width, opts.mode);
+      const hit = this.cache.get(k);
+      if (hit) out[section.key] = hit;
+      else {
+        pending.push(section);
+        keys.set(section.key, k);
+      }
+    }
+    if (!pending.length) return out;
+    const measurer = new FormeMeasurer({
+      registry: opts.registry,
+      theme: opts.theme,
+      styles: opts.styles,
+      format: opts.format,
+      mode: opts.mode,
+      pageWidth: width,
+      margins: { top: 0, right: 0, bottom: 0, left: 0 },
+      fonts: this.config.fonts,
+      render: this.config.render
+    });
+    const measured = await measurer.measure(pending, width);
+    for (const [sectionKey, geometry] of Object.entries(measured)) {
+      out[sectionKey] = geometry;
+      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);
+    }
+    return out;
+  }
+};
+
+// src/api.ts
+import {
+  computePageGeometry,
+  mergeTheme,
+  renderNode as renderNode3,
+  resolveTemplate,
+  migrateTemplate
+} from "@broadpaper/core";
+import { mapStyle as mapStyle4 } from "@formepdf/shared";
+import { producerString, resolveLicenseStatus, watermarkFor } from "@broadpaper/license";
+import { BroadPaper, configure, resolveLicenseStatus as resolveLicenseStatus2, verifyLicense, parseLicense } from "@broadpaper/license";
+import { computePageGeometry as pageGeometry, paginate, resolveValue } from "@broadpaper/core";
+
+// src/paged.ts
+import {
+  renderNode as renderNode2,
+  walkVNodes as walkVNodes2
+} from "@broadpaper/core";
+import { mapStyle as mapStyle3 } from "@formepdf/shared";
+
+// src/clip.ts
+import { styleString as styleString2 } from "@broadpaper/core";
+var EPS = 0.01;
+function cropToWindow(root, geom, from, to) {
+  const w = { geom, from, to, dropped: 0 };
+  const node = crop(root, w, void 0);
+  return { node, offset: w.dropped };
+}
+function outside(w, top, height) {
+  return top + height <= w.from + EPS || top >= w.to - EPS;
+}
+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;
+  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) => {
+    if (typeof c === "string") return c;
+    const next = crop(c, w, rows);
+    if (next !== c) changed = true;
+    return next;
+  });
+  return changed ? { ...v, children } : v;
+}
+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`);
+  return { ...v, props: { ...v.props, style: kept.join(";") }, children: [] };
+}
+function cropTable(table, w, rows) {
+  if (rows.length === 0) return table;
+  const keep = rows.map((r) => !outside(w, r.top, r.height));
+  if (keep.every(Boolean)) return table;
+  const first = keep.indexOf(true);
+  if (first === -1) return { tag: "div", props: { style: "height:0" }, children: [] };
+  w.dropped += rows[first].top - rows[0].top;
+  let index = 0;
+  const rewrite = (node) => {
+    const children = [];
+    for (const c of node.children) {
+      if (typeof c === "string") continue;
+      if (c.tag === "thead" || c.tag === "tbody" || c.tag === "tfoot") {
+        const next = rewrite(c);
+        if (next) children.push(next);
+      } else if (c.tag === "tr") {
+        if (keep[index++]) children.push(c);
+      } else children.push(c);
+    }
+    if (node !== table && !children.some((c) => typeof c !== "string" && c.tag === "tr")) return null;
+    return { ...node, children };
+  };
+  return rewrite(table);
+}
+function round3(n) {
+  return Math.round(n * 100) / 100;
+}
+
+// src/paged.ts
+function box(left, top, width, height, children, clip = true, bleed = 0) {
+  const style = mapStyle3({
+    position: "absolute",
+    left: pxToPt(left),
+    top: pxToPt(top),
+    width: pxToPt(width + bleed),
+    height: pxToPt(height),
+    ...clip ? { overflow: "hidden" } : {}
+  });
+  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;
+  });
+  return clone;
+}
+function sectionsByKey(doc) {
+  const map = /* @__PURE__ */ new Map();
+  const visit = (n) => {
+    map.set(n.key, n);
+    n.children.forEach(visit);
+  };
+  for (const list of [doc.body, doc.header.default, doc.header.firstPage ?? [], doc.footer.default, doc.footer.firstPage ?? []]) list.forEach(visit);
+  return map;
+}
+function isPageDependent(nodes) {
+  const check = (n) => n.pageDependent === true || n.children.some(check);
+  return nodes.some(check);
+}
+function emitPages(input) {
+  const { resolved, paged, page, renderOpts, ctx, geometry } = input;
+  const byKey = sectionsByKey(resolved);
+  const width = page.contentWidth;
+  const bleed = page.margins.right;
+  const bodyDependsOnPage = isPageDependent(resolved.body);
+  const cache = /* @__PURE__ */ new Map();
+  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 (!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);
+    return out;
+  };
+  const region = (sections, opts) => {
+    const out = [];
+    for (const s of sections) {
+      const v = renderNode2(s, opts, width);
+      if (!v) continue;
+      const t = translate(v, ctx);
+      if (t) out.push(t.node);
+    }
+    return out;
+  };
+  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));
+    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)));
+    }
+    const fragments = [];
+    for (const f of p.fragments) {
+      const section = byKey.get(f.sectionKey);
+      if (!section) continue;
+      const extra = f.repeatHeaders.reduce((a, r) => a + r.height, 0);
+      const inner = [];
+      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 content = translateSection(section, opts, f.from, f.to);
+      if (content) {
+        const shifted = {
+          kind: { type: "View" },
+          style: mapStyle3({ position: "absolute", left: 0, top: pxToPt(content.offset - f.from), width: pxToPt(width) }),
+          children: [content.node]
+        };
+        inner.push(box(0, extra, width, f.to - f.from, [shifted], true, bleed));
+      }
+      fragments.push(box(0, f.y, width, f.height, inner, true, bleed));
+    }
+    children.push(box(page.margins.left, page.contentTop, width, page.contentHeight, fragments, true, bleed));
+    const footerSections = p.first && resolved.footer.firstPage ? resolved.footer.firstPage : resolved.footer.default;
+    if (footerSections.length && page.footerHeight > 0) {
+      children.push(box(page.margins.left, page.footerTop, width, page.footerHeight, region(footerSections, opts)));
+    }
+    return {
+      kind: {
+        type: "Page",
+        config: {
+          size: { Custom: { width: pxToPt(page.width), height: pxToPt(page.height) } },
+          margin: { top: 0, right: 0, bottom: 0, left: 0 },
+          // Nothing may reflow: this page is exactly what the paginator decided.
+          wrap: false
+        }
+      },
+      style: input.background ? mapStyle3({ backgroundColor: input.background }) : {},
+      children
+    };
+  });
+}
+
+// src/api.ts
+async function buildFormeDocument(opts) {
+  const license = await resolveLicenseStatus(opts.license !== void 0 ? { license: opts.license } : {});
+  const { template } = migrateTemplate(opts.template);
+  const theme = mergeTheme(opts.theme);
+  const geom = computePageGeometry(template.page);
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const format = {
+    locale: opts.locale ?? template.settings?.locale ?? "en-GB",
+    currency: opts.currency ?? template.settings?.currency ?? "GBP",
+    timeZone: opts.timeZone ?? template.settings?.timeZone,
+    now
+  };
+  const resolved = resolveTemplate({
+    template,
+    registry: opts.registry,
+    theme,
+    dataSources: opts.dataSources,
+    data: opts.data,
+    mode: "preview",
+    now,
+    locale: format.locale,
+    currency: format.currency,
+    timeZone: format.timeZone
+  });
+  const renderOpts = {
+    registry: opts.registry,
+    theme,
+    styles: template.styles,
+    mode: "preview",
+    page: { number: 1, total: 1 },
+    format,
+    width: geom.contentWidth
+  };
+  const ctx = { warnings: /* @__PURE__ */ new Set() };
+  const translate2 = (sections) => {
+    const out = [];
+    for (const s of sections) {
+      const v = renderNode3(s, renderOpts, geom.contentWidth);
+      if (!v) continue;
+      const node = vnodeToForme(v, ctx);
+      if (node) out.push(node);
+    }
+    return out;
+  };
+  const children = [];
+  const mark = watermarkFor(license);
+  if (mark) 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 });
+  children.push(...translate2(resolved.body));
+  const page = {
+    kind: {
+      type: "Page",
+      config: {
+        size: { Custom: { width: pxToPt(geom.width), height: pxToPt(geom.height) } },
+        margin: { top: pxToPt(geom.margins.top), right: pxToPt(geom.margins.right), bottom: pxToPt(geom.margins.bottom), left: pxToPt(geom.margins.left) },
+        wrap: true
+      }
+    },
+    style: {},
+    children
+  };
+  const doc = {
+    children: [page],
+    metadata: { title: template.name, creator: producerString(license), ...opts.metadata ?? {} },
+    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" }));
+  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)];
+  return { doc, warnings, license };
+}
+var engineLoader = null;
+var engine = null;
+function setEngineLoader(loader) {
+  engineLoader = loader;
+}
+async function defaultRenderer(doc) {
+  if (!engineLoader) {
+    throw new Error(
+      "No Forme engine is available. Import @broadpaper/forme from its package entry point, or pass a `renderer` to render with an engine you loaded yourself."
+    );
+  }
+  engine ??= await engineLoader();
+  return engine(doc);
+}
+async function renderPdf(opts) {
+  const started = Date.now();
+  const { doc, warnings } = await buildFormeDocument(opts);
+  const render = opts.renderer ?? defaultRenderer;
+  const result = await render(doc);
+  const layout = result.layout ?? null;
+  return {
+    pdf: result.pdf,
+    pages: layout?.pages.length ?? 0,
+    layout,
+    warnings: [...warnings, ...result.warnings ?? []],
+    durationMs: Date.now() - started
+  };
+}
+async function renderPdfPaginated(opts) {
+  const started = Date.now();
+  const license = await resolveLicenseStatus(opts.license !== void 0 ? { license: opts.license } : {});
+  const { template } = migrateTemplate(opts.template);
+  const theme = mergeTheme(opts.theme);
+  const geom = pageGeometry(template.page);
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const format = {
+    locale: opts.locale ?? template.settings?.locale ?? "en-GB",
+    currency: opts.currency ?? template.settings?.currency ?? "GBP",
+    timeZone: opts.timeZone ?? template.settings?.timeZone,
+    now
+  };
+  const resolved = resolveTemplate({
+    template,
+    registry: opts.registry,
+    theme,
+    dataSources: opts.dataSources,
+    data: opts.data,
+    mode: "preview",
+    now,
+    locale: format.locale,
+    currency: format.currency,
+    timeZone: format.timeZone
+  });
+  const renderOpts = {
+    registry: opts.registry,
+    theme,
+    styles: template.styles,
+    mode: "preview",
+    page: { number: 1, total: 1 },
+    format,
+    width: geom.contentWidth
+  };
+  const ctx = { warnings: /* @__PURE__ */ new Set(), suppressPageBreaks: true };
+  const render = opts.renderer ?? defaultRenderer;
+  const measure = async (sections) => {
+    if (!sections.length) return {};
+    const measured = [];
+    for (const section of sections) {
+      const v = renderNode3(section, renderOpts, geom.contentWidth);
+      if (!v) continue;
+      const t = translate(v, ctx);
+      if (t) measured.push({ section, node: t.node, ann: t.ann });
+    }
+    if (!measured.length) return {};
+    const doc2 = {
+      children: [
+        {
+          kind: {
+            type: "Page",
+            config: {
+              size: { Custom: { width: pxToPt(geom.width), height: UNBOUNDED_PAGE_HEIGHT } },
+              margin: { top: pxToPt(geom.margins.top), right: pxToPt(geom.margins.right), bottom: pxToPt(geom.margins.bottom), left: pxToPt(geom.margins.left) },
+              wrap: true
+            }
+          },
+          style: {},
+          children: measured.map((m) => m.node)
+        }
+      ],
+      metadata: {},
+      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 ?? [];
+    const scale2 = 1 / PX_TO_PT_LOCAL;
+    const scaled = pages2[0]?.elements.map((e) => scaleElement(e, scale2)) ?? [];
+    return geometryFromLayout(measured, scaled, geom.contentWidth);
+  };
+  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;
+  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
+  };
+}
+var PX_TO_PT_LOCAL = 72 / 96;
+function scaleElement(el, scale2) {
+  return {
+    ...el,
+    x: el.x * scale2,
+    y: el.y * scale2,
+    width: el.width * scale2,
+    height: el.height * scale2,
+    children: (el.children ?? []).map((c) => scaleElement(c, scale2))
+  };
+}
+function baseStyle(theme) {
+  return mapStyle4({
+    fontSize: pxToPt(theme.typography.baseFontSize ?? 11),
+    fontFamily: theme.typography.bodyFont.split(",")[0].trim().replace(/^['"]|['"]$/g, "")
+  });
+}
+function fontEntries(fonts) {
+  return fonts.map((f) => ({ family: f.family, src: f.src, weight: f.weight ?? 400, style: f.style ?? "normal" }));
+}
+
+export {
+  PX_TO_PT,
+  pxToPt,
+  parseDeclarations,
+  translateStyle,
+  translate,
+  vnodeToForme,
+  watermarkNode,
+  UNBOUNDED_PAGE_HEIGHT,
+  geometryFromLayout,
+  FormeMeasurer,
+  FormeEditorMeasurer,
+  buildFormeDocument,
+  setEngineLoader,
+  renderPdf,
+  renderPdfPaginated,
+  BroadPaper,
+  configure,
+  resolveLicenseStatus2 as resolveLicenseStatus,
+  verifyLicense,
+  parseLicense
+};
+//# sourceMappingURL=chunk-KE7FFMY2.js.map