pdfmake 0.3.4 → 0.3.6

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);

package/src/PageElementWriter.js

@@ -173,11 +173,130 @@ class PageElementWriter extends ElementWriter {
 		this.repeatables.pop();
 	}
 
+	/**
+	 * Move to the next column in a column group (snaking columns).
+	 * Handles repeatables and emits columnChanged event.
+	 */
+	moveToNextColumn() {
+		let nextColumn = this.context().moveToNextColumn();
+
+		// Handle repeatables (like table headers) for the new column
+		this.repeatables.forEach(function (rep) {
+			// In snaking columns, we WANT headers to repeat.
+			// However, in Standard Page Breaks, headers are drawn using useBlockXOffset=true (original absolute X).
+			// This works for page breaks because margins are consistent.
+			// In Snaking Columns, the X position changes for each column.
+			// If we use true, the header is drawn at the *original* X position (Col 1), overlapping/invisible.
+			// We MUST use false to force drawing relative to the CURRENT context X (new column start).
+			this.addFragment(rep, false);
+		}, this);
+
+		this.emit('columnChanged', {
+			prevY: nextColumn.prevY,
+			y: this.context().y
+		});
+	}
+
+	/**
+	 * Check if currently in a column group that can move to next column.
+	 * Only returns true if snakingColumns is enabled for the column group.
+	 * @returns {boolean}
+	 */
+	canMoveToNextColumn() {
+		let ctx = this.context();
+		let snakingSnapshot = ctx.getSnakingSnapshot();
+
+		if (snakingSnapshot) {
+			// Check if we're inside a nested (non-snaking) column group.
+			// If so, don't allow a snaking column move — it would corrupt
+			// the inner row's layout (e.g. product name in col 1, price in col 2).
+			// The inner row should complete via normal page break instead.
+			for (let i = ctx.snapshots.length - 1; i >= 0; i--) {
+				let snap = ctx.snapshots[i];
+				if (snap.snakingColumns) {
+					break; // Reached the snaking snapshot, no inner groups found
+				}
+				if (!snap.overflowed) {
+					return false; // Found a non-snaking, non-overflowed inner group
+				}
+			}
+
+			let overflowCount = 0;
+			for (let i = ctx.snapshots.length - 1; i >= 0; i--) {
+				if (ctx.snapshots[i].overflowed) {
+					overflowCount++;
+				} else {
+					break;
+				}
+			}
+
+			if (snakingSnapshot.columnWidths &&
+				overflowCount >= snakingSnapshot.columnWidths.length - 1) {
+				return false;
+			}
+
+			let currentColumnWidth = ctx.availableWidth || ctx.lastColumnWidth || 0;
+			let nextColumnWidth = snakingSnapshot.columnWidths ?
+				snakingSnapshot.columnWidths[overflowCount + 1] : currentColumnWidth;
+			let nextX = ctx.x + currentColumnWidth + (snakingSnapshot.gap || 0);
+			let page = ctx.getCurrentPage();
+			let pageWidth = page.pageSize.width;
+			let rightMargin = page.pageMargins ? page.pageMargins.right : 0;
+			let parentRightMargin = ctx.marginXTopParent ? ctx.marginXTopParent[1] : 0;
+			let rightBoundary = pageWidth - rightMargin - parentRightMargin;
+
+			return (nextX + nextColumnWidth) <= (rightBoundary + 1);
+		}
+		return false;
+	}
+
 	_fitOnPage(addFct) {
 		let position = addFct();
 		if (!position) {
-			this.moveToNextPage();
-			position = addFct();
+			if (this.canMoveToNextColumn()) {
+				this.moveToNextColumn();
+				position = addFct();
+			}
+
+			if (!position) {
+				let ctx = this.context();
+				let snakingSnapshot = ctx.getSnakingSnapshot();
+
+				if (snakingSnapshot) {
+					if (ctx.isInNestedNonSnakingGroup()) {
+						// Inside a table cell within snaking columns — use standard page break.
+						// Don't reset snaking state; the table handles its own breaks.
+						// Column breaks happen between rows in processTable instead.
+						this.moveToNextPage();
+					} else {
+						this.moveToNextPage();
+
+						// 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;
+					}
+
+					position = addFct();
+				} else {
+					while (ctx.snapshots.length > 0 && ctx.snapshots[ctx.snapshots.length - 1].overflowed) {
+						let popped = ctx.snapshots.pop();
+						let prevSnapshot = ctx.snapshots[ctx.snapshots.length - 1];
+						if (prevSnapshot) {
+							ctx.x = prevSnapshot.x;
+							ctx.y = prevSnapshot.y;
+							ctx.availableHeight = prevSnapshot.availableHeight;
+							ctx.availableWidth = popped.availableWidth;
+							ctx.lastColumnWidth = prevSnapshot.lastColumnWidth;
+						}
+					}
+
+					this.moveToNextPage();
+					position = addFct();
+				}
+			}
 		}
 		return position;
 	}

package/src/Printer.js

@@ -7,21 +7,6 @@ import Renderer from './Renderer';
 import { isNumber, isValue } from './helpers/variableType';
 import { convertToDynamicContent } from './helpers/tools';
 
-/**
- * Printer which turns document definition into a pdf
- *
- * @example
- * var fontDescriptors = {
- *	Roboto: {
- *		normal: 'fonts/Roboto-Regular.ttf',
- *		bold: 'fonts/Roboto-Medium.ttf',
- *		italics: 'fonts/Roboto-Italic.ttf',
- *		bolditalics: 'fonts/Roboto-MediumItalic.ttf'
- *	}
- * };
- *
- * var printer = new PdfPrinter(fontDescriptors);
- */
 class PdfPrinter {
 
 	/**
@@ -29,7 +14,7 @@ class PdfPrinter {
 	 * @param {object} virtualfs
 	 * @param {object} urlResolver
 	 */
-	constructor(fontDescriptors, virtualfs = null, urlResolver = null) {
+	constructor(fontDescriptors, virtualfs, urlResolver) {
 		this.fontDescriptors = fontDescriptors;
 		this.virtualfs = virtualfs;
 		this.urlResolver = urlResolver;
@@ -127,10 +112,6 @@ class PdfPrinter {
 			return { url: url, headers: {} };
 		};
 
-		if (this.urlResolver === null) {
-			return;
-		}
-
 		for (let font in this.fontDescriptors) {
 			if (this.fontDescriptors.hasOwnProperty(font)) {
 				if (this.fontDescriptors[font].normal) {

package/src/Renderer.js

@@ -41,6 +41,7 @@ class Renderer {
 	constructor(pdfDocument, progressCallback) {
 		this.pdfDocument = pdfDocument;
 		this.progressCallback = progressCallback;
+		this.outlineMap = [];
 	}
 
 	renderPages(pages) {
@@ -128,6 +129,18 @@ class Renderer {
 			}
 		}
 
+		if (line._outline) {
+			let parentOutline = this.pdfDocument.outline;
+			if (line._outline.parentId && this.outlineMap[line._outline.parentId]) {
+				parentOutline = this.outlineMap[line._outline.parentId];
+			}
+
+			let outline = parentOutline.addItem(line._outline.text, { expanded: line._outline.expanded });
+			if (line._outline.id) {
+				this.outlineMap[line._outline.id] = outline;
+			}
+		}
+
 		if (line._pageNodeRef) {
 			preparePageNodeRefLine(line._pageNodeRef, line.inlines[0]);
 		}

package/src/SVGMeasure.js

@@ -26,8 +26,8 @@ const parseSVG = (svgString) => {
 
 	try {
 		doc = new 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") {

package/src/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 });
 
@@ -274,7 +274,6 @@ class TableProcessor {
 							lineColor: borderColor
 						}, false, isNumber(overrideY), null, forcePage);
 						currentLine = null;
-						borderColor = null;
 						cellAbove = null;
 						currentCell = null;
 						rowCellAbove = null;
@@ -356,9 +355,6 @@ class TableProcessor {
 			dash: dash,
 			lineColor: borderColor
 		}, false, true);
-		cellBefore = null;
-		currentCell = null;
-		borderColor = null;
 	}
 
 	endTable(writer) {

package/src/URLResolver.js

@@ -6,7 +6,7 @@ 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 });
 	}
 }
 
@@ -14,6 +14,14 @@ class URLResolver {
 	constructor(fs) {
 		this.fs = fs;
 		this.resolving = {};
+		this.urlAccessPolicy = undefined;
+	}
+
+	/**
+	 * @param {(url: string) => boolean} callback
+	 */
+	setUrlAccessPolicy(callback) {
+		this.urlAccessPolicy = callback;
 	}
 
 	resolve(url, headers = {}) {
@@ -22,6 +30,11 @@ class URLResolver {
 				if (this.fs.existsSync(url)) {
 					return; // url was downloaded earlier
 				}
+
+				if ((typeof this.urlAccessPolicy !== 'undefined') && (this.urlAccessPolicy(url) !== true)) {
+					throw new Error(`Access to URL denied by resource access policy: ${url}`);
+				}
+
 				const buffer = await fetchUrl(url, headers);
 				this.fs.writeFileSync(url, buffer);
 			}

package/src/base.js

@@ -2,12 +2,13 @@ import Printer from './Printer';
 import virtualfs from './virtual-fs';
 import { pack } from './helpers/tools';
 import { isObject } from './helpers/variableType';
+import URLResolver from './URLResolver';
 
 class pdfmake {
 
 	constructor() {
 		this.virtualfs = virtualfs;
-		this.urlResolver = null;
+		this.urlAccessPolicy = undefined;
 	}
 
 	/**
@@ -27,12 +28,33 @@ class pdfmake {
 		options.progressCallback = this.progressCallback;
 		options.tableLayouts = this.tableLayouts;
 
-		let printer = new Printer(this.fonts, this.virtualfs, this.urlResolver());
+		const isServer = typeof process !== 'undefined' && process?.versions?.node;
+		if (typeof this.urlAccessPolicy === 'undefined' && isServer) {
+			console.warn(
+				'No URL access policy defined. Consider using setUrlAccessPolicy() to restrict external resource downloads.'
+			);
+		}
+
+		let urlResolver = new URLResolver(this.virtualfs);
+		urlResolver.setUrlAccessPolicy(this.urlAccessPolicy);
+
+		let printer = new Printer(this.fonts, this.virtualfs, urlResolver);
 		const pdfDocumentPromise = printer.createPdfKitDocument(docDefinition, options);
 
 		return this._transformToDocument(pdfDocumentPromise);
 	}
 
+	/**
+	 * @param {(url: string) => boolean} callback
+	 */
+	setUrlAccessPolicy(callback) {
+		if (callback !== undefined && typeof callback !== 'function') {
+			throw new Error("Parameter 'callback' has an invalid type. Function or undefined expected.");
+		}
+
+		this.urlAccessPolicy = callback;
+	}
+
 	setProgressCallback(callback) {
 		this.progressCallback = callback;
 	}

package/src/browser-extensions/index.js

@@ -1,6 +1,5 @@
 import pdfmakeBase from '../base';
 import OutputDocumentBrowser from './OutputDocumentBrowser';
-import URLResolver from '../URLResolver';
 import fs from 'fs';
 import configurator from 'core-js/configurator';
 
@@ -21,7 +20,6 @@ let defaultClientFonts = {
 class pdfmake extends pdfmakeBase {
 	constructor() {
 		super();
-		this.urlResolver = () => new URLResolver(this.virtualfs);
 		this.fonts = defaultClientFonts;
 	}
 

package/src/index.js

@@ -1,11 +1,9 @@
 const pdfmakeBase = require('./base').default;
 const OutputDocumentServer = require('./OutputDocumentServer').default;
-const URLResolver = require('./URLResolver').default;
 
 class pdfmake extends pdfmakeBase {
 	constructor() {
 		super();
-		this.urlResolver = () => new URLResolver(this.virtualfs);
 	}
 
 	_transformToDocument(doc) {