@shadow-garden/bapbong-layout-engine 0.1.0

package/dist/index.js

@@ -0,0 +1,1447 @@
+// packages/layout-engine/src/lib/layout-engine.ts
+import {
+  createNumberingCounter
+} from "@shadow-garden/bapbong-model";
+var DEFAULT_FONT = { family: "Arial", sizePt: 11, bold: false, italic: false };
+var PT_TO_PX = 96 / 72;
+var HEADING_PT = { 1: 24, 2: 18, 3: 14, 4: 12, 5: 11, 6: 11 };
+var LINE_HEIGHT_FACTOR = 1.2;
+var BASELINE_FACTOR = 0.8;
+var DEFAULT_TAB_WIDTH = 48;
+var SUPERSUB_SCALE = 0.66;
+var CELL_PAD_X = 7.2;
+var CELL_PAD_Y = 0;
+var FOOTNOTE_FONT_SCALE = 0.85;
+var FOOTNOTE_AREA_GAP = 12;
+var sizePx = (font) => font.sizePt * PT_TO_PX;
+function findMark(marks, name) {
+  return marks.find((m) => m.type.name === name);
+}
+function resolveRun(node, base, pos) {
+  const marks = node.marks;
+  const font = { ...base };
+  if (findMark(marks, "strong")) font.bold = true;
+  if (findMark(marks, "em")) font.italic = true;
+  const size = findMark(marks, "fontSize");
+  if (size) font.sizePt = Number(size.attrs["size"]) || base.sizePt;
+  const family = findMark(marks, "fontFamily");
+  if (family) font.family = String(family.attrs["family"] ?? base.family);
+  const color = findMark(marks, "textColor");
+  const link = findMark(marks, "link");
+  const run = {
+    text: node.text ?? "",
+    font,
+    color: color ? String(color.attrs["color"]) : void 0,
+    link: link ? String(link.attrs["href"]) : void 0,
+    pos
+  };
+  if (findMark(marks, "underline")) run.underline = true;
+  if (findMark(marks, "strike")) run.strike = true;
+  const highlight = findMark(marks, "highlight");
+  if (highlight) run.background = String(highlight.attrs["color"]);
+  const va = findMark(marks, "vertAlign");
+  if (va) run.vertAlign = va.attrs["value"] === "sub" ? "sub" : "super";
+  const fn = findMark(marks, "footnote");
+  if (fn) run.footnoteRef = Number(fn.attrs["num"]) || void 0;
+  const cm = findMark(marks, "comment");
+  if (cm) run.commentIds = cm.attrs["ids"];
+  return run;
+}
+function resolveField(node, base, pos) {
+  const marks = node.marks;
+  const font = { ...base };
+  if (findMark(marks, "strong")) font.bold = true;
+  if (findMark(marks, "em")) font.italic = true;
+  const size = findMark(marks, "fontSize");
+  if (size) font.sizePt = Number(size.attrs["size"]) || base.sizePt;
+  const family = findMark(marks, "fontFamily");
+  if (family) font.family = String(family.attrs["family"] ?? base.family);
+  const color = findMark(marks, "textColor");
+  return {
+    field: node.attrs["kind"] === "pages" ? "pageCount" : "pageNumber",
+    font,
+    color: color ? String(color.attrs["color"]) : void 0,
+    pos
+  };
+}
+function resolveImage(node, pos) {
+  const a = node.attrs;
+  const link = findMark(node.marks, "link");
+  return {
+    src: String(a["src"] ?? ""),
+    width: Number(a["width"]) || 0,
+    height: Number(a["height"]) || 0,
+    link: link ? String(link.attrs["href"]) : void 0,
+    ...a["shape"] ? { shape: a["shape"] } : {},
+    ...Number(a["rotation"]) ? { rotation: Number(a["rotation"]) } : {},
+    pos
+  };
+}
+function paragraphToFlow(node, base, nodePos, allowFloats = false, marker) {
+  const contentStart = nodePos + 1;
+  const headingLevel = node.attrs["heading"];
+  const runBase = headingLevel ? { ...base, sizePt: HEADING_PT[headingLevel] ?? base.sizePt, bold: true } : base;
+  const runs = [];
+  const floats = [];
+  node.forEach((child, offset) => {
+    if (child.isText) runs.push(resolveRun(child, runBase, contentStart + offset));
+    else if (child.type.name === "image") {
+      const float = child.attrs["float"];
+      if (float && allowFloats) {
+        const f = {
+          ...float,
+          src: String(child.attrs["src"] ?? ""),
+          width: Number(child.attrs["width"]) || 0,
+          height: Number(child.attrs["height"]) || 0,
+          pos: contentStart + offset,
+          ...child.attrs["shape"] ? { shape: child.attrs["shape"] } : {},
+          ...Number(child.attrs["rotation"]) ? { rotation: Number(child.attrs["rotation"]) } : {}
+        };
+        const tb = child.attrs["textbox"];
+        if (tb && tb.paragraphs.length > 0) {
+          const schema = child.type.schema;
+          f.content = tb.paragraphs.map(
+            (json, i) => paragraphToFlow(schema.nodeFromJSON(json), base, i)
+          );
+          if (tb.inset) f.inset = tb.inset;
+        }
+        floats.push(f);
+      } else {
+        runs.push(resolveImage(child, contentStart + offset));
+      }
+    } else if (child.type.name === "page_field")
+      runs.push(resolveField(child, runBase, contentStart + offset));
+    else if (child.type.name === "hard_break") runs.push({ break: true, pos: contentStart + offset });
+  });
+  const list = node.attrs["list"];
+  const align = node.attrs["align"];
+  const indent = node.attrs["indent"];
+  const flow = {
+    type: "paragraph",
+    runs,
+    marker: marker ?? (list?.marker || void 0),
+    align: align ?? void 0,
+    indent: indent ?? void 0,
+    pos: contentStart,
+    end: contentStart + node.content.size
+  };
+  if (floats.length > 0) flow.floats = floats;
+  const tabs = node.attrs["tabs"];
+  if (tabs) flow.tabs = tabs;
+  const spacing = node.attrs["spacing"];
+  if (spacing) flow.spacing = spacing;
+  if (node.attrs["pageBreakBefore"] === true) flow.pageBreakBefore = true;
+  return flow;
+}
+function nodeHasFloats(node) {
+  let found = false;
+  node.forEach((child) => {
+    if (child.type.name === "image" && child.attrs["float"]) found = true;
+  });
+  return found;
+}
+function markerFor(node, counter) {
+  const list = node.attrs["list"];
+  if (!list) return void 0;
+  return (counter?.next(list.numId, list.level) || list.marker) ?? void 0;
+}
+function nodeToBlock(node, base, nodePos, allowFloats = false, counter) {
+  if (node.type.name === "paragraph")
+    return paragraphToFlow(node, base, nodePos, allowFloats, markerFor(node, counter));
+  if (node.type.name === "table") return tableToFlow(node, base, nodePos, counter);
+  return null;
+}
+function tableToFlow(node, base, nodePos, counter) {
+  const rows = [];
+  node.forEach((rowNode, rowOffset) => {
+    const rowPos = nodePos + 1 + rowOffset;
+    const cells = [];
+    rowNode.forEach((cellNode, cellOffset) => {
+      const cellPos = rowPos + 1 + cellOffset;
+      const content = [];
+      cellNode.forEach((child, childOffset) => {
+        const block = nodeToBlock(child, base, cellPos + 1 + childOffset, true, counter);
+        if (block) content.push(block);
+      });
+      const a = cellNode.attrs;
+      cells.push({
+        colspan: Number(a["colspan"]) || 1,
+        rowspan: Number(a["rowspan"]) || 1,
+        colwidth: a["colwidth"] ?? null,
+        background: a["background"] ?? void 0,
+        vAlign: a["vAlign"] ?? void 0,
+        borders: a["borders"] ?? void 0,
+        content
+      });
+    });
+    const row = { cells };
+    if (rowNode.attrs["header"] === true) row.header = true;
+    if (rowNode.attrs["cantSplit"] === true) row.cantSplit = true;
+    const height = rowNode.attrs["height"];
+    if (height) row.height = height;
+    rows.push(row);
+  });
+  const flow = { type: "table", rows };
+  const cellPadding = node.attrs["cellPadding"];
+  if (cellPadding) flow.cellPadding = cellPadding;
+  const align = node.attrs["align"];
+  if (align) flow.align = align;
+  const borders = node.attrs["borders"];
+  if (borders) flow.borders = borders;
+  return flow;
+}
+function toFlowBlocks(doc, defaultFont = {}, allowFloats = true) {
+  const base = { ...DEFAULT_FONT, ...defaultFont };
+  const counter = createNumberingCounter(doc.attrs["numbering"]);
+  const blocks = [];
+  doc.forEach((node, offset) => {
+    const block = nodeToBlock(node, base, offset, allowFloats, counter);
+    if (block) blocks.push(block);
+  });
+  return blocks;
+}
+function tokenizeInline(inline, ctx) {
+  if ("break" in inline) {
+    return [{ isBreak: true, font: ctx.base, width: 0, isSpace: false, pos: inline.pos, size: 1 }];
+  }
+  if ("src" in inline) {
+    return [
+      {
+        image: inline,
+        font: ctx.base,
+        link: inline.link,
+        width: inline.width,
+        isSpace: false,
+        pos: inline.pos,
+        size: 1
+      }
+    ];
+  }
+  if ("field" in inline) {
+    return [
+      {
+        field: inline.field,
+        text: ctx.fieldPlaceholder,
+        font: inline.font,
+        color: inline.color,
+        width: ctx.measure(ctx.fieldPlaceholder, inline.font),
+        isSpace: false,
+        pos: inline.pos,
+        size: 1
+      }
+    ];
+  }
+  const font = inline.vertAlign ? { ...inline.font, sizePt: inline.font.sizePt * SUPERSUB_SCALE } : inline.font;
+  let offset = 0;
+  return inline.text.split(/(\t| +)/).filter((part) => part.length > 0).map((part) => {
+    const isTab = part === "	";
+    const isSpace = isTab || /^ +$/.test(part);
+    const pos = inline.pos != null ? inline.pos + offset : void 0;
+    offset += part.length;
+    return {
+      text: part,
+      font,
+      color: inline.color,
+      link: inline.link,
+      underline: inline.underline,
+      strike: inline.strike,
+      background: inline.background,
+      vertAlign: inline.vertAlign,
+      footnoteRef: inline.footnoteRef,
+      commentIds: inline.commentIds,
+      width: isTab ? 0 : ctx.measure(part, font),
+      isSpace,
+      isTab,
+      pos,
+      size: part.length
+    };
+  });
+}
+function draftToLine(d, y, dx = 0) {
+  const line = {
+    x: d.x + dx,
+    y,
+    width: d.width,
+    height: d.height,
+    baseline: d.baseline,
+    segments: dx === 0 ? d.segments : d.segments.map((s) => ({ ...s, x: s.x + dx }))
+  };
+  if (d.images.length > 0) {
+    line.images = dx === 0 ? d.images : d.images.map((im) => ({ ...im, x: im.x + dx }));
+  }
+  if (d.from != null) line.from = d.from;
+  if (d.to != null) line.to = d.to;
+  return line;
+}
+function wrapParagraph(block, ctx, bandFn, emit) {
+  const { base, measure, metrics, tabWidth } = ctx;
+  const indent = block.indent;
+  const indentLeft = indent?.left ?? 0;
+  const indentRight = indent?.right ?? 0;
+  const firstLineDelta = indent?.hanging != null ? -indent.hanging : indent?.firstLine ?? 0;
+  const align = block.align ?? "left";
+  const tokens = block.runs.flatMap((inline) => tokenizeInline(inline, ctx));
+  const baseMetrics = metrics ? metrics(base) : null;
+  const nominalH = baseMetrics ? baseMetrics.ascent + baseMetrics.descent : sizePx(base) * LINE_HEIGHT_FACTOR;
+  let band = bandFn(nominalH);
+  let lineLeft = band.left + indentLeft;
+  let lineRight = band.right - indentRight;
+  let marker = null;
+  let markerTextX = 0;
+  if (block.marker) {
+    marker = {
+      x: lineLeft + firstLineDelta,
+      text: block.marker,
+      font: base,
+      width: measure(block.marker, base)
+    };
+    markerTextX = marker.x + measure(`${block.marker} `, base);
+  }
+  const firstLineStart = marker ? markerTextX : lineLeft + firstLineDelta;
+  let contStart = marker ? Math.max(markerTextX, lineLeft) : lineLeft;
+  let lineTokens = [];
+  let lineWidth = 0;
+  let firstLine = true;
+  let prevTo;
+  let maxFontPx = sizePx(base);
+  let maxImagePx = 0;
+  let maxAscent = baseMetrics?.ascent ?? 0;
+  let maxDescent = baseMetrics?.descent ?? 0;
+  const lineStart = () => firstLine ? firstLineStart : contStart;
+  const tabAdvance = (x) => {
+    const k = Math.floor((x - lineLeft) / tabWidth) + 1;
+    return lineLeft + k * tabWidth - x;
+  };
+  const tabStops = block.tabs ? [...block.tabs].sort((a, b) => a.pos - b.pos) : [];
+  const LEADER_CHARS = { dot: ".", hyphen: "-", underscore: "_", middleDot: "\xB7" };
+  const MIN_TAB = 2;
+  const tabGroup = (ti) => {
+    let width = 0;
+    let decimalPrefix = null;
+    for (let j = ti + 1; j < tokens.length; j++) {
+      const t = tokens[j];
+      if (t.isTab) break;
+      if (decimalPrefix === null && t.text != null && !t.field) {
+        const m = /[.,]/.exec(t.text);
+        if (m) decimalPrefix = width + measure(t.text.slice(0, m.index), t.font);
+      }
+      width += t.width;
+    }
+    return { width, decimalPrefix };
+  };
+  const resolveTab = (token, x, ti) => {
+    token.origPos ??= token.pos;
+    token.pos = token.origPos;
+    token.text = "	";
+    const stop = tabStops.find((s) => lineLeft + s.pos > x + 0.5);
+    if (!stop) {
+      token.width = tabAdvance(x);
+      return;
+    }
+    const stopX = Math.min(lineLeft + stop.pos, lineRight);
+    if (stopX <= x + 0.5) {
+      token.width = tabAdvance(x);
+      return;
+    }
+    let w = stopX - x;
+    if (stop.val !== "left") {
+      const g = tabGroup(ti);
+      const hang = stop.val === "right" ? g.width : stop.val === "center" ? g.width / 2 : g.decimalPrefix ?? g.width;
+      w = stopX - x - hang;
+      if (w < MIN_TAB) {
+        token.width = tabAdvance(x);
+        return;
+      }
+    }
+    token.width = w;
+    if (stop.leader) {
+      const ch = LEADER_CHARS[stop.leader] ?? ".";
+      const chW = measure(ch, token.font);
+      const n = chW > 0 ? Math.floor(w / chW) : 0;
+      if (n > 1) {
+        token.text = ch.repeat(n - 1);
+        token.pos = void 0;
+      }
+    }
+  };
+  const flushLine = (isLast) => {
+    const startX = lineStart();
+    const avail = lineRight - startX;
+    let end = lineTokens.length;
+    let contentWidth = lineWidth;
+    while (end > 0 && lineTokens[end - 1].isSpace) {
+      contentWidth -= lineTokens[end - 1].width;
+      end--;
+    }
+    let x = startX;
+    let extraPerGap = 0;
+    if (align === "justify" && !isLast) {
+      const gaps = lineTokens.slice(0, end).filter((t) => t.isSpace && !t.isTab).length;
+      if (gaps > 0) extraPerGap = (avail - contentWidth) / gaps;
+    } else if (align === "center") {
+      x += Math.max(0, (avail - contentWidth) / 2);
+    } else if (align === "right") {
+      x += Math.max(0, avail - contentWidth);
+    }
+    const segments = [];
+    const images = [];
+    for (let i = 0; i < end; i++) {
+      const t = lineTokens[i];
+      if (t.image) {
+        images.push({
+          x,
+          src: t.image.src,
+          width: t.image.width,
+          height: t.image.height,
+          link: t.link,
+          ...t.image.shape ? { shape: t.image.shape } : {},
+          ...t.image.rotation ? { rotation: t.image.rotation } : {},
+          pos: t.pos
+        });
+      } else {
+        const seg = {
+          x,
+          text: t.text ?? "",
+          font: t.font,
+          color: t.color,
+          link: t.link,
+          underline: t.underline,
+          strike: t.strike,
+          background: t.background,
+          vertAlign: t.vertAlign,
+          width: t.width,
+          pos: t.pos
+        };
+        if (t.field) seg.field = t.field;
+        if (t.footnoteRef != null) seg.footnoteRef = t.footnoteRef;
+        if (t.commentIds) seg.commentIds = t.commentIds;
+        segments.push(seg);
+      }
+      x += t.width + (t.isSpace && !t.isTab ? extraPerGap : 0);
+    }
+    const firstPos = lineTokens.find((t, i) => i < end && t.pos != null)?.pos;
+    let lastEnd;
+    for (let i = end - 1; i >= 0; i--) {
+      const t = lineTokens[i];
+      if (t.pos != null) {
+        lastEnd = t.pos + t.size;
+        break;
+      }
+    }
+    const from = firstPos ?? prevTo ?? block.pos;
+    const to = lastEnd ?? from;
+    let height;
+    let baseline;
+    if (metrics) {
+      height = maxAscent + maxDescent;
+      baseline = maxAscent;
+    } else {
+      height = Math.max(maxFontPx * LINE_HEIGHT_FACTOR, maxImagePx);
+      baseline = height * BASELINE_FACTOR;
+    }
+    const sp = block.spacing;
+    if (sp?.line) {
+      const target = sp.lineRule === "exact" ? sp.line : sp.lineRule === "atLeast" ? Math.max(height, sp.line) : height * sp.line;
+      baseline += Math.max(0, target - height) * (sp.lineRule === "exact" ? baseline / height : 1);
+      height = target;
+    }
+    const painted = firstLine && marker ? [marker, ...segments] : segments;
+    emit({ x: startX, width: lineRight - startX, height, baseline, segments: painted, images, from, to });
+    prevTo = to;
+    lineTokens = [];
+    lineWidth = 0;
+    maxFontPx = sizePx(base);
+    maxImagePx = 0;
+    maxAscent = baseMetrics?.ascent ?? 0;
+    maxDescent = baseMetrics?.descent ?? 0;
+    firstLine = false;
+    band = bandFn(nominalH);
+    lineLeft = band.left + indentLeft;
+    lineRight = band.right - indentRight;
+    contStart = marker ? Math.max(markerTextX, lineLeft) : lineLeft;
+  };
+  let clusterText = "";
+  let clusterWidth = 0;
+  let clusterFont = null;
+  const sameFont = (a, b) => a.family === b.family && a.sizePt === b.sizePt && a.bold === b.bold && a.italic === b.italic;
+  const resetCluster = () => {
+    clusterText = "";
+    clusterWidth = 0;
+    clusterFont = null;
+  };
+  const clusterable = (t) => t.text != null && !t.isSpace && !t.isTab && !t.field && !t.image;
+  let softWrapped = false;
+  for (let ti = 0; ti < tokens.length; ti++) {
+    const token = tokens[ti];
+    if (token.isBreak) {
+      if (token.pos != null) prevTo = token.pos + 1;
+      flushLine(false);
+      resetCluster();
+      softWrapped = false;
+      continue;
+    }
+    if (token.isSpace && !token.isTab && lineTokens.length === 0 && softWrapped) continue;
+    if (token.isTab) resolveTab(token, lineStart() + lineWidth, ti);
+    if (clusterable(token) && clusterFont && sameFont(clusterFont, token.font)) {
+      token.width = Math.max(0, measure(clusterText + token.text, token.font) - clusterWidth);
+    }
+    const cursor = lineStart() + lineWidth;
+    if (!token.isSpace && lineTokens.length > 0 && cursor + token.width > lineRight) {
+      flushLine(false);
+      resetCluster();
+      softWrapped = true;
+      if (token.isTab) resolveTab(token, lineStart() + lineWidth, ti);
+      else if (clusterable(token)) token.width = measure(token.text, token.font);
+    }
+    if (clusterable(token) && lineTokens.length === 0 && token.text.length > 1 && lineStart() + token.width > lineRight) {
+      const avail = lineRight - lineStart();
+      let n = 1;
+      while (n < token.text.length && measure(token.text.slice(0, n + 1), token.font) <= avail) n++;
+      const restText = token.text.slice(n);
+      const rest = { ...token, text: restText, width: measure(restText, token.font), size: restText.length };
+      if (token.pos != null) rest.pos = token.pos + n;
+      token.text = token.text.slice(0, n);
+      token.size = n;
+      token.width = measure(token.text, token.font);
+      tokens.splice(ti + 1, 0, rest);
+    }
+    if (clusterable(token)) {
+      if (clusterFont && !sameFont(clusterFont, token.font)) resetCluster();
+      clusterText += token.text;
+      clusterWidth += token.width;
+      clusterFont = token.font;
+    } else {
+      resetCluster();
+    }
+    lineTokens.push(token);
+    lineWidth += token.width;
+    if (token.image) {
+      const rotH = rotatedBoxHeight(token.image);
+      maxImagePx = Math.max(maxImagePx, rotH);
+      maxAscent = Math.max(maxAscent, token.image.height / 2 + rotH / 2);
+      maxDescent = Math.max(maxDescent, Math.max(0, (rotH - token.image.height) / 2));
+    } else {
+      maxFontPx = Math.max(maxFontPx, sizePx(token.font));
+      if (metrics) {
+        const m = metrics(token.font);
+        maxAscent = Math.max(maxAscent, m.ascent);
+        maxDescent = Math.max(maxDescent, m.descent);
+      }
+    }
+  }
+  flushLine(true);
+}
+function rotatedBoxHeight(img) {
+  if (!img.rotation) return img.height;
+  const rad = img.rotation * Math.PI / 180;
+  return Math.abs(img.width * Math.sin(rad)) + Math.abs(img.height * Math.cos(rad));
+}
+function layoutParagraph(block, contentLeft, contentRight, ctx) {
+  const drafts = [];
+  wrapParagraph(
+    block,
+    ctx,
+    () => ({ left: contentLeft, right: contentRight }),
+    (d) => drafts.push(d)
+  );
+  return drafts;
+}
+function offsetTable(table, dy) {
+  table.y += dy;
+  for (const cell of table.cells) {
+    cell.y += dy;
+    for (const line of cell.lines) line.y += dy;
+    if (cell.floats) for (const f of cell.floats) f.y += dy;
+    if (cell.tables) for (const t of cell.tables) offsetTable(t, dy);
+  }
+}
+function shiftLineX(line, dx) {
+  line.x += dx;
+  for (const seg of line.segments) seg.x += dx;
+  if (line.images) for (const im of line.images) im.x += dx;
+}
+function shiftTableX(table, dx) {
+  if (dx === 0) return;
+  table.x += dx;
+  for (const cell of table.cells) {
+    cell.x += dx;
+    for (const line of cell.lines) shiftLineX(line, dx);
+    if (cell.floats) for (const f of cell.floats) f.x += dx;
+    if (cell.tables) for (const t of cell.tables) shiftTableX(t, dx);
+  }
+}
+var TEXTBOX_INSET = { l: 10, t: 5, r: 10, b: 5 };
+function resolveFloat(f, x, y, ctx) {
+  const rf = { x, y, width: f.width, height: f.height, src: f.src };
+  if (f.pos != null) rf.pos = f.pos;
+  if (f.rotation) rf.rotation = f.rotation;
+  if (f.shape) rf.shape = f.shape;
+  if (f.content && f.content.length > 0) {
+    const inset = f.inset ?? TEXTBOX_INSET;
+    const right = Math.max(inset.l + MIN_BAND, f.width - inset.r);
+    const inner = layoutFlow(f.content, inset.l, right, ctx);
+    const lines = inner.lines.map((l) => ({ ...l, y: l.y + inset.t }));
+    stripPositions(lines, inner.tables);
+    if (lines.length > 0) rf.lines = lines;
+  }
+  return rf;
+}
+function layoutFlow(blocks, contentLeft, contentRight, ctx) {
+  const lines = [];
+  const tables = [];
+  const floats = [];
+  let y = 0;
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      for (const f of block.floats ?? []) {
+        const fx = f.hAlign === "right" ? contentRight - f.width : f.hAlign === "center" ? (contentLeft + contentRight - f.width) / 2 : contentLeft + (f.hOffset ?? 0);
+        const fy = y + (f.vOffset ?? 0);
+        floats.push(resolveFloat(f, fx, fy, ctx));
+      }
+      for (const d of layoutParagraph(block, contentLeft, contentRight, ctx)) {
+        lines.push(draftToLine(d, y));
+        y += d.height;
+      }
+    } else {
+      const table = layoutTable(block, contentLeft, contentRight, ctx);
+      offsetTable(table, y);
+      tables.push(table);
+      y += table.height;
+    }
+  }
+  return { lines, tables, floats, height: y };
+}
+function eachCell(rows, ncols, visit) {
+  const spanned = new Array(ncols).fill(0);
+  for (let r = 0; r < rows.length; r++) {
+    let col = 0;
+    for (const cell of rows[r].cells) {
+      while (col < ncols && spanned[col] > 0) col++;
+      visit(r, cell, col);
+      for (let k = 0; k < cell.colspan && col + k < ncols; k++) spanned[col + k] = cell.rowspan;
+      col += cell.colspan;
+    }
+    for (let i = 0; i < ncols; i++) if (spanned[i] > 0) spanned[i]--;
+  }
+}
+function layoutTable(table, contentLeft, contentRight, ctx) {
+  const avail = contentRight - contentLeft;
+  const nrows = table.rows.length;
+  const ncols = table.rows.reduce(
+    (m, r) => Math.max(m, r.cells.reduce((s, c) => s + c.colspan, 0)),
+    0
+  );
+  const colWidths = new Array(ncols).fill(0);
+  eachCell(table.rows, ncols, (_r, cell, startCol) => {
+    if (cell.colwidth && cell.colwidth.length === cell.colspan) {
+      for (let k = 0; k < cell.colspan && startCol + k < ncols; k++) {
+        if (colWidths[startCol + k] === 0) colWidths[startCol + k] = cell.colwidth[k];
+      }
+    }
+  });
+  const known = colWidths.reduce((s, w) => s + w, 0);
+  const unknown = colWidths.filter((w) => w === 0).length;
+  if (unknown > 0) {
+    const share = Math.max(0, (avail - known) / unknown);
+    for (let i = 0; i < ncols; i++) if (colWidths[i] === 0) colWidths[i] = share;
+  }
+  const natural = colWidths.reduce((s, w) => s + w, 0);
+  if (natural > avail && natural > 0) {
+    const scale = avail / natural;
+    for (let i = 0; i < ncols; i++) colWidths[i] *= scale;
+  }
+  const tableWidth = colWidths.reduce((s, w) => s + w, 0);
+  const xShift = table.align === "center" ? Math.max(0, (avail - tableWidth) / 2) : table.align === "right" ? Math.max(0, avail - tableWidth) : 0;
+  const colX = new Array(ncols + 1).fill(contentLeft + xShift);
+  for (let i = 0; i < ncols; i++) colX[i + 1] = colX[i] + colWidths[i];
+  const pad = {
+    left: table.cellPadding?.left ?? CELL_PAD_X,
+    right: table.cellPadding?.right ?? CELL_PAD_X,
+    top: table.cellPadding?.top ?? CELL_PAD_Y,
+    bottom: table.cellPadding?.bottom ?? CELL_PAD_Y
+  };
+  const cellDrafts = [];
+  eachCell(table.rows, ncols, (r, cell, col) => {
+    let cellWidth = 0;
+    for (let k = 0; k < cell.colspan && col + k < ncols; k++) cellWidth += colWidths[col + k];
+    const cellLeft = colX[col];
+    const flow = layoutFlow(cell.content, cellLeft + pad.left, cellLeft + cellWidth - pad.right, ctx);
+    cellDrafts.push({
+      startRow: r,
+      startCol: col,
+      colspan: cell.colspan,
+      rowspan: cell.rowspan,
+      cellLeft,
+      cellWidth,
+      lines: flow.lines,
+      tables: flow.tables,
+      floats: flow.floats,
+      contentHeight: flow.height,
+      background: cell.background,
+      vAlign: cell.vAlign,
+      borders: cell.borders
+    });
+  });
+  const rowHeight = new Array(nrows).fill(0);
+  for (const c of cellDrafts) {
+    if (c.rowspan === 1) {
+      rowHeight[c.startRow] = Math.max(rowHeight[c.startRow], c.contentHeight + pad.top + pad.bottom);
+    }
+  }
+  for (const c of cellDrafts) {
+    if (c.rowspan > 1) {
+      const need = c.contentHeight + pad.top + pad.bottom;
+      let span = 0;
+      for (let r = c.startRow; r < c.startRow + c.rowspan && r < nrows; r++) span += rowHeight[r];
+      if (need > span) {
+        const last = Math.min(c.startRow + c.rowspan - 1, nrows - 1);
+        rowHeight[last] += need - span;
+      }
+    }
+  }
+  for (let r = 0; r < nrows; r++) {
+    const h = table.rows[r]?.height;
+    if (h) rowHeight[r] = h.exact ? h.value : Math.max(rowHeight[r], h.value);
+  }
+  const rowY = new Array(nrows + 1).fill(0);
+  for (let r = 0; r < nrows; r++) rowY[r + 1] = rowY[r] + rowHeight[r];
+  const cells = cellDrafts.map((c) => {
+    let height = 0;
+    for (let r = c.startRow; r < c.startRow + c.rowspan && r < nrows; r++) height += rowHeight[r];
+    const slack = Math.max(0, height - pad.top - pad.bottom - c.contentHeight);
+    const vOffset = c.vAlign === "bottom" ? slack : c.vAlign === "center" ? slack / 2 : 0;
+    const dy = rowY[c.startRow] + pad.top + vOffset;
+    const lines = c.lines.map((ln) => ({ ...ln, y: ln.y + dy }));
+    c.tables.forEach((t) => offsetTable(t, dy));
+    const cell = {
+      x: c.cellLeft,
+      y: rowY[c.startRow],
+      width: c.cellWidth,
+      height,
+      colspan: c.colspan,
+      rowspan: c.rowspan,
+      lines
+    };
+    if (c.background) cell.background = c.background;
+    if (c.borders) cell.borders = c.borders;
+    if (c.tables.length > 0) cell.tables = c.tables;
+    if (c.floats.length > 0) cell.floats = c.floats.map((f) => ({ ...f, y: f.y + dy }));
+    return cell;
+  });
+  const resolved = { x: contentLeft + xShift, y: 0, width: tableWidth, height: rowY[nrows], cells };
+  if (table.borders) resolved.borders = table.borders;
+  let headerRows = 0;
+  while (headerRows < nrows && table.rows[headerRows].header) headerRows++;
+  if (headerRows > 0 && headerRows < nrows) {
+    const headerBottom = rowY[headerRows];
+    const spansOut = cells.some((c) => c.y < headerBottom && c.y + c.height > headerBottom);
+    if (!spansOut) resolved.headerBottom = headerBottom;
+  }
+  const cantSplitBands = table.rows.map((row, r) => row.cantSplit ? { top: rowY[r], bottom: rowY[r + 1] } : null).filter((b) => b !== null);
+  if (cantSplitBands.length > 0) resolved.cantSplitBands = cantSplitBands;
+  return resolved;
+}
+function blockItemHeight(item) {
+  if ("para" in item) {
+    const lines = item.para.drafts?.reduce((s, d) => s + d.height, 0) ?? 0;
+    return lines + (item.para.before ?? 0) + (item.para.after ?? 0);
+  }
+  return item.table.height;
+}
+function assignSectionHeights(items) {
+  let current = null;
+  for (const item of items) {
+    if (item.section) {
+      current = item.section;
+      current.height = 0;
+    }
+    if (current) current.height = (current.height ?? 0) + blockItemHeight(item);
+  }
+}
+var MIN_BAND = 24;
+function shiftCell(cell, dy) {
+  cell.y += dy;
+  for (const line of cell.lines) line.y += dy;
+  cell.floats?.forEach((f) => f.y += dy);
+  cell.tables?.forEach((t) => offsetTable(t, dy));
+  return cell;
+}
+function cloneTable(t) {
+  return { ...t, cells: t.cells.map(cloneCell) };
+}
+function cloneCell(cell) {
+  const copy = { ...cell, lines: cell.lines.map((l) => ({ ...l })) };
+  if (cell.tables) copy.tables = cell.tables.map(cloneTable);
+  if (cell.floats) copy.floats = cell.floats.map((f) => ({ ...f }));
+  return copy;
+}
+function splitTableAt(table, cut) {
+  const straddlers = /* @__PURE__ */ new Map();
+  let splitBottom = cut;
+  let contHeight = 0;
+  for (const cell of table.cells) {
+    if (cell.y >= cut || cell.y + cell.height <= cut) continue;
+    splitBottom = Math.max(splitBottom, cell.y + cell.height);
+    const remLines = cell.lines.filter((l) => l.y + l.height > cut);
+    const remTables = (cell.tables ?? []).filter((t) => t.y + t.height > cut);
+    const firstY = Math.min(
+      remLines.length ? Math.min(...remLines.map((l) => l.y)) : Infinity,
+      remTables.length ? Math.min(...remTables.map((t) => t.y)) : Infinity
+    );
+    const first = firstY === Infinity ? cut : firstY;
+    const extent = Math.max(
+      remLines.length ? Math.max(...remLines.map((l) => l.y + l.height)) : first,
+      remTables.length ? Math.max(...remTables.map((t) => t.y + t.height)) : first
+    ) - first;
+    contHeight = Math.max(contHeight, extent);
+    straddlers.set(cell, { cell, remLines, remTables, firstY: first });
+  }
+  const topCells = [];
+  const restCells = [];
+  for (const cell of table.cells) {
+    if (cell.y + cell.height <= cut) {
+      topCells.push(cell);
+    } else if (cell.y >= cut) {
+      restCells.push(shiftCell(cloneCell(cell), contHeight - splitBottom));
+    } else {
+      const c = straddlers.get(cell);
+      const topLines = cell.lines.filter((l) => l.y + l.height <= cut);
+      const topTables = (cell.tables ?? []).filter((t) => t.y + t.height <= cut);
+      const topCell = { ...cell, height: cut - cell.y, lines: topLines };
+      if (topTables.length > 0) topCell.tables = topTables;
+      else delete topCell.tables;
+      const topFloats = (cell.floats ?? []).filter((f) => f.y + f.height <= cut);
+      if (topFloats.length > 0) topCell.floats = topFloats;
+      else delete topCell.floats;
+      topCells.push(topCell);
+      const delta = -c.firstY;
+      const lines = c.remLines.map((l) => ({ ...l, y: l.y + delta }));
+      const remTables = c.remTables.map(cloneTable);
+      remTables.forEach((t) => offsetTable(t, delta));
+      const remFloats = (cell.floats ?? []).filter((f) => f.y + f.height > cut).map((f) => ({ ...f, y: f.y + delta }));
+      const contCell = {
+        x: cell.x,
+        y: 0,
+        width: cell.width,
+        height: contHeight,
+        colspan: cell.colspan,
+        rowspan: cell.rowspan,
+        lines
+      };
+      if (remTables.length > 0) contCell.tables = remTables;
+      if (remFloats.length > 0) contCell.floats = remFloats;
+      restCells.push(contCell);
+    }
+  }
+  const top = { x: table.x, y: 0, width: table.width, height: cut, cells: topCells };
+  const rest = {
+    x: table.x,
+    y: 0,
+    width: table.width,
+    height: contHeight + (table.height - splitBottom),
+    cells: restCells
+  };
+  if (table.borders) {
+    top.borders = table.borders;
+    rest.borders = table.borders;
+  }
+  return { top, rest };
+}
+function cloneHeaderCells(table, headerBottom) {
+  const band = table.cells.filter((c) => c.y + c.height <= headerBottom);
+  if (band.some((c) => c.tables && c.tables.length > 0)) return null;
+  return band.map((cell) => ({
+    ...cell,
+    tables: void 0,
+    floats: cell.floats?.map((f) => ({ ...f })),
+    lines: cell.lines.map((l) => {
+      const line = { ...l, segments: l.segments.map((s) => ({ ...s, pos: void 0 })) };
+      delete line.from;
+      delete line.to;
+      if (line.images) line.images = line.images.map((im) => ({ ...im, pos: void 0 }));
+      return line;
+    })
+  }));
+}
+function buildCtx(config) {
+  return {
+    base: { ...DEFAULT_FONT, ...config.defaultFont },
+    measure: config.measureText,
+    metrics: config.measureMetrics,
+    tabWidth: config.tabWidth ?? DEFAULT_TAB_WIDTH,
+    fieldPlaceholder: "1"
+  };
+}
+function placeBlocks(items, config, ctx, band, footnotes) {
+  const { page } = config;
+  const top = band?.top ?? page.margin.top;
+  const bottom = band?.bottom ?? page.height - page.margin.bottom;
+  const contentLeft = page.margin.left;
+  const contentRight = page.width - page.margin.right;
+  const pages = [];
+  let lines = [];
+  let tables = [];
+  let pageFloats = [];
+  let exclusions = [];
+  let y = top;
+  const contentWidth = contentRight - contentLeft;
+  let colCount = 1;
+  let colGap = 0;
+  let colWidth = contentWidth;
+  let colIndex = 0;
+  let bandTop = top;
+  let sectionMaxY = top;
+  let colDirty = false;
+  const xShift = () => colIndex * (colWidth + colGap);
+  const colX0 = () => contentLeft + xShift();
+  const colX1 = () => colX0() + colWidth;
+  const bump = () => {
+    if (y > sectionMaxY) sectionMaxY = y;
+  };
+  const applyColumns = (cols) => {
+    colCount = Math.max(1, cols.count);
+    colGap = colCount > 1 ? cols.gap : 0;
+    colWidth = (contentWidth - colGap * (colCount - 1)) / colCount;
+  };
+  let pageFnNums = [];
+  const pageFnSet = /* @__PURE__ */ new Set();
+  const noteHeight = (n) => footnotes?.get(n)?.height ?? 0;
+  const reservedFor = (nums) => nums.length === 0 ? 0 : FOOTNOTE_AREA_GAP + nums.reduce((s, n) => s + noteHeight(n), 0);
+  const limit = () => bottom - reservedFor(pageFnNums);
+  const lineFnNums = (segs) => {
+    const out = [];
+    for (const s of segs) {
+      if (s.footnoteRef != null && footnotes?.has(s.footnoteRef) && !out.includes(s.footnoteRef)) {
+        out.push(s.footnoteRef);
+      }
+    }
+    return out;
+  };
+  const commitFns = (nums) => {
+    for (const n of nums) {
+      if (!pageFnSet.has(n)) {
+        pageFnNums.push(n);
+        pageFnSet.add(n);
+      }
+    }
+  };
+  const addedReserve = (nums) => {
+    const fresh = nums.filter((n) => !pageFnSet.has(n));
+    return fresh.length === 0 ? 0 : reservedFor([...pageFnNums, ...fresh]) - reservedFor(pageFnNums);
+  };
+  const tableFootnoteNums = (t, maxY = Infinity) => {
+    const out = [];
+    const scan = (ls) => {
+      for (const l of ls)
+        for (const s of l.segments) {
+          const n = s.footnoteRef;
+          if (n != null && footnotes?.has(n) && !pageFnSet.has(n) && !out.includes(n)) out.push(n);
+        }
+    };
+    for (const c of t.cells) {
+      if (c.y >= maxY) continue;
+      scan(c.lines);
+      if (c.tables) for (const nt of c.tables) for (const nc of nt.cells) scan(nc.lines);
+    }
+    return out;
+  };
+  let balanceTarget = null;
+  let sectionRemaining = 0;
+  let balancing = false;
+  const colBottom = () => balanceTarget != null && colIndex < colCount - 1 ? Math.min(limit(), bandTop + balanceTarget) : limit();
+  const rebalance = () => {
+    if (!balancing) {
+      balanceTarget = null;
+      return;
+    }
+    const pageColH = limit() - bandTop;
+    balanceTarget = sectionRemaining <= colCount * pageColH ? Math.max(1, sectionRemaining / colCount) : null;
+  };
+  const buildFootnoteArea = (nums) => {
+    const areaTop = bottom - reservedFor(nums);
+    let fy = areaTop + FOOTNOTE_AREA_GAP;
+    const out = [];
+    for (const n of nums) {
+      const body = footnotes?.get(n);
+      if (!body) continue;
+      for (const l of body.lines) out.push({ ...l, y: l.y + fy });
+      fy += body.height;
+    }
+    return { separatorY: areaTop + FOOTNOTE_AREA_GAP / 2, lines: out };
+  };
+  const finalizePage = () => {
+    const resolved = { index: pages.length, width: page.width, height: page.height, lines };
+    if (tables.length > 0) resolved.tables = tables;
+    if (pageFloats.length > 0) resolved.floats = pageFloats;
+    if (pageFnNums.length > 0) resolved.footnotes = buildFootnoteArea(pageFnNums);
+    pages.push(resolved);
+    lines = [];
+    tables = [];
+    pageFloats = [];
+    exclusions = [];
+    pageFnNums = [];
+    pageFnSet.clear();
+    colIndex = 0;
+    bandTop = top;
+    sectionMaxY = top;
+    colDirty = false;
+    y = top;
+  };
+  const breakBand = () => {
+    bump();
+    if (colIndex < colCount - 1) {
+      colIndex++;
+      colDirty = false;
+      y = bandTop;
+    } else {
+      finalizePage();
+      rebalance();
+    }
+  };
+  const emitLine = (draft) => {
+    let add = lineFnNums(draft.segments).filter((n) => !pageFnSet.has(n));
+    const floor = () => Math.min(colBottom(), bottom - reservedFor([...pageFnNums, ...add]));
+    if (y + draft.height > floor() && colDirty) {
+      breakBand();
+      add = lineFnNums(draft.segments).filter((n) => !pageFnSet.has(n));
+    }
+    lines.push(draftToLine(draft, y, xShift()));
+    colDirty = true;
+    y += draft.height;
+    sectionRemaining -= draft.height;
+    bump();
+    commitFns(add);
+  };
+  const pageHasContent = () => lines.length > 0 || tables.length > 0 || pageFloats.length > 0;
+  const registerFloats = (flow, yPara) => {
+    for (const f of flow.floats ?? []) {
+      const baseL = f.hRel === "page" ? 0 : contentLeft;
+      const baseR = f.hRel === "page" ? page.width : contentRight;
+      const fx = f.hAlign === "right" ? baseR - f.width : f.hAlign === "center" ? (baseL + baseR - f.width) / 2 : f.hAlign === "left" ? baseL : baseL + (f.hOffset ?? 0);
+      const fy = f.vRel === "page" ? f.vOffset ?? 0 : f.vRel === "margin" ? top + (f.vOffset ?? 0) : yPara + (f.vOffset ?? 0);
+      pageFloats.push(resolveFloat(f, fx, fy, ctx));
+      colDirty = true;
+      if (f.wrap === "square") {
+        exclusions.push({
+          left: fx - (f.distL ?? 0),
+          right: fx + f.width + (f.distR ?? 0),
+          top: fy - (f.distT ?? 0),
+          bottom: fy + f.height + (f.distB ?? 0)
+        });
+      } else if (f.wrap === "topAndBottom") {
+        exclusions.push({
+          left: -Infinity,
+          right: Infinity,
+          top: fy - (f.distT ?? 0),
+          bottom: fy + f.height + (f.distB ?? 0)
+        });
+      }
+    }
+  };
+  const bandAt = (yy, h) => {
+    let L = colX0();
+    let R = colX1();
+    for (const ex of exclusions) {
+      if (ex.bottom <= yy || ex.top >= yy + h) continue;
+      const leftGap = Math.min(R, ex.left) - L;
+      const rightGap = R - Math.max(L, ex.right);
+      if (rightGap >= leftGap) L = Math.max(L, ex.right);
+      else R = Math.min(R, ex.left);
+    }
+    return R - L >= MIN_BAND ? { left: L, right: R } : null;
+  };
+  const placeParaBanded = (flow) => {
+    registerFloats(flow, y);
+    wrapParagraph(
+      flow,
+      ctx,
+      (estH) => {
+        for (; ; ) {
+          if (y + estH > colBottom() && colDirty) {
+            breakBand();
+            continue;
+          }
+          const b = bandAt(y, estH);
+          if (b) return b;
+          const blockers = exclusions.filter((ex) => ex.top < y + estH && ex.bottom > y);
+          if (blockers.length === 0) return { left: colX0(), right: colX1() };
+          y = Math.min(...blockers.map((ex) => ex.bottom));
+        }
+      },
+      (draft) => emitLine(draft)
+    );
+  };
+  let firstItem = true;
+  for (const item of items) {
+    if (item.section) {
+      if (firstItem) {
+        applyColumns(item.section);
+      } else if (item.section.newPage) {
+        if (pageHasContent()) finalizePage();
+        applyColumns(item.section);
+      } else {
+        bump();
+        if (sectionMaxY >= limit()) {
+          finalizePage();
+        } else {
+          bandTop = sectionMaxY;
+          y = bandTop;
+          colIndex = 0;
+          colDirty = false;
+        }
+        applyColumns(item.section);
+      }
+      balancing = colCount > 1;
+      sectionRemaining = item.section.height ?? 0;
+      rebalance();
+    }
+    firstItem = false;
+    if ("para" in item) {
+      if (item.para.pageBreakBefore && pageHasContent()) {
+        finalizePage();
+        rebalance();
+      }
+      if (item.para.before && colDirty) {
+        y += item.para.before;
+        sectionRemaining -= item.para.before;
+      }
+      const drafts = item.para.drafts;
+      const draftsHeight = drafts?.reduce((s, d) => s + d.height, 0) ?? 0;
+      const floatsAhead = exclusions.some((ex) => ex.bottom > y && ex.top < y + draftsHeight);
+      if (drafts && !floatsAhead) {
+        for (const d of drafts) emitLine(d);
+      } else {
+        placeParaBanded(item.para.getFlow());
+      }
+      if (item.para.after) {
+        y += item.para.after;
+        sectionRemaining -= item.para.after;
+      }
+    } else {
+      let table = item.table;
+      const placeTable = (t) => {
+        offsetTable(t, y);
+        shiftTableX(t, xShift());
+        tables.push(t);
+        colDirty = true;
+        commitFns(tableFootnoteNums(t));
+        y += t.height;
+        sectionRemaining -= t.height;
+        bump();
+      };
+      for (; ; ) {
+        const avail = colBottom() - y;
+        if (table.height + addedReserve(tableFootnoteNums(table)) <= avail) {
+          placeTable(table);
+          break;
+        }
+        const hb = table.headerBottom != null && table.headerBottom < (limit() - bandTop) / 2 ? table.headerBottom : 0;
+        let cut = 0;
+        for (const cell of table.cells) {
+          if (cell.y > hb && cell.y <= avail) cut = Math.max(cut, cell.y);
+        }
+        if (cut === 0) {
+          let firstRowBottom = table.height;
+          for (const cell of table.cells) {
+            if (cell.y > hb && cell.y < firstRowBottom) firstRowBottom = cell.y;
+          }
+          const fitsFullBand = firstRowBottom - hb <= limit() - bandTop;
+          const rowCantSplit = (table.cantSplitBands ?? []).some(
+            (b) => b.top <= hb + 0.5 && b.bottom >= firstRowBottom - 0.5
+          );
+          if (rowCantSplit && fitsFullBand && colDirty) {
+            breakBand();
+            continue;
+          }
+          cut = avail;
+        }
+        if (cut <= hb) {
+          if (colDirty) {
+            breakBand();
+            continue;
+          }
+          placeTable(table);
+          break;
+        }
+        const { top: topFrag, rest } = splitTableAt(table, cut);
+        if (rest.height >= table.height) {
+          placeTable(table);
+          break;
+        }
+        const topHasContent = topFrag.cells.some(
+          (c) => c.lines.length > 0 || (c.tables?.length ?? 0) > 0
+        );
+        if (!topHasContent && colDirty) {
+          breakBand();
+          continue;
+        }
+        if (hb > 0) {
+          const ghosts = cloneHeaderCells(table, hb);
+          if (ghosts) {
+            for (const cell of rest.cells) shiftCell(cell, hb);
+            rest.cells.unshift(...ghosts);
+            rest.height += hb;
+            rest.headerBottom = hb;
+          }
+        }
+        placeTable(topFrag);
+        breakBand();
+        table = rest;
+      }
+    }
+  }
+  if (pageHasContent() || pages.length === 0) finalizePage();
+  return { pages };
+}
+function layoutBlocks(blocks, config) {
+  const ctx = buildCtx(config);
+  const left = config.page.margin.left;
+  const right = config.page.width - config.page.margin.right;
+  const cols = config.columns ?? { count: 1, gap: 0 };
+  const colWidth = columnWidth(right - left, cols);
+  const colRight = left + colWidth;
+  const items = blocks.map((block, i) => {
+    const item = block.type === "paragraph" ? {
+      para: {
+        getFlow: () => block,
+        drafts: block.floats?.length ? null : layoutParagraph(block, left, colRight, ctx),
+        before: block.spacing?.before,
+        after: block.spacing?.after,
+        pageBreakBefore: block.pageBreakBefore
+      }
+    } : { table: layoutTable(block, left, colRight, ctx) };
+    if (i === 0) item.section = { ...cols, newPage: true };
+    return item;
+  });
+  assignSectionHeights(items);
+  return placeBlocks(items, config, ctx);
+}
+function columnWidth(totalWidth, cols) {
+  const count = Math.max(1, cols.count);
+  const gap = count > 1 ? cols.gap : 0;
+  return (totalWidth - gap * (count - 1)) / count;
+}
+function shiftDrafts(drafts, delta) {
+  return drafts.map((d) => ({
+    ...d,
+    from: d.from != null ? d.from + delta : d.from,
+    to: d.to != null ? d.to + delta : d.to,
+    segments: d.segments.map((s) => s.pos != null ? { ...s, pos: s.pos + delta } : s),
+    images: d.images.map((im) => im.pos != null ? { ...im, pos: im.pos + delta } : im)
+  }));
+}
+function cloneLineShifted(l, delta) {
+  const out = {
+    ...l,
+    segments: l.segments.map((s) => s.pos != null ? { ...s, pos: s.pos + delta } : { ...s })
+  };
+  if (l.images) out.images = l.images.map((im) => im.pos != null ? { ...im, pos: im.pos + delta } : { ...im });
+  if (l.from != null) out.from = l.from + delta;
+  if (l.to != null) out.to = l.to + delta;
+  return out;
+}
+function cloneTableShifted(t, delta) {
+  return {
+    ...t,
+    borders: t.borders ? { ...t.borders } : t.borders,
+    cells: t.cells.map((c) => ({
+      ...c,
+      borders: c.borders ? { ...c.borders } : c.borders,
+      lines: c.lines.map((l) => cloneLineShifted(l, delta)),
+      tables: c.tables?.map((nt) => cloneTableShifted(nt, delta)),
+      floats: c.floats?.map((f) => ({ ...f }))
+    }))
+  };
+}
+function tableHasList(node) {
+  let found = false;
+  node.descendants((n) => {
+    if (found) return false;
+    if (n.type.name === "paragraph" && n.attrs["list"]) found = true;
+    return !found;
+  });
+  return found;
+}
+var LayoutCache = class {
+  paragraphs = /* @__PURE__ */ new WeakMap();
+  tables = /* @__PURE__ */ new WeakMap();
+};
+function createLayoutCache() {
+  return new LayoutCache();
+}
+var CHROME_DISTANCE = 48;
+function layVariants(docs, fn) {
+  const out = {};
+  if (docs.default) out.default = fn(docs.default);
+  if (docs.first) out.first = fn(docs.first);
+  if (docs.even) out.even = fn(docs.even);
+  return out;
+}
+function maxBandHeight(bands) {
+  return Math.max(0, ...[bands.default, bands.first, bands.even].filter(Boolean).map((b) => b.height));
+}
+function anyBandHasFields(bands) {
+  return [bands.default, bands.first, bands.even].some(
+    (b) => b?.lines.some((l) => l.segments.some((s) => s.field)) ?? false
+  );
+}
+function stripPositions(lines, tables) {
+  for (const line of lines) {
+    delete line.from;
+    delete line.to;
+    for (const seg of line.segments) delete seg.pos;
+    if (line.images) for (const im of line.images) delete im.pos;
+  }
+  for (const t of tables) {
+    for (const c of t.cells) {
+      stripPositions(c.lines, c.tables ?? []);
+      if (c.floats) for (const f of c.floats) delete f.pos;
+    }
+  }
+}
+function layoutChrome(doc, topY, left, right, ctx) {
+  const flow = layoutFlow(toFlowBlocks(doc, ctx.base, true), left, right, ctx);
+  const lines = flow.lines.map((l) => ({ ...l, y: l.y + topY }));
+  flow.tables.forEach((t) => offsetTable(t, topY));
+  stripPositions(lines, flow.tables);
+  const band = { lines, tables: flow.tables, height: flow.height };
+  if (flow.floats.length > 0)
+    band.floats = flow.floats.map((f) => ({ ...f, y: f.y + topY, pos: void 0 }));
+  return band;
+}
+function layoutFooterChrome(doc, pageHeight, left, right, ctx) {
+  const flow = layoutChrome(doc, 0, left, right, ctx);
+  const topY = pageHeight - CHROME_DISTANCE - flow.height;
+  const band = {
+    lines: flow.lines.map((l) => ({ ...l, y: l.y + topY })),
+    tables: flow.tables,
+    height: flow.height
+  };
+  band.tables.forEach((t) => offsetTable(t, topY));
+  if (flow.floats) band.floats = flow.floats.map((f) => ({ ...f, y: f.y + topY }));
+  return band;
+}
+function layoutFootnoteBody(doc, left, right, ctx) {
+  const fnCtx = { ...ctx, base: { ...ctx.base, sizePt: ctx.base.sizePt * FOOTNOTE_FONT_SCALE } };
+  const flow = layoutFlow(toFlowBlocks(doc, fnCtx.base, false), left, right, fnCtx);
+  stripPositions(flow.lines, flow.tables);
+  return { lines: flow.lines, height: flow.height };
+}
+function layout(doc, config, cache, chrome, footnotes) {
+  const ctx = buildCtx(config);
+  const { page } = config;
+  const left = page.margin.left;
+  const right = page.width - page.margin.right;
+  const headerDocs = { default: chrome?.header, first: chrome?.headerFirst, even: chrome?.headerEven };
+  const footerDocs = { default: chrome?.footer, first: chrome?.footerFirst, even: chrome?.footerEven };
+  const layHeaders = (c) => layVariants(headerDocs, (d) => layoutChrome(d, CHROME_DISTANCE, left, right, c));
+  const layFooters = (c) => layVariants(footerDocs, (d) => layoutFooterChrome(d, page.height, left, right, c));
+  let headers = layHeaders(ctx);
+  let footers = layFooters(ctx);
+  let top = page.margin.top;
+  let bottom = page.height - page.margin.bottom;
+  if (headers.default || headers.first || headers.even) {
+    top = Math.max(top, CHROME_DISTANCE + maxBandHeight(headers));
+  }
+  if (footers.default || footers.first || footers.even) {
+    bottom = Math.min(bottom, page.height - CHROME_DISTANCE - maxBandHeight(footers));
+  }
+  const counter = createNumberingCounter(doc.attrs["numbering"]);
+  const sections = doc.attrs["sections"] ?? [
+    { blockCount: doc.childCount, columns: { count: 1, gap: 0 }, newPage: true }
+  ];
+  const blockSection = [];
+  for (const sec of sections) {
+    for (let k = 0; k < sec.blockCount; k++) {
+      blockSection.push({ columns: sec.columns, start: k === 0, newPage: sec.newPage });
+    }
+  }
+  const lastSec = sections[sections.length - 1];
+  while (blockSection.length < doc.childCount) {
+    blockSection.push({ columns: lastSec.columns, start: false, newPage: lastSec.newPage });
+  }
+  const items = [];
+  doc.forEach((node, offset, index) => {
+    const bs = blockSection[index] ?? { columns: { count: 1, gap: 0 }, start: false, newPage: true };
+    const colRight = left + columnWidth(right - left, bs.columns);
+    const tag = (item) => {
+      if (bs.start) item.section = { ...bs.columns, newPage: bs.newPage };
+      return item;
+    };
+    if (node.type.name === "paragraph") {
+      const marker = markerFor(node, counter);
+      const getFlow = () => paragraphToFlow(node, ctx.base, offset, true, marker);
+      const sp = node.attrs["spacing"];
+      const para = (drafts2) => ({
+        getFlow,
+        drafts: drafts2,
+        before: sp?.before,
+        after: sp?.after,
+        pageBreakBefore: node.attrs["pageBreakBefore"] === true
+      });
+      if (nodeHasFloats(node)) {
+        items.push(tag({ para: para(null) }));
+        return;
+      }
+      const contentStart = offset + 1;
+      const hit = cache?.paragraphs.get(node);
+      if (hit && hit.left === left && hit.right === colRight && hit.marker === marker) {
+        if (hit.basePos !== contentStart) {
+          hit.drafts = shiftDrafts(hit.drafts, contentStart - hit.basePos);
+          hit.basePos = contentStart;
+        }
+        items.push(tag({ para: para(hit.drafts) }));
+        return;
+      }
+      const flow = paragraphToFlow(node, ctx.base, offset, true, marker);
+      const drafts = layoutParagraph(flow, left, colRight, ctx);
+      cache?.paragraphs.set(node, { left, right: colRight, basePos: contentStart, marker, drafts });
+      items.push(tag({ para: { ...para(drafts), getFlow: () => flow } }));
+    } else if (node.type.name === "table") {
+      const hit = cache?.tables.get(node);
+      if (hit && hit.left === left && hit.right === colRight) {
+        items.push(tag({ table: cloneTableShifted(hit.table, offset - hit.basePos) }));
+        return;
+      }
+      const table = layoutTable(tableToFlow(node, ctx.base, offset, counter), left, colRight, ctx);
+      if (cache && !tableHasList(node)) {
+        cache.tables.set(node, { left, right: colRight, basePos: offset, table });
+        items.push(tag({ table: cloneTableShifted(table, 0) }));
+      } else {
+        items.push(tag({ table }));
+      }
+    }
+  });
+  let fnMap;
+  if (footnotes) {
+    fnMap = /* @__PURE__ */ new Map();
+    for (const key of Object.keys(footnotes)) {
+      const num = Number(key);
+      fnMap.set(num, layoutFootnoteBody(footnotes[num], left, right, ctx));
+    }
+  }
+  assignSectionHeights(items);
+  const resolved = placeBlocks(items, config, ctx, { top, bottom }, fnMap);
+  if (anyBandHasFields(headers) || anyBandHasFields(footers)) {
+    const fieldCtx = { ...ctx, fieldPlaceholder: String(resolved.pages.length) };
+    headers = layHeaders(fieldCtx);
+    footers = layFooters(fieldCtx);
+  }
+  if (headers.default) resolved.pageHeader = headers.default;
+  if (headers.first) resolved.pageHeaderFirst = headers.first;
+  if (headers.even) resolved.pageHeaderEven = headers.even;
+  if (footers.default) resolved.pageFooter = footers.default;
+  if (footers.first) resolved.pageFooterFirst = footers.first;
+  if (footers.even) resolved.pageFooterEven = footers.even;
+  if (chrome?.titlePg || chrome?.evenAndOdd) {
+    resolved.chromeSelect = { titlePg: !!chrome.titlePg, evenAndOdd: !!chrome.evenAndOdd };
+  }
+  return resolved;
+}
+export {
+  LayoutCache,
+  createLayoutCache,
+  layout,
+  layoutBlocks,
+  toFlowBlocks
+};