pdfmake 0.3.0-beta.8 → 0.3.0

package/src/TableProcessor.js

@@ -1,5 +1,5 @@
 import ColumnCalculator from './columnCalculator';
-import { isNumber } from './helpers/variableType';
+import { isNumber, isPositiveInteger } from './helpers/variableType';
 
 class TableProcessor {
 	constructor(tableNode) {
@@ -95,28 +95,48 @@ class TableProcessor {
 		this.layout = tableNode._layout;
 
 		availableWidth = writer.context().availableWidth - this.offsets.total;
-		ColumnCalculator.buildColumnWidths(tableNode.table.widths, availableWidth);
+		ColumnCalculator.buildColumnWidths(tableNode.table.widths, availableWidth, this.offsets.total, tableNode);
 
 		this.tableWidth = tableNode._offsets.total + getTableInnerContentWidth();
 		this.rowSpanData = prepareRowSpanData();
 		this.cleanUpRepeatables = false;
 
-		this.headerRows = tableNode.table.headerRows || 0;
-		if (this.headerRows > tableNode.table.body.length) {
-			throw new Error(`Too few rows in the table. Property headerRows requires at least ${this.headerRows}, contains only ${tableNode.table.body.length}`);
+		// headersRows and rowsWithoutPageBreak (headerRows + keepWithHeaderRows)
+		this.headerRows = 0;
+		this.rowsWithoutPageBreak = 0;
+
+		const headerRows = tableNode.table.headerRows;
+
+		if (isPositiveInteger(headerRows)) {
+			this.headerRows = headerRows;
+
+			if (this.headerRows > tableNode.table.body.length) {
+				throw new Error(`Too few rows in the table. Property headerRows requires at least ${this.headerRows}, contains only ${tableNode.table.body.length}`);
+			}
+
+			this.rowsWithoutPageBreak = this.headerRows;
+
+			const keepWithHeaderRows = tableNode.table.keepWithHeaderRows;
+
+			if (isPositiveInteger(keepWithHeaderRows)) {
+				this.rowsWithoutPageBreak += keepWithHeaderRows;
+			}
 		}
 
-		this.rowsWithoutPageBreak = this.headerRows + (tableNode.table.keepWithHeaderRows || 0);
 		this.dontBreakRows = tableNode.table.dontBreakRows || false;
 
-		if (this.rowsWithoutPageBreak) {
+		if (this.rowsWithoutPageBreak || this.dontBreakRows) {
 			writer.beginUnbreakableBlock();
+			// Draw the top border of the table
+			this.drawHorizontalLine(0, writer);
+			if (this.rowsWithoutPageBreak && this.dontBreakRows) {
+				// We just increase the value of transactionLevel
+				writer.beginUnbreakableBlock();
+			}
 		}
 
 		// update the border properties of all cells before drawing any lines
 		prepareCellBorders(this.tableNode.table.body);
-
-		this.drawHorizontalLine(0, writer);
 	}
 
 	onRowBreak(rowIndex, writer) {
@@ -135,7 +155,12 @@ class TableProcessor {
 
 		this.rowCallback = this.onRowBreak(rowIndex, writer);
 		writer.addListener('pageChanged', this.rowCallback);
-		if (this.dontBreakRows) {
+		if (rowIndex == 0 && !this.dontBreakRows && !this.rowsWithoutPageBreak) {
+			// We store the 'y' to draw later and if necessary the top border of the table
+			this._tableTopBorderY = writer.context().y;
+			writer.context().moveDown(this.topLineWidth);
+		}
+		if (this.dontBreakRows && rowIndex > 0) {
 			writer.beginUnbreakableBlock();
 		}
 		this.rowTopY = writer.context().y;
@@ -146,7 +171,7 @@ class TableProcessor {
 		writer.context().moveDown(this.rowPaddingTop);
 	}
 
-	drawHorizontalLine(lineIndex, writer, overrideY) {
+	drawHorizontalLine(lineIndex, writer, overrideY, moveDown = true, forcePage) {
 		let lineWidth = this.layout.hLineWidth(lineIndex, this.tableNode);
 		if (lineWidth) {
 			let style = this.layout.hLineStyle(lineIndex, this.tableNode);
@@ -244,7 +269,7 @@ class TableProcessor {
 							lineWidth: lineWidth,
 							dash: dash,
 							lineColor: borderColor
-						}, false, overrideY);
+						}, false, isNumber(overrideY), null, forcePage);
 						currentLine = null;
 						borderColor = null;
 						cellAbove = null;
@@ -254,7 +279,9 @@ class TableProcessor {
 				}
 			}
 
-			writer.context().moveDown(lineWidth);
+			if (moveDown) {
+				writer.context().moveDown(lineWidth);
+			}
 		}
 	}
 
@@ -390,6 +417,15 @@ class TableProcessor {
 		ys[ys.length - 1].y1 = endingY;
 
 		let skipOrphanePadding = (ys[0].y1 - ys[0].y0 === this.rowPaddingTop);
+		if (rowIndex === 0 && !skipOrphanePadding && !this.rowsWithoutPageBreak && !this.dontBreakRows) {
+			// Draw the top border of the table
+			let pageTableStartedAt = null;
+			if (pageBreaks && pageBreaks.length > 0) {
+				// Get the page where table started at
+				pageTableStartedAt = pageBreaks[0].prevPage;
+			}
+			this.drawHorizontalLine(0, writer, this._tableTopBorderY, false, pageTableStartedAt);
+		}
 		for (let yi = (skipOrphanePadding ? 1 : 0), yl = ys.length; yi < yl; yi++) {
 			let willBreak = yi < ys.length - 1;
 			let rowBreakWithoutHeader = (yi > 0 && !this.headerRows);
@@ -409,6 +445,14 @@ class TableProcessor {
 				this.reservedAtBottom = 0;
 			}
 
+			// Draw horizontal lines before the vertical lines so they are not overridden
+			if (willBreak && this.layout.hLineWhenBroken !== false) {
+				this.drawHorizontalLine(rowIndex + 1, writer, y2);
+			}
+			if (rowBreakWithoutHeader && this.layout.hLineWhenBroken !== false) {
+				this.drawHorizontalLine(rowIndex, writer, y1);
+			}
+
 			for (let i = 0, l = xs.length; i < l; i++) {
 				let leftCellBorder = false;
 				let rightCellBorder = false;
@@ -474,7 +518,9 @@ class TableProcessor {
 								h: bgHeight,
 								lineWidth: 0,
 								color: fillColor,
-								fillOpacity: fillOpacity
+								fillOpacity: fillOpacity,
+								// mark if we are in an unbreakable block
+								_isFillColorFromUnbreakable: !!writer.transactionLevel
 							}, false, true, writer.context().backgroundLength[writer.context().page]);
 						}
 
@@ -493,13 +539,6 @@ class TableProcessor {
 					}
 				}
 			}
-
-			if (willBreak && this.layout.hLineWhenBroken !== false) {
-				this.drawHorizontalLine(rowIndex + 1, writer, y2);
-			}
-			if (rowBreakWithoutHeader && this.layout.hLineWhenBroken !== false) {
-				this.drawHorizontalLine(rowIndex, writer, y1);
-			}
 		}
 
 		writer.context().page = endingPage;
@@ -538,7 +577,8 @@ class TableProcessor {
 
 		if (this.dontBreakRows) {
 			const pageChangedCallback = () => {
-				if (!this.headerRows && this.layout.hLineWhenBroken !== false) {
+				if (rowIndex > 0 && !this.headerRows && this.layout.hLineWhenBroken !== false) {
+					// Draw the top border of the row after a page break
 					this.drawHorizontalLine(rowIndex, writer);
 				}
 			};

package/src/TextBreaker.js

@@ -1,19 +1,38 @@
-import LineBreaker from '@foliojs-fork/linebreak';
+import LineBreaker from 'linebreak';
 import { isObject } from './helpers/variableType';
 import StyleContextStack from './StyleContextStack';
 
 /**
  * @param {string} text
  * @param {boolean} noWrap
+ * @param {boolean} breakAll
  * @returns {Array}
  */
-const splitWords = (text, noWrap) => {
+const splitWords = (text, noWrap, breakAll = false) => {
 	let words = [];
+	if (text === undefined || text === null) {
+		text = '';
+	} else {
+		text = String(text);
+	}
 
 	if (noWrap) {
 		words.push({ text: text });
 		return words;
 	}
+	if (breakAll) {
+		return text.split('').map(c => {
+			if(c.match(/^\n$|^\r$/)) { // new line
+				return { text: '', lineEnd: true };
+			}
+			return { text: c };
+		});
+	}
+
+	if (text.length === 0) {
+		words.push({ text: '' });
+		return words;
+	}
 
 	let breaker = new LineBreaker(text);
 	let last = 0;
@@ -101,16 +120,16 @@ class TextBreaker {
 			let item = texts[i];
 			let style = null;
 			let words;
-
+			let breakAll = StyleContextStack.getStyleProperty(item || {}, styleContextStack, 'wordBreak', 'normal') === 'break-all';
 			let noWrap = StyleContextStack.getStyleProperty(item || {}, styleContextStack, 'noWrap', false);
 			if (isObject(item)) {
 				if (item._textRef && item._textRef._textNodeRef.text) {
 					item.text = item._textRef._textNodeRef.text;
 				}
-				words = splitWords(item.text, noWrap);
+				words = splitWords(item.text, noWrap, breakAll);
 				style = StyleContextStack.copyStyle(item);
 			} else {
-				words = splitWords(item, noWrap);
+				words = splitWords(item, noWrap, breakAll);
 			}
 
 			if (lastWord && words.length) {

package/src/TextInlines.js

@@ -45,7 +45,7 @@ class TextInlines {
 	 * Converts an array of strings (or inline-definition-objects) into a collection
 	 * of inlines and calculated minWidth/maxWidth and their min/max widths
 	 *
-	 * @param {Array} textArray an array of inline-definition-objects (or strings)
+	 * @param {Array|object} textArray an array of inline-definition-objects (or strings)
 	 * @param {StyleContextStack} styleContextStack current style stack
 	 * @returns {object} collection of inlines, minWidth, maxWidth
 	 */

package/src/URLResolver.js

@@ -1,35 +1,14 @@
-import http from 'http';
-import https from 'https';
-
-const fetchUrl = (url, headers = {}) => {
-	return new Promise((resolve, reject) => {
-		const parsedUrl = new URL(url);
-		const h = (parsedUrl.protocol === 'https:') ? https : http;
-		let options = {
-			headers: headers
-		};
-
-		h.get(url, options, res => {
-			if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) { // redirect url
-				fetchUrl(res.headers.location).then(buffer => {
-					resolve(buffer);
-				}, result => {
-					reject(result);
-				});
-				return;
-			}
-
-			const ok = res.statusCode >= 200 && res.statusCode < 300;
-			if (!ok) {
-				reject(new TypeError(`Failed to fetch (status code: ${res.statusCode}, url: "${url}")`));
-			}
-
-			const chunks = [];
-			res.on('end', () => resolve(Buffer.concat(chunks)));
-			res.on('data', d => chunks.push(d));
-		}).on('error', reject);
-	});
-};
+async function fetchUrl(url, headers = {}) {
+	try {
+		const response = await fetch(url, { headers });
+		if (!response.ok) {
+			throw new Error(`Failed to fetch (status code: ${response.status}, url: "${url}")`);
+		}
+		return await response.arrayBuffer();
+	} catch (error) {
+		throw new Error(`Network request failed (url: "${url}", error: ${error.message})`);
+	}
+}
 
 class URLResolver {
 	constructor(fs) {
@@ -38,38 +17,25 @@ class URLResolver {
 	}
 
 	resolve(url, headers = {}) {
-		if (!this.resolving[url]) {
-			this.resolving[url] = new Promise((resolve, reject) => {
-				if (url.toLowerCase().indexOf('https://') === 0 || url.toLowerCase().indexOf('http://') === 0) {
-					if (this.fs.existsSync(url)) {
-						// url was downloaded earlier
-						resolve();
-					} else {
-						fetchUrl(url, headers).then(buffer => {
-							this.fs.writeFileSync(url, buffer);
-							resolve();
-						}, result => {
-							reject(result);
-						});
-					}
-				} else {
-					// cannot be resolved
-					resolve();
+		const resolveUrlInternal = async () => {
+			if (url.toLowerCase().startsWith('https://') || url.toLowerCase().startsWith('http://')) {
+				if (this.fs.existsSync(url)) {
+					return; // url was downloaded earlier
 				}
-			});
-		}
+				const buffer = await fetchUrl(url, headers);
+				this.fs.writeFileSync(url, buffer);
+			}
+			// else cannot be resolved
+		};
 
+		if (!this.resolving[url]) {
+			this.resolving[url] = resolveUrlInternal();
+		}
 		return this.resolving[url];
 	}
 
 	resolved() {
-		return new Promise((resolve, reject) => {
-			Promise.all(Object.values(this.resolving)).then(() => {
-				resolve();
-			}, result => {
-				reject(result);
-			});
-		});
+		return Promise.all(Object.values(this.resolving));
 	}
 
 }

package/src/base.js

@@ -18,7 +18,7 @@ class pdfmake {
 		options.progressCallback = this.progressCallback;
 		options.tableLayouts = this.tableLayouts;
 
-		let printer = new Printer(this.fonts, this.virtualfs, this.urlResolver);
+		let printer = new Printer(this.fonts, this.virtualfs, this.urlResolver());
 		const pdfDocumentPromise = printer.createPdfKitDocument(docDefinition, options);
 
 		return this._transformToDocument(pdfDocumentPromise);

package/src/browser-extensions/OutputDocumentBrowser.js

@@ -20,98 +20,60 @@ class OutputDocumentBrowser extends OutputDocument {
 	/**
 	 * @returns {Promise<Blob>}
 	 */
-	getBlob() {
-		return new Promise((resolve, reject) => {
-			this.getBuffer().then(buffer => {
-				try {
-					let blob = new Blob([buffer], { type: 'application/pdf' });
-					resolve(blob);
-				} catch (e) {
-					reject(e);
-				}
-			}, result => {
-				reject(result);
-			});
-		});
+	async getBlob() {
+		const buffer = await this.getBuffer();
+		return new Blob([buffer], { type: 'application/pdf' });
 	}
 
 	/**
 	 * @param {string} filename
 	 * @returns {Promise}
 	 */
-	download(filename = 'file.pdf') {
-		return new Promise((resolve, reject) => {
-			this.getBlob().then(blob => {
-				try {
-					saveAs(blob, filename);
-					resolve();
-				} catch (e) {
-					reject(e);
-				}
-			}, result => {
-				reject(result);
-			});
-		});
+	async download(filename = 'file.pdf') {
+		const blob = await this.getBlob();
+		saveAs(blob, filename);
 	}
 
 	/**
 	 * @param {Window} win
 	 * @returns {Promise}
 	 */
-	open(win = null) {
-		return new Promise((resolve, reject) => {
-			if (!win) {
-				win = openWindow();
-			}
-			this.getBlob().then(blob => {
-				try {
-					let urlCreator = window.URL || window.webkitURL;
-					let pdfUrl = urlCreator.createObjectURL(blob);
-					win.location.href = pdfUrl;
+	async open(win = null) {
+		if (!win) {
+			win = openWindow();
+		}
+		const blob = await this.getBlob();
+		try {
+			let urlCreator = window.URL || window.webkitURL;
+			let pdfUrl = urlCreator.createObjectURL(blob);
+			win.location.href = pdfUrl;
 
-					//
-					resolve();
-					/* temporarily disabled
-					if (win === window) {
-						resolve();
-					} else {
-						setTimeout(() => {
-							if (win.window === null) { // is closed by AdBlock
-								window.location.href = pdfUrl; // open in actual window
-							}
-							resolve();
-						}, 500);
+			/* temporarily disabled
+			if (win === window) {
+				return;
+			} else {
+				setTimeout(() => {
+					if (win.window === null) { // is closed by AdBlock
+						window.location.href = pdfUrl; // open in actual window
 					}
-					*/
-				} catch (e) {
-					win.close();
-					reject(e);
-				}
-			}, result => {
-				reject(result);
-			});
-		});
+					return;
+				}, 500);
+			}
+			*/
+		} finally {
+			win.close();
+		}
 	}
 
 	/**
 	 * @param {Window} win
 	 * @returns {Promise}
 	 */
-	print(win = null) {
-		return new Promise((resolve, reject) => {
-			this.getStream().then(stream => {
-				stream.setOpenActionAsPrint();
-				return this.open(win).then(() => {
-					resolve();
-				}, result => {
-					reject(result);
-				});
-			}, result => {
-				reject(result);
-			});
-		});
+	async print(win = null) {
+		const stream = await this.getStream();
+		stream.setOpenActionAsPrint();
+		await this.open(win);
 	}
-
 }
 
 export default OutputDocumentBrowser;

package/src/browser-extensions/index.js

@@ -1,12 +1,12 @@
 import pdfmakeBase from '../base';
 import OutputDocumentBrowser from './OutputDocumentBrowser';
-import URLBrowserResolver from './URLBrowserResolver';
+import URLResolver from '../URLResolver';
 import fs from 'fs';
 import configurator from 'core-js/configurator';
 
 // core-js: Polyfills will be used only if natives completely unavailable.
 configurator({
-  useNative: ['Promise']
+	useNative: ['Promise']
 });
 
 let defaultClientFonts = {
@@ -21,7 +21,7 @@ let defaultClientFonts = {
 class pdfmake extends pdfmakeBase {
 	constructor() {
 		super();
-		this.urlResolver = new URLBrowserResolver(this.virtualfs);
+		this.urlResolver = () => new URLResolver(this.virtualfs);
 		this.fonts = defaultClientFonts;
 	}
 

package/src/browser-extensions/pdfMake.js

@@ -1,15 +1 @@
-const isBrowserSupported = () => {
-	if ((typeof window === 'undefined') || (typeof window.navigator === 'undefined')) {
-		// Enviroment is not browser.
-		return true;
-	}
-
-	// Internet Explorer 10 and older is not supported.
-	return window.navigator.userAgent.indexOf("MSIE") === -1;
-};
-
-if (!isBrowserSupported()) {
-	throw new Error('pdfmake: Internet Explorer 10 and older is not supported. Upgrade to version 11 or use modern browser.');
-}
-
 module.exports = require('./index').default;

package/src/browser-extensions/standard-fonts/Courier.js

@@ -2,10 +2,10 @@ var fs = require('fs');
 
 var fontContainer = {
 	vfs: {
-		'data/Courier.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier.afm', 'utf8'), encoding: 'utf8' },
-		'data/Courier-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier-Bold.afm', 'utf8'), encoding: 'utf8' },
-		'data/Courier-Oblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier-Oblique.afm', 'utf8'), encoding: 'utf8' },
-		'data/Courier-BoldOblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Courier-BoldOblique.afm', 'utf8'), encoding: 'utf8' }
+		'data/Courier.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier.afm', 'utf8'), encoding: 'utf8' },
+		'data/Courier-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier-Bold.afm', 'utf8'), encoding: 'utf8' },
+		'data/Courier-Oblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier-Oblique.afm', 'utf8'), encoding: 'utf8' },
+		'data/Courier-BoldOblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Courier-BoldOblique.afm', 'utf8'), encoding: 'utf8' }
 	},
 	fonts: {
 		Courier: {

package/src/browser-extensions/standard-fonts/Helvetica.js

@@ -2,10 +2,10 @@ var fs = require('fs');
 
 var fontContainer = {
 	vfs: {
-		'data/Helvetica.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica.afm', 'utf8'), encoding: 'utf8' },
-		'data/Helvetica-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica-Bold.afm', 'utf8'), encoding: 'utf8' },
-		'data/Helvetica-Oblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica-Oblique.afm', 'utf8'), encoding: 'utf8' },
-		'data/Helvetica-BoldOblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Helvetica-BoldOblique.afm', 'utf8'), encoding: 'utf8' }
+		'data/Helvetica.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica.afm', 'utf8'), encoding: 'utf8' },
+		'data/Helvetica-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica-Bold.afm', 'utf8'), encoding: 'utf8' },
+		'data/Helvetica-Oblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica-Oblique.afm', 'utf8'), encoding: 'utf8' },
+		'data/Helvetica-BoldOblique.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Helvetica-BoldOblique.afm', 'utf8'), encoding: 'utf8' }
 	},
 	fonts: {
 		Helvetica: {

package/src/browser-extensions/standard-fonts/Symbol.js

@@ -2,7 +2,7 @@ var fs = require('fs');
 
 var fontContainer = {
 	vfs: {
-		'data/Symbol.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Symbol.afm', 'utf8'), encoding: 'utf8' }
+		'data/Symbol.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Symbol.afm', 'utf8'), encoding: 'utf8' }
 	},
 	fonts: {
 		Symbol: {

package/src/browser-extensions/standard-fonts/Times.js

@@ -2,10 +2,10 @@ var fs = require('fs');
 
 var fontContainer = {
 	vfs: {
-		'data/Times-Roman.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-Roman.afm', 'utf8'), encoding: 'utf8' },
-		'data/Times-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-Bold.afm', 'utf8'), encoding: 'utf8' },
-		'data/Times-Italic.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-Italic.afm', 'utf8'), encoding: 'utf8' },
-		'data/Times-BoldItalic.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/Times-BoldItalic.afm', 'utf8'), encoding: 'utf8' }
+		'data/Times-Roman.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-Roman.afm', 'utf8'), encoding: 'utf8' },
+		'data/Times-Bold.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-Bold.afm', 'utf8'), encoding: 'utf8' },
+		'data/Times-Italic.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-Italic.afm', 'utf8'), encoding: 'utf8' },
+		'data/Times-BoldItalic.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/Times-BoldItalic.afm', 'utf8'), encoding: 'utf8' }
 	},
 	fonts: {
 		Times: {

package/src/browser-extensions/standard-fonts/ZapfDingbats.js

@@ -2,7 +2,7 @@ var fs = require('fs');
 
 var fontContainer = {
 	vfs: {
-		'data/ZapfDingbats.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/@foliojs-fork/pdfkit/js/data/ZapfDingbats.afm', 'utf8'), encoding: 'utf8' }
+		'data/ZapfDingbats.afm': { data: fs.readFileSync(__dirname + '/../../../node_modules/pdfkit/js/data/ZapfDingbats.afm', 'utf8'), encoding: 'utf8' }
 	},
 	fonts: {
 		ZapfDingbats: {

package/src/columnCalculator.js

@@ -1,6 +1,6 @@
 import { isString } from './helpers/variableType';
 
-function buildColumnWidths(columns, availableWidth) {
+function buildColumnWidths(columns, availableWidth, offsetTotal = 0, tableNode) {
 	let autoColumns = [];
 	let autoMin = 0;
 	let autoMax = 0;
@@ -24,10 +24,31 @@ function buildColumnWidths(columns, availableWidth) {
 		}
 	});
 
-	fixedColumns.forEach(col => {
+	fixedColumns.forEach((col, colIndex) => {
 		// width specified as %
 		if (isString(col.width) && /\d+%/.test(col.width)) {
-			col.width = parseFloat(col.width) * initial_availableWidth / 100;
+			// In tables we have to take into consideration the reserved width for paddings and borders
+			let reservedWidth = 0;
+			if (tableNode) {
+				const paddingLeft = tableNode._layout.paddingLeft(colIndex, tableNode);
+				const paddingRight = tableNode._layout.paddingRight(colIndex, tableNode);
+				const borderLeft = tableNode._layout.vLineWidth(colIndex, tableNode);
+				const borderRight = tableNode._layout.vLineWidth(colIndex + 1, tableNode);
+				if (colIndex === 0) {
+					// first column assumes whole borderLeft and half of border right
+					reservedWidth = paddingLeft + paddingRight + borderLeft + (borderRight / 2);
+
+				} else if (colIndex === fixedColumns.length - 1) {
+					// last column assumes whole borderRight and half of border left
+					reservedWidth = paddingLeft + paddingRight + (borderLeft / 2) + borderRight;
+
+				} else {
+					// Columns in the middle assume half of each border
+					reservedWidth = paddingLeft + paddingRight + (borderLeft / 2) + (borderRight / 2);
+				}
+			}
+			const totalAvailableWidth = initial_availableWidth + offsetTotal;
+			col.width = (parseFloat(col.width) * totalAvailableWidth / 100) - reservedWidth;
 		}
 		if (col.width < (col._minWidth) && col.elasticWidth) {
 			col._calcWidth = col._minWidth;

package/src/helpers/tools.js

@@ -37,3 +37,8 @@ export function offsetVector(vector, x, y) {
 			break;
 	}
 }
+
+export function convertToDynamicContent(staticContent) {
+	return () => // copy to new object
+		JSON.parse(JSON.stringify(staticContent));
+}

package/src/helpers/variableType.js

@@ -14,6 +14,17 @@ export function isNumber(variable) {
 	return (typeof variable === 'number') || (variable instanceof Number);
 }
 
+/**
+ * @param {any} variable
+ * @returns {boolean}
+ */
+export function isPositiveInteger(variable) {
+	if (!isNumber(variable) || !Number.isInteger(variable) || variable <= 0) {
+		return false;
+	}
+	return true;
+}
+
 /**
  * @param {any} variable
  * @returns {boolean}