use a closure to store dependencies

lib/single-file/modules/css-fonts-alt-minifier.js

@@ -50,51 +50,57 @@ this.fontsAltMinifier = this.fontsAltMinifier || (() => {
 		"ultra-expanded": "200%"
 	};
 
+	let cssTree;
+
 	return {
-		process: (doc, stylesheets) => {
-			const fontsDetails = {
-				fonts: new Map(),
-				medias: new Map(),
-				supports: new Map()
-			};
-			const stats = { rules: { processed: 0, discarded: 0 }, fonts: { processed: 0, discarded: 0 } };
-			let sheetIndex = 0;
-			stylesheets.forEach(stylesheetInfo => {
-				const cssRules = stylesheetInfo.stylesheet.children;
-				if (cssRules) {
-					stats.rules.processed += cssRules.getSize();
-					stats.rules.discarded += cssRules.getSize();
-					if (stylesheetInfo.mediaText && stylesheetInfo.mediaText != MEDIA_ALL) {
-						const mediaFontsDetails = createFontsDetailsInfo();
-						fontsDetails.medias.set("media-" + sheetIndex + "-" + stylesheetInfo.mediaText, mediaFontsDetails);
-						getFontsDetails(doc, cssRules, sheetIndex, mediaFontsDetails);
-					} else {
-						getFontsDetails(doc, cssRules, sheetIndex, fontsDetails);
-					}
-				}
-				sheetIndex++;
-			});
-			processFontDetails(fontsDetails);
-			sheetIndex = 0;
-			stylesheets.forEach(stylesheetInfo => {
-				const cssRules = stylesheetInfo.stylesheet.children;
-				const media = stylesheetInfo.mediaText;
-				if (cssRules) {
-					if (media && media != MEDIA_ALL) {
-						processFontFaceRules(cssRules, sheetIndex, fontsDetails.medias.get("media-" + sheetIndex + "-" + media), stats);
-					} else {
-						processFontFaceRules(cssRules, sheetIndex, fontsDetails, stats);
-					}
-					stats.rules.discarded -= cssRules.getSize();
+		getInstance(cssTreeImpl) {
+			cssTree = cssTreeImpl;
+			return {
+				process: (doc, stylesheets) => {
+					const fontsDetails = {
+						fonts: new Map(),
+						medias: new Map(),
+						supports: new Map()
+					};
+					const stats = { rules: { processed: 0, discarded: 0 }, fonts: { processed: 0, discarded: 0 } };
+					let sheetIndex = 0;
+					stylesheets.forEach(stylesheetInfo => {
+						const cssRules = stylesheetInfo.stylesheet.children;
+						if (cssRules) {
+							stats.rules.processed += cssRules.getSize();
+							stats.rules.discarded += cssRules.getSize();
+							if (stylesheetInfo.mediaText && stylesheetInfo.mediaText != MEDIA_ALL) {
+								const mediaFontsDetails = createFontsDetailsInfo();
+								fontsDetails.medias.set("media-" + sheetIndex + "-" + stylesheetInfo.mediaText, mediaFontsDetails);
+								getFontsDetails(doc, cssRules, sheetIndex, mediaFontsDetails);
+							} else {
+								getFontsDetails(doc, cssRules, sheetIndex, fontsDetails);
+							}
+						}
+						sheetIndex++;
+					});
+					processFontDetails(fontsDetails);
+					sheetIndex = 0;
+					stylesheets.forEach(stylesheetInfo => {
+						const cssRules = stylesheetInfo.stylesheet.children;
+						const media = stylesheetInfo.mediaText;
+						if (cssRules) {
+							if (media && media != MEDIA_ALL) {
+								processFontFaceRules(cssRules, sheetIndex, fontsDetails.medias.get("media-" + sheetIndex + "-" + media), stats);
+							} else {
+								processFontFaceRules(cssRules, sheetIndex, fontsDetails, stats);
+							}
+							stats.rules.discarded -= cssRules.getSize();
+						}
+						sheetIndex++;
+					});
+					return stats;
 				}
-				sheetIndex++;
-			});
-			return stats;
+			};
 		}
 	};
 
 	function getFontsDetails(doc, cssRules, sheetIndex, mediaFontsDetails) {
-		const cssTree = this.fontsAltMinifier.cssTree;
 		let mediaIndex = 0, supportsIndex = 0;
 		cssRules.forEach(ruleData => {
 			if (ruleData.type == "Atrule" && ruleData.name == "media" && ruleData.block && ruleData.block.children && ruleData.prelude) {
@@ -163,7 +169,6 @@ this.fontsAltMinifier = this.fontsAltMinifier || (() => {
 	}
 
 	function processFontFaceRules(cssRules, sheetIndex, fontsDetails, stats) {
-		const cssTree = this.fontsAltMinifier.cssTree;
 		const removedRules = [];
 		let mediaIndex = 0, supportsIndex = 0;
 		for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
@@ -190,7 +195,6 @@ this.fontsAltMinifier = this.fontsAltMinifier || (() => {
 	}
 
 	function processFontFaceRule(ruleData, fontInfo, stats) {
-		const cssTree = this.fontsAltMinifier.cssTree;
 		const findSource = fontFormat => fontInfo.find(source => !source.src.match(EMPTY_URL_SOURCE) && source.format == fontFormat);
 		const filterSource = fontSource => fontInfo.filter(source => source == fontSource || source.src.startsWith(LOCAL_SOURCE));
 		stats.fonts.processed += fontInfo.length;

lib/single-file/modules/css-fonts-minifier.js

@@ -31,53 +31,62 @@ this.fontsMinifier = this.fontsMinifier || (() => {
 		bold: "700"
 	};
 
+	let cssTree, fontPropertyParser, docHelper;
+
 	return {
-		process: (doc, stylesheets, styles, options) => {
-			const stats = { rules: { processed: 0, discarded: 0 }, fonts: { processed: 0, discarded: 0 } };
-			const fontsInfo = { declared: [], used: [] };
-			const workStyleElement = doc.createElement("style");
-			let docContent = "";
-			doc.body.appendChild(workStyleElement);
-			stylesheets.forEach(stylesheetInfo => {
-				const cssRules = stylesheetInfo.stylesheet.children;
-				if (cssRules) {
-					stats.processed += cssRules.getSize();
-					stats.discarded += cssRules.getSize();
-					getFontsInfo(cssRules, fontsInfo);
-					docContent = getRulesTextContent(doc, cssRules, workStyleElement, docContent);
-				}
-			});
-			styles.forEach(declarations => {
-				const fontFamilyNames = getFontFamilyNames(declarations);
-				if (fontFamilyNames.length) {
-					fontsInfo.used.push(fontFamilyNames);
-				}
-				docContent = getDeclarationsTextContent(declarations.children, workStyleElement, docContent);
-			});
-			workStyleElement.remove();
-			docContent += doc.body.innerText;
-			const variableFound = fontsInfo.used.find(fontNames => fontNames.find(fontName => fontName.startsWith("var(--")));
-			let unusedFonts, filteredUsedFonts;
-			if (variableFound) {
-				unusedFonts = [];
-			} else {
-				filteredUsedFonts = new Map();
-				fontsInfo.used.forEach(fontNames => fontNames.forEach(familyName => {
-					if (fontsInfo.declared.find(fontInfo => fontInfo.fontFamily == familyName)) {
-						const optionalData = options.usedFonts && options.usedFonts.filter(fontInfo => fontInfo[0] == familyName);
-						filteredUsedFonts.set(familyName, optionalData);
+		getInstance(cssTreeImpl, fontPropertyParserImpl, docHelperImpl) {
+			cssTree = cssTreeImpl;
+			fontPropertyParser = fontPropertyParserImpl;
+			docHelper = docHelperImpl;
+			return {
+				process: (doc, stylesheets, styles, options) => {
+					const stats = { rules: { processed: 0, discarded: 0 }, fonts: { processed: 0, discarded: 0 } };
+					const fontsInfo = { declared: [], used: [] };
+					const workStyleElement = doc.createElement("style");
+					let docContent = "";
+					doc.body.appendChild(workStyleElement);
+					stylesheets.forEach(stylesheetInfo => {
+						const cssRules = stylesheetInfo.stylesheet.children;
+						if (cssRules) {
+							stats.processed += cssRules.getSize();
+							stats.discarded += cssRules.getSize();
+							getFontsInfo(cssRules, fontsInfo);
+							docContent = getRulesTextContent(doc, cssRules, workStyleElement, docContent);
+						}
+					});
+					styles.forEach(declarations => {
+						const fontFamilyNames = getFontFamilyNames(declarations);
+						if (fontFamilyNames.length) {
+							fontsInfo.used.push(fontFamilyNames);
+						}
+						docContent = getDeclarationsTextContent(declarations.children, workStyleElement, docContent);
+					});
+					workStyleElement.remove();
+					docContent += doc.body.innerText;
+					const variableFound = fontsInfo.used.find(fontNames => fontNames.find(fontName => fontName.startsWith("var(--")));
+					let unusedFonts, filteredUsedFonts;
+					if (variableFound) {
+						unusedFonts = [];
+					} else {
+						filteredUsedFonts = new Map();
+						fontsInfo.used.forEach(fontNames => fontNames.forEach(familyName => {
+							if (fontsInfo.declared.find(fontInfo => fontInfo.fontFamily == familyName)) {
+								const optionalData = options.usedFonts && options.usedFonts.filter(fontInfo => fontInfo[0] == familyName);
+								filteredUsedFonts.set(familyName, optionalData);
+							}
+						}));
+						unusedFonts = fontsInfo.declared.filter(fontInfo => !filteredUsedFonts.has(fontInfo.fontFamily));
 					}
-				}));
-				unusedFonts = fontsInfo.declared.filter(fontInfo => !filteredUsedFonts.has(fontInfo.fontFamily));
-			}
-			stylesheets.forEach(stylesheetInfo => {
-				const cssRules = stylesheetInfo.stylesheet.children;
-				if (cssRules) {
-					filterUnusedFonts(cssRules, fontsInfo.declared, unusedFonts, filteredUsedFonts, docContent);
-					stats.rules.discarded -= cssRules.getSize();
+					stylesheets.forEach(stylesheetInfo => {
+						const cssRules = stylesheetInfo.stylesheet.children;
+						if (cssRules) {
+							filterUnusedFonts(cssRules, fontsInfo.declared, unusedFonts, filteredUsedFonts, docContent);
+							stats.rules.discarded -= cssRules.getSize();
+						}
+					});
+					return stats;
 				}
-			});
-			return stats;
+			};
 		}
 	};
 
@@ -152,7 +161,6 @@ this.fontsMinifier = this.fontsMinifier || (() => {
 	}
 
 	function getDeclarationValue(declarations, propertyName) {
-		const cssTree = this.fontsMinifier.cssTree;
 		let property;
 		if (declarations) {
 			property = declarations.filter(declaration => declaration.property == propertyName).tail;
@@ -167,7 +175,6 @@ this.fontsMinifier = this.fontsMinifier || (() => {
 	}
 
 	function getFontFamilyNames(declarations) {
-		const [cssTree, fontPropertyParser] = [this.fontsMinifier.cssTree, this.fontsMinifier.fontPropertyParser];
 		let fontFamilyName = declarations.children.filter(node => node.property == "font-family").tail;
 		let fontFamilyNames = [];
 		if (fontFamilyName) {
@@ -260,7 +267,6 @@ this.fontsMinifier = this.fontsMinifier || (() => {
 	}
 
 	function getDeclarationUnescapedValue(declarations, property, workStylesheet) {
-		const docHelper = this.fontsMinifier.docHelper;
 		const rawValue = docHelper.removeQuotes(getDeclarationValue(declarations, property) || "");
 		if (rawValue) {
 			workStylesheet.textContent = "tmp { content:\"" + rawValue + "\"}";

lib/single-file/modules/css-matched-rules.js

@@ -25,6 +25,8 @@ this.matchedRules = this.matchedRules || (() => {
 	const REGEXP_VENDOR_IDENTIFIER = /-(ms|webkit|moz|o)-/;
 	const DEBUG = false;
 
+	let cssTree;
+
 	class MatchedRules {
 		constructor(doc, stylesheets, styles) {
 			this.doc = doc;
@@ -70,8 +72,13 @@ this.matchedRules = this.matchedRules || (() => {
 	}
 
 	return {
-		getMediaAllInfo(doc, stylesheets, styles) {
-			return new MatchedRules(doc, stylesheets, styles).getMediaAllInfo();
+		getInstance(cssTreeImpl) {
+			cssTree = cssTreeImpl;
+			return {
+				getMediaAllInfo(doc, stylesheets, styles) {
+					return new MatchedRules(doc, stylesheets, styles).getMediaAllInfo();
+				}
+			};
 		}
 	};
 
@@ -84,7 +91,6 @@ this.matchedRules = this.matchedRules || (() => {
 	}
 
 	function getMatchedElementsRules(doc, cssRules, mediaInfo, sheetIndex, styles, matchedElementsCache, workStylesheet) {
-		const cssTree = this.matchedRules.cssTree;
 		let mediaIndex = 0;
 		let ruleIndex = 0;
 		let startTime;
@@ -126,7 +132,6 @@ this.matchedRules = this.matchedRules || (() => {
 	}
 
 	function getMatchedElementsSelector(doc, selectorInfo, styles, matchedElementsCache) {
-		const cssTree = this.matchedRules.cssTree;
 		let selectorText;
 		const selectorData = cssTree.parse(cssTree.generate(selectorInfo.selector.data), { context: "selector" });
 		const filteredSelectorText = getFilteredSelector({ data: selectorData });
@@ -165,7 +170,6 @@ this.matchedRules = this.matchedRules || (() => {
 	}
 
 	function getFilteredSelector(selector) {
-		const cssTree = this.matchedRules.cssTree;
 		const removedSelectors = [];
 		selector = { data: cssTree.parse(cssTree.generate(selector.data), { context: "selector" }) };
 		filterPseudoClasses(selector);
@@ -263,7 +267,6 @@ this.matchedRules = this.matchedRules || (() => {
 	}
 
 	function processDeclarations(declarationsInfo, declarations, selectorInfo, processedProperties, workStylesheet) {
-		const cssTree = this.matchedRules.cssTree;
 		for (let declaration = declarations.tail; declaration; declaration = declaration.prev) {
 			const declarationData = declaration.data;
 			const declarationText = cssTree.generate(declarationData);

lib/single-file/modules/css-medias-alt-minifier.js

@@ -23,23 +23,30 @@ this.mediasMinifier = this.mediasMinifier || (() => {
 	const MEDIA_ALL = "all";
 	const MEDIA_SCREEN = "screen";
 
+	let cssTree, mediaQueryParser;
+
 	return {
-		process: stylesheets => {
-			const stats = { processed: 0, discarded: 0 };
-			stylesheets.forEach((stylesheetInfo, element) => {
-				if (matchesMediaType(stylesheetInfo.mediaText || MEDIA_ALL, MEDIA_SCREEN) && stylesheetInfo.stylesheet.children) {
-					const removedRules = processRules(stylesheetInfo.stylesheet.children, stats);
-					removedRules.forEach(({ cssRules, cssRule }) => cssRules.remove(cssRule));
-				} else {
-					stylesheets.delete(element);
+		getInstance(cssTreeImpl, mediaQueryParserImpl) {
+			cssTree = cssTreeImpl;
+			mediaQueryParser = mediaQueryParserImpl;
+			return {
+				process: stylesheets => {
+					const stats = { processed: 0, discarded: 0 };
+					stylesheets.forEach((stylesheetInfo, element) => {
+						if (matchesMediaType(stylesheetInfo.mediaText || MEDIA_ALL, MEDIA_SCREEN) && stylesheetInfo.stylesheet.children) {
+							const removedRules = processRules(stylesheetInfo.stylesheet.children, stats);
+							removedRules.forEach(({ cssRules, cssRule }) => cssRules.remove(cssRule));
+						} else {
+							stylesheets.delete(element);
+						}
+					});
+					return stats;
 				}
-			});
-			return stats;
+			};
 		}
 	};
 
 	function processRules(cssRules, stats, removedRules = []) {
-		const cssTree = this.mediasMinifier.cssTree;
 		for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
 			const ruleData = cssRule.data;
 			if (ruleData.type == "Atrule" && ruleData.name == "media" && ruleData.block && ruleData.block.children && ruleData.prelude && ruleData.prelude.children) {
@@ -60,7 +67,6 @@ this.mediasMinifier = this.mediasMinifier || (() => {
 	}
 
 	function matchesMediaType(mediaText, mediaType) {
-		const mediaQueryParser = this.mediasMinifier.mediaQueryParser;
 		const foundMediaTypes = flatten(mediaQueryParser.parseMediaList(mediaText).map(node => getMediaTypes(node, mediaType)));
 		return foundMediaTypes.find(mediaTypeInfo => (!mediaTypeInfo.not && (mediaTypeInfo.value == mediaType || mediaTypeInfo.value == MEDIA_ALL))
 			|| (mediaTypeInfo.not && (mediaTypeInfo.value == MEDIA_ALL || mediaTypeInfo.value != mediaType)));

lib/single-file/modules/css-rules-minifier.js

@@ -22,41 +22,47 @@ this.cssRulesMinifier = this.cssRulesMinifier || (() => {
 
 	const DEBUG = false;
 
+	let cssTree;
+
 	return {
-		process: (stylesheets, styles, mediaAllInfo) => {
-			const stats = { processed: 0, discarded: 0 };
-			let sheetIndex = 0;
-			stylesheets.forEach(stylesheetInfo => {
-				let mediaInfo;
-				if (stylesheetInfo.mediaText && stylesheetInfo.mediaText != "all") {
-					mediaInfo = mediaAllInfo.medias.get("style-" + sheetIndex + "-" + stylesheetInfo.mediaText);
-				} else {
-					mediaInfo = mediaAllInfo;
-				}
-				const cssRules = stylesheetInfo.stylesheet.children;
-				if (cssRules) {
-					stats.processed += cssRules.getSize();
-					stats.discarded += cssRules.getSize();
-					processRules(cssRules, sheetIndex, mediaInfo);
-					stats.discarded -= cssRules.getSize();
+		getInstance(cssTreeImpl) {
+			cssTree = cssTreeImpl;
+			return {
+				process: (stylesheets, styles, mediaAllInfo) => {
+					const stats = { processed: 0, discarded: 0 };
+					let sheetIndex = 0;
+					stylesheets.forEach(stylesheetInfo => {
+						let mediaInfo;
+						if (stylesheetInfo.mediaText && stylesheetInfo.mediaText != "all") {
+							mediaInfo = mediaAllInfo.medias.get("style-" + sheetIndex + "-" + stylesheetInfo.mediaText);
+						} else {
+							mediaInfo = mediaAllInfo;
+						}
+						const cssRules = stylesheetInfo.stylesheet.children;
+						if (cssRules) {
+							stats.processed += cssRules.getSize();
+							stats.discarded += cssRules.getSize();
+							processRules(cssRules, sheetIndex, mediaInfo);
+							stats.discarded -= cssRules.getSize();
+						}
+						sheetIndex++;
+					});
+					let startTime;
+					if (DEBUG) {
+						startTime = Date.now();
+						log("  -- STARTED processStyleAttribute");
+					}
+					styles.forEach(style => processStyleAttribute(style, mediaAllInfo));
+					if (DEBUG) {
+						log("  -- ENDED   processStyleAttribute delay =", Date.now() - startTime);
+					}
+					return stats;
 				}
-				sheetIndex++;
-			});
-			let startTime;
-			if (DEBUG) {
-				startTime = Date.now();
-				log("  -- STARTED processStyleAttribute");
-			}
-			styles.forEach(style => processStyleAttribute(style, mediaAllInfo));
-			if (DEBUG) {
-				log("  -- ENDED   processStyleAttribute delay =", Date.now() - startTime);
-			}
-			return stats;
+			};
 		}
 	};
 
 	function processRules(cssRules, sheetIndex, mediaInfo) {
-		const cssTree = this.cssRulesMinifier.cssTree;
 		let mediaRuleIndex = 0, startTime;
 		if (DEBUG && cssRules.getSize() > 1) {
 			startTime = Date.now();
@@ -98,7 +104,6 @@ this.cssRulesMinifier = this.cssRulesMinifier || (() => {
 	}
 
 	function processRuleInfo(ruleData, ruleInfo, pseudoSelectors) {
-		const cssTree = this.cssRulesMinifier.cssTree;
 		const removedDeclarations = [];
 		const removedSelectors = [];
 		let pseudoSelectorFound;

lib/single-file/modules/html-images-alt-minifier.js

@@ -22,25 +22,32 @@ this.imagesAltMinifier = this.imagesAltMinifier || (() => {
 
 	const EMPTY_IMAGE = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
 
+	let srcsetParser;
+
 	return {
-		process(doc) {
-			doc.querySelectorAll("picture").forEach(pictureElement => {
-				const imgElement = pictureElement.querySelector("img");
-				if (imgElement) {
-					let srcData = getImgSrcData(imgElement);
-					let { src, srcset } = srcData;
-					if (!src) {
-						const sources = Array.from(pictureElement.querySelectorAll("source")).reverse();
-						const data = getSourceSrcData(Array.from(sources));
-						src = data.src;
-						if (!srcset) {
-							srcset = data.srcset;
+		getInstance(srcsetParserImpl) {
+			srcsetParser = srcsetParserImpl;
+			return {
+				process(doc) {
+					doc.querySelectorAll("picture").forEach(pictureElement => {
+						const imgElement = pictureElement.querySelector("img");
+						if (imgElement) {
+							let srcData = getImgSrcData(imgElement);
+							let { src, srcset } = srcData;
+							if (!src) {
+								const sources = Array.from(pictureElement.querySelectorAll("source")).reverse();
+								const data = getSourceSrcData(Array.from(sources));
+								src = data.src;
+								if (!srcset) {
+									srcset = data.srcset;
+								}
+							}
+							setSrc({ src, srcset }, imgElement, pictureElement);
 						}
-					}
-					setSrc({ src, srcset }, imgElement, pictureElement);
+					});
+					doc.querySelectorAll(":not(picture) > img[srcset]").forEach(imgElement => setSrc(getImgSrcData(imgElement), imgElement));
 				}
-			});
-			doc.querySelectorAll(":not(picture) > img[srcset]").forEach(imgElement => setSrc(getImgSrcData(imgElement), imgElement));
+			};
 		}
 	};
 
@@ -98,7 +105,7 @@ this.imagesAltMinifier = this.imagesAltMinifier || (() => {
 
 	function getSourceSrc(sourceSrcSet) {
 		if (sourceSrcSet) {
-			const srcset = this.imagesAltMinifier.srcsetParser.process(sourceSrcSet);
+			const srcset = srcsetParser.process(sourceSrcSet);
 			return (srcset.find(srcset => srcset.url)).url;
 		}
 	}

lib/single-file/single-file-browser.js

@@ -46,23 +46,14 @@ this.SingleFileBrowser = this.SingleFileBrowser || (() => {
 		cssMinifier: this.cssMinifier,
 		docHelper: docHelper,
 		htmlMinifier: this.htmlMinifier,
-		fontsMinifier: this.fontsMinifier,
-		fontsAltMinifier: this.fontsAltMinifier,
-		cssRulesMinifier: this.cssRulesMinifier,
-		matchedRules: this.matchedRules,
-		mediasMinifier: this.mediasMinifier,
-		imagesAltMinifier: this.imagesAltMinifier,
-		serializer: this.serializer
+		serializer: this.serializer,
+		fontsMinifier: this.fontsMinifier.getInstance(cssTree, this.fontPropertyParser, docHelper),
+		fontsAltMinifier: this.fontsAltMinifier.getInstance(cssTree),
+		cssRulesMinifier: this.cssRulesMinifier.getInstance(cssTree),
+		matchedRules: this.matchedRules.getInstance(cssTree),
+		mediasMinifier: this.mediasMinifier.getInstance(cssTree, this.mediaQueryParser),
+		imagesAltMinifier: this.imagesAltMinifier.getInstance(this.srcsetParser)
 	};
-	modules.fontsAltMinifier.cssTree = cssTree;
-	modules.fontsMinifier.cssTree = cssTree;
-	modules.fontsMinifier.fontPropertyParser = this.fontPropertyParser;
-	modules.fontsMinifier.docHelper = docHelper;
-	modules.matchedRules.cssTree = cssTree;
-	modules.mediasMinifier.cssTree = cssTree;
-	modules.mediasMinifier.mediaQueryParser = this.mediaQueryParser;
-	modules.cssRulesMinifier.cssTree = cssTree;
-	modules.imagesAltMinifier.srcsetParser = this.srcsetParser;
 	const domUtil = {
 		getContent, parseDocContent, parseSVGContent, isValidFontUrl, getContentSize, digestText
 	};

node/single-file-node.js

@@ -31,28 +31,20 @@ const SCRIPTS = [
 ];
 
 SCRIPTS.forEach(scriptPath => eval(fs.readFileSync(scriptPath).toString()));
+const docHelper = this.docHelper;
 const modules = {
-	docHelper: this.docHelper,
+	docHelper: docHelper,
 	srcsetParser: this.srcsetParser,
 	cssMinifier: this.cssMinifier,
 	htmlMinifier: this.htmlMinifier,
-	fontsMinifier: this.fontsMinifier,
-	fontsAltMinifier: this.fontsAltMinifier,
-	cssRulesMinifier: this.cssRulesMinifier,
-	matchedRules: this.matchedRules,
-	mediasMinifier: this.mediasMinifier,
-	imagesAltMinifier: this.imagesAltMinifier,
-	serializer: this.serializer
+	serializer: this.serializer,
+	fontsMinifier: this.fontsMinifier.getInstance(this.cssTree, this.fontPropertyParser, docHelper),
+	fontsAltMinifier: this.fontsAltMinifier.getInstance(this.cssTree),
+	cssRulesMinifier: this.cssRulesMinifier.getInstance(this.cssTree),
+	matchedRules: this.matchedRules.getInstance(this.cssTree),
+	mediasMinifier: this.mediasMinifier.getInstance(this.cssTree, this.mediaQueryParser),
+	imagesAltMinifier: this.imagesAltMinifier.getInstance(this.srcsetParser)
 };
-modules.fontsAltMinifier.cssTree = this.cssTree;
-modules.fontsMinifier.cssTree = this.cssTree;
-modules.fontsMinifier.fontPropertyParser = this.fontPropertyParser;
-modules.fontsMinifier.docHelper = this.docHelper;
-modules.matchedRules.cssTree = this.cssTree;
-modules.mediasMinifier.cssTree = this.cssTree;
-modules.mediasMinifier.mediaQueryParser = this.mediaQueryParser;
-modules.cssRulesMinifier.cssTree = this.cssTree;
-modules.imagesAltMinifier.srcsetParser = this.srcsetParser;
 const domUtil = {
 	getContent,
 	parseDocContent,
@@ -132,7 +124,7 @@ async function getContent(resourceURL, options) {
 		if (charsetValue) {
 			const matchCharset = charsetValue.match(/^charset=(.*)/);
 			if (matchCharset && matchCharset[1]) {
-				charset = this.docHelper.removeQuotes(matchCharset[1].trim());
+				charset = docHelper.removeQuotes(matchCharset[1].trim());
 			}
 		}
 	}