inject dependencies into modules from single-file-browser.js

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

@@ -18,8 +18,6 @@
  *   along with SingleFile.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* global cssTree */
-
 this.fontsAltMinifier = this.fontsAltMinifier || (() => {
 
 	const REGEXP_URL_SIMPLE_QUOTES_FN = /url\s*\(\s*'(.*?)'\s*\)/i;
@@ -96,6 +94,7 @@ this.fontsAltMinifier = this.fontsAltMinifier || (() => {
 	};
 
 	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) {
@@ -164,6 +163,7 @@ 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,6 +190,7 @@ 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;
@@ -230,6 +231,7 @@ this.fontsAltMinifier = this.fontsAltMinifier || (() => {
 	}
 
 	function getPropertyValue(ruleData, propertyName) {
+		const cssTree = this.fontsAltMinifier.cssTree;
 		let property;
 		if (ruleData.block.children) {
 			property = ruleData.block.children.filter(node => node.property == propertyName).tail;

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

@@ -18,8 +18,6 @@
  *   along with SingleFile.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* global cssTree, fontPropertyParser, docHelper */
-
 this.fontsMinifier = this.fontsMinifier || (() => {
 
 	const REGEXP_COMMA = /\s*,\s*/;
@@ -154,6 +152,7 @@ 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;
@@ -168,6 +167,7 @@ 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,6 +260,7 @@ 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

@@ -18,8 +18,6 @@
  *   along with SingleFile.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* global cssTree */
-
 this.matchedRules = this.matchedRules || (() => {
 
 	const MEDIA_ALL = "all";
@@ -86,6 +84,7 @@ 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;
@@ -127,6 +126,7 @@ 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,6 +165,7 @@ 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);
@@ -262,6 +263,7 @@ 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

@@ -18,8 +18,6 @@
  *   along with SingleFile.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* global cssTree, mediaQueryParser */
-
 this.mediasMinifier = this.mediasMinifier || (() => {
 
 	const MEDIA_ALL = "all";
@@ -41,6 +39,7 @@ this.mediasMinifier = this.mediasMinifier || (() => {
 	};
 
 	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) {
@@ -61,6 +60,7 @@ 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

@@ -18,8 +18,6 @@
  *   along with SingleFile.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* global cssTree */
-
 this.cssRulesMinifier = this.cssRulesMinifier || (() => {
 
 	const DEBUG = false;
@@ -58,6 +56,7 @@ this.cssRulesMinifier = this.cssRulesMinifier || (() => {
 	};
 
 	function processRules(cssRules, sheetIndex, mediaInfo) {
+		const cssTree = this.cssRulesMinifier.cssTree;
 		let mediaRuleIndex = 0, startTime;
 		if (DEBUG && cssRules.getSize() > 1) {
 			startTime = Date.now();
@@ -99,6 +98,7 @@ 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

@@ -18,8 +18,6 @@
  *   along with SingleFile.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* global srcsetParser */
-
 this.imagesAltMinifier = this.imagesAltMinifier || (() => {
 
 	const EMPTY_IMAGE = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
@@ -100,7 +98,7 @@ this.imagesAltMinifier = this.imagesAltMinifier || (() => {
 
 	function getSourceSrc(sourceSrcSet) {
 		if (sourceSrcSet) {
-			const srcset = srcsetParser.process(sourceSrcSet);
+			const srcset = this.imagesAltMinifier.srcsetParser.process(sourceSrcSet);
 			return (srcset.find(srcset => srcset.url)).url;
 		}
 	}

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

@@ -20,9 +20,9 @@
 
 /* global 
 	DocUtilCore,
-	crypto, 
 	cssTree,
-	docHelper, 
+	docHelper,
+	crypto, 
 	fetch, 
 	setTimeout, 
 	superFetch, 
@@ -41,10 +41,35 @@ this.SingleFileBrowser = this.SingleFileBrowser || (() => {
 	const PREFIX_CONTENT_TYPE_TEXT = "text/";
 	const FONT_FACE_TEST_MAX_DELAY = 1000;
 
+	const modules = {
+		srcsetParser: this.srcsetParser,
+		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
+	};
+	this.fontsAltMinifier.cssTree = cssTree;
+	this.fontsMinifier.cssTree = cssTree;
+	this.fontsMinifier.fontPropertyParser = this.fontPropertyParser;
+	this.fontsMinifier.docHelper = docHelper;
+	this.matchedRules.cssTree = cssTree;
+	this.mediasMinifier.cssTree = cssTree;
+	this.mediasMinifier.mediaQueryParser = this.mediaQueryParser;
+	this.cssRulesMinifier.cssTree = cssTree;
+	this.imagesAltMinifier.srcsetParser = this.srcsetParser;
+	const domUtil = {
+		getContent, parseDocContent, parseSVGContent, isValidFontUrl, getContentSize, digestText
+	};
 	let fetchResource;
 	return {
 		getClass: () => {
-			const DocUtil = DocUtilCore.getClass(getContent, parseDocContent, parseSVGContent, isValidFontUrl, getContentSize, digestText);
+			const DocUtil = DocUtilCore.getClass(modules, domUtil);
 			return SingleFileCore.getClass(DocUtil, cssTree);
 		}
 	};

lib/single-file/util/doc-util-core.js

@@ -18,49 +18,37 @@
  *   along with SingleFile.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* global 
-	cssMinifier, 
-	cssRulesMinifier, 
-	docHelper, 
-	fontsAltMinifier, 
-	fontsMinifier, 
-	htmlMinifier, 
-	imagesAltMinifier, 
-	matchedRules, 
-	mediasMinifier, 
-	serializer, 
-	srcsetParser, 
-	URL */
+/* global URL */
 
 this.DocUtilCore = this.DocUtilCore || (() => {
 
-	if (this.serializer === undefined) {
-		this.serializer = {
-			process(doc) {
-				const docType = doc.doctype;
-				let docTypeString = "";
-				if (docType) {
-					docTypeString = "<!DOCTYPE " + docType.nodeName;
-					if (docType.publicId) {
-						docTypeString += " PUBLIC \"" + docType.publicId + "\"";
-						if (docType.systemId)
-							docTypeString += " \"" + docType.systemId + "\"";
-					} else if (docType.systemId)
-						docTypeString += " SYSTEM \"" + docType.systemId + "\"";
-					if (docType.internalSubset)
-						docTypeString += " [" + docType.internalSubset + "]";
-					docTypeString += "> ";
-				}
-				return docTypeString + doc.documentElement.outerHTML;
+	return {
+		getClass: (modules, domUtil) => {
+			if (modules.serializer === undefined) {
+				modules.serializer = {
+					process(doc) {
+						const docType = doc.doctype;
+						let docTypeString = "";
+						if (docType) {
+							docTypeString = "<!DOCTYPE " + docType.nodeName;
+							if (docType.publicId) {
+								docTypeString += " PUBLIC \"" + docType.publicId + "\"";
+								if (docType.systemId)
+									docTypeString += " \"" + docType.systemId + "\"";
+							} else if (docType.systemId)
+								docTypeString += " SYSTEM \"" + docType.systemId + "\"";
+							if (docType.internalSubset)
+								docTypeString += " [" + docType.internalSubset + "]";
+							docTypeString += "> ";
+						}
+						return docTypeString + doc.documentElement.outerHTML;
+					}
+				};
 			}
-		};
-	}
 
-	return {
-		getClass: (getContent, parseDocContent, parseSVGContent, isValidFontUrl, getContentSize, digestText) => {
 			return class DocUtl {
 				static async getContent(resourceURL, options) {
-					return getContent(resourceURL, options);
+					return domUtil.getContent(resourceURL, options);
 				}
 
 				static parseURL(resourceURL, baseURI) {
@@ -72,103 +60,103 @@ this.DocUtilCore = this.DocUtilCore || (() => {
 				}
 
 				static parseDocContent(content, baseURI) {
-					return parseDocContent(content, baseURI);
+					return domUtil.parseDocContent(content, baseURI);
 				}
 
 				static parseSVGContent(content) {
-					return parseSVGContent(content);
+					return domUtil.parseSVGContent(content);
 				}
 
 				static async digest(algo, text) {
-					return digestText(algo, text);
+					return domUtil.digestText(algo, text);
 				}
 
 				static getContentSize(content) {
-					return getContentSize(content);
+					return domUtil.getContentSize(content);
 				}
 
 				static async validFont(urlFunction) {
-					return isValidFontUrl(urlFunction);
+					return domUtil.isValidFontUrl(urlFunction);
 				}
 
 				static minifyHTML(doc, options) {
-					return htmlMinifier.process(doc, options);
+					return modules.htmlMinifier.process(doc, options);
 				}
 
 				static postMinifyHTML(doc) {
-					return htmlMinifier.postProcess(doc);
+					return modules.htmlMinifier.postProcess(doc);
 				}
 
 				static minifyCSSRules(stylesheets, styles, mediaAllInfo) {
-					return cssRulesMinifier.process(stylesheets, styles, mediaAllInfo);
+					return modules.cssRulesMinifier.process(stylesheets, styles, mediaAllInfo);
 				}
 
 				static removeUnusedFonts(doc, stylesheets, styles, options) {
-					return fontsMinifier.process(doc, stylesheets, styles, options);
+					return modules.fontsMinifier.process(doc, stylesheets, styles, options);
 				}
 
 				static removeAlternativeFonts(doc, stylesheets) {
-					return fontsAltMinifier.process(doc, stylesheets);
+					return modules.fontsAltMinifier.process(doc, stylesheets);
 				}
 
 				static getMediaAllInfo(doc, stylesheets, styles) {
-					return matchedRules.getMediaAllInfo(doc, stylesheets, styles);
+					return modules.matchedRules.getMediaAllInfo(doc, stylesheets, styles);
 				}
 
 				static compressCSS(content, options) {
-					return cssMinifier.processString(content, options);
+					return modules.cssMinifier.processString(content, options);
 				}
 
 				static minifyMedias(stylesheets) {
-					return mediasMinifier.process(stylesheets);
+					return modules.mediasMinifier.process(stylesheets);
 				}
 
 				static removeAlternativeImages(doc, options) {
-					return imagesAltMinifier.process(doc, options);
+					return modules.imagesAltMinifier.process(doc, options);
 				}
 
 				static parseSrcset(srcset) {
-					return srcsetParser.process(srcset);
+					return modules.srcsetParser.process(srcset);
 				}
 
 				static preProcessDoc(doc, win, options) {
-					return docHelper.preProcessDoc(doc, win, options);
+					return modules.docHelper.preProcessDoc(doc, win, options);
 				}
 
 				static postProcessDoc(doc, options) {
-					docHelper.postProcessDoc(doc, options);
+					modules.docHelper.postProcessDoc(doc, options);
 				}
 
 				static serialize(doc, compressHTML) {
-					return serializer.process(doc, compressHTML);
+					return modules.serializer.process(doc, compressHTML);
 				}
 
 				static removeQuotes(string) {
-					return docHelper.removeQuotes(string);
+					return modules.docHelper.removeQuotes(string);
 				}
 
 				static windowIdAttributeName(sessionId) {
-					return docHelper.windowIdAttributeName(sessionId);
+					return modules.docHelper.windowIdAttributeName(sessionId);
 				}
 
 				static preservedSpaceAttributeName(sessionId) {
-					return docHelper.preservedSpaceAttributeName(sessionId);
+					return modules.docHelper.preservedSpaceAttributeName(sessionId);
 				}
 
 				static removedContentAttributeName(sessionId) {
-					return docHelper.removedContentAttributeName(sessionId);
+					return modules.docHelper.removedContentAttributeName(sessionId);
 				}
 
 				static imagesAttributeName(sessionId) {
-					return docHelper.imagesAttributeName(sessionId);
+					return modules.docHelper.imagesAttributeName(sessionId);
 				}
 
 				static inputValueAttributeName(sessionId) {
-					return docHelper.inputValueAttributeName(sessionId);
+					return modules.docHelper.inputValueAttributeName(sessionId);
 				}
 
 				static shadowRootAttributeName(sessionId) {
-					return docHelper.shadowRootAttributeName(sessionId);
+					return modules.docHelper.shadowRootAttributeName(sessionId);
 				}
 			};
 		}