pdfmake 0.3.0-beta.1 → 0.3.0-beta.10

package/src/LayoutBuilder.js

@@ -32,6 +32,7 @@ class LayoutBuilder {
 		this.pageMargins = pageMargins;
 		this.svgMeasure = svgMeasure;
 		this.tableLayouts = {};
+		this.nestedLevel = 0;
 	}
 
 	registerTableLayouts(tableLayouts) {
@@ -369,16 +370,50 @@ class LayoutBuilder {
 				}
 			}
 
-			if (margin) {
-				this.writer.context().moveDown(margin[1]);
+			const isDetachedBlock = node.relativePosition || node.absolutePosition;
+
+			// Detached nodes have no margins, their position is only determined by 'x' and 'y'
+			if (margin && !isDetachedBlock) {
+				const availableHeight = this.writer.context().availableHeight;
+				// If top margin is bigger than available space, move to next page
+				// Necessary for nodes inside tables
+				if (availableHeight - margin[1] < 0) {
+					// Consume the whole available space
+					this.writer.context().moveDown(availableHeight);
+					this.writer.moveToNextPage(node.pageOrientation);
+					/**
+					 * TODO - Something to consider:
+					 * Right now the node starts at the top of next page (after header)
+					 * Another option would be to apply just the top margin that has not been consumed in the page before
+					 * It would something like: this.write.context().moveDown(margin[1] - availableHeight)
+					 */
+				} else {
+					this.writer.context().moveDown(margin[1]);
+				}
+				// Apply lateral margins
 				this.writer.context().addMargin(margin[0], margin[2]);
 			}
-
 			callback();
 
-			if (margin) {
+			// Detached nodes have no margins, their position is only determined by 'x' and 'y'
+			if (margin && !isDetachedBlock) {
+				const availableHeight = this.writer.context().availableHeight;
+				// If bottom margin is bigger than available space, move to next page
+				// Necessary for nodes inside tables
+				if (availableHeight - margin[3] < 0) {
+					this.writer.context().moveDown(availableHeight);
+					this.writer.moveToNextPage(node.pageOrientation);
+					/**
+					 * TODO - Something to consider:
+					 * Right now next node starts at the top of next page (after header)
+					 * Another option would be to apply the bottom margin that has not been consumed in the next page?
+					 * It would something like: this.write.context().moveDown(margin[3] - availableHeight)
+					 */
+				} else {
+					this.writer.context().moveDown(margin[3]);
+				}
+				// Apply lateral margins
 				this.writer.context().addMargin(-margin[0], -margin[2]);
-				this.writer.context().moveDown(margin[3]);
 			}
 
 			if (node.pageBreak === 'after') {
@@ -439,6 +474,8 @@ class LayoutBuilder {
 				this.processCanvas(node);
 			} else if (node.qr) {
 				this.processQr(node);
+			} else if (node.attachment) {
+				this.processAttachment(node);
 			} else if (!node._span) {
 				throw new Error(`Unrecognized document structure: ${stringifyNode(node)}`);
 			}
@@ -465,6 +502,7 @@ class LayoutBuilder {
 
 	// columns
 	processColumns(columnNode) {
+		this.nestedLevel++;
 		let columns = columnNode.columns;
 		let availableWidth = this.writer.context().availableWidth;
 		let gaps = gapArray(columnNode._gap);
@@ -474,9 +512,17 @@ class LayoutBuilder {
 		}
 
 		ColumnCalculator.buildColumnWidths(columns, availableWidth);
-		let result = this.processRow(columns, columns, gaps);
+		let result = this.processRow({
+			marginX: columnNode._margin ? [columnNode._margin[0], columnNode._margin[2]] : [0, 0],
+			cells: columns,
+			widths: columns,
+			gaps
+		});
 		addAll(columnNode.positions, result.positions);
-
+		this.nestedLevel--;
+		if (this.nestedLevel === 0) {
+			this.writer.context().resetMarginXTopParent();
+		}
 		function gapArray(gap) {
 			if (!gap) {
 				return null;
@@ -493,7 +539,38 @@ class LayoutBuilder {
 		}
 	}
 
-	processRow(columns, widths, gaps, tableBody, tableRow, height) {
+	findStartingSpanCell(arr, i) {
+		let requiredColspan = 1;
+		for (let index = i - 1; index >= 0; index--) {
+			if (!arr[index]._span) {
+				if (arr[index].rowSpan > 1 && (arr[index].colSpan || 1) === requiredColspan) {
+					return arr[index];
+				} else {
+					return null;
+				}
+			}
+			requiredColspan++;
+		}
+		return null;
+	}
+
+	processRow({ marginX = [0, 0], dontBreakRows = false, rowsWithoutPageBreak = 0, cells, widths, gaps, tableBody, rowIndex, height }) {
+		const updatePageBreakData = (page, prevY) => {
+			let pageDesc;
+			// Find page break data for this row and page
+			for (let i = 0, l = pageBreaks.length; i < l; i++) {
+				let desc = pageBreaks[i];
+				if (desc.prevPage === page) {
+					pageDesc = desc;
+					break;
+				}
+			}
+			// If row has page break in this page, update prevY
+			if (pageDesc) {
+				pageDesc.prevY = Math.max(pageDesc.prevY, prevY);
+			}
+		};
+
 		const storePageBreakData = data => {
 			let pageDesc;
 
@@ -513,17 +590,25 @@ class LayoutBuilder {
 			pageDesc.y = Math.min(pageDesc.y, data.y);
 		};
 
+		const isUnbreakableRow = dontBreakRows || rowIndex <= rowsWithoutPageBreak - 1;
 		let pageBreaks = [];
 		let positions = [];
-
+		let willBreakByHeight = false;
 		this.writer.addListener('pageChanged', storePageBreakData);
 
-		widths = widths || columns;
+		// Check if row should break by height
+		if (!isUnbreakableRow && height > this.writer.context().availableHeight) {
+			willBreakByHeight = true;
+		}
+
+		widths = widths || cells;
+		// Use the marginX if we are in a top level table/column (not nested)
+		const marginXParent = this.nestedLevel === 1 ? marginX : null;
 
-		this.writer.context().beginColumnGroup();
+		this.writer.context().beginColumnGroup(marginXParent);
 
-		for (let i = 0, l = columns.length; i < l; i++) {
-			let column = columns[i];
+		for (let i = 0, l = cells.length; i < l; i++) {
+			let column = cells[i];
 			let width = widths[i]._calcWidth;
 			let leftOffset = colLeftOffset(i);
 
@@ -533,18 +618,85 @@ class LayoutBuilder {
 				}
 			}
 
-			this.writer.context().beginColumn(width, leftOffset, getEndingCell(column, i));
+			// if rowspan starts in this cell, we retrieve the last cell affected by the rowspan
+			const endingCell = getEndingCell(column, i);
+			if (endingCell) {
+				// We store a reference of the ending cell in the first cell of the rowspan
+				column._endingCell = endingCell;
+				column._endingCell._startingRowSpanY = column._startingRowSpanY;
+			}
+
+			// Check if exists and retrieve the cell that started the rowspan in case we are in the cell just after
+			let startingSpanCell = this.findStartingSpanCell(cells, i);
+			let endingSpanCell = null;
+			if (startingSpanCell && startingSpanCell._endingCell) {
+				// Reference to the last cell of the rowspan
+				endingSpanCell = startingSpanCell._endingCell;
+				// Store if we are in an unbreakable block when we save the context and the originalX
+				if (this.writer.transactionLevel > 0) {
+					endingSpanCell._isUnbreakableContext = true;
+					endingSpanCell._originalXOffset = this.writer.originalX;
+				}
+			}
+
+			// We pass the endingSpanCell reference to store the context just after processing rowspan cell
+			this.writer.context().beginColumn(width, leftOffset, endingSpanCell);
+
 			if (!column._span) {
 				this.processNode(column);
 				addAll(positions, column.positions);
 			} else if (column._columnEndingContext) {
+				let discountY = 0;
+				if (dontBreakRows) {
+					// Calculate how many points we have to discount to Y when dontBreakRows and rowSpan are combined
+					const ctxBeforeRowSpanLastRow = this.writer.contextStack[this.writer.contextStack.length - 1];
+					discountY = ctxBeforeRowSpanLastRow.y - column._startingRowSpanY;
+				}
+				let originalXOffset = 0;
+				// If context was saved from an unbreakable block and we are not in an unbreakable block anymore
+				// We have to sum the originalX (X before starting unbreakable block) to X
+				if (column._isUnbreakableContext && !this.writer.transactionLevel) {
+					originalXOffset = column._originalXOffset;
+				}
 				// row-span ending
-				this.writer.context().markEnding(column);
+				// Recover the context after processing the rowspanned cell
+				this.writer.context().markEnding(column, originalXOffset, discountY);
+			}
+		}
+
+		// Check if last cell is part of a span
+		let endingSpanCell = null;
+		const lastColumn = cells.length > 0 ? cells[cells.length - 1] : null;
+		if (lastColumn) {
+			// Previous column cell has a rowspan
+			if (lastColumn._endingCell) {
+				endingSpanCell = lastColumn._endingCell;
+				// Previous column cell is part of a span
+			} else if (lastColumn._span === true) {
+				// We get the cell that started the span where we set a reference to the ending cell
+				const startingSpanCell = this.findStartingSpanCell(cells, cells.length);
+				if (startingSpanCell) {
+					// Context will be stored here (ending cell)
+					endingSpanCell = startingSpanCell._endingCell;
+					// Store if we are in an unbreakable block when we save the context and the originalX
+					if (this.writer.transactionLevel > 0) {
+						endingSpanCell._isUnbreakableContext = true;
+						endingSpanCell._originalXOffset = this.writer.originalX;
+					}
+				}
 			}
 		}
 
-		this.writer.context().completeColumnGroup(height);
+		// If there are page breaks in this row, update data with prevY of last cell
+		updatePageBreakData(this.writer.context().page, this.writer.context().y);
+
+		// If content did not break page, check if we should break by height
+		if (!isUnbreakableRow && pageBreaks.length === 0 && willBreakByHeight) {
+			this.writer.context().moveDown(this.writer.context().availableHeight);
+			this.writer.moveToNextPage();
+		}
 
+		this.writer.context().completeColumnGroup(height, endingSpanCell);
 		this.writer.removeListener('pageChanged', storePageBreakData);
 
 		return { pageBreaks: pageBreaks, positions: positions };
@@ -558,7 +710,7 @@ class LayoutBuilder {
 
 		function getEndingCell(column, columnIndex) {
 			if (column.rowSpan && column.rowSpan > 1) {
-				let endingRow = tableRow + column.rowSpan - 1;
+				let endingRow = rowIndex + column.rowSpan - 1;
 				if (endingRow >= tableBody.length) {
 					throw new Error(`Row span for column ${columnIndex} (with indexes starting from 0) exceeded row count`);
 				}
@@ -615,12 +767,23 @@ class LayoutBuilder {
 
 	// tables
 	processTable(tableNode) {
+		this.nestedLevel++;
 		let processor = new TableProcessor(tableNode);
 
 		processor.beginTable(this.writer);
 
 		let rowHeights = tableNode.table.heights;
 		for (let i = 0, l = tableNode.table.body.length; i < l; i++) {
+			// if dontBreakRows and row starts a rowspan
+			// we store the 'y' of the beginning of each rowSpan
+			if (processor.dontBreakRows) {
+				tableNode.table.body[i].forEach(cell => {
+					if (cell.rowSpan && cell.rowSpan > 1) {
+						cell._startingRowSpanY = this.writer.context().y;
+					}
+				});
+			}
+
 			processor.beginRow(i, this.writer);
 
 			let height;
@@ -636,13 +799,28 @@ class LayoutBuilder {
 				height = undefined;
 			}
 
-			let result = this.processRow(tableNode.table.body[i], tableNode.table.widths, tableNode._offsets.offsets, tableNode.table.body, i, height);
+			let result = this.processRow({
+				marginX: tableNode._margin ? [tableNode._margin[0], tableNode._margin[2]] : [0, 0],
+				dontBreakRows: processor.dontBreakRows,
+				rowsWithoutPageBreak: processor.rowsWithoutPageBreak,
+				cells: tableNode.table.body[i],
+				widths: tableNode.table.widths,
+				gaps: tableNode._offsets.offsets,
+				tableBody: tableNode.table.body,
+				rowIndex: i,
+				height
+			});
+
 			addAll(tableNode.positions, result.positions);
 
 			processor.endRow(i, this.writer, result.pageBreaks);
 		}
 
 		processor.endTable(this.writer);
+		this.nestedLevel--;
+		if (this.nestedLevel === 0) {
+			this.writer.context().resetMarginXTopParent();
+		}
 	}
 
 	// leafs (texts)
@@ -774,6 +952,11 @@ class LayoutBuilder {
 		let position = this.writer.addQr(node);
 		node.positions.push(position);
 	}
+
+	processAttachment(node) {
+		let position = this.writer.addAttachment(node);
+		node.positions.push(position);
+	}
 }
 
 function decorateNode(node) {

package/src/OutputDocument.js

@@ -4,7 +4,7 @@ class OutputDocument {
 	 * @param {Promise<object>} pdfDocumentPromise
 	 */
 	constructor(pdfDocumentPromise) {
-		this.bufferSize = 9007199254740991;
+		this.bufferSize = 1073741824;
 		this.pdfDocumentPromise = pdfDocumentPromise;
 		this.bufferPromise = null;
 	}

package/src/PDFDocument.js

@@ -13,7 +13,7 @@ const typeName = (bold, italics) => {
 };
 
 class PDFDocument extends PDFKit {
-	constructor(fonts = {}, images = {}, patterns = {}, options = {}, virtualfs = null) {
+	constructor(fonts = {}, images = {}, patterns = {}, attachments = {}, options = {}, virtualfs = null) {
 		super(options);
 
 		this.fonts = {};
@@ -41,6 +41,7 @@ class PDFDocument extends PDFKit {
 
 
 		this.images = images;
+		this.attachments = attachments;
 		this.virtualfs = virtualfs;
 	}
 
@@ -134,6 +135,31 @@ class PDFDocument extends PDFKit {
 		return null;
 	}
 
+	provideAttachment(src) {
+		const checkRequired = obj => {
+			if (!obj) {
+				throw new Error('No attachment');
+			}
+			if (!obj.src) {
+				throw new Error('The "src" key is required for attachments');
+			}
+
+			return obj;
+		};
+
+		if (typeof src === 'object') {
+			return checkRequired(src);
+		}
+
+		let attachment = checkRequired(this.attachments[src]);
+
+		if (this.virtualfs && this.virtualfs.existsSync(attachment.src)) {
+			return this.virtualfs.readFileSync(attachment.src);
+		}
+
+		return attachment;
+	}
+
 	setOpenActionAsPrint() {
 		let printActionRef = this.ref({
 			Type: 'Action',

package/src/PageElementWriter.js

@@ -35,6 +35,10 @@ class PageElementWriter extends ElementWriter {
 		return this._fitOnPage(() => super.addQr(qr, index));
 	}
 
+	addAttachment(attachment, index) {
+		return this._fitOnPage(() => super.addAttachment(attachment, index));
+	}
+
 	addVector(vector, ignoreContextX, ignoreContextY, index) {
 		return super.addVector(vector, ignoreContextX, ignoreContextY, index);
 	}

package/src/Printer.js

@@ -49,6 +49,7 @@ class PdfPrinter {
 					docDefinition.version = docDefinition.version || '1.3';
 					docDefinition.compress = typeof docDefinition.compress === 'boolean' ? docDefinition.compress : true;
 					docDefinition.images = docDefinition.images || {};
+					docDefinition.attachments = docDefinition.attachments || {};
 					docDefinition.pageMargins = isValue(docDefinition.pageMargins) ? docDefinition.pageMargins : 40;
 					docDefinition.patterns = docDefinition.patterns || {};
 
@@ -61,6 +62,7 @@ class PdfPrinter {
 						userPassword: docDefinition.userPassword,
 						ownerPassword: docDefinition.ownerPassword,
 						permissions: docDefinition.permissions,
+						lang: docDefinition.language,
 						fontLayoutCache: typeof options.fontLayoutCache === 'boolean' ? options.fontLayoutCache : true,
 						bufferPages: options.bufferPages || false,
 						autoFirstPage: false,
@@ -68,7 +70,8 @@ class PdfPrinter {
 						font: null
 					};
 
-					this.pdfKitDoc = new PDFDocument(this.fontDescriptors, docDefinition.images, docDefinition.patterns, pdfOptions, this.virtualfs);
+					this.pdfKitDoc = new PDFDocument(this.fontDescriptors, docDefinition.images, docDefinition.patterns, docDefinition.attachments, pdfOptions, this.virtualfs);
+					embedFiles(docDefinition, this.pdfKitDoc);
 
 					const builder = new LayoutBuilder(pageSize, normalizePageMargin(docDefinition.pageMargins), new SVGMeasure());
 
@@ -108,6 +111,14 @@ class PdfPrinter {
 	 * @returns {Promise}
 	 */
 	resolveUrls(docDefinition) {
+		const getExtendedUrl = url => {
+			if (typeof url === 'object') {
+				return { url: url.url, headers: url.headers };
+			}
+
+			return { url: url, headers: {} };
+		};
+
 		return new Promise((resolve, reject) => {
 			if (this.urlResolver === null) {
 				resolve();
@@ -116,16 +127,48 @@ class PdfPrinter {
 			for (let font in this.fontDescriptors) {
 				if (this.fontDescriptors.hasOwnProperty(font)) {
 					if (this.fontDescriptors[font].normal) {
-						this.urlResolver.resolve(this.fontDescriptors[font].normal);
+						if (Array.isArray(this.fontDescriptors[font].normal)) { // TrueType Collection
+							let url = getExtendedUrl(this.fontDescriptors[font].normal[0]);
+							this.urlResolver.resolve(url.url, url.headers);
+							this.fontDescriptors[font].normal[0] = url.url;
+						} else {
+							let url = getExtendedUrl(this.fontDescriptors[font].normal);
+							this.urlResolver.resolve(url.url, url.headers);
+							this.fontDescriptors[font].normal = url.url;
+						}
 					}
 					if (this.fontDescriptors[font].bold) {
-						this.urlResolver.resolve(this.fontDescriptors[font].bold);
+						if (Array.isArray(this.fontDescriptors[font].bold)) { // TrueType Collection
+							let url = getExtendedUrl(this.fontDescriptors[font].bold[0]);
+							this.urlResolver.resolve(url.url, url.headers);
+							this.fontDescriptors[font].bold[0] = url.url;
+						} else {
+							let url = getExtendedUrl(this.fontDescriptors[font].bold);
+							this.urlResolver.resolve(url.url, url.headers);
+							this.fontDescriptors[font].bold = url.url;
+						}
 					}
 					if (this.fontDescriptors[font].italics) {
-						this.urlResolver.resolve(this.fontDescriptors[font].italics);
+						if (Array.isArray(this.fontDescriptors[font].italics)) { // TrueType Collection
+							let url = getExtendedUrl(this.fontDescriptors[font].italics[0]);
+							this.urlResolver.resolve(url.url, url.headers);
+							this.fontDescriptors[font].italics[0] = url.url;
+						} else {
+							let url = getExtendedUrl(this.fontDescriptors[font].italics);
+							this.urlResolver.resolve(url.url, url.headers);
+							this.fontDescriptors[font].italics = url.url;
+						}
 					}
 					if (this.fontDescriptors[font].bolditalics) {
-						this.urlResolver.resolve(this.fontDescriptors[font].bolditalics);
+						if (Array.isArray(this.fontDescriptors[font].bolditalics)) { // TrueType Collection
+							let url = getExtendedUrl(this.fontDescriptors[font].bolditalics[0]);
+							this.urlResolver.resolve(url.url, url.headers);
+							this.fontDescriptors[font].bolditalics[0] = url.url;
+						} else {
+							let url = getExtendedUrl(this.fontDescriptors[font].bolditalics);
+							this.urlResolver.resolve(url.url, url.headers);
+							this.fontDescriptors[font].bolditalics = url.url;
+						}
 					}
 				}
 			}
@@ -133,7 +176,29 @@ class PdfPrinter {
 			if (docDefinition.images) {
 				for (let image in docDefinition.images) {
 					if (docDefinition.images.hasOwnProperty(image)) {
-						this.urlResolver.resolve(docDefinition.images[image]);
+						let url = getExtendedUrl(docDefinition.images[image]);
+						this.urlResolver.resolve(url.url, url.headers);
+						docDefinition.images[image] = url.url;
+					}
+				}
+			}
+
+			if (docDefinition.attachments) {
+				for (let attachment in docDefinition.attachments) {
+					if (docDefinition.attachments.hasOwnProperty(attachment) && docDefinition.attachments[attachment].src) {
+						let url = getExtendedUrl(docDefinition.attachments[attachment].src);
+						this.urlResolver.resolve(url.url, url.headers);
+						docDefinition.attachments[attachment].src = url.url;
+					}
+				}
+			}
+
+			if (docDefinition.files) {
+				for (let file in docDefinition.files) {
+					if (docDefinition.files.hasOwnProperty(file) && docDefinition.files[file].src) {
+						let url = getExtendedUrl(docDefinition.files[file].src);
+						this.urlResolver.resolve(url.url, url.headers);
+						docDefinition.files[file].src = url.url;
 					}
 				}
 			}
@@ -180,6 +245,23 @@ function createMetadata(docDefinition) {
 	return info;
 }
 
+function embedFiles(docDefinition, pdfKitDoc) {
+	if (docDefinition.files) {
+		for (const key in docDefinition.files) {
+			const file = docDefinition.files[key];
+
+			if (!file.src) return;
+
+			if (pdfKitDoc.virtualfs && pdfKitDoc.virtualfs.existsSync(file.src)) {
+				file.src = pdfKitDoc.virtualfs.readFileSync(file.src);
+			}
+
+			file.name = file.name || key;
+			pdfKitDoc.file(file.src, file);
+		}
+	}
+}
+
 function calculatePageHeight(pages, margins) {
 	function getItemHeight(item) {
 		if (typeof item.item.getHeight === 'function') {
@@ -187,7 +269,11 @@ function calculatePageHeight(pages, margins) {
 		} else if (item.item._height) {
 			return item.item._height;
 		} else if (item.type === 'vector') {
-			return item.item.y1 > item.item.y2 ? item.item.y1 : item.item.y2;
+			if (typeof item.item.y1 !== 'undefined') {
+				return item.item.y1 > item.item.y2 ? item.item.y1 : item.item.y2;
+			} else {
+				return item.item.h;
+			}
 		} else {
 			// TODO: add support for next item types
 			return 0;

package/src/Renderer.js

@@ -78,6 +78,9 @@ class Renderer {
 					case 'svg':
 						this.renderSVG(item.item);
 						break;
+					case 'attachment':
+						this.renderAttachment(item.item);
+						break;
 					case 'beginClip':
 						this.beginClip(item.item);
 						break;
@@ -306,6 +309,27 @@ class Renderer {
 		if (image.linkToDestination) {
 			this.pdfDocument.goTo(image.x, image.y, image._width, image._height, image.linkToDestination);
 		}
+		if (image.linkToFile) {
+			const attachment = this.pdfDocument.provideAttachment(image.linkToFile);
+			this.pdfDocument.fileAnnotation(
+				image.x,
+				image.y,
+				image._width,
+				image._height,
+				attachment,
+				// add empty rectangle as file annotation appearance with the same size as the rendered image
+				{
+					AP: {
+						N: {
+							Type: 'XObject',
+							Subtype: 'Form',
+							FormType: 1,
+							BBox: [image.x, image.y, image._width, image._height]
+						}
+					},
+				}
+			);
+		}
 	}
 
 	renderSVG(svg) {
@@ -326,6 +350,17 @@ class Renderer {
 		SVGtoPDF(this.pdfDocument, svg.svg, svg.x, svg.y, options);
 	}
 
+	renderAttachment(attachment) {
+		const file = this.pdfDocument.provideAttachment(attachment.attachment);
+
+		const options = {};
+		if (attachment.icon) {
+			options.Name = attachment.icon;
+		}
+
+		this.pdfDocument.fileAnnotation(attachment.x, attachment.y, attachment._width, attachment._height, file, options);
+	}
+
 	beginClip(rect) {
 		this.pdfDocument.save();
 		this.pdfDocument.addContent(`${rect.x} ${rect.y} ${rect.width} ${rect.height} re`);

package/src/StyleContextStack.js

@@ -79,50 +79,9 @@ class StyleContextStack {
 			this.push(styleNames[i]);
 		}
 
-		let styleProperties = [
-			'font',
-			'fontSize',
-			'fontFeatures',
-			'bold',
-			'italics',
-			'alignment',
-			'color',
-			'columnGap',
-			'fillColor',
-			'fillOpacity',
-			'decoration',
-			'decorationStyle',
-			'decorationColor',
-			'background',
-			'lineHeight',
-			'characterSpacing',
-			'noWrap',
-			'markerColor',
-			'leadingIndent',
-			'sup',
-			'sub'
-			//'tableCellPadding'
-			// 'cellBorder',
-			// 'headerCellBorder',
-			// 'oddRowCellBorder',
-			// 'evenRowCellBorder',
-			// 'tableBorder'
-		];
-		let styleOverrideObject = {};
-		let pushStyleOverrideObject = false;
-
-		styleProperties.forEach(key => {
-			if (isValue(item[key])) {
-				styleOverrideObject[key] = item[key];
-				pushStyleOverrideObject = true;
-			}
-		});
-
-		if (pushStyleOverrideObject) {
-			this.push(styleOverrideObject);
-		}
-
-		return styleNames.length + (pushStyleOverrideObject ? 1 : 0);
+		// rather than spend significant time making a styleOverrideObject, just add item
+		this.push(item);
+		return styleNames.length + 1;
 	}
 
 	/**