medical-form-printer 0.2.0 → 0.3.0

package/dist/node.js

@@ -561,6 +561,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) {
@@ -806,6 +807,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};
@@ -1088,6 +1090,7 @@ function createInlineStyles(theme = defaultTheme) {
     // Footer
     printFooter: {
       marginTop: "10mm",
+      minHeight: theme.fontSize.small,
       display: "flex",
       justifyContent: "space-between",
       fontSize: theme.fontSize.small,
@@ -1353,6 +1356,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");
@@ -1484,9 +1491,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>`;
 }
 
@@ -1551,14 +1560,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, {
@@ -1567,26 +1793,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) {
@@ -1851,7 +2077,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}
@@ -1874,7 +2100,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",
@@ -1926,7 +2152,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}
@@ -1961,8 +2187,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),
@@ -2597,9 +2828,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");
@@ -3622,6 +3853,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 */
@@ -3637,8 +3870,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 = {
@@ -3710,7 +3970,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
@@ -3741,7 +4001,8 @@ function calculatePageBreaks(items, options) {
     pageHeight,
     headerHeight = 0,
     footerHeight = 0,
-    repeatTableHeaders = true
+    repeatTableHeaders = true,
+    lastPageExtraHeight = 0
   } = options;
   if (items.length === 0) {
     return {
@@ -3762,6 +4023,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) {
@@ -3787,6 +4052,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;
@@ -3850,7 +4118,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);
@@ -3920,6 +4188,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
@@ -3956,7 +4975,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 {
@@ -4078,15 +5098,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 "";
@@ -4094,34 +5123,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();
@@ -4151,6 +5262,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) {
@@ -4198,12 +5310,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 = {
@@ -4211,14 +5341,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);
@@ -4237,6 +5399,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} {
@@ -4276,6 +5443,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} {
@@ -4307,6 +5500,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 */
@@ -4346,6 +5550,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);
@@ -4440,6 +5928,6 @@ async function mergePdfs(documents, options, pdfOptions) {
   return Buffer.from(mergedBuffer);
 }
 
-export { AbstractPageRenderer, CSS_NAMESPACE, ContainerSection, DEFAULT_BASE_UNIT, DEFAULT_DPI, DEFAULT_PAGINATED_RENDER_CONFIG, FONT_FAMILY, FONT_STYLE, FONT_WEIGHT, FontLoadError, FormDataTraverser, FormatVisitor, FormatterFactory, HtmlBuilder, HtmlElementBuilder, ISOLATION_ROOT_CLASS, LeafSection, MM_PER_INCH, MeasureVisitor, PAGE_16K, PAGE_A4, PAGE_A5, PAGE_PRESETS, PageBuilder, PaginatedPageRenderer, SIZE_MULTIPLIERS, SectionRendererFactory, SectionTreeTraverser, SinglePageRenderer, StrategyContext, TableBuilder, UNIT_CONVERSIONS, ValidationVisitor, buildTableHeaderMap, calculatePageBreaks, calculatePageBreaksSimple, calculateUsableHeight, calculateUsableHeightMm, calculateUsableWidth, calculateUsableWidthMm, clamp, convertFromMm, convertToMm, createDefaultStrategyContext, createFormDataTraverser, createFormatVisitor, createInlineStyles, createMeasureVisitor, createOverflowFieldConfig, createOverflowFieldConfigs, createPageDimensions, createPaginatedPageRenderer, createRenderConfigFromPaginationConfig, createScaledTheme, createSectionComponent, createSectionTree, createSinglePageRenderer, createThemeWithBaseUnit, createValidationVisitor, defaultColors, defaultFonts, defaultInlineStyles, defaultMultipliers, defaultScaledConfig, defaultTheme, div2 as div, each, escapeAttr, escapeHtml, extractWatermarkOptions, findTableHeader, footer2 as footer, formatBoolean, formatDate, formatNumber, formatPadding, formatSize, formatValue, fragment, generateCss, generateIsolatedCss, generatePaginationCss, getDefaultFormatterFactory, getDefaultSectionRendererFactory, getFontCss, getFontDataUrl, getNamespacedClass, getOverflowFieldConfig, getOverflowFirstLine, getOverflowRest, getPageContentHeight, getPageDimensions, getPageStyles, getSectionRenderer, h, h12 as h1, hasAnyOverflowContent, hasOverflowContent, header2 as header, isChecked, isFontLoaded, isOverflowField, main2 as main, mergePdfs, mergeStyles, mergeTheme, mmToPt, mmToPx, namespaceClass, namespaceClasses, normalizeOpacity, p2 as p, processOverflowFields, ptToMm, pxToMm, registerSectionRenderer, renderPaginatedHtml, renderPaginatedHtmlSimple, renderSectionTree, renderToHtml, renderToIsolatedFragment, renderToIsolatedHtml, renderToPdf, renderWatermarkHtml, scaleValue, span2 as span, styleToString, table2 as table, tbody2 as tbody, td2 as td, th2 as th, thead2 as thead, tr2 as tr, usePrintPagination, validatePageBreakResult, waitForFonts, when };
+export { AbstractPageRenderer, CSS_NAMESPACE, ContainerSection, DEFAULT_BASE_UNIT, DEFAULT_DPI, DEFAULT_OVERFLOW_TEXT, DEFAULT_PAGINATED_RENDER_CONFIG, ENGLISH_OVERFLOW_TEXT, FONT_FAMILY, FONT_STYLE, FONT_WEIGHT, FontLoadError, FormDataTraverser, FormatVisitor, FormatterFactory, HtmlBuilder, HtmlElementBuilder, ISOLATION_ROOT_CLASS, LeafSection, MEASURABLE_ITEM_TYPES, MM_PER_INCH, MeasureVisitor, OVERFLOW_CSS_CLASSES, OverflowPaginationStrategy, PAGE_16K, PAGE_A4, PAGE_A5, PAGE_PRESETS, PAGINATION_DEFAULTS, PageBuilder, PaginatedPageRenderer, PaginationContext, SIZE_MULTIPLIERS, SectionRendererFactory, SectionTreeTraverser, SinglePageRenderer, SmartPaginationStrategy, StrategyContext, TableBuilder, UNIT_CONVERSIONS, ValidationVisitor, buildTableHeaderMap, calculatePageBreaks, calculatePageBreaksSimple, calculateUsableHeight, calculateUsableHeightMm, calculateUsableWidth, calculateUsableWidthMm, clamp, convertFromMm, convertToMm, createDefaultPaginationContext, createDefaultStrategyContext, createFormDataTraverser, createFormatVisitor, createInlineStyles, createMeasureVisitor, createOverflowFieldConfig, createOverflowFieldConfigs, createPageDimensions, createPaginatedPageRenderer, createRenderConfigFromPaginationConfig, createScaledTheme, createSectionComponent, createSectionTree, createSinglePageRenderer, createThemeWithBaseUnit, createValidationVisitor, defaultColors, defaultFonts, defaultInlineStyles, defaultMultipliers, defaultScaledConfig, defaultTheme, div2 as div, each, escapeAttr, escapeHtml, extractWatermarkOptions, findOverflowFieldCell, findOverflowFieldLabel, findTableHeader, footer2 as footer, formatBoolean, formatDate, formatNumber, formatPadding, formatSize, formatValue, fragment, generateCss, generateIsolatedCss, generatePaginationCss, getDefaultFormatterFactory, getDefaultSectionRendererFactory, getFontCss, getFontDataUrl, getNamespacedClass, getOverflowFieldConfig, getOverflowFieldNames, getOverflowFieldsFromConfig, getOverflowFirstLine, getOverflowRest, getPageContentHeight, getPageDimensions, getPageStyles, getSectionRenderer, h, h12 as h1, hasAnyContinuationContent, hasAnyOverflowContent, hasOverflowContent, header2 as header, isChecked, isFontLoaded, isOverflowField, isOverflowSection, main2 as main, mergeOverflowTextConfig, mergePdfs, mergeStyles, mergeTheme, mmToPt, mmToPx, namespaceClass, namespaceClasses, normalizeOpacity, p2 as p, processOverflowFields, ptToMm, pxToMm, registerSectionRenderer, renderOverflowContinuation, renderOverflowContinuationPage, renderOverflowFirstLine, renderPaginatedHtml, renderPaginatedHtmlSimple, renderSectionTree, renderToHtml, renderToIsolatedFragment, renderToIsolatedHtml, renderToPdf, renderWatermarkHtml, scaleValue, span2 as span, styleToString, table2 as table, tbody2 as tbody, td2 as td, th2 as th, thead3 as thead, tr3 as tr, usePrintPagination, validatePageBreakResult, waitForFonts, when };
 //# sourceMappingURL=node.js.map
 //# sourceMappingURL=node.js.map