medical-form-printer 0.2.0 → 0.3.0

package/dist/node.cjs

@@ -563,6 +563,7 @@ function generateSectionStyles(theme, cls2, config) {
   font-size: ${theme.fontSize.sectionTitle};
   font-weight: bold;
   margin-bottom: ${theme.spacing.xs};
+  text-align: center;
 }`;
 }
 function generateInfoGridStyles(_theme, cls2) {
@@ -808,6 +809,7 @@ function generateFooterStyles(theme, cls2) {
 /* Footer */
 .${cls2("print-footer")} {
   margin-top: ${theme.spacing.footerMarginTop};
+  min-height: ${theme.fontSize.small};
   display: flex;
   justify-content: space-between;
   font-size: ${theme.fontSize.small};
@@ -1090,6 +1092,7 @@ function createInlineStyles(theme = defaultTheme) {
     // Footer
     printFooter: {
       marginTop: "10mm",
+      minHeight: theme.fontSize.small,
       display: "flex",
       justifyContent: "space-between",
       fontSize: theme.fontSize.small,
@@ -1355,6 +1358,10 @@ function each(items, renderer) {
   }).join("");
 }
 var div = () => h("div");
+var span = () => h("span");
+var thead = () => h("thead");
+var tr = () => h("tr");
+var th = () => h("th");
 var header = () => h("header");
 var footer = () => h("footer");
 var main = () => h("main");
@@ -1486,9 +1493,11 @@ function renderCheckboxTextCell(cell, data, options) {
 }
 function renderTextareaCell(cell, data, options) {
   const value = getCellValue(cell, data);
+  const isOverflowHtml = data[`__overflow_html_${cell.field}`] === true;
+  const contentHtml = isOverflowHtml ? value : escapeHtml(value);
   return `<div class="${cls("info-item", options)} ${cls("textarea-item", options)}">
 <span class="${cls("label", options)}">${escapeHtml(cell.label)}:</span>
-<span class="${cls("textarea-content", options)}">${escapeHtml(value)}</span>
+<span class="${cls("textarea-content", options)}">${contentHtml}</span>
 </div>`;
 }
 
@@ -1553,14 +1562,231 @@ function isChecked(values, optionValue) {
   return String(values) === String(optionValue);
 }
 
+// src/renderer/section-renderers/table/header-strategy.ts
+var SimpleHeaderStrategy = class {
+  /**
+   * Check if this strategy can handle the configuration
+   * Returns true when headerRows is not provided or empty
+   */
+  canHandle(config) {
+    return !config.headerRows || config.headerRows.length === 0;
+  }
+  /**
+   * Render single-row header from columns configuration
+   */
+  render(config, options) {
+    const headers = config.columns.map((col) => {
+      const thBuilder = th().text(col.header);
+      if (col.width) {
+        thBuilder.style("width", col.width);
+      }
+      return thBuilder.build();
+    }).join("\n");
+    return tr().raw(headers).build();
+  }
+};
+var MultiRowHeaderStrategy = class {
+  /**
+   * Check if this strategy can handle the configuration
+   * Returns true when headerRows is provided and not empty
+   */
+  canHandle(config) {
+    return !!config.headerRows && config.headerRows.length > 0;
+  }
+  /**
+   * Render multi-row header from headerRows configuration
+   */
+  render(config, options) {
+    if (!config.headerRows || config.headerRows.length === 0) {
+      return "";
+    }
+    const totalColumns = config.columns.length;
+    const matrix = calculateCellMatrix(config.headerRows, totalColumns);
+    const rows = [];
+    for (let rowIndex = 0; rowIndex < config.headerRows.length; rowIndex++) {
+      const headerRow = config.headerRows[rowIndex];
+      const cells = [];
+      let cellIndex = 0;
+      for (let colIndex = 0; colIndex < totalColumns; colIndex++) {
+        const position = matrix[rowIndex]?.[colIndex];
+        if (position?.isOccupied) {
+          continue;
+        }
+        const cell = headerRow.cells[cellIndex];
+        if (!cell) {
+          cellIndex++;
+          continue;
+        }
+        const thBuilder = th().text(cell.text);
+        const colspan = Math.min(cell.colspan || 1, totalColumns - colIndex);
+        if (colspan > 1) {
+          thBuilder.attr("colspan", colspan);
+        }
+        const rowspan = Math.min(cell.rowspan || 1, config.headerRows.length - rowIndex);
+        if (rowspan > 1) {
+          thBuilder.attr("rowspan", rowspan);
+        }
+        if (cell.width) {
+          thBuilder.style("width", cell.width);
+        }
+        cells.push(thBuilder.build());
+        cellIndex++;
+        colIndex += colspan - 1;
+      }
+      rows.push(tr().raw(cells.join("\n")).build());
+    }
+    return rows.join("\n");
+  }
+};
+function calculateCellMatrix(headerRows, totalColumns) {
+  const rowCount = headerRows.length;
+  const matrix = [];
+  for (let row = 0; row < rowCount; row++) {
+    matrix[row] = [];
+    for (let col = 0; col < totalColumns; col++) {
+      matrix[row][col] = {
+        row,
+        col,
+        cell: null,
+        isOccupied: false
+      };
+    }
+  }
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    const headerRow = headerRows[rowIndex];
+    let cellIndex = 0;
+    let colIndex = 0;
+    while (colIndex < totalColumns && cellIndex < headerRow.cells.length) {
+      while (colIndex < totalColumns && matrix[rowIndex][colIndex].isOccupied) {
+        colIndex++;
+      }
+      if (colIndex >= totalColumns) break;
+      const cell = headerRow.cells[cellIndex];
+      const colspan = Math.min(cell.colspan || 1, totalColumns - colIndex);
+      const rowspan = Math.min(cell.rowspan || 1, rowCount - rowIndex);
+      for (let r = 0; r < rowspan; r++) {
+        for (let c = 0; c < colspan; c++) {
+          const targetRow = rowIndex + r;
+          const targetCol = colIndex + c;
+          if (targetRow < rowCount && targetCol < totalColumns) {
+            matrix[targetRow][targetCol] = {
+              row: targetRow,
+              col: targetCol,
+              cell: r === 0 && c === 0 ? cell : null,
+              isOccupied: r > 0
+              // Only mark as occupied for rows below the cell
+            };
+          }
+        }
+      }
+      colIndex += colspan;
+      cellIndex++;
+    }
+  }
+  return matrix;
+}
+
+// src/renderer/section-renderers/table/header-renderer.ts
+var BaseHeaderRenderer = class {
+  /**
+   * Create a new base header renderer
+   * @param strategies - Optional array of strategies (defaults to Simple and MultiRow)
+   */
+  constructor(strategies) {
+    this.strategies = strategies || [new MultiRowHeaderStrategy(), new SimpleHeaderStrategy()];
+  }
+  /**
+   * Render the table header using the appropriate strategy
+   * @param config - Table configuration
+   * @param options - Render options
+   * @returns Rendered header HTML string with thead wrapper
+   */
+  renderHeader(config, options) {
+    const strategy = this.selectStrategy(config);
+    const headerContent = strategy.render(config, options);
+    return thead().raw(headerContent).build();
+  }
+  /**
+   * Select the appropriate strategy for the configuration
+   * @param config - Table configuration
+   * @returns The selected strategy
+   */
+  selectStrategy(config) {
+    for (const strategy of this.strategies) {
+      if (strategy.canHandle(config)) {
+        return strategy;
+      }
+    }
+    return new SimpleHeaderStrategy();
+  }
+};
+var RowNumberHeaderDecorator = class {
+  /**
+   * Create a new row number header decorator
+   * @param renderer - The header renderer to wrap
+   */
+  constructor(renderer) {
+    this.wrapped = renderer;
+  }
+  /**
+   * Render the table header with row number column
+   * @param config - Table configuration
+   * @param options - Render options
+   * @returns Rendered header HTML string with row number column
+   */
+  renderHeader(config, options) {
+    if (!config.showRowNumber) {
+      return this.wrapped.renderHeader(config, options);
+    }
+    const rowCount = this.getHeaderRowCount(config);
+    const rowNumCell = th().text("No.");
+    if (rowCount > 1) {
+      rowNumCell.attr("rowspan", rowCount);
+    }
+    const rowNumHtml = rowNumCell.build();
+    const baseHtml = this.wrapped.renderHeader(config, options);
+    return this.insertRowNumberCell(baseHtml, rowNumHtml);
+  }
+  /**
+   * Get the number of header rows
+   * @param config - Table configuration
+   * @returns Number of header rows
+   */
+  getHeaderRowCount(config) {
+    if (config.headerRows && config.headerRows.length > 0) {
+      return config.headerRows.length;
+    }
+    return 1;
+  }
+  /**
+   * Insert row number cell into the first row of the header
+   * @param headerHtml - The base header HTML
+   * @param rowNumHtml - The row number cell HTML
+   * @returns Modified header HTML with row number cell
+   */
+  insertRowNumberCell(headerHtml, rowNumHtml) {
+    const firstTrMatch = headerHtml.match(/<tr>/);
+    if (!firstTrMatch) {
+      return headerHtml;
+    }
+    const insertIndex = headerHtml.indexOf("<tr>") + 4;
+    return headerHtml.slice(0, insertIndex) + "\n" + rowNumHtml + headerHtml.slice(insertIndex);
+  }
+};
+function createHeaderRenderer(config) {
+  const baseRenderer = new BaseHeaderRenderer();
+  if (config.showRowNumber) {
+    return new RowNumberHeaderDecorator(baseRenderer);
+  }
+  return baseRenderer;
+}
+
 // src/renderer/section-renderers/table.ts
-function renderTable(config, data, options) {
-  const headers = config.columns.map((col) => {
-    const width = col.width ? ` style="width: ${col.width}"` : "";
-    return `<th${width}>${escapeHtml(col.header)}</th>`;
-  }).join("\n");
-  const rows = data[config.dataField] || [];
-  const body = rows.map((row, index) => {
+function renderTable(config, data, options, partialOptions) {
+  const { rowIndices, includeHeader = true } = partialOptions || {};
+  const allRows = data[config.dataField] || [];
+  const rowsToRender = rowIndices ? rowIndices.filter((idx) => idx >= 0 && idx < allRows.length).map((idx) => ({ row: allRows[idx], originalIndex: idx })) : allRows.map((row, idx) => ({ row, originalIndex: idx }));
+  const body = rowsToRender.map(({ row, originalIndex }) => {
     const cells = config.columns.map((col) => {
       const value = row[col.field];
       const formattedValue = formatValue(value, col.type, {
@@ -1569,26 +1795,26 @@ function renderTable(config, data, options) {
       });
       return `<td>${escapeHtml(formattedValue)}</td>`;
     }).join("\n");
-    const rowNumber = config.showRowNumber ? `<td>${index + 1}</td>
+    const rowNumber = config.showRowNumber ? `<td>${originalIndex + 1}</td>
 ` : "";
     return `<tr>
 ${rowNumber}${cells}
 </tr>`;
   }).join("\n");
-  const rowNumberHeader = config.showRowNumber ? "<th>No.</th>\n" : "";
+  const headerHtml = includeHeader ? renderTableHeader(config, options) : "";
   return `<div class="${cls("print-section", options)} ${cls("data-table", options)}">
 <table>
-<thead>
-<tr>
-${rowNumberHeader}${headers}
-</tr>
-</thead>
+${headerHtml}
 <tbody>
 ${body}
 </tbody>
 </table>
 </div>`;
 }
+function renderTableHeader(config, options) {
+  const renderer = createHeaderRenderer(config);
+  return renderer.renderHeader(config, options);
+}
 
 // src/renderer/section-renderers/checkbox-grid.ts
 function renderCheckboxGrid(config, data, options) {
@@ -1853,7 +2079,7 @@ function renderFooter(schema) {
   }
   let pageNumberHtml = "";
   if (footer3.showPageNumber) {
-    pageNumberHtml = '<span class="page-number"></span>';
+    pageNumberHtml = '<span class="page-number">Page 1 of 1</span>';
   }
   return `<footer class="print-footer">
 ${notesHtml}
@@ -1876,7 +2102,7 @@ function renderWatermark(text, opacity) {
   return `<div class="watermark"${style}>${escapeHtml(text)}</div>`;
 }
 function renderToHtml(schema, data, options) {
-  const theme = mergeTheme(options?.theme);
+  const theme = schema.baseUnit ? createThemeWithBaseUnit(schema.baseUnit) : mergeTheme(options?.theme);
   const css = generateCss(theme);
   const pageClasses = [
     "print-page",
@@ -1928,7 +2154,7 @@ function renderFooter2(schema) {
   const { footer: footer3 } = schema;
   if (!footer3) return "";
   const notes = footer3.notes ? `<span class="${ns}-footer-notes">${escapeHtml(footer3.notes)}</span>` : "";
-  const pageNumber = footer3.showPageNumber ? `<span class="${ns}-page-number"></span>` : "";
+  const pageNumber = footer3.showPageNumber ? `<span class="${ns}-page-number">Page 1 of 1</span>` : "";
   return `<footer class="${ns}-print-footer">
 ${notes}
 ${pageNumber}
@@ -1963,8 +2189,13 @@ function getPageClasses(schema) {
   ].filter(Boolean).join(" ");
 }
 function createRenderContext(schema, data, options) {
+  let themeOverride = options?.theme;
+  if (schema.baseUnit) {
+    const scaledTheme = createThemeWithBaseUnit(schema.baseUnit);
+    themeOverride = { ...scaledTheme, ...options?.theme };
+  }
   return {
-    css: generateIsolatedCss(options?.theme),
+    css: generateIsolatedCss(themeOverride),
     pageClasses: getPageClasses(schema),
     header: renderHeader2(schema),
     sections: renderSections2(schema, data, options),
@@ -2599,9 +2830,9 @@ var HtmlElementBuilder = class _HtmlElementBuilder {
 var div2 = () => new HtmlElementBuilder("div");
 var span2 = () => new HtmlElementBuilder("span");
 var table2 = () => new HtmlElementBuilder("table");
-var thead2 = () => new HtmlElementBuilder("thead");
+var thead3 = () => new HtmlElementBuilder("thead");
 var tbody2 = () => new HtmlElementBuilder("tbody");
-var tr2 = () => new HtmlElementBuilder("tr");
+var tr3 = () => new HtmlElementBuilder("tr");
 var th2 = () => new HtmlElementBuilder("th");
 var td2 = () => new HtmlElementBuilder("td");
 var p2 = () => new HtmlElementBuilder("p");
@@ -3624,6 +3855,8 @@ function createFormDataTraverser() {
 var PAGINATION_DEFAULTS = {
   /** Maximum characters for overflow field first page */
   OVERFLOW_FIRST_LINE_CHARS: 60,
+  /** Minimum table row height estimate (mm) */
+  MIN_ROW_HEIGHT: 8,
   /** Default DPI (dots per inch), standard screen DPI is 96 */
   DPI: 96,
   /** 1 inch = 25.4 millimeters */
@@ -3639,8 +3872,35 @@ var PAGINATION_DEFAULTS = {
 var DEFAULT_DPI = PAGINATION_DEFAULTS.DPI;
 var MM_PER_INCH = PAGINATION_DEFAULTS.MM_PER_INCH;
 var MEASURABLE_ITEM_TYPES = {
+  /** Page header with hospital, department, title */
+  HEADER: "header",
+  /** Content section (info-grid, checkbox-grid, etc.) */
+  SECTION: "section",
+  /** Table header row */
   TABLE_HEADER: "table-header",
-  TABLE_ROW: "table-row"};
+  /** Table body row */
+  TABLE_ROW: "table-row",
+  /** Signature area (separate from footer, has own pagination rules) */
+  SIGNATURE: "signature",
+  /** Page footer with page number and notes */
+  FOOTER: "footer"
+};
+var DEFAULT_OVERFLOW_TEXT = {
+  /** Continuation marker on first page */
+  seeNextMarker: "\uFF08\u7EED\u89C1\u9644\u9875\uFF09",
+  /** Label suffix on continuation page */
+  continuationSuffix: "\uFF08\u7EED\uFF09",
+  /** Page title suffix for continuation pages */
+  pageTitleSuffix: "\uFF08\u7EED\uFF09"
+};
+var ENGLISH_OVERFLOW_TEXT = {
+  /** Continuation marker on first page */
+  seeNextMarker: "(continued on next page)",
+  /** Label suffix on continuation page */
+  continuationSuffix: "(continued)",
+  /** Page title suffix for continuation pages */
+  pageTitleSuffix: "(continued)"
+};
 
 // src/pagination/page-dimensions.ts
 var PAGE_16K = {
@@ -3712,7 +3972,7 @@ function createPageDimensions(width, height, margins = {}) {
   };
 }
 
-// src/pagination/page-break-calculator.ts
+// src/pagination/strategies/smart/page-break-calculator.ts
 function findTableHeader(items, tableId) {
   return items.find(
     (item) => item.type === MEASURABLE_ITEM_TYPES.TABLE_HEADER && item.tableId === tableId
@@ -3743,7 +4003,8 @@ function calculatePageBreaks(items, options) {
     pageHeight,
     headerHeight = 0,
     footerHeight = 0,
-    repeatTableHeaders = true
+    repeatTableHeaders = true,
+    lastPageExtraHeight = 0
   } = options;
   if (items.length === 0) {
     return {
@@ -3764,6 +4025,10 @@ function calculatePageBreaks(items, options) {
       currentPageTableHeaders.add(item.tableId);
     }
     let heightAfterAdd = currentHeight + item.height;
+    const isLastItem = i === items.length - 1;
+    if (isLastItem && lastPageExtraHeight > 0) {
+      heightAfterAdd += lastPageExtraHeight;
+    }
     let needsHeaderRepeat = false;
     let tableHeader;
     if (isTableRow(item) && repeatTableHeaders) {
@@ -3789,6 +4054,9 @@ function calculatePageBreaks(items, options) {
           currentPageTableHeaders.add(item.tableId);
         }
       }
+      if (isLastItem && lastPageExtraHeight > 0) {
+        currentHeight + item.height + lastPageExtraHeight;
+      }
     } else if (needsHeaderRepeat && tableHeader) {
       currentPage.repeatedHeaders.push(tableHeader.id);
       currentHeight += tableHeader.height;
@@ -3852,7 +4120,7 @@ function getPageContentHeight(page, items) {
   return height;
 }
 
-// src/pagination/overflow-handler.ts
+// src/pagination/strategies/overflow/overflow-handler.ts
 function toSafeString(value) {
   if (value == null) return "";
   return String(value);
@@ -3922,6 +4190,757 @@ function hasAnyOverflowContent(data, configs) {
   });
 }
 
+// src/pagination/strategies/overflow/overflow-pagination.ts
+var OVERFLOW_CSS_CLASSES = {
+  /** First page truncated content container */
+  OVERFLOW_FIRST_LINE: "overflow-first-line",
+  /** Continuation page content container */
+  OVERFLOW_CONTINUATION: "overflow-continuation",
+  /** "see next page" marker (red color) */
+  SEE_NEXT: "see-next",
+  /** Field label on continuation page */
+  OVERFLOW_LABEL: "overflow-label",
+  /** Overflow content (preserves whitespace) */
+  OVERFLOW_CONTENT: "overflow-content"
+};
+function isOverflowSection(section2, overflowFields) {
+  if (section2.type !== "info-grid") {
+    return false;
+  }
+  if (overflowFields.length === 0) {
+    return false;
+  }
+  const config = section2.config;
+  for (const row of config.rows) {
+    for (const cell of row.cells) {
+      if (overflowFields.includes(cell.field)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function findOverflowFieldLabel(section2, fieldName) {
+  if (section2.type !== "info-grid") {
+    return fieldName;
+  }
+  const config = section2.config;
+  for (const row of config.rows) {
+    for (const cell of row.cells) {
+      if (cell.field === fieldName) {
+        return cell.label || fieldName;
+      }
+    }
+  }
+  return fieldName;
+}
+function findOverflowFieldCell(section2, fieldName) {
+  if (section2.type !== "info-grid") {
+    return void 0;
+  }
+  const config = section2.config;
+  for (const row of config.rows) {
+    for (const cell of row.cells) {
+      if (cell.field === fieldName) {
+        return cell;
+      }
+    }
+  }
+  return void 0;
+}
+function getOverflowFieldsFromConfig(paginationConfig) {
+  if (!paginationConfig) {
+    return [];
+  }
+  const fields = paginationConfig.overflow?.fields ?? paginationConfig.overflowFields;
+  if (!fields || fields.length === 0) {
+    return [];
+  }
+  const maxChars = paginationConfig.overflow?.firstLineChars ?? paginationConfig.overflowFirstLineChars ?? PAGINATION_DEFAULTS.OVERFLOW_FIRST_LINE_CHARS;
+  return fields.map((fieldName) => ({
+    fieldName,
+    maxFirstLineChars: maxChars
+  }));
+}
+function getOverflowFieldNames(paginationConfig) {
+  if (!paginationConfig) {
+    return [];
+  }
+  return paginationConfig.overflow?.fields ?? paginationConfig.overflowFields ?? [];
+}
+function renderOverflowFirstLine(value, maxChars, textConfig, cls2) {
+  const firstLine = getOverflowFirstLine(value, maxChars);
+  const hasOverflow = hasOverflowContent(value, maxChars);
+  if (!hasOverflow) {
+    return span().class(cls2(OVERFLOW_CSS_CLASSES.OVERFLOW_FIRST_LINE)).text(firstLine).build();
+  }
+  const marker = span().class(cls2(OVERFLOW_CSS_CLASSES.SEE_NEXT)).text(textConfig.seeNextMarker).build();
+  const escapedFirstLine = escapeHtml(firstLine + " ");
+  return span().class(cls2(OVERFLOW_CSS_CLASSES.OVERFLOW_FIRST_LINE)).raw(escapedFirstLine + marker).build();
+}
+function renderOverflowContinuation(result, fieldLabel, textConfig, cls2) {
+  if (!result.hasOverflow || !result.rest) {
+    return "";
+  }
+  const labelText = `${fieldLabel}${textConfig.continuationSuffix}\uFF1A`;
+  const labelHtml = div().class(cls2(OVERFLOW_CSS_CLASSES.OVERFLOW_LABEL)).text(labelText).build();
+  const contentHtml = div().class(cls2(OVERFLOW_CSS_CLASSES.OVERFLOW_CONTENT)).text(result.rest).build();
+  return div().class(cls2(OVERFLOW_CSS_CLASSES.OVERFLOW_CONTINUATION)).raw(labelHtml + "\n" + contentHtml).build();
+}
+function mergeOverflowTextConfig(config) {
+  return {
+    ...DEFAULT_OVERFLOW_TEXT,
+    ...config
+  };
+}
+var PAGE_CSS_CLASSES = {
+  PRINT_PAGE: "print-page",
+  CONTINUATION_PAGE: "continuation-page",
+  PRINT_HEADER: "print-header",
+  PRINT_FOOTER: "print-footer",
+  PRINT_CONTENT: "print-content",
+  HOSPITAL_NAME: "hospital-name",
+  DEPARTMENT_NAME: "department-name",
+  FORM_TITLE: "form-title",
+  PAGE_NUMBER: "page-number"
+};
+function renderOverflowPageHeader(ctx, cls2) {
+  const parts = [];
+  if (ctx.hospital) {
+    parts.push(
+      div().class(cls2(PAGE_CSS_CLASSES.HOSPITAL_NAME)).text(ctx.hospital).build()
+    );
+  }
+  if (ctx.department) {
+    parts.push(
+      div().class(cls2(PAGE_CSS_CLASSES.DEPARTMENT_NAME)).text(ctx.department).build()
+    );
+  }
+  const titleText = `${ctx.title} ${ctx.textConfig.pageTitleSuffix}`;
+  parts.push(
+    div().class(cls2(PAGE_CSS_CLASSES.FORM_TITLE)).text(titleText).build()
+  );
+  return div().class(cls2(PAGE_CSS_CLASSES.PRINT_HEADER)).raw(parts.join("\n")).build();
+}
+function renderOverflowPageFooter(ctx, cls2) {
+  const format = ctx.pageNumberFormat ?? "Page {current} of {total}";
+  const pageNumberText = format.replace("{current}", String(ctx.pageNumber)).replace("{total}", String(ctx.totalPages));
+  const pageNumberHtml = span().class(cls2(PAGE_CSS_CLASSES.PAGE_NUMBER)).text(pageNumberText).build();
+  return div().class(cls2(PAGE_CSS_CLASSES.PRINT_FOOTER)).raw(pageNumberHtml).build();
+}
+function renderOverflowPageContent(ctx, cls2) {
+  const parts = [];
+  for (const { result, label } of ctx.overflowFields) {
+    if (result.hasOverflow && result.rest) {
+      const fieldHtml = renderOverflowContinuation(result, label, ctx.textConfig, cls2);
+      if (fieldHtml) {
+        parts.push(fieldHtml);
+      }
+    }
+  }
+  return div().class(cls2(PAGE_CSS_CLASSES.PRINT_CONTENT)).raw(parts.join("\n")).build();
+}
+function renderOverflowContinuationPage(ctx, cls2, pageSize = "16k", orientation = "portrait") {
+  const pageClasses = [
+    cls2(PAGE_CSS_CLASSES.PRINT_PAGE),
+    cls2(pageSize),
+    cls2(orientation),
+    cls2(PAGE_CSS_CLASSES.CONTINUATION_PAGE)
+  ].join(" ");
+  const parts = [];
+  parts.push(renderOverflowPageHeader(ctx, cls2));
+  parts.push(renderOverflowPageContent(ctx, cls2));
+  if (ctx.showSignature && ctx.signatureHtml) {
+    parts.push(ctx.signatureHtml);
+  }
+  parts.push(renderOverflowPageFooter(ctx, cls2));
+  return div().class(pageClasses).attr("data-page", ctx.pageNumber).raw(parts.join("\n")).build();
+}
+function hasAnyContinuationContent(overflowFields) {
+  return overflowFields.some(({ result }) => result.hasOverflow && result.rest);
+}
+
+// src/pagination/strategies/pagination-strategy.ts
+var PaginationContext = class {
+  /**
+   * Create pagination context with strategies
+   * @param strategies - Array of pagination strategies
+   * @requirements 4.1 - Context accepts strategies in constructor
+   */
+  constructor(strategies) {
+    this.strategies = strategies;
+  }
+  /**
+   * Get strategies that apply to the given schema
+   * @param schema - Print schema with pagination configuration
+   * @returns Array of applicable strategies
+   * @requirements 4.2 - Context provides getApplicableStrategies method
+   */
+  getApplicableStrategies(schema) {
+    return this.strategies.filter((strategy) => strategy.shouldApply(schema));
+  }
+  /**
+   * Render content using applicable strategies
+   * Uses the first applicable strategy, falls back to non-paginated rendering if none apply
+   * @param schema - Print schema with pagination configuration
+   * @param data - Form data to render
+   * @param options - Render options
+   * @returns Rendered HTML string
+   * @requirements 4.3, 4.4 - Context provides render method and executes strategies
+   */
+  render(schema, data, options) {
+    const applicableStrategies = this.getApplicableStrategies(schema);
+    if (applicableStrategies.length === 0) {
+      throw new Error("No applicable pagination strategy found and fallback not implemented yet");
+    }
+    const strategy = applicableStrategies[0];
+    return strategy.render(schema, data, options);
+  }
+  /**
+   * Add a strategy to the context
+   * @param strategy - Strategy to add
+   */
+  addStrategy(strategy) {
+    this.strategies.push(strategy);
+  }
+  /**
+   * Remove a strategy from the context
+   * @param strategyName - Name of strategy to remove
+   * @returns Whether strategy was found and removed
+   */
+  removeStrategy(strategyName) {
+    const index = this.strategies.findIndex((s) => s.name === strategyName);
+    if (index >= 0) {
+      this.strategies.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get all registered strategies
+   * @returns Array of all strategies
+   */
+  getAllStrategies() {
+    return [...this.strategies];
+  }
+  /**
+   * Get strategy by name
+   * @param name - Strategy name
+   * @returns Strategy if found, undefined otherwise
+   */
+  getStrategy(name) {
+    return this.strategies.find((s) => s.name === name);
+  }
+};
+
+// src/pagination/measurer-types.ts
+var DEFAULT_MEASURE_CONFIG = {
+  containerWidth: 624,
+  // Approximately 165mm @ 96dpi (16K paper usable width)
+  fontSize: "10pt",
+  lineHeight: 1.8,
+  fontFamily: "'Source Han Serif SC', 'SimSun', 'Song Ti', serif"
+};
+var MEASURE_CONTAINER_CLASS = "print-measure-container";
+var DEFAULT_TEXT_ESTIMATE_OPTIONS = {
+  containerWidth: 624,
+  fontSize: 13.33,
+  // 10pt ≈ 13.33px
+  lineHeight: 1.8,
+  isChinese: true
+};
+function createDualSelector(classNames) {
+  return classNames.flatMap((cn) => [`.${cn}`, `.${CSS_NAMESPACE}-${cn}`]).join(", ");
+}
+function createSectionWrapperSelector(wrapperClass, sectionClass) {
+  return [
+    // Wrapper with data-section-id
+    `.${wrapperClass}[data-section-id]`,
+    `.${CSS_NAMESPACE}-${wrapperClass}[data-section-id]`,
+    // Direct section class
+    `.${sectionClass}`,
+    `.${CSS_NAMESPACE}-${sectionClass}`,
+    // Compound class (div.print-section.section-class)
+    `div.print-section.${sectionClass}`,
+    `div.${CSS_NAMESPACE}-print-section.${CSS_NAMESPACE}-${sectionClass}`
+  ].join(", ");
+}
+var MEASURE_SELECTORS = {
+  /** Header selector - matches .print-header and .mpr-print-header */
+  HEADER: createDualSelector(["print-header"]),
+  /** Footer selector - matches .print-footer and .mpr-print-footer */
+  FOOTER: createDualSelector(["print-footer"]),
+  /** Page body selector - matches .print-body/.print-content variants */
+  BODY: createDualSelector(["print-body", "print-content"]),
+  /** Section title selector */
+  SECTION_TITLE: createDualSelector(["section-title"]),
+  /** Info grid wrapper selector */
+  INFO_GRID_WRAPPER: createSectionWrapperSelector("info-grid-wrapper", "info-grid"),
+  /** Data table wrapper selector */
+  TABLE_WRAPPER: createSectionWrapperSelector("data-table-wrapper", "data-table"),
+  /** Checkbox grid wrapper selector */
+  CHECKBOX_GRID_WRAPPER: createSectionWrapperSelector("checkbox-grid-wrapper", "checkbox-grid"),
+  /** Medical checkbox row wrapper selector */
+  MEDICAL_CHECKBOX_ROW_WRAPPER: createDualSelector(["medical-checkbox-row-wrapper[data-section-id]"]),
+  /** Notes selector */
+  NOTES: createDualSelector(["notes-text", "notes-section"]),
+  /** Signature area selector */
+  SIGNATURE: createDualSelector(["signature-area"]),
+  /** Table header selector (standard HTML element, no namespace needed) */
+  TABLE_HEADER: "thead",
+  /** Table rows selector (standard HTML element, no namespace needed) */
+  TABLE_ROWS: "tbody tr"
+};
+
+// src/pagination/content-measurer.ts
+function isBrowserEnvironment() {
+  return typeof window !== "undefined" && typeof document !== "undefined" && typeof document.createElement === "function";
+}
+function ensureBrowserEnvironment() {
+  if (!isBrowserEnvironment()) {
+    throw new Error(
+      "Content measurer requires browser environment. Use Puppeteer for Node.js environment."
+    );
+  }
+}
+function createMeasureContainer(config = DEFAULT_MEASURE_CONFIG, options = {}) {
+  ensureBrowserEnvironment();
+  const mergedConfig = {
+    ...DEFAULT_MEASURE_CONFIG,
+    ...config
+  };
+  const {
+    className = MEASURE_CONTAINER_CLASS,
+    appendToBody = true,
+    customStyles = {}
+  } = options;
+  const container = document.createElement("div");
+  container.className = className;
+  Object.assign(container.style, {
+    // Hide container
+    position: "absolute",
+    left: "-9999px",
+    top: "-9999px",
+    visibility: "hidden",
+    // Dimensions
+    width: `${mergedConfig.containerWidth}px`,
+    // Print styles
+    fontSize: mergedConfig.fontSize,
+    lineHeight: String(mergedConfig.lineHeight),
+    fontFamily: mergedConfig.fontFamily,
+    // Ensure consistent box model
+    boxSizing: "border-box",
+    // Prevent content overflow affecting measurement
+    overflow: "hidden",
+    // Custom styles
+    ...customStyles
+  });
+  if (appendToBody) {
+    document.body.appendChild(container);
+  }
+  return container;
+}
+function destroyMeasureContainer(container) {
+  if (container && container.parentNode) {
+    container.parentNode.removeChild(container);
+  }
+}
+function measureElementHeight(element, container) {
+  ensureBrowserEnvironment();
+  const clone = element.cloneNode(true);
+  clone.style.visibility = "visible";
+  clone.style.position = "static";
+  clone.style.display = "";
+  container.appendChild(clone);
+  const computedStyle = window.getComputedStyle(clone);
+  const marginTop = parseFloat(computedStyle.marginTop) || 0;
+  const marginBottom = parseFloat(computedStyle.marginBottom) || 0;
+  const rect = clone.getBoundingClientRect();
+  const height = rect.height + marginTop + marginBottom;
+  container.removeChild(clone);
+  return height;
+}
+function measureElementWithOptions(element, container, options) {
+  const height = measureElementHeight(element, container);
+  return {
+    id: options.id,
+    type: options.type,
+    height,
+    tableId: options.tableId,
+    dataIndex: options.dataIndex
+  };
+}
+function measureTableRows(tableElement, container, options) {
+  ensureBrowserEnvironment();
+  const { tableId, includeHeader = true, includeRows = true } = options;
+  const results = [];
+  const tableClone = tableElement.cloneNode(true);
+  tableClone.style.visibility = "visible";
+  tableClone.style.position = "static";
+  container.appendChild(tableClone);
+  if (includeHeader) {
+    const thead4 = tableClone.querySelector(MEASURE_SELECTORS.TABLE_HEADER);
+    if (thead4) {
+      const theadRect = thead4.getBoundingClientRect();
+      results.push({
+        id: `${tableId}-header`,
+        type: "table-header",
+        height: theadRect.height,
+        tableId
+      });
+    }
+  }
+  if (includeRows) {
+    const rows = tableClone.querySelectorAll(MEASURE_SELECTORS.TABLE_ROWS);
+    rows.forEach((row, index) => {
+      const rowRect = row.getBoundingClientRect();
+      results.push({
+        id: `${tableId}-row-${index}`,
+        type: "table-row",
+        height: rowRect.height,
+        tableId,
+        dataIndex: index
+      });
+    });
+  }
+  container.removeChild(tableClone);
+  return results;
+}
+function estimateTextHeight(text, options = DEFAULT_TEXT_ESTIMATE_OPTIONS) {
+  if (!text) return 0;
+  const {
+    containerWidth,
+    fontSize = DEFAULT_TEXT_ESTIMATE_OPTIONS.fontSize,
+    lineHeight = DEFAULT_TEXT_ESTIMATE_OPTIONS.lineHeight,
+    isChinese = DEFAULT_TEXT_ESTIMATE_OPTIONS.isChinese
+  } = options;
+  const charWidth = isChinese ? fontSize : fontSize * 0.5;
+  const charsPerLine = Math.floor(containerWidth / charWidth);
+  const lines = text.split("\n");
+  let totalLines = 0;
+  for (const line of lines) {
+    if (line.length === 0) {
+      totalLines += 1;
+    } else {
+      const effectiveLength = isChinese ? line.length : countEffectiveChars(line);
+      totalLines += Math.ceil(effectiveLength / charsPerLine);
+    }
+  }
+  return totalLines * fontSize * lineHeight;
+}
+function countEffectiveChars(text) {
+  let count = 0;
+  for (const char of text) {
+    if (char.charCodeAt(0) > 127) {
+      count += 2;
+    } else {
+      count += 1;
+    }
+  }
+  return count;
+}
+var ALTERNATIVE_TABLE_SELECTORS = "div.data-table, div.mpr-data-table, table";
+function findPrintPageContainer(container) {
+  const printPage = container.querySelector(".print-page, .mpr-print-page");
+  if (printPage) {
+    return printPage;
+  }
+  return container;
+}
+function isTableElement(element) {
+  return element.matches(MEASURE_SELECTORS.TABLE_WRAPPER) || element.matches(ALTERNATIVE_TABLE_SELECTORS) || element.tagName === "TABLE";
+}
+function measureTableInto(element, tableId, results) {
+  const tableElement = element.tagName === "TABLE" ? element : element.querySelector("table");
+  if (!tableElement) return;
+  const thead4 = tableElement.querySelector(MEASURE_SELECTORS.TABLE_HEADER);
+  if (thead4) {
+    results.push({
+      id: `${tableId}-header`,
+      type: "table-header",
+      height: thead4.getBoundingClientRect().height,
+      tableId
+    });
+  }
+  const rows = tableElement.querySelectorAll(MEASURE_SELECTORS.TABLE_ROWS);
+  rows.forEach((row, rowIndex) => {
+    results.push({
+      id: `${tableId}-row-${rowIndex}`,
+      type: "table-row",
+      height: row.getBoundingClientRect().height,
+      tableId,
+      dataIndex: rowIndex
+    });
+  });
+}
+function measureHeaderInto(pageContainer, results) {
+  const header3 = pageContainer.querySelector(MEASURE_SELECTORS.HEADER);
+  if (header3) {
+    results.push({
+      id: "page-header",
+      type: "header",
+      height: header3.getBoundingClientRect().height
+    });
+  }
+}
+function measureFooterInto(pageContainer, printBody, results) {
+  const footer3 = pageContainer.querySelector(MEASURE_SELECTORS.FOOTER);
+  if (footer3) {
+    const rect = footer3.getBoundingClientRect();
+    const computedStyle = window.getComputedStyle(footer3);
+    const marginTop = parseFloat(computedStyle.marginTop) || 0;
+    const marginBottom = parseFloat(computedStyle.marginBottom) || 0;
+    const footerHeight = rect.height + marginTop + marginBottom;
+    if (footerHeight > 0) {
+      results.push({
+        id: "page-footer",
+        type: "footer",
+        height: footerHeight
+      });
+    }
+  }
+  if (printBody) {
+    const notes = printBody.querySelectorAll(MEASURE_SELECTORS.NOTES);
+    notes.forEach((note, index) => {
+      const rect = note.getBoundingClientRect();
+      const computedStyle = window.getComputedStyle(note);
+      const marginTop = parseFloat(computedStyle.marginTop) || 0;
+      const marginBottom = parseFloat(computedStyle.marginBottom) || 0;
+      const noteHeight = rect.height + marginTop + marginBottom;
+      if (noteHeight > 0) {
+        results.push({
+          id: `notes-${index}`,
+          type: "footer",
+          height: noteHeight
+        });
+      }
+    });
+  }
+}
+function measureSignaturesInto(container, results) {
+  const signatures = container.querySelectorAll(MEASURE_SELECTORS.SIGNATURE);
+  signatures.forEach((sig, index) => {
+    results.push({
+      id: `signature-${index}`,
+      type: "signature",
+      height: sig.getBoundingClientRect().height
+    });
+  });
+}
+function measureSectionsInto(printBody, results, options) {
+  const { measureSections, measureTables } = options;
+  let sectionIndex = 0;
+  const allSectionSelectors = [
+    MEASURE_SELECTORS.INFO_GRID_WRAPPER,
+    MEASURE_SELECTORS.TABLE_WRAPPER,
+    MEASURE_SELECTORS.CHECKBOX_GRID_WRAPPER,
+    MEASURE_SELECTORS.MEDICAL_CHECKBOX_ROW_WRAPPER
+  ].join(", ");
+  const allSectionElements = printBody.querySelectorAll(allSectionSelectors);
+  allSectionElements.forEach((element) => {
+    const isTable = isTableElement(element);
+    if (isTable && measureTables) {
+      measureTableInto(element, `table-${sectionIndex}`, results);
+      sectionIndex++;
+    } else if (!isTable && measureSections) {
+      results.push({
+        id: `section-${sectionIndex}`,
+        type: "section",
+        height: element.getBoundingClientRect().height
+      });
+      sectionIndex++;
+    }
+  });
+  if (allSectionElements.length === 0 && measureTables) {
+    const tableContainers = printBody.querySelectorAll(ALTERNATIVE_TABLE_SELECTORS);
+    tableContainers.forEach((tableContainer) => {
+      measureTableInto(tableContainer, `table-${sectionIndex}`, results);
+      sectionIndex++;
+    });
+  }
+}
+function measureAll(contentContainer, container, options = {}) {
+  ensureBrowserEnvironment();
+  const {
+    measureHeader = true,
+    measureFooter = true,
+    measureSignature = true,
+    measureTables = true,
+    measureSections = true
+  } = options;
+  const results = [];
+  const clone = contentContainer.cloneNode(true);
+  clone.style.visibility = "visible";
+  clone.style.position = "static";
+  container.appendChild(clone);
+  const pageContainer = findPrintPageContainer(clone);
+  if (measureHeader) {
+    measureHeaderInto(pageContainer, results);
+  }
+  const printBody = pageContainer.querySelector(MEASURE_SELECTORS.BODY);
+  if (printBody && (measureSections || measureTables)) {
+    measureSectionsInto(printBody, results, { measureSections, measureTables });
+  }
+  if (measureFooter) {
+    measureFooterInto(pageContainer, printBody, results);
+  }
+  if (measureSignature) {
+    measureSignaturesInto(clone, results);
+  }
+  container.removeChild(clone);
+  return results;
+}
+function createContentMeasurer(config = DEFAULT_MEASURE_CONFIG) {
+  const state = {
+    container: null,
+    config: { ...DEFAULT_MEASURE_CONFIG, ...config }
+  };
+  const getContainer = () => {
+    if (!state.container) {
+      state.container = createMeasureContainer(state.config);
+    }
+    return state.container;
+  };
+  const measureElement = (element) => {
+    const container = getContainer();
+    return measureElementHeight(element, container);
+  };
+  const measureElementWith = (element, options) => {
+    const container = getContainer();
+    return measureElementWithOptions(element, container, options);
+  };
+  const measureTable = (tableElement, options) => {
+    const container = getContainer();
+    return measureTableRows(tableElement, container, options);
+  };
+  const measureAllContent = (contentContainer, options) => {
+    const container = getContainer();
+    return measureAll(contentContainer, container, options);
+  };
+  const cleanup = () => {
+    if (state.container) {
+      destroyMeasureContainer(state.container);
+      state.container = null;
+    }
+  };
+  return {
+    /** Measure single element height */
+    measureElement,
+    /** Measure element with options */
+    measureElementWith,
+    /** Batch measure table rows */
+    measureTable,
+    /** Measure all content */
+    measureAll: measureAllContent,
+    /** Estimate text height */
+    estimateTextHeight,
+    /** Clean up measurement container */
+    cleanup,
+    /** Measurement configuration */
+    config: state.config,
+    /** Check if in browser environment */
+    isBrowserEnvironment
+  };
+}
+
+// src/pagination/strategies/smart/dom-measurement-strategy.ts
+var DomMeasurementStrategy = class {
+  /**
+   * Measure content and return measurable items with actual DOM heights
+   *
+   * @param schema - Print schema with pagination configuration
+   * @param data - Form data containing actual content (e.g., table rows)
+   * @param _config - Measurement configuration options (unused, kept for interface compliance)
+   * @returns Array of measurable items with heights in pixels
+   *
+   * @throws Error if not running in browser environment
+   * @throws Error if DOM measurement fails
+   *
+   * @requirements 3.1, 3.2, 3.3, 3.4, 3.5 - DOM measurement implementation
+   */
+  measure(schema, data, _config) {
+    if (!isBrowserEnvironment()) {
+      throw new Error(
+        "DomMeasurementStrategy requires browser environment. Smart pagination with DOM measurement is only available in browser. For Node.js, use Puppeteer or provide pre-measured items."
+      );
+    }
+    const containerWidth = this.getContainerWidth(schema);
+    const measurer = createContentMeasurer({ containerWidth });
+    let tempContainer = null;
+    try {
+      const tempHtml = renderToIsolatedFragment(schema, data);
+      tempContainer = this.createTempContainer(tempHtml, containerWidth);
+      document.body.appendChild(tempContainer);
+      const items = measurer.measureAll(tempContainer);
+      return this.filterInvalidItems(items);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`DOM measurement failed: ${message}`);
+    } finally {
+      if (tempContainer?.parentNode) {
+        tempContainer.parentNode.removeChild(tempContainer);
+      }
+      measurer.cleanup();
+    }
+  }
+  // ==================== Private Helper Methods ====================
+  /**
+   * Get container width for measurement based on page dimensions
+   * Reuses page dimension presets from page-dimensions module
+   *
+   * @param schema - Print schema with page configuration
+   * @returns Container width in pixels
+   */
+  getContainerWidth(schema) {
+    const pageSize = schema.pageSize?.toUpperCase() ?? "16K";
+    const dimensions = getPageDimensions(pageSize);
+    return calculateUsableWidth(dimensions);
+  }
+  /**
+   * Create temporary hidden container for measurement
+   *
+   * @param html - HTML content to measure
+   * @param width - Container width in pixels
+   * @returns Hidden container element
+   *
+   * @requirements 3.1 - Render content to hidden DOM container
+   */
+  createTempContainer(html, width) {
+    const container = document.createElement("div");
+    container.style.position = "absolute";
+    container.style.left = "-9999px";
+    container.style.top = "-9999px";
+    container.style.visibility = "hidden";
+    container.style.width = `${width}px`;
+    container.style.boxSizing = "border-box";
+    container.style.overflow = "hidden";
+    container.innerHTML = html;
+    return container;
+  }
+  /**
+   * Filter out items with invalid heights
+   *
+   * Removes items with zero or negative heights that would cause
+   * pagination calculation issues.
+   *
+   * @param items - Measured items from DOM
+   * @returns Valid measurable items with positive heights
+   */
+  filterInvalidItems(items) {
+    return items.filter((item) => {
+      if (item.height <= 0) {
+        if (item.type !== "footer") {
+          console.warn(
+            `DomMeasurementStrategy: Item "${item.id}" has invalid height ${item.height}, skipping`
+          );
+        }
+        return false;
+      }
+      return true;
+    });
+  }
+};
+
 // src/pagination/paginated-renderer.ts
 var CSS_CLASSES = {
   // Page structure
@@ -3958,7 +4977,8 @@ var DEFAULT_PAGINATED_RENDER_CONFIG = {
   continuationSuffix: "(continued)",
   pageNumberFormat: "Page {current} of {total}",
   pageDimensions: PAGE_16K,
-  isolated: false
+  isolated: false,
+  overflowText: DEFAULT_OVERFLOW_TEXT
 };
 function mergeConfig(config) {
   return {
@@ -4080,15 +5100,24 @@ var contentRenderers = {
     if (!section2) return "";
     return renderSectionWithTitle(section2, data, options, cls2);
   },
-  // Table row rendering needs to be wrapped in table, recommend using renderAllSections fallback
+  // Table row rendering is handled by renderTableRows function
   "table-row": () => "",
-  // Table headers are usually handled in repeatedHeaders
+  // Table headers are handled by renderTableRows function
   "table-header": () => "",
   // Following types are handled in dedicated functions
   header: () => "",
   footer: () => "",
   signature: () => ""
 };
+function renderPartialTable(section2, data, options, cls2, rowIndices, includeHeader) {
+  if (section2.type !== "table") return "";
+  const tableHtml = renderTable(section2.config, data, options, {
+    rowIndices,
+    includeHeader
+  });
+  const titleHtml = section2.title && includeHeader ? div().class(cls2(CSS_CLASSES.SECTION_TITLE)).text(section2.title).build() : "";
+  return `${titleHtml}${tableHtml}`;
+}
 function renderContentItem(itemId, itemMap, sectionMap, data, options, cls2) {
   const item = itemMap.get(itemId);
   if (!item) return "";
@@ -4096,34 +5125,116 @@ function renderContentItem(itemId, itemMap, sectionMap, data, options, cls2) {
   return renderer ? renderer(item, sectionMap, data, options, cls2) : "";
 }
 function renderAllSections(ctx, cls2) {
-  const { schema, data, options } = ctx;
+  const { schema, data, options, isFirstPage, overflowResults, overflowFieldNames, overflowTextConfig } = ctx;
   const parts = [];
+  const overflowResultMap = /* @__PURE__ */ new Map();
+  if (overflowResults) {
+    for (const result of overflowResults) {
+      overflowResultMap.set(result.fieldName, result);
+    }
+  }
   for (const section2 of schema.sections) {
     if (section2.type === "signature-area") continue;
-    parts.push(renderSectionWithTitle(section2, data, options, cls2));
+    if (isFirstPage && overflowFieldNames && overflowFieldNames.length > 0 && isOverflowSection(section2, overflowFieldNames)) {
+      parts.push(renderSectionWithOverflow(section2, data, options, cls2, overflowResultMap, overflowTextConfig));
+    } else {
+      parts.push(renderSectionWithTitle(section2, data, options, cls2));
+    }
   }
   return parts.join("\n");
 }
+function renderSectionWithOverflow(section2, data, options, cls2, overflowResultMap, textConfig) {
+  const titleHtml = section2.title ? div().class(cls2(CSS_CLASSES.SECTION_TITLE)).text(section2.title).build() : "";
+  if (section2.type === "info-grid") {
+    const config = section2.config;
+    const modifiedData = { ...data };
+    const mergedTextConfig = textConfig ?? DEFAULT_OVERFLOW_TEXT;
+    for (const row of config.rows) {
+      for (const cell of row.cells) {
+        const overflowResult = overflowResultMap.get(cell.field);
+        if (overflowResult) {
+          const maxChars = PAGINATION_DEFAULTS.OVERFLOW_FIRST_LINE_CHARS;
+          const renderedContent = renderOverflowFirstLine(
+            data[cell.field],
+            maxChars,
+            mergedTextConfig,
+            cls2
+          );
+          modifiedData[cell.field] = renderedContent;
+          modifiedData[`__overflow_html_${cell.field}`] = true;
+        }
+      }
+    }
+    const content2 = renderSection(section2.type, section2.config, modifiedData, options);
+    return `${titleHtml}${content2}`;
+  }
+  const content = renderSection(section2.type, section2.config, data, options);
+  return `${titleHtml}${content}`;
+}
 function renderPageBody(ctx, sectionMap, cls2) {
-  const { page, data, options, measuredItems } = ctx;
+  const { page, data, options, measuredItems, isFirstPage, overflowFieldNames } = ctx;
   const parts = [];
-  const repeatedHeaders = renderRepeatedHeaders(ctx, sectionMap, cls2);
-  if (repeatedHeaders) {
-    parts.push(repeatedHeaders);
-  }
   const itemMap = new Map(measuredItems.map((m) => [m.id, m]));
   const hasValidItems = page.items.length > 0 && page.items.some((itemId) => {
     const item = itemMap.get(itemId);
-    return item?.type === "section";
+    return item?.type === "section" || item?.type === "table-header" || item?.type === "table-row";
   });
-  if (hasValidItems) {
+  const hasOverflowFields = isFirstPage && overflowFieldNames && overflowFieldNames.length > 0;
+  if (hasValidItems && !hasOverflowFields) {
+    const tableRowsByTableId = /* @__PURE__ */ new Map();
+    const renderedTables = /* @__PURE__ */ new Set();
     for (const itemId of page.items) {
-      const content = renderContentItem(itemId, itemMap, sectionMap, data, options, cls2);
-      if (content) {
-        parts.push(content);
+      const item = itemMap.get(itemId);
+      if (!item) continue;
+      if (item.type === "table-header" && item.tableId) {
+        if (!tableRowsByTableId.has(item.tableId)) {
+          tableRowsByTableId.set(item.tableId, { indices: [], hasHeader: true });
+        } else {
+          tableRowsByTableId.get(item.tableId).hasHeader = true;
+        }
+      } else if (item.type === "table-row" && item.tableId && item.dataIndex !== void 0) {
+        if (!tableRowsByTableId.has(item.tableId)) {
+          tableRowsByTableId.set(item.tableId, { indices: [], hasHeader: false });
+        }
+        tableRowsByTableId.get(item.tableId).indices.push(item.dataIndex);
+      }
+    }
+    for (const itemId of page.items) {
+      const item = itemMap.get(itemId);
+      if (!item) continue;
+      if (item.type === "section") {
+        const content = renderContentItem(itemId, itemMap, sectionMap, data, options, cls2);
+        if (content) {
+          parts.push(content);
+        }
+      } else if ((item.type === "table-header" || item.type === "table-row") && item.tableId) {
+        if (!renderedTables.has(item.tableId)) {
+          renderedTables.add(item.tableId);
+          const tableData = tableRowsByTableId.get(item.tableId);
+          const section2 = sectionMap.get(item.tableId);
+          if (section2 && tableData) {
+            const hasRepeatedHeader = page.repeatedHeaders.includes(`${item.tableId}-header`);
+            const includeHeader = tableData.hasHeader || hasRepeatedHeader;
+            const tableHtml = renderPartialTable(
+              section2,
+              data,
+              options,
+              cls2,
+              tableData.indices,
+              includeHeader
+            );
+            if (tableHtml) {
+              parts.push(tableHtml);
+            }
+          }
+        }
       }
     }
   } else {
+    const repeatedHeaders = renderRepeatedHeaders(ctx, sectionMap, cls2);
+    if (repeatedHeaders) {
+      parts.push(repeatedHeaders);
+    }
     parts.push(renderAllSections(ctx, cls2));
   }
   return main().class(cls2(CSS_CLASSES.PRINT_CONTENT)).raw(parts.join("\n")).build();
@@ -4153,6 +5264,7 @@ function buildSectionMap(schema, measuredItems) {
     if (section2.type === "table") {
       const tableConfig = section2.config;
       map.set(`table-${tableConfig.dataField}`, section2);
+      map.set(`table-${index}`, section2);
     }
   });
   for (const item of measuredItems) {
@@ -4200,12 +5312,30 @@ function renderPaginatedHtml(context) {
   const mergedConfig = mergeConfig(config);
   const theme = mergeTheme(options?.theme);
   const cls2 = createClassNameFn2(mergedConfig.isolated);
+  const renderOptions2 = mergedConfig.isolated ? { ...options, classPrefix: CSS_NAMESPACE } : options;
   const baseCss = mergedConfig.isolated ? generateIsolatedCss(options?.theme) : generateCss(theme);
   const paginationCss = generatePaginationCss(mergedConfig.isolated);
   const fullCss = `${baseCss}
 ${paginationCss}`;
   const sectionMap = buildSectionMap(schema, measuredItems);
-  const { totalPages } = pageBreakResult;
+  const overflowFieldNames = getOverflowFieldNames(schema.pagination);
+  const overflowConfigs = createOverflowFieldConfigs(overflowFieldNames);
+  const overflowResults = overflowConfigs.length > 0 ? processOverflowFields(data, overflowConfigs) : [];
+  const overflowTextConfig = mergeOverflowTextConfig(mergedConfig.overflowText);
+  const overflowFieldsWithLabels = overflowResults.map((result) => {
+    let label = result.fieldName;
+    for (const section2 of schema.sections) {
+      const foundLabel = findOverflowFieldLabel(section2, result.fieldName);
+      if (foundLabel !== result.fieldName) {
+        label = foundLabel;
+        break;
+      }
+    }
+    return { result, label };
+  });
+  const needsOverflowPage = hasAnyContinuationContent(overflowFieldsWithLabels);
+  const baseTotalPages = pageBreakResult.totalPages;
+  const totalPages = needsOverflowPage ? baseTotalPages + 1 : baseTotalPages;
   const pages = pageBreakResult.pages.map((page, i) => {
     const pageNumber = i + 1;
     const pageCtx = {
@@ -4213,14 +5343,46 @@ ${paginationCss}`;
       pageNumber,
       totalPages,
       isFirstPage: pageNumber === 1,
-      isLastPage: pageNumber === totalPages,
+      isLastPage: pageNumber === totalPages && !needsOverflowPage,
       schema,
       data,
-      options,
+      options: renderOptions2,
       measuredItems,
-      config: mergedConfig};
+      config: mergedConfig,
+      // Pass overflow context for first page
+      overflowResults: pageNumber === 1 ? overflowResults : void 0,
+      overflowFieldNames: pageNumber === 1 ? overflowFieldNames : void 0,
+      overflowTextConfig
+    };
     return renderSinglePage(pageCtx, sectionMap, cls2);
   });
+  if (needsOverflowPage) {
+    let signatureHtml;
+    if (mergedConfig.showSignatureOnEachPage) {
+      const signatureSection = schema.sections.find((s) => s.type === "signature-area");
+      if (signatureSection) {
+        signatureHtml = renderSection(signatureSection.type, signatureSection.config, data, renderOptions2);
+      }
+    }
+    const overflowPageHtml = renderOverflowContinuationPage(
+      {
+        pageNumber: totalPages,
+        totalPages,
+        title: schema.header.title,
+        hospital: schema.header.hospital,
+        department: schema.header.department,
+        overflowFields: overflowFieldsWithLabels,
+        textConfig: overflowTextConfig,
+        showSignature: mergedConfig.showSignatureOnEachPage,
+        signatureHtml,
+        pageNumberFormat: mergedConfig.pageNumberFormat
+      },
+      cls2,
+      schema.pageSize.toLowerCase(),
+      schema.orientation
+    );
+    pages.push(overflowPageHtml);
+  }
   const pagesHtml = pages.join("\n");
   const bodyContent = mergedConfig.isolated ? generateIsolatedBodyContent(fullCss, pagesHtml) : pagesHtml;
   return generateHtmlDocument(schema.header.title, fullCss, bodyContent, mergedConfig.isolated);
@@ -4239,6 +5401,11 @@ function generatePaginationCss(isolated = false) {
   const pageBreakBefore = cls2(CSS_CLASSES.PAGE_BREAK_BEFORE);
   const pageBreakAfter = cls2(CSS_CLASSES.PAGE_BREAK_AFTER);
   const noPageBreak = cls2(CSS_CLASSES.NO_PAGE_BREAK);
+  const overflowFirstLine = cls2(OVERFLOW_CSS_CLASSES.OVERFLOW_FIRST_LINE);
+  const overflowContinuation = cls2(OVERFLOW_CSS_CLASSES.OVERFLOW_CONTINUATION);
+  const seeNext = cls2(OVERFLOW_CSS_CLASSES.SEE_NEXT);
+  const overflowLabel = cls2(OVERFLOW_CSS_CLASSES.OVERFLOW_LABEL);
+  const overflowContent = cls2(OVERFLOW_CSS_CLASSES.OVERFLOW_CONTENT);
   return `
 /* Paginated document styles */
 ${rootSelector} {
@@ -4278,6 +5445,32 @@ ${rootSelector} .${printPage} {
   flex: 1;
 }
 
+/* Overflow field styles */
+.${overflowFirstLine} {
+  display: inline;
+}
+
+.${overflowContinuation} {
+  margin-top: 1em;
+  padding: 0.5em 0;
+}
+
+.${seeNext} {
+  color: #dc2626;
+  font-weight: 500;
+  margin-left: 0.25em;
+}
+
+.${overflowLabel} {
+  font-weight: 500;
+  margin-bottom: 0.5em;
+}
+
+.${overflowContent} {
+  white-space: pre-wrap;
+  line-height: 1.6;
+}
+
 /* Print styles */
 @media print {
   ${rootSelector} {
@@ -4309,6 +5502,17 @@ ${rootSelector} .${printPage} {
   .${signatureArea} {
     page-break-inside: avoid;
   }
+  
+  /* Overflow field print styles */
+  .${seeNext} {
+    color: #dc2626;
+    -webkit-print-color-adjust: exact;
+    print-color-adjust: exact;
+  }
+  
+  .${overflowContent} {
+    white-space: pre-wrap;
+  }
 }
 
 /* Pagination control classes */
@@ -4348,6 +5552,290 @@ function createRenderConfigFromPaginationConfig(paginationConfig) {
   };
 }
 
+// src/pagination/strategies/smart/smart-pagination-strategy.ts
+var SmartPaginationStrategy = class {
+  /**
+   * Constructor with optional measurement strategy injection
+   * @param measurementStrategy - Custom measurement strategy (defaults to DomMeasurementStrategy)
+   * @requirements 1.3 - Dependency injection for measurement strategy
+   */
+  constructor(measurementStrategy) {
+    /**
+     * Strategy name identifier
+     * @requirements 2.1 - Strategy name
+     */
+    this.name = "smart-pagination";
+    this.measurementStrategy = measurementStrategy ?? new DomMeasurementStrategy();
+  }
+  /**
+   * Check if smart pagination should be applied
+   * @param schema - Print schema with pagination configuration
+   * @returns Whether smart pagination is enabled
+   * @requirements 2.5 - shouldApply checks smartPagination.enabled
+   */
+  shouldApply(schema) {
+    return schema.pagination?.smartPagination?.enabled === true;
+  }
+  /**
+   * Render content using smart pagination
+   * Delegates to existing calculatePageBreaks and renderPaginatedHtml functions
+   * Uses injected measurement strategy for DOM measurement
+   * @param schema - Print schema with pagination configuration
+   * @param data - Form data to render
+   * @param options - Render options
+   * @returns Rendered HTML string
+   * @requirements 1.3, 2.3, 2.4, 3.1, 3.2, 4.1, 4.2, 4.3, 4.4 - Delegate to existing functions with correct measurement data
+   */
+  render(schema, data, options) {
+    const measuredItems = options?.measuredItems ?? this.measurementStrategy.measure(
+      schema,
+      data,
+      {
+        minRowHeight: schema.pagination?.smartPagination?.minRowHeight ?? 8,
+        pageHeight: this.getPageHeight(schema)
+      }
+    );
+    const headerHeight = this.extractHeaderHeight(measuredItems);
+    const footerHeight = this.extractFooterHeight(measuredItems);
+    const signatureHeight = this.extractSignatureHeight(measuredItems);
+    const signatureOnEachPage = schema.pagination?.display?.signatureOnEachPage ?? false;
+    const effectiveFooterHeight = signatureOnEachPage ? footerHeight + signatureHeight : footerHeight;
+    const lastPageExtraHeight = signatureOnEachPage ? 0 : signatureHeight;
+    const contentItems = this.filterContentItems(measuredItems);
+    const pageBreakResult = calculatePageBreaks(contentItems, {
+      pageHeight: this.getPageHeight(schema),
+      headerHeight,
+      footerHeight: effectiveFooterHeight,
+      repeatTableHeaders: schema.pagination?.display?.repeatTableHeaders ?? true,
+      lastPageExtraHeight
+    });
+    const renderOptions2 = options ? {
+      theme: void 0
+      // Will be handled by renderPaginatedHtml
+    } : void 0;
+    return renderPaginatedHtml({
+      schema,
+      data,
+      options: renderOptions2,
+      pageBreakResult,
+      measuredItems,
+      config: {
+        isolated: options?.isolated,
+        showHeaderOnEachPage: schema.pagination?.display?.headerOnEachPage ?? true,
+        showFooterOnEachPage: schema.pagination?.display?.footerOnEachPage ?? true,
+        showSignatureOnEachPage: schema.pagination?.display?.signatureOnEachPage ?? false
+      }
+    });
+  }
+  // ==================== Private Helper Methods ====================
+  /**
+   * Extract header height from measured items
+   * Finds the item with type 'header' and returns its height
+   * @param items - All measured items
+   * @returns Header height in pixels, or 0 if no header item found
+   * @requirements 1.1, 1.2, 1.4 - Extract header height from measured results
+   */
+  extractHeaderHeight(items) {
+    const headerItem = items.find((item) => item.type === "header");
+    return headerItem?.height ?? 0;
+  }
+  /**
+   * Extract footer height from measured items
+   * Only includes 'footer' type items. Signature height is handled separately
+   * based on signatureOnEachPage configuration.
+   * @param items - All measured items
+   * @returns Footer height in pixels, or 0 if no footer items found
+   * @requirements 2.1, 2.2, 2.4 - Extract footer height from measured results
+   */
+  extractFooterHeight(items) {
+    let totalHeight = 0;
+    for (const item of items) {
+      if (item.type === "footer") {
+        totalHeight += item.height;
+      }
+    }
+    return totalHeight;
+  }
+  /**
+   * Extract signature height from measured items
+   * @param items - All measured items
+   * @returns Signature height in pixels, or 0 if no signature items found
+   */
+  extractSignatureHeight(items) {
+    let totalHeight = 0;
+    for (const item of items) {
+      if (item.type === "signature") {
+        totalHeight += item.height;
+      }
+    }
+    return totalHeight;
+  }
+  /**
+   * Filter content items for pagination calculation
+   * Excludes header, footer, and signature items - only keeps section and table items
+   * @param items - All measured items
+   * @returns Array containing only section, table-header, and table-row items
+   * @requirements 4.1, 4.2, 4.3, 4.4 - Filter non-content items from pagination
+   */
+  filterContentItems(items) {
+    return items.filter(
+      (item) => item.type === "section" || item.type === "table-header" || item.type === "table-row"
+    );
+  }
+  /**
+   * Get page height for pagination calculation
+   * @param _schema - Print schema (unused in current implementation)
+   * @returns Page height in pixels
+   */
+  getPageHeight(_schema) {
+    const pageDimensions = PAGE_16K;
+    const mmToPixels = (mm) => mm * 96 / 25.4;
+    const availableHeight = pageDimensions.height - pageDimensions.marginTop - pageDimensions.marginBottom;
+    return mmToPixels(availableHeight);
+  }
+  /**
+   * Estimate measurable items when not provided
+   * Creates basic section items for each schema section
+   *
+   * @deprecated Since v1.4.0. Use DomMeasurementStrategy instead.
+   * This method only provides rough estimates and does not measure actual DOM heights.
+   * The method is no longer used internally - SmartPaginationStrategy now uses
+   * MeasurementStrategy (default: DomMeasurementStrategy) for accurate DOM-based measurement.
+   * Will be removed in v2.0.0.
+   *
+   * @see {@link DomMeasurementStrategy} - For accurate DOM-based measurement
+   * @see {@link MeasurementStrategy} - Interface for custom measurement strategies
+   *
+   * @param schema - Print schema
+   * @returns Estimated measurable items (inaccurate)
+   * @requirements 5.1, 5.2, 5.3, 5.4 - Deprecated method with annotations
+   */
+  estimateItems(schema) {
+    const items = [];
+    const minRowHeight = schema.pagination?.smartPagination?.minRowHeight ?? 8;
+    const mmToPixels = (mm) => mm * 96 / 25.4;
+    const estimatedSectionHeight = mmToPixels(minRowHeight * 3);
+    schema.sections.forEach((section2, index) => {
+      const sectionId = `section-${index}`;
+      items.push({
+        id: sectionId,
+        type: "section",
+        height: estimatedSectionHeight
+      });
+      if (section2.type === "table") {
+        const tableConfig = section2.config;
+        const tableId = `table-${tableConfig.dataField}`;
+        items.push({
+          id: `${tableId}-header`,
+          type: "table-header",
+          height: mmToPixels(minRowHeight),
+          tableId
+        });
+        for (let i = 0; i < 5; i++) {
+          items.push({
+            id: `${tableId}-row-${i}`,
+            type: "table-row",
+            height: mmToPixels(minRowHeight),
+            tableId,
+            dataIndex: i
+          });
+        }
+      }
+    });
+    return items;
+  }
+};
+
+// src/pagination/strategies/overflow/overflow-pagination-strategy.ts
+var OverflowPaginationStrategy = class {
+  constructor() {
+    /**
+     * Strategy name identifier
+     * @requirements 3.1 - Strategy name
+     */
+    this.name = "overflow-pagination";
+  }
+  /**
+   * Check if overflow pagination should be applied
+   * @param schema - Print schema with pagination configuration
+   * @returns Whether overflow pagination is configured
+   * @requirements 3.5 - shouldApply checks pagination.overflow.fields has items
+   */
+  shouldApply(schema) {
+    const fields = schema.pagination?.overflow?.fields;
+    return Array.isArray(fields) && fields.length > 0;
+  }
+  /**
+   * Render content using overflow pagination
+   * Delegates to existing renderPaginatedHtml with overflow configuration
+   * @param schema - Print schema with pagination configuration
+   * @param data - Form data to render
+   * @param options - Render options
+   * @returns Rendered HTML string
+   * @requirements 3.4 - Delegate to existing renderPaginatedHtml with overflow config
+   */
+  render(schema, data, options) {
+    const pageBreakResult = this.createSinglePageResult();
+    const overflowTextConfig = this.mergeOverflowTextConfig(options?.textConfig);
+    const renderOptions2 = options ? {
+      theme: void 0
+      // Will be handled by renderPaginatedHtml
+    } : void 0;
+    return renderPaginatedHtml({
+      schema,
+      data,
+      options: renderOptions2,
+      pageBreakResult,
+      measuredItems: [],
+      // Overflow pagination doesn't use measured items
+      config: {
+        isolated: options?.isolated,
+        showHeaderOnEachPage: schema.pagination?.display?.headerOnEachPage ?? true,
+        showFooterOnEachPage: schema.pagination?.display?.footerOnEachPage ?? true,
+        showSignatureOnEachPage: schema.pagination?.display?.signatureOnEachPage ?? false,
+        overflowText: overflowTextConfig
+      }
+    });
+  }
+  // ==================== Private Helper Methods ====================
+  /**
+   * Create single page result for overflow pagination
+   * Overflow pagination uses a single logical page, with continuation pages handled separately
+   * @returns Single page break result
+   */
+  createSinglePageResult() {
+    return {
+      pages: [{
+        pageNumber: 1,
+        isContinuation: false,
+        items: [],
+        // Items will be handled by renderAllSections fallback
+        repeatedHeaders: []
+      }],
+      totalPages: 1
+    };
+  }
+  /**
+   * Merge overflow text configuration with defaults
+   * @param config - Partial overflow text configuration
+   * @returns Complete overflow text configuration
+   */
+  mergeOverflowTextConfig(config) {
+    return {
+      ...DEFAULT_OVERFLOW_TEXT,
+      ...config
+    };
+  }
+};
+
+// src/pagination/strategies/index.ts
+function createDefaultPaginationContext() {
+  return new PaginationContext([
+    new SmartPaginationStrategy(),
+    new OverflowPaginationStrategy()
+  ]);
+}
+
 // src/pagination/index.ts
 function usePrintPagination(dimensions = PAGE_16K) {
   const usableHeight = calculateUsableHeight(dimensions);
@@ -4447,7 +5935,9 @@ exports.CSS_NAMESPACE = CSS_NAMESPACE;
 exports.ContainerSection = ContainerSection;
 exports.DEFAULT_BASE_UNIT = DEFAULT_BASE_UNIT;
 exports.DEFAULT_DPI = DEFAULT_DPI;
+exports.DEFAULT_OVERFLOW_TEXT = DEFAULT_OVERFLOW_TEXT;
 exports.DEFAULT_PAGINATED_RENDER_CONFIG = DEFAULT_PAGINATED_RENDER_CONFIG;
+exports.ENGLISH_OVERFLOW_TEXT = ENGLISH_OVERFLOW_TEXT;
 exports.FONT_FAMILY = FONT_FAMILY;
 exports.FONT_STYLE = FONT_STYLE;
 exports.FONT_WEIGHT = FONT_WEIGHT;
@@ -4459,18 +5949,24 @@ exports.HtmlBuilder = HtmlBuilder;
 exports.HtmlElementBuilder = HtmlElementBuilder;
 exports.ISOLATION_ROOT_CLASS = ISOLATION_ROOT_CLASS;
 exports.LeafSection = LeafSection;
+exports.MEASURABLE_ITEM_TYPES = MEASURABLE_ITEM_TYPES;
 exports.MM_PER_INCH = MM_PER_INCH;
 exports.MeasureVisitor = MeasureVisitor;
+exports.OVERFLOW_CSS_CLASSES = OVERFLOW_CSS_CLASSES;
+exports.OverflowPaginationStrategy = OverflowPaginationStrategy;
 exports.PAGE_16K = PAGE_16K;
 exports.PAGE_A4 = PAGE_A4;
 exports.PAGE_A5 = PAGE_A5;
 exports.PAGE_PRESETS = PAGE_PRESETS;
+exports.PAGINATION_DEFAULTS = PAGINATION_DEFAULTS;
 exports.PageBuilder = PageBuilder;
 exports.PaginatedPageRenderer = PaginatedPageRenderer;
+exports.PaginationContext = PaginationContext;
 exports.SIZE_MULTIPLIERS = SIZE_MULTIPLIERS;
 exports.SectionRendererFactory = SectionRendererFactory;
 exports.SectionTreeTraverser = SectionTreeTraverser;
 exports.SinglePageRenderer = SinglePageRenderer;
+exports.SmartPaginationStrategy = SmartPaginationStrategy;
 exports.StrategyContext = StrategyContext;
 exports.TableBuilder = TableBuilder;
 exports.UNIT_CONVERSIONS = UNIT_CONVERSIONS;
@@ -4485,6 +5981,7 @@ exports.calculateUsableWidthMm = calculateUsableWidthMm;
 exports.clamp = clamp;
 exports.convertFromMm = convertFromMm;
 exports.convertToMm = convertToMm;
+exports.createDefaultPaginationContext = createDefaultPaginationContext;
 exports.createDefaultStrategyContext = createDefaultStrategyContext;
 exports.createFormDataTraverser = createFormDataTraverser;
 exports.createFormatVisitor = createFormatVisitor;
@@ -4512,6 +6009,8 @@ exports.each = each;
 exports.escapeAttr = escapeAttr;
 exports.escapeHtml = escapeHtml;
 exports.extractWatermarkOptions = extractWatermarkOptions;
+exports.findOverflowFieldCell = findOverflowFieldCell;
+exports.findOverflowFieldLabel = findOverflowFieldLabel;
 exports.findTableHeader = findTableHeader;
 exports.footer = footer2;
 exports.formatBoolean = formatBoolean;
@@ -4530,6 +6029,8 @@ exports.getFontCss = getFontCss;
 exports.getFontDataUrl = getFontDataUrl;
 exports.getNamespacedClass = getNamespacedClass;
 exports.getOverflowFieldConfig = getOverflowFieldConfig;
+exports.getOverflowFieldNames = getOverflowFieldNames;
+exports.getOverflowFieldsFromConfig = getOverflowFieldsFromConfig;
 exports.getOverflowFirstLine = getOverflowFirstLine;
 exports.getOverflowRest = getOverflowRest;
 exports.getPageContentHeight = getPageContentHeight;
@@ -4538,13 +6039,16 @@ exports.getPageStyles = getPageStyles;
 exports.getSectionRenderer = getSectionRenderer;
 exports.h = h;
 exports.h1 = h12;
+exports.hasAnyContinuationContent = hasAnyContinuationContent;
 exports.hasAnyOverflowContent = hasAnyOverflowContent;
 exports.hasOverflowContent = hasOverflowContent;
 exports.header = header2;
 exports.isChecked = isChecked;
 exports.isFontLoaded = isFontLoaded;
 exports.isOverflowField = isOverflowField;
+exports.isOverflowSection = isOverflowSection;
 exports.main = main2;
+exports.mergeOverflowTextConfig = mergeOverflowTextConfig;
 exports.mergePdfs = mergePdfs;
 exports.mergeStyles = mergeStyles;
 exports.mergeTheme = mergeTheme;
@@ -4558,6 +6062,9 @@ exports.processOverflowFields = processOverflowFields;
 exports.ptToMm = ptToMm;
 exports.pxToMm = pxToMm;
 exports.registerSectionRenderer = registerSectionRenderer;
+exports.renderOverflowContinuation = renderOverflowContinuation;
+exports.renderOverflowContinuationPage = renderOverflowContinuationPage;
+exports.renderOverflowFirstLine = renderOverflowFirstLine;
 exports.renderPaginatedHtml = renderPaginatedHtml;
 exports.renderPaginatedHtmlSimple = renderPaginatedHtmlSimple;
 exports.renderSectionTree = renderSectionTree;
@@ -4573,8 +6080,8 @@ exports.table = table2;
 exports.tbody = tbody2;
 exports.td = td2;
 exports.th = th2;
-exports.thead = thead2;
-exports.tr = tr2;
+exports.thead = thead3;
+exports.tr = tr3;
 exports.usePrintPagination = usePrintPagination;
 exports.validatePageBreakResult = validatePageBreakResult;
 exports.waitForFonts = waitForFonts;