pdfmake 0.3.4 → 0.3.5

package/js/SVGMeasure.js

@@ -28,8 +28,10 @@ const parseSVG = svgString => {
   let doc;
   try {
     doc = new _xmldoc.XmlDocument(svgString);
-  } catch (err) {
-    throw new Error('Invalid svg document (' + err + ')');
+  } catch (error) {
+    throw new Error('Invalid svg document (' + error + ')', {
+      cause: error
+    });
   }
   if (doc.name !== "svg") {
     throw new Error('Invalid svg document (expected <svg>)');

package/js/TableProcessor.js

@@ -20,7 +20,7 @@ class TableProcessor {
     const prepareRowSpanData = () => {
       let rsd = [];
       let x = 0;
-      let lastWidth = 0;
+      let lastWidth;
       rsd.push({
         left: 0,
         rowSpan: 0
@@ -250,7 +250,6 @@ class TableProcessor {
               lineColor: borderColor
             }, false, (0, _variableType.isNumber)(overrideY), null, forcePage);
             currentLine = null;
-            borderColor = null;
             cellAbove = null;
             currentCell = null;
             rowCellAbove = null;
@@ -325,9 +324,6 @@ class TableProcessor {
       dash: dash,
       lineColor: borderColor
     }, false, true);
-    cellBefore = null;
-    currentCell = null;
-    borderColor = null;
   }
   endTable(writer) {
     if (this.cleanUpRepeatables) {

package/js/URLResolver.js

@@ -12,7 +12,9 @@ async function fetchUrl(url, headers = {}) {
     }
     return await response.arrayBuffer();
   } catch (error) {
-    throw new Error(`Network request failed (url: "${url}", error: ${error.message})`);
+    throw new Error(`Network request failed (url: "${url}", error: ${error.message})`, {
+      cause: error
+    });
   }
 }
 class URLResolver {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdfmake",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Client/server side PDF printing in pure JavaScript",
   "main": "js/index.js",
   "esnext": "src/index.js",
@@ -18,15 +18,15 @@
     "@babel/core": "^7.29.0",
     "@babel/plugin-transform-modules-commonjs": "^7.28.6",
     "@babel/preset-env": "^7.29.0",
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^10.0.1",
     "assert": "^2.1.0",
     "babel-loader": "^10.0.0",
     "brfs": "^2.0.2",
     "browserify-zlib": "^0.2.0",
     "buffer": "^6.0.3",
     "core-js": "^3.48.0",
-    "eslint": "^9.39.2",
-    "eslint-plugin-jsdoc": "^62.5.4",
+    "eslint": "^10.0.1",
+    "eslint-plugin-jsdoc": "^62.7.0",
     "expose-loader": "^5.0.1",
     "file-saver": "^2.0.5",
     "globals": "^17.3.0",
@@ -43,7 +43,7 @@
     "terser-webpack-plugin": "^5.3.16",
     "transform-loader": "^0.2.4",
     "util": "^0.12.5",
-    "webpack": "^5.105.0",
+    "webpack": "^5.105.2",
     "webpack-cli": "^6.0.1"
   },
   "engines": {

package/src/DocMeasure.js

@@ -218,6 +218,10 @@ class DocMeasure {
 					{ text: item._textNodeRef.text, linkToDestination: destination, alignment: 'left', style: lineStyle, margin: lineMargin },
 					{ text: '00000', linkToDestination: destination, alignment: 'right', _tocItemRef: item._nodeRef, style: lineNumberStyle, margin: [0, lineMargin[1], 0, lineMargin[3]] }
 				]);
+
+				if (node.toc.outlines) {
+					item._textNodeRef.outline = item._textNodeRef.outline || true;
+				}
 			}
 
 			node.toc._table = {

package/src/DocumentContext.js

@@ -19,7 +19,7 @@ class DocumentContext extends EventEmitter {
 		this.backgroundLength = [];
 	}
 
-	beginColumnGroup(marginXTopParent, bottomByPage = {}) {
+	beginColumnGroup(marginXTopParent, bottomByPage = {}, snakingColumns = false, columnGap = 0, columnWidths = null) {
 		this.snapshots.push({
 			x: this.x,
 			y: this.y,
@@ -34,7 +34,10 @@ class DocumentContext extends EventEmitter {
 				availableWidth: this.availableWidth,
 				page: this.page
 			},
-			lastColumnWidth: this.lastColumnWidth
+			lastColumnWidth: this.lastColumnWidth,
+			snakingColumns: snakingColumns,
+			gap: columnGap,
+			columnWidths: columnWidths
 		});
 
 		this.lastColumnWidth = 0;
@@ -45,20 +48,74 @@ class DocumentContext extends EventEmitter {
 
 	updateBottomByPage() {
 		const lastSnapshot = this.snapshots[this.snapshots.length - 1];
+		if (!lastSnapshot) {
+			return;
+		}
 		const lastPage = this.page;
 		let previousBottom = -Number.MIN_VALUE;
-		if (lastSnapshot.bottomByPage[lastPage]) {
+		if (lastSnapshot.bottomByPage && lastSnapshot.bottomByPage[lastPage]) {
 			previousBottom = lastSnapshot.bottomByPage[lastPage];
 		}
-		lastSnapshot.bottomByPage[lastPage] = Math.max(previousBottom, this.y);
+		if (lastSnapshot.bottomByPage) {
+			lastSnapshot.bottomByPage[lastPage] = Math.max(previousBottom, this.y);
+		}
 	}
 
 	resetMarginXTopParent() {
 		this.marginXTopParent = null;
 	}
 
+	/**
+	 * Find the most recent (deepest) snaking column group snapshot.
+	 * @returns {object|null}
+	 */
+	getSnakingSnapshot() {
+		for (let i = this.snapshots.length - 1; i >= 0; i--) {
+			if (this.snapshots[i].snakingColumns) {
+				return this.snapshots[i];
+			}
+		}
+		return null;
+	}
+
+	inSnakingColumns() {
+		return !!this.getSnakingSnapshot();
+	}
+
+	/**
+	 * Check if we're inside a nested non-snaking column group (e.g., a table row)
+	 * within an outer snaking column group. This is used to prevent snaking-specific
+	 * breaks inside table cells — the table's own page break mechanism should handle
+	 * row breaks, and column breaks should happen between rows.
+	 * @returns {boolean}
+	 */
+	isInNestedNonSnakingGroup() {
+		for (let i = this.snapshots.length - 1; i >= 0; i--) {
+			let snap = this.snapshots[i];
+			if (snap.snakingColumns) {
+				return false; // Reached snaking snapshot without finding inner group
+			}
+			if (!snap.overflowed) {
+				return true; // Found non-snaking, non-overflowed inner group
+			}
+		}
+		return false;
+	}
+
 	beginColumn(width, offset, endingCell) {
+		// Find the correct snapshot for this column group.
+		// When a snaking column break (moveToNextColumn) occurs during inner column
+		// processing, overflowed snapshots may sit above this column group's snapshot.
+		// We need to skip past those to find the one from our beginColumnGroup call.
 		let saved = this.snapshots[this.snapshots.length - 1];
+		if (saved && saved.overflowed) {
+			for (let i = this.snapshots.length - 1; i >= 0; i--) {
+				if (!this.snapshots[i].overflowed) {
+					saved = this.snapshots[i];
+					break;
+				}
+			}
+		}
 
 		this.calculateBottomMost(saved, endingCell);
 
@@ -102,6 +159,48 @@ class DocumentContext extends EventEmitter {
 	completeColumnGroup(height, endingCell) {
 		let saved = this.snapshots.pop();
 
+		// Track the maximum bottom position across all columns (including overflowed).
+		// Critical for snaking: content after columns must appear below the tallest column.
+		let maxBottomY = this.y;
+		let maxBottomPage = this.page;
+		let maxBottomAvailableHeight = this.availableHeight;
+
+		// Pop overflowed snapshots created by moveToNextColumn (snaking columns).
+		// Merge their bottomMost values to find the true maximum.
+		while (saved && saved.overflowed) {
+			let bm = bottomMostContext(
+				{
+					page: maxBottomPage,
+					y: maxBottomY,
+					availableHeight: maxBottomAvailableHeight
+				},
+				saved.bottomMost || {}
+			);
+			maxBottomPage = bm.page;
+			maxBottomY = bm.y;
+			maxBottomAvailableHeight = bm.availableHeight;
+			saved = this.snapshots.pop();
+		}
+
+		if (!saved) {
+			return {};
+		}
+
+		// Apply the max bottom from all overflowed columns to this base snapshot
+		if (
+			maxBottomPage > saved.bottomMost.page ||
+			(maxBottomPage === saved.bottomMost.page &&
+				maxBottomY > saved.bottomMost.y)
+		) {
+			saved.bottomMost = {
+				x: saved.x,
+				y: maxBottomY,
+				page: maxBottomPage,
+				availableHeight: maxBottomAvailableHeight,
+				availableWidth: saved.availableWidth
+			};
+		}
+
 		this.calculateBottomMost(saved, endingCell);
 
 		this.x = saved.x;
@@ -125,16 +224,152 @@ class DocumentContext extends EventEmitter {
 			this.availableHeight -= (y - saved.bottomMost.y);
 		}
 
-		 if (height && (saved.bottomMost.y - saved.y < height)) {
-		 	this.height = height;
-		 } else {
+		if (height && (saved.bottomMost.y - saved.y < height)) {
+			this.height = height;
+		} else {
 			this.height = saved.bottomMost.y - saved.y;
-		 }
+		}
 
 		this.lastColumnWidth = saved.lastColumnWidth;
 		return saved.bottomByPage;
 	}
 
+	/**
+	 * Move to the next column in a column group (snaking columns).
+	 * Creates an overflowed snapshot to track that we've moved to the next column.
+	 * @returns {object} Position info for the new column
+	 */
+	moveToNextColumn() {
+		let prevY = this.y;
+		let snakingSnapshot = this.getSnakingSnapshot();
+
+		if (!snakingSnapshot) {
+			return { prevY: prevY, y: this.y };
+		}
+
+		// Update snaking snapshot's bottomMost with current position BEFORE resetting.
+		// This captures where content reached in the current column (overflow point).
+		this.calculateBottomMost(snakingSnapshot, null);
+
+		// Calculate new X position: move right by current column width + gap
+		let overflowCount = 0;
+		for (let i = this.snapshots.length - 1; i >= 0; i--) {
+			if (this.snapshots[i].overflowed) {
+				overflowCount++;
+			} else {
+				break;
+			}
+		}
+
+		let currentColumnWidth = (snakingSnapshot.columnWidths && snakingSnapshot.columnWidths[overflowCount]) || this.lastColumnWidth || this.availableWidth;
+		let nextColumnWidth = (snakingSnapshot.columnWidths && snakingSnapshot.columnWidths[overflowCount + 1]) || currentColumnWidth;
+
+		this.lastColumnWidth = nextColumnWidth;
+
+		let newX = this.x + (currentColumnWidth || 0) + (snakingSnapshot.gap || 0);
+		let newY = snakingSnapshot.y;
+
+		this.snapshots.push({
+			x: newX,
+			y: newY,
+			availableHeight: snakingSnapshot.availableHeight,
+			availableWidth: nextColumnWidth,
+			page: this.page,
+			overflowed: true,
+			bottomMost: {
+				x: newX,
+				y: newY,
+				availableHeight: snakingSnapshot.availableHeight,
+				availableWidth: nextColumnWidth,
+				page: this.page
+			},
+			lastColumnWidth: nextColumnWidth,
+			snakingColumns: true,
+			gap: snakingSnapshot.gap,
+			columnWidths: snakingSnapshot.columnWidths
+		});
+
+		this.x = newX;
+		this.y = newY;
+		this.availableHeight = snakingSnapshot.availableHeight;
+		this.availableWidth = nextColumnWidth;
+
+		// Sync non-overflowed inner snapshots (e.g. inner column groups for
+		// product/price rows) with the new snaking column position.
+		// Without this, inner beginColumn would read stale y/page/x values.
+		for (let i = this.snapshots.length - 2; i >= 0; i--) {
+			let snapshot = this.snapshots[i];
+			if (snapshot.overflowed || snapshot.snakingColumns) {
+				break; // Stop at first overflowed or snaking snapshot
+			}
+			snapshot.x = newX;
+			snapshot.y = newY;
+			snapshot.page = this.page;
+			snapshot.availableHeight = snakingSnapshot.availableHeight;
+			if (snapshot.bottomMost) {
+				snapshot.bottomMost.x = newX;
+				snapshot.bottomMost.y = newY;
+				snapshot.bottomMost.page = this.page;
+				snapshot.bottomMost.availableHeight = snakingSnapshot.availableHeight;
+			}
+		}
+
+		return { prevY: prevY, y: this.y };
+	}
+
+	/**
+	 * Reset snaking column state when moving to a new page.
+	 * Clears overflowed snapshots, resets X to left margin, sets width to first column,
+	 * and syncs all snapshots to new page coordinates.
+	 */
+	resetSnakingColumnsForNewPage() {
+		let snakingSnapshot = this.getSnakingSnapshot();
+		if (!snakingSnapshot) {
+			return;
+		}
+
+		let pageTopY = this.pageMargins.top;
+		let pageInnerHeight = this.getCurrentPage().pageSize.height - this.pageMargins.top - this.pageMargins.bottom;
+
+		// When moving to new page, start at first column.
+		// Reset width to FIRST column width, not last column from previous page.
+		let firstColumnWidth = snakingSnapshot.columnWidths ? snakingSnapshot.columnWidths[0] : (this.lastColumnWidth || this.availableWidth);
+
+		// Clean up overflowed snapshots
+		while (this.snapshots.length > 1 && this.snapshots[this.snapshots.length - 1].overflowed) {
+			this.snapshots.pop();
+		}
+
+		// Reset X to start of first column (left margin)
+		if (this.marginXTopParent) {
+			this.x = this.pageMargins.left + this.marginXTopParent[0];
+		} else {
+			this.x = this.pageMargins.left;
+		}
+		this.availableWidth = firstColumnWidth;
+		this.lastColumnWidth = firstColumnWidth;
+
+		// Sync all snapshots to new page state.
+		// When page break occurs within snaking columns, update ALL snapshots
+		// (not just snaking column snapshots) to reflect new page coordinates.
+		// This ensures nested structures (like inner product/price columns)
+		// don't retain stale values that would cause layout corruption.
+		for (let i = 0; i < this.snapshots.length; i++) {
+			let snapshot = this.snapshots[i];
+			let isSnakingSnapshot = !!snapshot.snakingColumns;
+			snapshot.x = this.x;
+			snapshot.y = isSnakingSnapshot ? pageTopY : this.y;
+			snapshot.availableHeight = isSnakingSnapshot ? pageInnerHeight : this.availableHeight;
+			snapshot.page = this.page;
+			if (snapshot.bottomMost) {
+				snapshot.bottomMost.x = this.x;
+				snapshot.bottomMost.y = isSnakingSnapshot ? pageTopY : this.y;
+				snapshot.bottomMost.availableHeight = isSnakingSnapshot ? pageInnerHeight : this.availableHeight;
+				snapshot.bottomMost.page = this.page;
+			}
+		}
+	}
+
 	addMargin(left, right) {
 		this.x += left;
 		this.availableWidth -= left + (right || 0);
@@ -318,7 +553,6 @@ const getPageSize = (currentPage, newPageOrientation) => {
 			height: currentPage.pageSize.height
 		};
 	}
-
 };
 
 

package/src/LayoutBuilder.js

@@ -420,7 +420,11 @@ class LayoutBuilder {
 				if (availableHeight - margin[1] < 0) {
 					// Consume the whole available space
 					this.writer.context().moveDown(availableHeight);
-					this.writer.moveToNextPage(node.pageOrientation);
+					if (this.writer.context().inSnakingColumns() && !this.writer.context().isInNestedNonSnakingGroup()) {
+						this.snakingAwarePageBreak(node.pageOrientation);
+					} else {
+						this.writer.moveToNextPage(node.pageOrientation);
+					}
 					/**
 					 * TODO - Something to consider:
 					 * Right now the node starts at the top of next page (after header)
@@ -442,7 +446,11 @@ class LayoutBuilder {
 				// Necessary for nodes inside tables
 				if (availableHeight - margin[3] < 0) {
 					this.writer.context().moveDown(availableHeight);
-					this.writer.moveToNextPage(node.pageOrientation);
+					if (this.writer.context().inSnakingColumns() && !this.writer.context().isInNestedNonSnakingGroup()) {
+						this.snakingAwarePageBreak(node.pageOrientation);
+					} else {
+						this.writer.moveToNextPage(node.pageOrientation);
+					}
 					/**
 					 * TODO - Something to consider:
 					 * Right now next node starts at the top of next page (after header)
@@ -553,6 +561,37 @@ class LayoutBuilder {
 		}
 	}
 
+	/**
+	 * Helper for page breaks that respects snaking column context.
+	 * When in snaking columns, first tries moving to next column.
+	 * If no columns available, moves to next page and resets x to left margin.
+	 * @param {string} pageOrientation - Optional page orientation for the new page
+	 */
+	snakingAwarePageBreak(pageOrientation) {
+		let ctx = this.writer.context();
+		let snakingSnapshot = ctx.getSnakingSnapshot();
+		if (!snakingSnapshot) {
+			return;
+		}
+
+		// Try flowing to next column first
+		if (this.writer.canMoveToNextColumn()) {
+			this.writer.moveToNextColumn();
+			return;
+		}
+
+		// No more columns available, move to new page
+		this.writer.moveToNextPage(pageOrientation);
+
+		// Reset snaking column state for the new page
+		// Save lastColumnWidth before reset — if we're inside a nested
+		// column group (e.g. product/price row), the reset would overwrite
+		// it with the snaking column width, corrupting inner column layout.
+		let savedLastColumnWidth = ctx.lastColumnWidth;
+		ctx.resetSnakingColumnsForNewPage();
+		ctx.lastColumnWidth = savedLastColumnWidth;
+	}
+
 	// vertical container
 	processVerticalContainer(node) {
 		node.stack.forEach(item => {
@@ -648,7 +687,8 @@ class LayoutBuilder {
 			marginX: columnNode._margin ? [columnNode._margin[0], columnNode._margin[2]] : [0, 0],
 			cells: columns,
 			widths: columns,
-			gaps
+			gaps,
+			snakingColumns: columnNode.snakingColumns
 		});
 		addAll(columnNode.positions, result.positions);
 		this.nestedLevel--;
@@ -838,7 +878,7 @@ class LayoutBuilder {
 		return null;
 	}
 
-	processRow({ marginX = [0, 0], dontBreakRows = false, rowsWithoutPageBreak = 0, cells, widths, gaps, tableNode, tableBody, rowIndex, height }) {
+	processRow({ marginX = [0, 0], dontBreakRows = false, rowsWithoutPageBreak = 0, cells, widths, gaps, tableNode, tableBody, rowIndex, height, snakingColumns = false }) {
 		const isUnbreakableRow = dontBreakRows || rowIndex <= rowsWithoutPageBreak - 1;
 		let pageBreaks = [];
 		let pageBreaksByRowSpan = [];
@@ -855,8 +895,19 @@ class LayoutBuilder {
 		// Use the marginX if we are in a top level table/column (not nested)
 		const marginXParent = this.nestedLevel === 1 ? marginX : null;
 		const _bottomByPage = tableNode ? tableNode._bottomByPage : null;
-		this.writer.context().beginColumnGroup(marginXParent, _bottomByPage);
-
+		// Pass column gap and widths to context snapshot for snaking columns
+		// to advance correctly and reset to first-column width on new pages.
+		const columnGapForGroup = (gaps && gaps.length > 1) ? gaps[1] : 0;
+		const columnWidthsForContext = widths.map(w => w._calcWidth);
+		this.writer.context().beginColumnGroup(marginXParent, _bottomByPage,
+			snakingColumns, columnGapForGroup, columnWidthsForContext);
+
+		// IMPORTANT: We iterate ALL columns even when snakingColumns is enabled.
+		// This is intentional — beginColumn() must be called for each column to set up
+		// proper geometry (widths, offsets) and rowspan/colspan tracking. The
+		// completeColumnGroup() call at the end depends on this bookkeeping to compute
+		// heights correctly. Content processing is skipped for columns > 0 via
+		// skipForSnaking below, but the column structure must still be established.
 		for (let i = 0, l = cells.length; i < l; i++) {
 			let cell = cells[i];
 			let cellIndexBegin = i;
@@ -913,7 +964,13 @@ class LayoutBuilder {
 			// We pass the endingSpanCell reference to store the context just after processing rowspan cell
 			this.writer.context().beginColumn(width, leftOffset, endOfRowSpanCell);
 
-			if (!cell._span) {
+			// When snaking, only process content from the first column (i === 0).
+			// Content overflows into subsequent columns via moveToNextColumn().
+			// We skip content processing here but NOT the beginColumn() call above —
+			// the column geometry setup is still needed for proper layout bookkeeping.
+			const skipForSnaking = snakingColumns && i > 0;
+
+			if (!cell._span && !skipForSnaking) {
 				this.processNode(cell, true);
 				this.writer.context().updateBottomByPage();
 
@@ -968,7 +1025,11 @@ class LayoutBuilder {
 		// If content did not break page, check if we should break by height
 		if (willBreakByHeight && !isUnbreakableRow && pageBreaks.length === 0) {
 			this.writer.context().moveDown(this.writer.context().availableHeight);
-			this.writer.moveToNextPage();
+			if (snakingColumns) {
+				this.snakingAwarePageBreak();
+			} else {
+				this.writer.moveToNextPage();
+			}
 		}
 
 		const bottomByPage = this.writer.context().completeColumnGroup(height, endingSpanCell);
@@ -989,7 +1050,7 @@ class LayoutBuilder {
 				itemBegin.cell = cell;
 				itemBegin.bottomY = this.writer.context().y;
 				itemBegin.isCellContentMultiPage = !itemBegin.cell.positions.every(item => item.pageNumber === itemBegin.cell.positions[0].pageNumber);
-				itemBegin.getViewHeight = function() {
+				itemBegin.getViewHeight = function () {
 					if (this.cell._willBreak) {
 						return this.cell._bottomY - this.cell._rowTopPageY;
 					}
@@ -1009,7 +1070,7 @@ class LayoutBuilder {
 
 					return this.viewHeight;
 				};
-				itemBegin.getNodeHeight = function() {
+				itemBegin.getNodeHeight = function () {
 					return this.nodeHeight;
 				};
 
@@ -1077,7 +1138,32 @@ class LayoutBuilder {
 		processor.beginTable(this.writer);
 
 		let rowHeights = tableNode.table.heights;
+		let lastRowHeight = 0;
+
 		for (let i = 0, l = tableNode.table.body.length; i < l; i++) {
+			// Between table rows: check if we should move to the next snaking column.
+			// This must happen AFTER the previous row's endRow (borders drawn) and
+			// BEFORE this row's beginRow. At this point, the table row column group
+			// has been completed, so canMoveToNextColumn() works correctly.
+			if (i > 0 && this.writer.context().inSnakingColumns()) {
+				// Estimate minimum space for next row: use last row's height as heuristic,
+				// or fall back to a minimum of padding + line height + border
+				let minRowHeight = lastRowHeight > 0 ? lastRowHeight : (
+					processor.rowPaddingTop + 14 + processor.rowPaddingBottom +
+					processor.bottomLineWidth + processor.topLineWidth
+				);
+				if (this.writer.context().availableHeight < minRowHeight) {
+					this.snakingAwarePageBreak();
+
+					// Skip border when headerRows present (header repeat includes it)
+					if (processor.layout.hLineWhenBroken !== false && !processor.headerRows) {
+						processor.drawHorizontalLine(i, this.writer);
+					}
+				}
+			}
+
+			let rowYBefore = this.writer.context().y;
+
 			// if dontBreakRows and row starts a rowspan
 			// we store the 'y' of the beginning of each rowSpan
 			if (processor.dontBreakRows) {
@@ -1130,6 +1216,12 @@ class LayoutBuilder {
 			}
 
 			processor.endRow(i, this.writer, result.pageBreaks);
+
+			// Track the height of the completed row for the next row's estimate
+			let rowYAfter = this.writer.context().y;
+			if (this.writer.context().page === pageBeforeProcessing) {
+				lastRowHeight = rowYAfter - rowYBefore;
+			}
 		}
 
 		processor.endTable(this.writer);
@@ -1155,6 +1247,27 @@ class LayoutBuilder {
 			}
 		}
 
+		if (node.outline) {
+			line._outline = {
+				id: node.id,
+				parentId: node.outlineParentId,
+				text: node.outlineText || node.text,
+				expanded: node.outlineExpanded || false
+			};
+		} else if (Array.isArray(node.text)) {
+			for (let i = 0, l = node.text.length; i < l; i++) {
+				let item = node.text[i];
+				if (item.outline) {
+					line._outline = {
+						id: item.id,
+						parentId: item.outlineParentId,
+						text: item.outlineText || item.text,
+						expanded: item.outlineExpanded || false
+					};
+				}
+			}
+		}
+
 		if (node._tocItemRef) {
 			line._pageNodeRef = node._tocItemRef;
 		}
@@ -1176,6 +1289,28 @@ class LayoutBuilder {
 		}
 
 		while (line && (maxHeight === -1 || currentHeight < maxHeight)) {
+			// Check if line fits vertically in current context
+			if (line.getHeight() > this.writer.context().availableHeight && this.writer.context().y > this.writer.context().pageMargins.top) {
+				// Line doesn't fit, forced move to next page/column
+				// Only do snaking-specific break if we're in snaking columns AND NOT inside
+				// a nested non-snaking group (like a table row). Table cells should use
+				// standard page breaks — column breaks happen between table rows instead.
+				if (this.writer.context().inSnakingColumns() && !this.writer.context().isInNestedNonSnakingGroup()) {
+					this.snakingAwarePageBreak(node.pageOrientation);
+
+					// Always reflow text after a snaking break (column or page).
+					// This ensures text adapts to the new column width, whether it's narrower or wider.
+					if (line.inlines && line.inlines.length > 0) {
+						node._inlines.unshift(...line.inlines);
+					}
+					// Rebuild line with new width
+					line = this.buildNextLine(node);
+					continue;
+				} else {
+					this.writer.moveToNextPage(node.pageOrientation);
+				}
+			}
+
 			let positions = this.writer.addLine(line);
 			node.positions.push(positions);
 			line = this.buildNextLine(node);
@@ -1241,7 +1376,6 @@ class LayoutBuilder {
 			(line.hasEnoughSpaceForInline(textNode._inlines[0], textNode._inlines.slice(1)) || isForceContinue)) {
 			let isHardWrap = false;
 			let inline = textNode._inlines.shift();
-			isForceContinue = false;
 
 			if (!inline.noWrap && inline.text.length > 1 && inline.width > line.getAvailableWidth()) {
 				let maxChars = findMaxFitLength(inline.text, line.getAvailableWidth(), (txt) =>

package/src/PDFDocument.js

@@ -114,7 +114,7 @@ class PDFDocument extends PDFKit {
 				throw new Error('No image');
 			}
 		} catch (error) {
-			throw new Error(`Invalid image: ${error.toString()}\nImages dictionary should contain dataURL entries (or local file paths in node.js)`);
+			throw new Error(`Invalid image: ${error.toString()}\nImages dictionary should contain dataURL entries (or local file paths in node.js)`, { cause: error });
 		}
 
 		image.embed(this);