fix build issues and add typedoc

1 files changed, 72 insertions, 70 deletions

diff --git a/node_modules/webpack/lib/node/NodeSourcePlugin.js b/node_modules/webpack/lib/node/NodeSourcePlugin.js
index 4e0716a25..14a375445 100644
--- a/node_modules/webpack/lib/node/NodeSourcePlugin.js
+++ b/node_modules/webpack/lib/node/NodeSourcePlugin.js
@@ -2,83 +2,85 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php

 	Author Tobias Koppers @sokra

 */

-var AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");

-var ParserHelpers = require("../ParserHelpers");

-var nodeLibsBrowser = require("node-libs-browser");

+"use strict";

+const AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");

+const ParserHelpers = require("../ParserHelpers");

+const nodeLibsBrowser = require("node-libs-browser");

 

-function NodeSourcePlugin(options) {

-	this.options = options;

-}

-module.exports = NodeSourcePlugin;

-NodeSourcePlugin.prototype.apply = function(compiler) {

-	var options = this.options;

-

-	function getPathToModule(module, type) {

-		if(type === true || (type === undefined && nodeLibsBrowser[module])) {

-			if(!nodeLibsBrowser[module]) throw new Error("No browser version for node.js core module '" + module + "' available");

-			return nodeLibsBrowser[module];

-		} else if(type === "mock") {

-			return require.resolve("node-libs-browser/mock/" + module);

-		} else if(type === "empty") {

-			return require.resolve("node-libs-browser/mock/empty");

-		} else return module;

+module.exports = class NodeSourcePlugin {

+	constructor(options) {

+		this.options = options;

 	}

+	apply(compiler) {

+		const options = this.options;

 

-	function addExpression(parser, name, module, type, suffix) {

-		suffix = suffix || "";

-		parser.plugin("expression " + name, function() {

-			if(this.state.module && this.state.module.resource === getPathToModule(module, type)) return;

-			var mockModule = ParserHelpers.requireFileAsExpression(this.state.module.context, getPathToModule(module, type));

-			return ParserHelpers.addParsedVariableToModule(this, name, mockModule + suffix);

-		});

-	}

+		function getPathToModule(module, type) {

+			if(type === true || (type === undefined && nodeLibsBrowser[module])) {

+				if(!nodeLibsBrowser[module]) throw new Error(`No browser version for node.js core module ${module} available`);

+				return nodeLibsBrowser[module];

+			} else if(type === "mock") {

+				return require.resolve(`node-libs-browser/mock/${module}`);

+			} else if(type === "empty") {

+				return require.resolve("node-libs-browser/mock/empty");

+			} else return module;

+		}

 

-	compiler.plugin("compilation", function(compilation, params) {

-		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {

+		function addExpression(parser, name, module, type, suffix) {

+			suffix = suffix || "";

+			parser.plugin(`expression ${name}`, function() {

+				if(this.state.module && this.state.module.resource === getPathToModule(module, type)) return;

+				const mockModule = ParserHelpers.requireFileAsExpression(this.state.module.context, getPathToModule(module, type));

+				return ParserHelpers.addParsedVariableToModule(this, name, mockModule + suffix);

+			});

+		}

 

-			if(parserOptions.node === false)

-				return;

+		compiler.plugin("compilation", function(compilation, params) {

+			params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {

 

-			var localOptions = options;

-			if(parserOptions.node)

-				localOptions = Object.assign({}, localOptions, parserOptions.node);

+				if(parserOptions.node === false)

+					return;

 

-			if(localOptions.global) {

-				parser.plugin("expression global", function() {

-					var retrieveGlobalModule = ParserHelpers.requireFileAsExpression(this.state.module.context, require.resolve("../../buildin/global.js"));

-					return ParserHelpers.addParsedVariableToModule(this, "global", retrieveGlobalModule);

-				});

-			}

-			if(localOptions.process) {

-				var processType = localOptions.process;

-				addExpression(parser, "process", "process", processType);

-			}

-			if(localOptions.console) {

-				var consoleType = localOptions.console;

-				addExpression(parser, "console", "console", consoleType);

-			}

-			var bufferType = localOptions.Buffer;

-			if(bufferType) {

-				addExpression(parser, "Buffer", "buffer", bufferType, ".Buffer");

-			}

-			if(localOptions.setImmediate) {

-				var setImmediateType = localOptions.setImmediate;

-				addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate");

-				addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate");

-			}

+				let localOptions = options;

+				if(parserOptions.node)

+					localOptions = Object.assign({}, localOptions, parserOptions.node);

+

+				if(localOptions.global) {

+					parser.plugin("expression global", function() {

+						const retrieveGlobalModule = ParserHelpers.requireFileAsExpression(this.state.module.context, require.resolve("../../buildin/global.js"));

+						return ParserHelpers.addParsedVariableToModule(this, "global", retrieveGlobalModule);

+					});

+				}

+				if(localOptions.process) {

+					const processType = localOptions.process;

+					addExpression(parser, "process", "process", processType);

+				}

+				if(localOptions.console) {

+					const consoleType = localOptions.console;

+					addExpression(parser, "console", "console", consoleType);

+				}

+				const bufferType = localOptions.Buffer;

+				if(bufferType) {

+					addExpression(parser, "Buffer", "buffer", bufferType, ".Buffer");

+				}

+				if(localOptions.setImmediate) {

+					const setImmediateType = localOptions.setImmediate;

+					addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate");

+					addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate");

+				}

+			});

 		});

-	});

-	compiler.plugin("after-resolvers", function(compiler) {

-		Object.keys(nodeLibsBrowser).forEach(function(lib) {

-			if(options[lib] !== false) {

-				compiler.resolvers.normal.apply(

-					new AliasPlugin("described-resolve", {

-						name: lib,

-						onlyModule: true,

-						alias: getPathToModule(lib, options[lib])

-					}, "resolve")

-				);

-			}

+		compiler.plugin("after-resolvers", (compiler) => {

+			Object.keys(nodeLibsBrowser).forEach((lib) => {

+				if(options[lib] !== false) {

+					compiler.resolvers.normal.apply(

+						new AliasPlugin("described-resolve", {

+							name: lib,

+							onlyModule: true,

+							alias: getPathToModule(lib, options[lib])

+						}, "resolve")

+					);

+				}

+			});

 		});

-	});

+	}

 };