webpack 5.68.0 → 5.70.0

package/lib/ContextModuleFactory.js

@@ -167,6 +167,9 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 				asyncLib.parallel(
 					[
 						callback => {
+							const results = [];
+							const yield_ = obj => results.push(obj);
+
 							contextResolver.resolve(
 								{},
 								context,
@@ -174,11 +177,12 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 								{
 									fileDependencies,
 									missingDependencies,
-									contextDependencies
+									contextDependencies,
+									yield: yield_
 								},
-								(err, result) => {
+								err => {
 									if (err) return callback(err);
-									callback(null, result);
+									callback(null, results);
 								}
 							);
 						},
@@ -213,15 +217,25 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 								contextDependencies
 							});
 						}
-
+						let [contextResult, loaderResult] = result;
+						if (contextResult.length > 1) {
+							const first = contextResult[0];
+							contextResult = contextResult.filter(r => r.path);
+							if (contextResult.length === 0) contextResult.push(first);
+						}
 						this.hooks.afterResolve.callAsync(
 							{
 								addon:
 									loadersPrefix +
-									result[1].join("!") +
-									(result[1].length > 0 ? "!" : ""),
-								resource: result[0],
+									loaderResult.join("!") +
+									(loaderResult.length > 0 ? "!" : ""),
+								resource:
+									contextResult.length > 1
+										? contextResult.map(r => r.path)
+										: contextResult[0].path,
 								resolveDependencies: this.resolveDependencies.bind(this),
+								resourceQuery: contextResult[0].query,
+								resourceFragment: contextResult[0].fragment,
 								...beforeResolveResult
 							},
 							(err, result) => {
@@ -278,26 +292,28 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 		} = options;
 		if (!regExp || !resource) return callback(null, []);
 
-		const addDirectoryChecked = (directory, visited, callback) => {
+		let severalContexts = false;
+		const addDirectoryChecked = (ctx, directory, visited, callback) => {
 			fs.realpath(directory, (err, realPath) => {
 				if (err) return callback(err);
 				if (visited.has(realPath)) return callback(null, []);
 				let recursionStack;
 				addDirectory(
+					ctx,
 					directory,
-					(dir, callback) => {
+					(_, dir, callback) => {
 						if (recursionStack === undefined) {
 							recursionStack = new Set(visited);
 							recursionStack.add(realPath);
 						}
-						addDirectoryChecked(dir, recursionStack, callback);
+						addDirectoryChecked(ctx, dir, recursionStack, callback);
 					},
 					callback
 				);
 			});
 		};
 
-		const addDirectory = (directory, addSubDirectory, callback) => {
+		const addDirectory = (ctx, directory, addSubDirectory, callback) => {
 			fs.readdir(directory, (err, files) => {
 				if (err) return callback(err);
 				const processedFiles = cmf.hooks.contextModuleFiles.call(
@@ -324,16 +340,15 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 
 								if (stat.isDirectory()) {
 									if (!recursive) return callback();
-									addSubDirectory(subResource, callback);
+									addSubDirectory(ctx, subResource, callback);
 								} else if (
 									stat.isFile() &&
 									(!include || subResource.match(include))
 								) {
 									const obj = {
-										context: resource,
+										context: ctx,
 										request:
-											"." +
-											subResource.substr(resource.length).replace(/\\/g, "/")
+											"." + subResource.substr(ctx.length).replace(/\\/g, "/")
 									};
 
 									this.hooks.alternativeRequests.callAsync(
@@ -344,8 +359,11 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 											alternatives = alternatives
 												.filter(obj => regExp.test(obj.request))
 												.map(obj => {
+													const request = severalContexts
+														? join(fs, obj.context, obj.request)
+														: obj.request;
 													const dep = new ContextElementDependency(
-														obj.request + resourceQuery + resourceFragment,
+														request + resourceQuery + resourceFragment,
 														obj.request,
 														typePrefix,
 														category,
@@ -382,12 +400,38 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 			});
 		};
 
-		if (typeof fs.realpath === "function") {
-			addDirectoryChecked(resource, new Set(), callback);
+		const addSubDirectory = (ctx, dir, callback) =>
+			addDirectory(ctx, dir, addSubDirectory, callback);
+
+		const visitResource = (resource, callback) => {
+			if (typeof fs.realpath === "function") {
+				addDirectoryChecked(resource, resource, new Set(), callback);
+			} else {
+				addDirectory(resource, resource, addSubDirectory, callback);
+			}
+		};
+
+		if (typeof resource === "string") {
+			visitResource(resource, callback);
 		} else {
-			const addSubDirectory = (dir, callback) =>
-				addDirectory(dir, addSubDirectory, callback);
-			addDirectory(resource, addSubDirectory, callback);
+			severalContexts = true;
+			asyncLib.map(resource, visitResource, (err, result) => {
+				if (err) return callback(err);
+
+				// result dependencies should have unique userRequest
+				// ordered by resolve result
+				const temp = new Set();
+				const res = [];
+				for (let i = 0; i < result.length; i++) {
+					const inner = result[i];
+					for (const el of inner) {
+						if (temp.has(el.userRequest)) continue;
+						res.push(el);
+						temp.add(el.userRequest);
+					}
+				}
+				callback(null, res);
+			});
 		}
 	}
 };

package/lib/EntryOptionPlugin.js

@@ -62,6 +62,7 @@ class EntryOptionPlugin {
 			runtime: desc.runtime,
 			layer: desc.layer,
 			dependOn: desc.dependOn,
+			baseUri: desc.baseUri,
 			publicPath: desc.publicPath,
 			chunkLoading: desc.chunkLoading,
 			asyncChunks: desc.asyncChunks,

package/lib/ExportsInfo.js

@@ -291,15 +291,15 @@ class ExportsInfo {
 			}
 		}
 		for (const exportInfo of this._exports.values()) {
+			if (!canMangle && exportInfo.canMangleProvide !== false) {
+				exportInfo.canMangleProvide = false;
+				changed = true;
+			}
 			if (excludeExports && excludeExports.has(exportInfo.name)) continue;
 			if (exportInfo.provided !== true && exportInfo.provided !== null) {
 				exportInfo.provided = null;
 				changed = true;
 			}
-			if (!canMangle && exportInfo.canMangleProvide !== false) {
-				exportInfo.canMangleProvide = false;
-				changed = true;
-			}
 			if (targetKey) {
 				exportInfo.setTarget(targetKey, targetModule, [exportInfo.name], -1);
 			}

package/lib/Generator.js

@@ -38,6 +38,7 @@
  * @property {NormalModule} module the module
  * @property {ChunkGraph} chunkGraph
  * @property {RuntimeSpec} runtime
+ * @property {RuntimeTemplate=} runtimeTemplate
  */
 
 /**

package/lib/ModuleHashingError.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @typedef {import("./Module")} Module */
+
+class ModuleHashingError extends WebpackError {
+	/**
+	 * Create a new ModuleHashingError
+	 * @param {Module} module related module
+	 * @param {Error} error Original error
+	 */
+	constructor(module, error) {
+		super();
+
+		this.name = "ModuleHashingError";
+		this.error = error;
+		this.message = error.message;
+		this.details = error.stack;
+		this.module = module;
+	}
+}
+
+module.exports = ModuleHashingError;

package/lib/NodeStuffPlugin.js

@@ -69,6 +69,16 @@ class NodeStuffPlugin {
 									);
 								}
 							});
+						parser.hooks.rename.for("global").tap("NodeStuffPlugin", expr => {
+							const dep = new ConstDependency(
+								RuntimeGlobals.global,
+								expr.range,
+								[RuntimeGlobals.global]
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return false;
+						});
 					}
 
 					const setModuleConstant = (expressionName, fn, warning) => {

package/lib/NormalModule.js

@@ -50,6 +50,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
 /** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compiler")} Compiler */
@@ -194,6 +195,25 @@ makeSerializable(
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
+/**
+ * @typedef {Object} NormalModuleCreateData
+ * @property {string=} layer an optional layer in which the module is
+ * @property {string} type module type
+ * @property {string} request request string
+ * @property {string} userRequest request intended by user (without loaders from config)
+ * @property {string} rawRequest request without resolving
+ * @property {LoaderItem[]} loaders list of loaders
+ * @property {string} resource path + query of the real resource
+ * @property {Record<string, any>=} resourceResolveData resource resolve data
+ * @property {string} context context directory for resolving
+ * @property {string=} matchResource path + query of the matched resource (virtual)
+ * @property {Parser} parser the parser used
+ * @property {Record<string, any>=} parserOptions the options of the parser used
+ * @property {Generator} generator the generator used
+ * @property {Record<string, any>=} generatorOptions the options of the generator used
+ * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
+ */
+
 /** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
@@ -246,22 +266,7 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {string=} options.layer an optional layer in which the module is
-	 * @param {string} options.type module type
-	 * @param {string} options.request request string
-	 * @param {string} options.userRequest request intended by user (without loaders from config)
-	 * @param {string} options.rawRequest request without resolving
-	 * @param {LoaderItem[]} options.loaders list of loaders
-	 * @param {string} options.resource path + query of the real resource
-	 * @param {Record<string, any>=} options.resourceResolveData resource resolve data
-	 * @param {string} options.context context directory for resolving
-	 * @param {string | undefined} options.matchResource path + query of the matched resource (virtual)
-	 * @param {Parser} options.parser the parser used
-	 * @param {object} options.parserOptions the options of the parser used
-	 * @param {Generator} options.generator the generator used
-	 * @param {object} options.generatorOptions the options of the generator used
-	 * @param {Object} options.resolveOptions options used for resolving requests from this module
+	 * @param {NormalModuleCreateData} options options object
 	 */
 	constructor({
 		layer,

package/lib/NormalModuleFactory.js

@@ -28,17 +28,25 @@ const LazySet = require("./util/LazySet");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
 const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge");
 const { join } = require("./util/fs");
-const { parseResource } = require("./util/identifier");
+const {
+	parseResource,
+	parseResourceWithoutFragment
+} = require("./util/identifier");
 
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./Generator")} Generator */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./NormalModule").NormalModuleCreateData} NormalModuleCreateData */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./ResolverFactory")} ResolverFactory */
 /** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
+/** @typedef {Pick<RuleSetRule, 'type'|'sideEffects'|'parser'|'generator'|'resolve'|'layer'>} ModuleSettings */
+/** @typedef {Partial<NormalModuleCreateData & {settings: ModuleSettings}>} CreateData */
+
 /**
  * @typedef {Object} ResolveData
  * @property {ModuleFactoryCreateData["contextInfo"]} contextInfo
@@ -48,7 +56,7 @@ const { parseResource } = require("./util/identifier");
  * @property {Record<string, any> | undefined} assertions
  * @property {ModuleDependency[]} dependencies
  * @property {string} dependencyType
- * @property {Object} createData
+ * @property {CreateData} createData
  * @property {LazySet<string>} fileDependencies
  * @property {LazySet<string>} missingDependencies
  * @property {LazySet<string>} contextDependencies
@@ -66,6 +74,11 @@ const { parseResource } = require("./util/identifier");
 
 /** @typedef {ResourceData & { data: Record<string, any> }} ResourceDataWithData */
 
+/** @typedef {Object} ParsedLoaderRequest
+ * @property {string} loader loader
+ * @property {string|undefined} options options
+ */
+
 const EMPTY_RESOLVE_OPTIONS = {};
 const EMPTY_PARSER_OPTIONS = {};
 const EMPTY_GENERATOR_OPTIONS = {};
@@ -97,27 +110,6 @@ const stringifyLoadersAndResource = (loaders, resource) => {
 	return str + resource;
 };
 
-/**
- * @param {string} resultString resultString
- * @returns {{loader: string, options: string|undefined}} parsed loader request
- */
-const identToLoaderRequest = resultString => {
-	const idx = resultString.indexOf("?");
-	if (idx >= 0) {
-		const loader = resultString.substr(0, idx);
-		const options = resultString.substr(idx + 1);
-		return {
-			loader,
-			options
-		};
-	} else {
-		return {
-			loader: resultString,
-			options: undefined
-		};
-	}
-};
-
 const needCalls = (times, callback) => {
 	return err => {
 		if (--times === 0) {
@@ -212,7 +204,7 @@ class NormalModuleFactory extends ModuleFactory {
 	}) {
 		super();
 		this.hooks = Object.freeze({
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */
 			resolve: new AsyncSeriesBailHook(["resolveData"]),
 			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
 			resolveForScheme: new HookMap(
@@ -222,15 +214,15 @@ class NormalModuleFactory extends ModuleFactory {
 			resolveInScheme: new HookMap(
 				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
 			),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
 			factorize: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
 			beforeResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
 			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], TODO>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
 			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
-			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], TODO>} */
+			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
 			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
 			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
 			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
@@ -264,6 +256,9 @@ class NormalModuleFactory extends ModuleFactory {
 		const cacheParseResource = parseResource.bindCache(
 			associatedObjectForCache
 		);
+		const cachedParseResourceWithoutFragment =
+			parseResourceWithoutFragment.bindCache(associatedObjectForCache);
+		this._parseResourceWithoutFragment = cachedParseResourceWithoutFragment;
 
 		this.hooks.factorize.tapAsync(
 			{
@@ -311,7 +306,9 @@ class NormalModuleFactory extends ModuleFactory {
 										return callback(new Error("Empty dependency (no request)"));
 									}
 
-									createdModule = new NormalModule(createData);
+									createdModule = new NormalModule(
+										/** @type {NormalModuleCreateData} */ (createData)
+									);
 								}
 
 								createdModule = this.hooks.module.call(
@@ -351,7 +348,7 @@ class NormalModuleFactory extends ModuleFactory {
 				let matchResourceData = undefined;
 				/** @type {string} */
 				let unresolvedResource;
-				/** @type {{loader: string, options: string|undefined}[]} */
+				/** @type {ParsedLoaderRequest[]} */
 				let elements;
 				let noPreAutoLoaders = false;
 				let noAutoLoaders = false;
@@ -405,7 +402,13 @@ class NormalModuleFactory extends ModuleFactory {
 							)
 							.split(/!+/);
 						unresolvedResource = rawElements.pop();
-						elements = rawElements.map(identToLoaderRequest);
+						elements = rawElements.map(el => {
+							const { path, query } = cachedParseResourceWithoutFragment(el);
+							return {
+								loader: path,
+								options: query ? query.slice(1) : undefined
+							};
+						});
 						scheme = getScheme(unresolvedResource);
 					} else {
 						unresolvedResource = requestWithoutMatchResource;
@@ -1017,12 +1020,14 @@ If changing the source code is not an option there is also a resolve options cal
 						}
 						if (err) return callback(err);
 
-						const parsedResult = identToLoaderRequest(result);
+						const parsedResult = this._parseResourceWithoutFragment(result);
 						const resolved = {
-							loader: parsedResult.loader,
+							loader: parsedResult.path,
 							options:
 								item.options === undefined
-									? parsedResult.options
+									? parsedResult.query
+										? parsedResult.query.slice(1)
+										: undefined
 									: item.options,
 							ident: item.options === undefined ? undefined : item.ident
 						};

package/lib/ProgressPlugin.js

@@ -96,7 +96,7 @@ const createDefaultHandler = (profile, logger) => {
 /**
  * @callback ReportProgress
  * @param {number} p
- * @param {...string[]} [args]
+ * @param {...string} [args]
  * @returns {void}
  */
 
@@ -531,15 +531,14 @@ class ProgressPlugin {
 			}
 		});
 		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
-		compiler.hooks.initialize.intercept({
+		compiler.hooks.beforeRun.intercept({
 			name: "ProgressPlugin",
 			call() {
 				handler(0, "");
 			}
 		});
-		interceptHook(compiler.hooks.initialize, 0.01, "setup", "initialize");
-		interceptHook(compiler.hooks.beforeRun, 0.02, "setup", "before run");
-		interceptHook(compiler.hooks.run, 0.03, "setup", "run");
+		interceptHook(compiler.hooks.beforeRun, 0.01, "setup", "before run");
+		interceptHook(compiler.hooks.run, 0.02, "setup", "run");
 		interceptHook(compiler.hooks.watchRun, 0.03, "setup", "watch run");
 		interceptHook(
 			compiler.hooks.normalModuleFactory,

package/lib/RuntimeTemplate.js

@@ -83,6 +83,7 @@ class RuntimeTemplate {
 		this.outputOptions = outputOptions || {};
 		this.requestShortener = requestShortener;
 		this.globalObject = getGlobalObject(outputOptions.globalObject);
+		this.contentHashReplacement = "X".repeat(outputOptions.hashDigestLength);
 	}
 
 	isIIFE() {

package/lib/TemplatedPathPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const mime = require("mime-types");
 const { basename, extname } = require("path");
 const util = require("util");
 const Chunk = require("./Chunk");
@@ -117,29 +118,53 @@ const replacePathVariables = (path, data, assetInfo) => {
 	// [name] - file
 	// [ext] - .js
 	if (typeof data.filename === "string") {
-		const { path: file, query, fragment } = parseResource(data.filename);
-
-		const ext = extname(file);
-		const base = basename(file);
-		const name = base.slice(0, base.length - ext.length);
-		const path = file.slice(0, file.length - base.length);
-
-		replacements.set("file", replacer(file));
-		replacements.set("query", replacer(query, true));
-		replacements.set("fragment", replacer(fragment, true));
-		replacements.set("path", replacer(path, true));
-		replacements.set("base", replacer(base));
-		replacements.set("name", replacer(name));
-		replacements.set("ext", replacer(ext, true));
-		// Legacy
-		replacements.set(
-			"filebase",
-			deprecated(
-				replacer(base),
-				"[filebase] is now [base]",
-				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
-			)
-		);
+		// check that filename is data uri
+		let match = data.filename.match(/^data:([^;,]+)/);
+		if (match) {
+			const ext = mime.extension(match[1]);
+			const emptyReplacer = replacer("", true);
+
+			replacements.set("file", emptyReplacer);
+			replacements.set("query", emptyReplacer);
+			replacements.set("fragment", emptyReplacer);
+			replacements.set("path", emptyReplacer);
+			replacements.set("base", emptyReplacer);
+			replacements.set("name", emptyReplacer);
+			replacements.set("ext", replacer(ext ? `.${ext}` : "", true));
+			// Legacy
+			replacements.set(
+				"filebase",
+				deprecated(
+					emptyReplacer,
+					"[filebase] is now [base]",
+					"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
+				)
+			);
+		} else {
+			const { path: file, query, fragment } = parseResource(data.filename);
+
+			const ext = extname(file);
+			const base = basename(file);
+			const name = base.slice(0, base.length - ext.length);
+			const path = file.slice(0, file.length - base.length);
+
+			replacements.set("file", replacer(file));
+			replacements.set("query", replacer(query, true));
+			replacements.set("fragment", replacer(fragment, true));
+			replacements.set("path", replacer(path, true));
+			replacements.set("base", replacer(base));
+			replacements.set("name", replacer(name));
+			replacements.set("ext", replacer(ext, true));
+			// Legacy
+			replacements.set(
+				"filebase",
+				deprecated(
+					replacer(base),
+					"[filebase] is now [base]",
+					"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
+				)
+			);
+		}
 	}
 
 	// Compilation context

package/lib/WebpackOptionsApply.js

@@ -35,6 +35,7 @@ const ResolverCachePlugin = require("./cache/ResolverCachePlugin");
 
 const CommonJsPlugin = require("./dependencies/CommonJsPlugin");
 const HarmonyModulesPlugin = require("./dependencies/HarmonyModulesPlugin");
+const ImportMetaContextPlugin = require("./dependencies/ImportMetaContextPlugin");
 const ImportMetaPlugin = require("./dependencies/ImportMetaPlugin");
 const ImportPlugin = require("./dependencies/ImportPlugin");
 const LoaderPlugin = require("./dependencies/LoaderPlugin");
@@ -361,6 +362,7 @@ class WebpackOptionsApply extends OptionsApply {
 		new RequireEnsurePlugin().apply(compiler);
 		new RequireContextPlugin().apply(compiler);
 		new ImportPlugin().apply(compiler);
+		new ImportMetaContextPlugin().apply(compiler);
 		new SystemPlugin().apply(compiler);
 		new ImportMetaPlugin().apply(compiler);
 		new URLPlugin().apply(compiler);