@flowaccount/pdfmake 1.0.4-staging.0 → 1.0.4-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowaccount/pdfmake",
-  "version": "1.0.4-staging.0",
+  "version": "1.0.4-staging.2",
   "description": "Client/server side PDF printing in pure JavaScript",
   "main": "src/printer.js",
   "browser": "build/pdfmake.js",

package/src/pageElementWriter.js

@@ -266,7 +266,7 @@ PageElementWriter.prototype.moveToNextPage = function (pageOrientation) {
 	this.writer.tracker.emit('pageChanged', {
 		prevPage: nextPage.prevPage,
 		prevY: nextPage.prevY,
-		y: nextPage.y
+		y: this.writer.context.y
 	});
 };
 

package/src/textTools.js

@@ -1,22 +1,17 @@
+/* jslint node: true */
 'use strict';
 
-var isString = require('./helpers').isString;
-var isNumber = require('./helpers').isNumber;
-var isObject = require('./helpers').isObject;
-var isArray = require('./helpers').isArray;
-var isUndefined = require('./helpers').isUndefined;
 var LineBreaker = require('@foliojs-fork/linebreak');
-var Tokenizer = require('@flowaccount/node-icu-tokenizer');
-var fontkit = require('fontkit');
+const Tokenizer = require('@flowaccount/node-icu-tokenizer');
+const fontkit = require('fontkit');
 
 var LEADING = /^(\s)+/g;
 var TRAILING = /(\s)+$/g;
 
-var fontCacheName = '';
-var fontCache = null;
-var fontSubstituteCache = {};
-var defaultFont = 'Roboto';
-
+var fontCacheName_new = '';
+var fontCache_new = {};
+var fontSubstituteCache = [];
+var defaultFont = '';
 /**
  * Creates an instance of TextTools - text measurement utility
  *
@@ -36,10 +31,57 @@ function TextTools(fontProvider) {
  * @return {Object}                   collection of inlines, minWidth, maxWidth
  */
 TextTools.prototype.buildInlines = function (textArray, styleContextStack) {
-	primeFontCaches.call(this, styleContextStack);
 
-	var measured = measure(this.fontProvider, textArray, styleContextStack);
 
+	defaultFont = (styleContextStack && styleContextStack.getProperty('font')) || 'Roboto';
+	// if(!fontCacheName_new)
+	// {
+		fontCacheName_new = defaultFont;
+		// Only open font files if fonts exist and provider has fonts property
+		if (this.fontProvider.fonts && this.fontProvider.fonts[fontCacheName_new] && this.fontProvider.fonts[fontCacheName_new].normal) {
+			try {
+				fontCache_new = fontkit.openSync(this.fontProvider.fonts[fontCacheName_new].normal);
+			} catch (e) {
+				// Font file doesn't exist (likely in tests), provide mock methods
+				fontCache_new = {
+					glyphsForString: function(text) {
+						// Return mock glyphs - all valid (id > 0)
+						return text.split('').map(function(char, i) {
+							return { id: i + 1, char: char };
+						});
+					}
+				};
+			}
+		}
+	//}
+	//var fcount = 0;
+	if (this.fontProvider.fonts) {
+		for(let fontItem in this.fontProvider.fonts) {
+			if(fontCacheName_new != fontItem) {
+				if(!fontSubstituteCache[fontItem])
+				{
+					try {
+						var fontObj = fontkit.openSync(this.fontProvider.fonts[fontItem].normal);
+						fontSubstituteCache[fontItem] = { "Name" : fontItem, "FontObj" : fontObj };
+					} catch (e) {
+						// Font file doesn't exist (likely in tests), provide mock font object
+						fontSubstituteCache[fontItem] = {
+							"Name" : fontItem,
+							"FontObj" : {
+								glyphsForString: function(text) {
+									// Return mock glyphs - all valid (id > 0)
+									return text.split('').map(function(char, i) {
+										return { id: i + 1, char: char };
+									});
+								}
+							}
+						};
+					}
+				}
+			}
+		}
+	}
+	var measured = measure(this.fontProvider, textArray, styleContextStack);
 	var minWidth = 0,
 		maxWidth = 0,
 		currentLineWidth;
@@ -48,7 +90,7 @@ TextTools.prototype.buildInlines = function (textArray, styleContextStack) {
 		minWidth = Math.max(minWidth, inline.width - inline.leadingCut - inline.trailingCut);
 
 		if (!currentLineWidth) {
-			currentLineWidth = { width: 0, leadingCut: inline.leadingCut, trailingCut: 0 };
+			currentLineWidth = {width: 0, leadingCut: inline.leadingCut, trailingCut: 0};
 		}
 
 		currentLineWidth.width += inline.width;
@@ -83,12 +125,11 @@ TextTools.prototype.buildInlines = function (textArray, styleContextStack) {
  * @return {Object}                   size of the specified string
  */
 TextTools.prototype.sizeOfString = function (text, styleContextStack) {
-	text = text ? text.toString().replace(/\t/g, '    ') : '';
+	text = text ? text.toString().replace('\t', '    ') : '';
 
 	//TODO: refactor - extract from measure
 	var fontName = getStyleProperty({}, styleContextStack, 'font', 'Roboto');
 	var fontSize = getStyleProperty({}, styleContextStack, 'fontSize', 12);
-	var fontFeatures = getStyleProperty({}, styleContextStack, 'fontFeatures', null);
 	var bold = getStyleProperty({}, styleContextStack, 'bold', false);
 	var italics = getStyleProperty({}, styleContextStack, 'italics', false);
 	var lineHeight = getStyleProperty({}, styleContextStack, 'lineHeight', 1);
@@ -97,7 +138,7 @@ TextTools.prototype.sizeOfString = function (text, styleContextStack) {
 	var font = this.fontProvider.provideFont(fontName, bold, italics);
 
 	return {
-		width: widthOfString(text, font, fontSize, characterSpacing, fontFeatures),
+		width: widthOfString(text, font, fontSize, characterSpacing),
 		height: font.lineHeight(fontSize) * lineHeight,
 		fontSize: fontSize,
 		lineHeight: lineHeight,
@@ -106,26 +147,31 @@ TextTools.prototype.sizeOfString = function (text, styleContextStack) {
 	};
 };
 
-/**
- * Returns size of the specified rotated string (without breaking it) using the current style
- *
- * @param  {string} text text to be measured
- * @param  {number} angle
- * @param  {object} styleContextStack current style stack
- * @returns {object} size of the specified string
- */
-TextTools.prototype.sizeOfRotatedText = function (text, angle, styleContextStack) {
-	var angleRad = angle * Math.PI / -180;
-	var size = this.sizeOfString(text, styleContextStack);
-	return {
-		width: Math.abs(size.height * Math.sin(angleRad)) + Math.abs(size.width * Math.cos(angleRad)),
-		height: Math.abs(size.width * Math.sin(angleRad)) + Math.abs(size.height * Math.cos(angleRad))
-	};
+TextTools.prototype.widthOfString = function (text, font, fontSize, characterSpacing) {
+	return widthOfString(text, font, fontSize, characterSpacing);
 };
 
-TextTools.prototype.widthOfString = function (text, font, fontSize, characterSpacing, fontFeatures) {
-	return widthOfString(text, font, fontSize, characterSpacing, fontFeatures);
-};
+function tokenizerWords(word) {
+
+	var regex = / /;
+	word = word.replace(regex, "[BLANK]");
+
+	var tokenizer = new Tokenizer().tokenize(word, { ignoreWhitespaceTokens:false });
+ for(var tItem in tokenizer){
+	 if(tItem < tokenizer.length){
+		 var numIndex = parseInt(tItem);
+		 if(tokenizer[numIndex].token == '[' && tokenizer[numIndex + 1].token  == 'BLANK' && tokenizer[numIndex + 2].token == ']') {
+			 tokenizer[numIndex].token = ' ';
+			 tokenizer[numIndex + 1].del = true;
+			 tokenizer[numIndex + 2].del = true;
+		 }
+
+	 } else {
+		 break;
+	 }
+ } 
+	 return tokenizer;
+}
 
 function splitWords(text, noWrap) {
 	var results = [];
@@ -133,86 +179,58 @@ function splitWords(text, noWrap) {
 	text = text.replace(/\t/g, '    ');
 	text = text.replace(/\r/g, '');
 
-	// Remove all invisible/hidden Unicode characters that can cause font rendering issues
-	// This includes: zero-width spaces, directional marks, line/paragraph separators, and other control characters
-	// See CLAUDE.md "Hidden Unicode Characters & Font Rendering Issues" for full list
-	text = text.replace(/[\u200B-\u200D\uFEFF\u200E\u200F\u202A-\u202E\u2028\u2029\u180E\u2060-\u2064\u206A-\u206F]/g, '');
+	// Remove Hidden Unicode
+	text = text.replace(/[\u200D\uFEFF\u200E\u200F\u202A-\u202E\u2028\u2029\u180E\u2060-\u2064\u206A-\u206F]/g, '');
 
 	if (noWrap) {
-		results.push({ text: text });
+		results.push({text: text});
 		return results;
-	}
+	} 
 
-	var breaker = new LineBreaker(text);
-	var last = 0;
-	var bk;
+		 var breaker = new LineBreaker(text);
+		 	var last = 0;
+		 	var bk;
 
-	while ((bk = breaker.nextBreak())) {
-		var word = text.slice(last, bk.position);
-		var isLineEnd = bk.required || /\r?\n$|\r$/.test(word);
-		var trimmed = word.trim();
-		var useTokenizer = !exceptTokenizer(trimmed) && needsTokenizer(trimmed);
+			while (bk = breaker.nextBreak()) {
+				var word = text.slice(last, bk.position);
 
-		if (!useTokenizer) {
-			var output = word;
-			if (isLineEnd) {
-				output = output.replace(/\r?\n$|\r$/, '');
-			}
-			results.push({ text: output, lineEnd: isLineEnd });
-		} else {
-			var tokenWord = tokenizerWords(word);
-			for (var tIndex = 0; tIndex < tokenWord.length; tIndex++) {
-				var token = tokenWord[tIndex];
-				if (!token || token.del) {
-					continue;
+				if(exceptTokenizer(word.trim()))
+				{				
+					results.push({text: word, lineEnd: (bk.required || word.match(/\r?\n$|\r$/))});
 				}
-
-				var tokenText = token.token;
-				var tokenResult = { text: tokenText };
-
-				if (tokenText === '\n') {
-					tokenResult.lineEnd = true;
-					tokenResult.text = '';
-				} else if (isLineEnd && tIndex === tokenWord.length - 1) {
-					tokenResult.text = tokenText.replace(/\r?\n$|\r$/, '');
-					tokenResult.lineEnd = true;
+				else if (bk.required || word.match(/\r?\n$|\r$/)) {
+					//word = word.replace(/\r?\n$|\r$/, '');
+
+					var tokenWord = tokenizerWords(word);
+					for (var tIndex in tokenWord) {
+						if (!tokenWord[tIndex].del) {
+							if (tIndex < tokenWord.length - 1 && tokenWord[tIndex].token != '\n') {
+								results.push({ text: tokenWord[tIndex].token });
+							} else {
+								results.push({ text: tokenWord[tIndex].token, lineEnd: true });
+							}
+						}
+					}
+				} else {
+					var tokenWord = tokenizerWords(word);
+					for (var tIndex in tokenWord) {
+						if (!tokenWord[tIndex].del) {
+							results.push({ text: tokenWord[tIndex].token });
+						}
+					}
 				}
 
-				results.push(tokenResult);
+				last = bk.position;
 			}
-		}
-
-		last = bk.position;
-	}
-
 	return results;
 }
 
-function tokenizerWords(word) {
-	var regex = / /;
-	word = word.replace(regex, '[BLANK]');
-
-	var tokenizer = new Tokenizer().tokenize(word, { ignoreWhitespaceTokens: false });
-
-	for (var i = 0; i < tokenizer.length; i++) {
-		if (tokenizer[i] && tokenizer[i].token === '[' &&
-			tokenizer[i + 1] && tokenizer[i + 1].token === 'BLANK' &&
-			tokenizer[i + 2] && tokenizer[i + 2].token === ']') {
-			tokenizer[i].token = ' ';
-			tokenizer[i + 1].del = true;
-			tokenizer[i + 2].del = true;
-		}
-	}
-
-	return tokenizer;
-}
-
 function copyStyle(source, destination) {
 	destination = destination || {};
 	source = source || {}; //TODO: default style
 
 	for (var key in source) {
-		if (key !== 'text' && Object.prototype.hasOwnProperty.call(source, key)) {
+		if (key != 'text' && source.hasOwnProperty(key)) {
 			destination[key] = source[key];
 		}
 	}
@@ -221,69 +239,26 @@ function copyStyle(source, destination) {
 }
 
 function normalizeTextArray(array, styleContextStack) {
-	function flatten(target) {
-		return target.reduce(function (prev, cur) {
-			var current = isObject(cur) && isArray(cur.text) ? flatten(cur.text) : cur;
-			var more = [].concat(current).some(Array.isArray);
-			return prev.concat(more ? flatten(current) : current);
-		}, []);
-	}
-
-	function getOneWord(index, words, noWrap) {
-		if (isUndefined(words[index])) {
-			return null;
-		}
-
-		if (words[index].lineEnd) {
-			return null;
-		}
-
-		var word = words[index].text;
-
-		if (noWrap) {
-			var tmpWords = splitWords(normalizeString(word), false);
-			if (isUndefined(tmpWords[tmpWords.length - 1])) {
-				return null;
-			}
-			word = tmpWords[tmpWords.length - 1].text;
-		}
-
-		return word;
-	}
-
 	var results = [];
 
-	if (!isArray(array)) {
+	if (!Array.isArray(array)) {
 		array = [array];
 	}
 
-	array = flatten(array);
-
-	var lastWord = null;
 	for (var i = 0, l = array.length; i < l; i++) {
 		var item = array[i];
 		var style = null;
 		var words;
 
 		var noWrap = getStyleProperty(item || {}, styleContextStack, 'noWrap', false);
-		if (isObject(item)) {
-			if (item._textRef && item._textRef._textNodeRef && item._textRef._textNodeRef.text) {
-				item.text = item._textRef._textNodeRef.text;
-			}
+
+		if (item !== null && (typeof item === 'object' || item instanceof Object)) {
 			words = splitWords(normalizeString(item.text), noWrap);
 			style = copyStyle(item);
 		} else {
 			words = splitWords(normalizeString(item), noWrap);
 		}
 
-		if (lastWord && words.length) {
-			var firstWord = getOneWord(0, words, noWrap);
-			var wrapWords = splitWords(normalizeString(lastWord + firstWord), false);
-			if (wrapWords.length === 1) {
-				results[results.length - 1].noNewLine = true;
-			}
-		}
-
 		for (var i2 = 0, l2 = words.length; i2 < l2; i2++) {
 			var result = {
 				text: words[i2].text
@@ -293,32 +268,29 @@ function normalizeTextArray(array, styleContextStack) {
 				result.lineEnd = true;
 			}
 
-			// Preserve leading spaces for words that come after a line break (not the first word)
-			// This fixes the issue where spaces at the beginning of new lines are removed
-			if (i2 > 0 && words[i2 - 1].lineEnd) {
-				result.preserveLeadingSpaces = true;
-			}
-
 			copyStyle(style, result);
 			results.push(result);
-		}
-
-		lastWord = null;
-		if (i + 1 < l) {
-			lastWord = getOneWord(words.length - 1, words, noWrap);
-		}
+		}								
 	}
-
 	return results;
 }
 
 function normalizeString(value) {
 	if (value === undefined || value === null) {
 		return '';
-	} else if (isNumber(value)) {
+	} else if (typeof value === 'number') {
 		return value.toString();
-	} else if (isString(value)) {
+	} else if (typeof value === 'string' || value instanceof String) {
 		return value;
+	} else if (Array.isArray(value)) {
+		// Handle arrays - extract text from first element if it exists
+		if (value.length > 0) {
+			return normalizeString(value[0]);
+		}
+		return '';
+	} else if (typeof value === 'object' && value.text !== undefined) {
+		// Recursively extract nested text property (handles { text: { text: 'hello' } })
+		return normalizeString(value.text);
 	} else {
 		return value.toString();
 	}
@@ -327,18 +299,22 @@ function normalizeString(value) {
 function getStyleProperty(item, styleContextStack, property, defaultValue) {
 	var value;
 
-	if (item && item[property] !== undefined && item[property] !== null) {
+	if (item[property] !== undefined && item[property] !== null) {
 		// item defines this property
 		return item[property];
 	}
 
-	if (!styleContextStack || typeof styleContextStack.auto !== 'function') {
+	if (!styleContextStack) {
 		return defaultValue;
 	}
 
-	styleContextStack.auto(item, function () {
+	if (styleContextStack.auto && typeof styleContextStack.auto === 'function') {
+		styleContextStack.auto(item, function () {
+			value = styleContextStack.getProperty(property);
+		});
+	} else if (styleContextStack.getProperty && typeof styleContextStack.getProperty === 'function') {
 		value = styleContextStack.getProperty(property);
-	});
+	}
 
 	if (value !== null && value !== undefined) {
 		return value;
@@ -347,9 +323,38 @@ function getStyleProperty(item, styleContextStack, property, defaultValue) {
 	}
 }
 
+function getFontCompaitible(item, fontProvider, styleContextStack) {
+	// Guard against missing or non-string text
+	if (!item.text || typeof item.text !== 'string') {
+		return defaultFont;
+	}
+
+	if(fontCacheName_new && fontCache_new && typeof fontCache_new.glyphsForString === 'function') {
+		var glyphList = fontCache_new.glyphsForString(item.text);
+		if(glyphList.filter(function(x) {return x.id <= 0;}).length == 0) {
+			return fontCacheName_new;
+		}
+	}
+	for(let count in fontSubstituteCache) {
+		var fontItem = fontSubstituteCache[count];
+		if(fontCacheName_new != fontItem.Name) {
+			var glyphList = fontItem.FontObj.glyphsForString(item.text);
+			if(glyphList.filter(function(x) {return x.id <= 0;}).length == 0) {
+				return fontItem.Name;
+			}
+		}
+	}
+	return defaultFont;
+}
+
 function measure(fontProvider, textArray, styleContextStack) {
 	var normalized = normalizeTextArray(textArray, styleContextStack);
 
+	// Filter out items without valid text (empty objects, etc.)
+	normalized = normalized.filter(function(item) {
+		return item.text && typeof item.text === 'string';
+	});
+
 	if (normalized.length) {
 		var leadingIndent = getStyleProperty(normalized[0], styleContextStack, 'leadingIndent', 0);
 
@@ -358,11 +363,10 @@ function measure(fontProvider, textArray, styleContextStack) {
 			normalized[0].leadingIndent = leadingIndent;
 		}
 	}
-
 	normalized.forEach(function (item) {
-		var fontName = getFontCompaitible(item);
+
+		var fontName = getFontCompaitible(item, fontProvider, styleContextStack);//getStyleProperty(item, styleContextStack, 'font', 'Roboto');
 		var fontSize = getStyleProperty(item, styleContextStack, 'fontSize', 12);
-		var fontFeatures = getStyleProperty(item, styleContextStack, 'fontFeatures', null);
 		var bold = getStyleProperty(item, styleContextStack, 'bold', false);
 		var italics = getStyleProperty(item, styleContextStack, 'italics', false);
 		var color = getStyleProperty(item, styleContextStack, 'color', 'black');
@@ -374,44 +378,34 @@ function measure(fontProvider, textArray, styleContextStack) {
 		var characterSpacing = getStyleProperty(item, styleContextStack, 'characterSpacing', 0);
 		var link = getStyleProperty(item, styleContextStack, 'link', null);
 		var linkToPage = getStyleProperty(item, styleContextStack, 'linkToPage', null);
-		var linkToDestination = getStyleProperty(item, styleContextStack, 'linkToDestination', null);
 		var noWrap = getStyleProperty(item, styleContextStack, 'noWrap', null);
 		var preserveLeadingSpaces = getStyleProperty(item, styleContextStack, 'preserveLeadingSpaces', false);
-		var preserveTrailingSpaces = getStyleProperty(item, styleContextStack, 'preserveTrailingSpaces', false);
-		var opacity = getStyleProperty(item, styleContextStack, 'opacity', 1);
-		var sup = getStyleProperty(item, styleContextStack, 'sup', false);
-		var sub = getStyleProperty(item, styleContextStack, 'sub', false);
-
-		if ((sup || sub) && item.fontSize === undefined) {
-			// font size reduction taken from here: https://en.wikipedia.org/wiki/Subscript_and_superscript#Desktop_publishing
-			fontSize *= 0.58;
-		}
 
 		var font = fontProvider.provideFont(fontName, bold, italics);
 
-		item.width = widthOfString(item.text, font, fontSize, characterSpacing, fontFeatures);
+		item.width = widthOfString(item.text, font, fontSize, characterSpacing);
 		item.height = font.lineHeight(fontSize) * lineHeight;
 
+		var leadingSpaces = item.text.match(LEADING);
+
 		if (!item.leadingCut) {
 			item.leadingCut = 0;
 		}
 
-		var leadingSpaces;
-		if (!preserveLeadingSpaces && (leadingSpaces = item.text.match(LEADING))) {
-			item.leadingCut += widthOfString(leadingSpaces[0], font, fontSize, characterSpacing, fontFeatures);
+		if (leadingSpaces && !preserveLeadingSpaces) {
+			item.leadingCut += widthOfString(leadingSpaces[0], font, fontSize, characterSpacing);
 		}
 
-		var trailingSpaces;
-		if (!preserveTrailingSpaces && (trailingSpaces = item.text.match(TRAILING))) {
-			item.trailingCut = widthOfString(trailingSpaces[0], font, fontSize, characterSpacing, fontFeatures);
-		} else if (item.trailingCut === undefined) {
+		var trailingSpaces = item.text.match(TRAILING);
+		if (trailingSpaces) {
+			item.trailingCut = widthOfString(trailingSpaces[0], font, fontSize, characterSpacing);
+		} else {
 			item.trailingCut = 0;
 		}
 
 		item.alignment = getStyleProperty(item, styleContextStack, 'alignment', 'left');
 		item.font = font;
 		item.fontSize = fontSize;
-		item.fontFeatures = fontFeatures;
 		item.characterSpacing = characterSpacing;
 		item.color = color;
 		item.decoration = decoration;
@@ -420,18 +414,14 @@ function measure(fontProvider, textArray, styleContextStack) {
 		item.background = background;
 		item.link = link;
 		item.linkToPage = linkToPage;
-		item.linkToDestination = linkToDestination;
 		item.noWrap = noWrap;
-		item.opacity = opacity;
-		item.sup = sup;
-		item.sub = sub;
 	});
 
 	return normalized;
 }
 
-function widthOfString(text, font, fontSize, characterSpacing, fontFeatures) {
-	return font.widthOfString(text, fontSize, fontFeatures) + ((characterSpacing || 0) * (text.length - 1));
+function widthOfString(text, font, fontSize, characterSpacing) {
+	return font.widthOfString(text, fontSize) + ((characterSpacing || 0) * (text.length - 1));
 }
 
 function exceptTokenizer(word) {
@@ -449,106 +439,4 @@ function exceptTokenizer(word) {
 	return listExceptWord.indexOf(word) > -1;
 }
 
-function needsTokenizer(word) {
-	if (!word) {
-		return false;
-	}
-
-	return /[\u0E00-\u0E7F]/.test(word);
-}
-
-function primeFontCaches(styleContextStack) {
-	if (styleContextStack && typeof styleContextStack.getProperty === 'function') {
-		var stackFont = styleContextStack.getProperty('font');
-		if (stackFont) {
-			defaultFont = stackFont;
-		}
-	}
-
-	if (!defaultFont) {
-		defaultFont = 'Roboto';
-	}
-
-	if (!this.fontProvider || !this.fontProvider.fonts) {
-		return;
-	}
-
-	if (defaultFont && fontCacheName !== defaultFont) {
-		var defaultFontDef = this.fontProvider.fonts[defaultFont];
-		var primaryFont = safeOpenFont(defaultFontDef && defaultFontDef.normal);
-
-		if (primaryFont) {
-			fontCacheName = defaultFont;
-			fontCache = primaryFont;
-		} else {
-			fontCacheName = '';
-			fontCache = null;
-		}
-	}
-
-	for (var fontItem in this.fontProvider.fonts) {
-		if (!Object.prototype.hasOwnProperty.call(this.fontProvider.fonts, fontItem)) {
-			continue;
-		}
-
-		if (fontItem === fontCacheName) {
-			continue;
-		}
-
-		if (!fontSubstituteCache[fontItem]) {
-			var substitute = safeOpenFont(this.fontProvider.fonts[fontItem].normal);
-			if (substitute) {
-				fontSubstituteCache[fontItem] = { Name: fontItem, FontObj: substitute };
-			}
-		}
-	}
-}
-
-function getFontCompaitible(item) {
-	var text = item.text || '';
-
-	if (fontCacheName && fontCache && !hasMissingGlyphs(fontCache.glyphsForString(text))) {
-		return fontCacheName;
-	}
-
-	for (var key in fontSubstituteCache) {
-		if (!Object.prototype.hasOwnProperty.call(fontSubstituteCache, key)) {
-			continue;
-		}
-
-		var fontItem = fontSubstituteCache[key];
-		if (!fontItem || !fontItem.FontObj || fontItem.Name === fontCacheName) {
-			continue;
-		}
-
-		if (!hasMissingGlyphs(fontItem.FontObj.glyphsForString(text))) {
-			return fontItem.Name;
-		}
-	}
-
-	return defaultFont || 'Roboto';
-}
-
-function hasMissingGlyphs(glyphList) {
-	for (var i = 0; i < glyphList.length; i++) {
-		if (!glyphList[i] || glyphList[i].id <= 0) {
-			return true;
-		}
-	}
-	return false;
-}
-
-function safeOpenFont(path) {
-	if (!path) {
-		return null;
-	}
-
-	try {
-		return fontkit.openSync(path);
-	} catch (error) {
-		void error;
-		return null;
-	}
-}
-
 module.exports = TextTools;