webpack 5.100.1 → 5.101.0

package/lib/HotModuleReplacementPlugin.js

@@ -123,7 +123,7 @@ class HotModuleReplacementPlugin {
 			const { hotAcceptCallback, hotAcceptWithoutCallback } =
 				HotModuleReplacementPlugin.getParserHooks(parser);
 
-			return expr => {
+			return (expr) => {
 				const module = parser.state.module;
 				const dep = new ConstDependency(
 					`${module.moduleArgument}.hot.accept`,
@@ -145,7 +145,7 @@ class HotModuleReplacementPlugin {
 					} else if (arg.isArray()) {
 						params =
 							/** @type {BasicEvaluatedExpression[]} */
-							(arg.items).filter(param => param.isString());
+							(arg.items).filter((param) => param.isString());
 					}
 					/** @type {string[]} */
 					const requests = [];
@@ -185,7 +185,7 @@ class HotModuleReplacementPlugin {
 		 * @param {typeof ModuleHotDeclineDependency} ParamDependency dependency
 		 * @returns {(expr: CallExpression) => boolean | undefined} callback
 		 */
-		const createDeclineHandler = (parser, ParamDependency) => expr => {
+		const createDeclineHandler = (parser, ParamDependency) => (expr) => {
 			const module = parser.state.module;
 			const dep = new ConstDependency(
 				`${module.moduleArgument}.hot.decline`,
@@ -205,7 +205,7 @@ class HotModuleReplacementPlugin {
 				} else if (arg.isArray()) {
 					params =
 						/** @type {BasicEvaluatedExpression[]} */
-						(arg.items).filter(param => param.isString());
+						(arg.items).filter((param) => param.isString());
 				}
 				for (const [idx, param] of params.entries()) {
 					const dep = new ParamDependency(
@@ -225,7 +225,7 @@ class HotModuleReplacementPlugin {
 		 * @param {JavascriptParser} parser the parser
 		 * @returns {(expr: Expression) => boolean | undefined} callback
 		 */
-		const createHMRExpressionHandler = parser => expr => {
+		const createHMRExpressionHandler = (parser) => (expr) => {
 			const module = parser.state.module;
 			const dep = new ConstDependency(
 				`${module.moduleArgument}.hot`,
@@ -243,13 +243,13 @@ class HotModuleReplacementPlugin {
 		 * @param {JavascriptParser} parser the parser
 		 * @returns {void}
 		 */
-		const applyModuleHot = parser => {
+		const applyModuleHot = (parser) => {
 			parser.hooks.evaluateIdentifier.for("module.hot").tap(
 				{
 					name: PLUGIN_NAME,
 					before: "NodeStuffPlugin"
 				},
-				expr =>
+				(expr) =>
 					evaluateToIdentifier(
 						"module.hot",
 						"module",
@@ -278,10 +278,10 @@ class HotModuleReplacementPlugin {
 		 * @param {JavascriptParser} parser the parser
 		 * @returns {void}
 		 */
-		const applyImportMetaHot = parser => {
+		const applyImportMetaHot = (parser) => {
 			parser.hooks.evaluateIdentifier
 				.for("import.meta.webpackHot")
-				.tap(PLUGIN_NAME, expr =>
+				.tap(PLUGIN_NAME, (expr) =>
 					evaluateToIdentifier(
 						"import.meta.webpackHot",
 						"import.meta",
@@ -381,7 +381,7 @@ class HotModuleReplacementPlugin {
 								chunk,
 								compareModulesById(chunkGraph)
 							),
-							m => /** @type {ModuleId} */ (chunkGraph.getModuleId(m))
+							(m) => /** @type {ModuleId} */ (chunkGraph.getModuleId(m))
 						);
 					}
 				});
@@ -391,7 +391,7 @@ class HotModuleReplacementPlugin {
 				const fullHashModules = new TupleSet();
 				/** @type {TupleSet<Module, RuntimeSpec>} */
 				const nonCodeGeneratedModules = new TupleSet();
-				compilation.hooks.fullHash.tap(PLUGIN_NAME, hash => {
+				compilation.hooks.fullHash.tap(PLUGIN_NAME, (hash) => {
 					const chunkGraph = compilation.chunkGraph;
 					const records = /** @type {Records} */ (compilation.records);
 					for (const chunk of compilation.chunks) {
@@ -399,7 +399,7 @@ class HotModuleReplacementPlugin {
 						 * @param {Module} module module
 						 * @returns {string} module hash
 						 */
-						const getModuleHash = module => {
+						const getModuleHash = (module) => {
 							if (
 								compilation.codeGenerationResults.has(module, chunk.runtime)
 							) {
@@ -524,7 +524,7 @@ class HotModuleReplacementPlugin {
 							const runtime = keyToRuntime(chunkRuntime[key]);
 							allOldRuntime = mergeRuntimeOwned(allOldRuntime, runtime);
 						}
-						forEachRuntime(allOldRuntime, runtime => {
+						forEachRuntime(allOldRuntime, (runtime) => {
 							const { path: filename, info: assetInfo } =
 								compilation.getPathWithInfo(
 									/** @type {NonNullable<OutputNormalized["hotUpdateMainFilename"]>} */
@@ -588,7 +588,7 @@ class HotModuleReplacementPlugin {
 							let removedFromRuntime;
 							const currentChunk = find(
 								compilation.chunks,
-								chunk => `${chunk.id}` === key
+								(chunk) => `${chunk.id}` === key
 							);
 							if (currentChunk) {
 								chunkId = currentChunk.id;
@@ -599,22 +599,22 @@ class HotModuleReplacementPlugin {
 								if (newRuntime === undefined) continue;
 								newModules = chunkGraph
 									.getChunkModules(currentChunk)
-									.filter(module => updatedModules.has(module, currentChunk));
+									.filter((module) => updatedModules.has(module, currentChunk));
 								newRuntimeModules = [
 									...chunkGraph.getChunkRuntimeModulesIterable(currentChunk)
-								].filter(module => updatedModules.has(module, currentChunk));
+								].filter((module) => updatedModules.has(module, currentChunk));
 								const fullHashModules =
 									chunkGraph.getChunkFullHashModulesIterable(currentChunk);
 								newFullHashModules =
 									fullHashModules &&
-									[...fullHashModules].filter(module =>
+									[...fullHashModules].filter((module) =>
 										updatedModules.has(module, currentChunk)
 									);
 								const dependentHashModules =
 									chunkGraph.getChunkDependentHashModulesIterable(currentChunk);
 								newDependentHashModules =
 									dependentHashModules &&
-									[...dependentHashModules].filter(module =>
+									[...dependentHashModules].filter((module) =>
 										updatedModules.has(module, currentChunk)
 									);
 								removedFromRuntime = subtractRuntime(oldRuntime, newRuntime);
@@ -626,7 +626,7 @@ class HotModuleReplacementPlugin {
 							}
 							if (removedFromRuntime) {
 								// chunk was removed from some runtimes
-								forEachRuntime(removedFromRuntime, runtime => {
+								forEachRuntime(removedFromRuntime, (runtime) => {
 									const item =
 										/** @type {HotUpdateMainContentByRuntimeItem} */
 										(
@@ -665,7 +665,7 @@ class HotModuleReplacementPlugin {
 										// module is no longer in this runtime combination
 										// We (incorrectly) assume that it's not in an overlapping runtime combination
 										// and dispose it from the main runtimes the chunk was removed from
-										forEachRuntime(removedFromRuntime, runtime => {
+										forEachRuntime(removedFromRuntime, (runtime) => {
 											// If the module is still used in this runtime, do not dispose it
 											// This could create a bad runtime state where the module is still loaded,
 											// but no chunk which contains it. This means we don't receive further HMR updates
@@ -764,7 +764,7 @@ class HotModuleReplacementPlugin {
 										compilation.hooks.chunkAsset.call(currentChunk, filename);
 									}
 								}
-								forEachRuntime(newRuntime, runtime => {
+								forEachRuntime(newRuntime, (runtime) => {
 									const item =
 										/** @type {HotUpdateMainContentByRuntimeItem} */ (
 											hotUpdateMainContentByRuntime.get(
@@ -829,7 +829,7 @@ To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename
 												...completelyRemovedModulesArray,
 												...Array.from(
 													removedModules,
-													m =>
+													(m) =>
 														/** @type {ModuleId} */ (chunkGraph.getModuleId(m))
 												)
 											]
@@ -863,28 +863,28 @@ To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename
 
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, parser => {
+					.tap(PLUGIN_NAME, (parser) => {
 						applyModuleHot(parser);
 						applyImportMetaHot(parser);
 					});
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
-					.tap(PLUGIN_NAME, parser => {
+					.tap(PLUGIN_NAME, (parser) => {
 						applyModuleHot(parser);
 					});
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, parser => {
+					.tap(PLUGIN_NAME, (parser) => {
 						applyImportMetaHot(parser);
 					});
-				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, module => {
+				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module) => {
 					module.hot = true;
 					return module;
 				});
 
 				NormalModule.getCompilationHooks(compilation).loader.tap(
 					PLUGIN_NAME,
-					context => {
+					(context) => {
 						context.hot = true;
 					}
 				);

package/lib/IgnorePlugin.js

@@ -71,8 +71,8 @@ class IgnorePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, nmf => {
-			nmf.hooks.beforeResolve.tap(PLUGIN_NAME, resolveData => {
+		compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => {
+			nmf.hooks.beforeResolve.tap(PLUGIN_NAME, (resolveData) => {
 				const result = this.checkIgnore(resolveData);
 
 				if (
@@ -93,7 +93,7 @@ class IgnorePlugin {
 				return result;
 			});
 		});
-		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, cmf => {
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => {
 			cmf.hooks.beforeResolve.tap(PLUGIN_NAME, this.checkIgnore);
 		});
 	}

package/lib/IgnoreWarningsPlugin.js

@@ -24,11 +24,11 @@ class IgnoreWarningsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
-			compilation.hooks.processWarnings.tap(PLUGIN_NAME, warnings =>
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.processWarnings.tap(PLUGIN_NAME, (warnings) =>
 				warnings.filter(
-					warning =>
-						!this._ignoreWarnings.some(ignore => ignore(warning, compilation))
+					(warning) =>
+						!this._ignoreWarnings.some((ignore) => ignore(warning, compilation))
 				)
 			);
 		});

package/lib/InitFragment.js

@@ -173,6 +173,12 @@ makeSerializable(InitFragment, "webpack/lib/InitFragment");
 InitFragment.prototype.merge =
 	/** @type {TODO} */
 	(undefined);
+InitFragment.prototype.getImported =
+	/** @type {TODO} */
+	(undefined);
+InitFragment.prototype.setImported =
+	/** @type {TODO} */
+	(undefined);
 
 InitFragment.STAGE_CONSTANTS = 10;
 InitFragment.STAGE_ASYNC_BOUNDARY = 20;

package/lib/InvalidDependenciesModuleWarning.js

@@ -18,7 +18,7 @@ class InvalidDependenciesModuleWarning extends WebpackError {
 	 */
 	constructor(module, deps) {
 		const orderedDeps = deps ? [...deps].sort() : [];
-		const depsList = orderedDeps.map(dep => ` * ${JSON.stringify(dep)}`);
+		const depsList = orderedDeps.map((dep) => ` * ${JSON.stringify(dep)}`);
 		super(`Invalid dependencies have been reported by plugins or loaders for this module. All reported dependencies need to be absolute paths.
 Invalid dependencies may lead to broken watching and caching.
 As best effort we try to convert all invalid values to absolute paths and converting globs into context dependencies, but this is deprecated behavior.

package/lib/JavascriptMetaInfoPlugin.js

@@ -32,7 +32,7 @@ class JavascriptMetaInfoPlugin {
 				 * @param {JavascriptParser} parser the parser
 				 * @returns {void}
 				 */
-				const handler = parser => {
+				const handler = (parser) => {
 					parser.hooks.call.for("eval").tap(PLUGIN_NAME, () => {
 						const buildInfo =
 							/** @type {BuildInfo} */

package/lib/LibManifestPlugin.js

@@ -86,7 +86,7 @@ class LibManifestPlugin {
 								this.options.entryOnly &&
 								!someInIterable(
 									moduleGraph.getIncomingConnections(module),
-									c => c.dependency instanceof EntryDependency
+									(c) => c.dependency instanceof EntryDependency
 								)
 							) {
 								continue;
@@ -129,7 +129,7 @@ class LibManifestPlugin {
 						mkdirp(
 							intermediateFileSystem,
 							dirname(intermediateFileSystem, targetPath),
-							err => {
+							(err) => {
 								if (err) return callback(err);
 								intermediateFileSystem.writeFile(targetPath, buffer, callback);
 							}

package/lib/LoaderOptionsPlugin.js

@@ -59,7 +59,7 @@ class LoaderOptionsPlugin {
 	 */
 	apply(compiler) {
 		const options = this.options;
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			NormalModule.getCompilationHooks(compilation).loader.tap(
 				PLUGIN_NAME,
 				(context, module) => {

package/lib/LoaderTargetPlugin.js

@@ -25,10 +25,10 @@ class LoaderTargetPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			NormalModule.getCompilationHooks(compilation).loader.tap(
 				PLUGIN_NAME,
-				loaderContext => {
+				(loaderContext) => {
 					loaderContext.target = this.target;
 				}
 			);

package/lib/MainTemplate.js

@@ -323,7 +323,7 @@ class MainTemplate {
 			/**
 			 * @param {PathData} options context data
 			 * @returns {string} interpolated path
-			 */ options =>
+			 */ (options) =>
 				compilation.getAssetPath(
 					/** @type {string} */
 					(compilation.outputOptions.publicPath),

package/lib/Module.js

@@ -775,7 +775,7 @@ class Module extends DependenciesBlock {
 			fromModule,
 			connections
 		] of moduleGraph.getIncomingConnectionsByOriginModule(this)) {
-			if (!connections.some(c => c.isTargetActive(chunk.runtime))) continue;
+			if (!connections.some((c) => c.isTargetActive(chunk.runtime))) continue;
 			for (const originChunk of chunkGraph.getModuleChunksIterable(
 				/** @type {Module} */ (fromModule)
 			)) {

package/lib/ModuleFilenameHelpers.js

@@ -96,13 +96,13 @@ const getHash =
  * @param {Record<string, () => T>} obj the object to convert to a lazy access object
  * @returns {T} the lazy access object
  */
-const lazyObject = obj => {
+const lazyObject = (obj) => {
 	const newObj = /** @type {T} */ ({});
 	for (const key of Object.keys(obj)) {
 		const fn = obj[key];
 		Object.defineProperty(newObj, key, {
 			get: () => fn(),
-			set: v => {
+			set: (v) => {
 				Object.defineProperty(newObj, key, {
 					value: v,
 					enumerable: true,
@@ -320,7 +320,7 @@ ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
 const matchPart = (str, test) => {
 	if (!test) return true;
 	if (Array.isArray(test)) {
-		return test.some(test => matchPart(str, test));
+		return test.some((test) => matchPart(str, test));
 	}
 	if (typeof test === "string") {
 		return str.startsWith(test);

package/lib/ModuleGraph.js

@@ -10,6 +10,8 @@ const ExportsInfo = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const SortableSet = require("./util/SortableSet");
 const WeakTupleMap = require("./util/WeakTupleMap");
+const { sortWithSourceOrder } = require("./util/comparators");
+const memoize = require("./util/memoize");
 
 /** @typedef {import("./Compilation").ModuleMemCaches} ModuleMemCaches */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
@@ -19,6 +21,13 @@ const WeakTupleMap = require("./util/WeakTupleMap");
 /** @typedef {import("./ModuleProfile")} ModuleProfile */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./dependencies/HarmonyImportSideEffectDependency")} HarmonyImportSideEffectDependency */
+/** @typedef {import("./dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
+/** @typedef {import("./util/comparators").DependencySourceOrder} DependencySourceOrder */
+
+const getCommonJsSelfReferenceDependency = memoize(() =>
+	require("./dependencies/CommonJsSelfReferenceDependency")
+);
 
 /**
  * @callback OptimizationBailoutFunction
@@ -32,7 +41,7 @@ const EMPTY_SET = new Set();
  * @param {SortableSet<ModuleGraphConnection>} set input
  * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
  */
-const getConnectionsByOriginModule = set => {
+const getConnectionsByOriginModule = (set) => {
 	const map = new Map();
 	/** @type {Module | 0} */
 	let lastModule = 0;
@@ -63,7 +72,7 @@ const getConnectionsByOriginModule = set => {
  * @param {SortableSet<ModuleGraphConnection>} set input
  * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
  */
-const getConnectionsByModule = set => {
+const getConnectionsByModule = (set) => {
 	const map = new Map();
 	/** @type {Module | 0} */
 	let lastModule = 0;
@@ -158,6 +167,12 @@ class ModuleGraph {
 		 * @private
 		 */
 		this._cacheStage = undefined;
+
+		/**
+		 * @type {WeakMap<Dependency, DependencySourceOrder>}
+		 * @private
+		 */
+		this._dependencySourceOrderMap = new WeakMap();
 	}
 
 	/**
@@ -186,6 +201,15 @@ class ModuleGraph {
 		dependency._parentModule = module;
 	}
 
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @param {number} index the index
+	 * @returns {void}
+	 */
+	setParentDependenciesBlockIndex(dependency, index) {
+		dependency._parentDependenciesBlockIndex = index;
+	}
+
 	/**
 	 * @param {Dependency} dependency the dependency
 	 * @returns {Module | undefined} parent module
@@ -265,6 +289,64 @@ class ModuleGraph {
 		targetMgm.incomingConnections.add(newConnection);
 	}
 
+	/**
+	 * @param {Dependency} dependency the need update dependency
+	 * @param {ModuleGraphConnection=} connection the target connection
+	 * @param {Module=} parentModule the parent module
+	 * @returns {void}
+	 */
+	updateParent(dependency, connection, parentModule) {
+		if (this._dependencySourceOrderMap.has(dependency)) {
+			return;
+		}
+		if (!connection || !parentModule) {
+			return;
+		}
+		const originDependency = connection.dependency;
+
+		// src/index.js
+		// import { c } from "lib/c" -> c = 0
+		// import { a, b } from "lib" -> a and b have the same source order -> a = b = 1
+		// import { d } from "lib/d" -> d = 2
+		const currentSourceOrder =
+			/** @type { HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ (
+				dependency
+			).sourceOrder;
+
+		// lib/index.js (reexport)
+		// import { a } from "lib/a" -> a = 0
+		// import { b } from "lib/b" -> b = 1
+		const originSourceOrder =
+			/** @type { HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ (
+				originDependency
+			).sourceOrder;
+		if (
+			typeof currentSourceOrder === "number" &&
+			typeof originSourceOrder === "number"
+		) {
+			// src/index.js
+			// import { c } from "lib/c" -> c = 0
+			// import { a } from "lib/a" -> a = 1.0 = 1(main) + 0.0(sub)
+			// import { b } from "lib/b" -> b = 1.1 = 1(main) + 0.1(sub)
+			// import { d } from "lib/d" -> d = 2
+			this._dependencySourceOrderMap.set(dependency, {
+				main: currentSourceOrder,
+				sub: originSourceOrder
+			});
+
+			// If dependencies like HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency have a SourceOrder,
+			// we sort based on it; otherwise, we preserve the original order.
+			sortWithSourceOrder(
+				parentModule.dependencies,
+				this._dependencySourceOrderMap
+			);
+
+			for (const [index, dep] of parentModule.dependencies.entries()) {
+				this.setParentDependenciesBlockIndex(dep, index);
+			}
+		}
+	}
+
 	/**
 	 * @param {Dependency} dependency the referencing dependency
 	 * @returns {void}
@@ -763,8 +845,7 @@ class ModuleGraph {
 		for (const connection of connections) {
 			if (
 				!connection.dependency ||
-				connection.dependency instanceof
-					require("./dependencies/CommonJsSelfReferenceDependency")
+				connection.dependency instanceof getCommonJsSelfReferenceDependency()
 			) {
 				continue;
 			}
@@ -879,7 +960,7 @@ class ModuleGraph {
 			 * @param {Module} module the module
 			 * @returns {ModuleGraph} the module graph
 			 */
-			module => {
+			(module) => {
 				const moduleGraph = moduleGraphForModuleMap.get(module);
 				if (!moduleGraph) {
 					throw new Error(

package/lib/ModuleInfoHeaderPlugin.js

@@ -26,7 +26,7 @@ const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
  * @param {Iterable<T>} iterable iterable
  * @returns {string} joined with comma
  */
-const joinIterableWithComma = iterable => {
+const joinIterableWithComma = (iterable) => {
 	// This is more performant than Array.from().join(", ")
 	// as it doesn't create an array
 	let str = "";
@@ -94,7 +94,7 @@ const printExportsInfoToSource = (
 						? ` -> ${target.module.readableIdentifier(requestShortener)}${
 								target.export
 									? ` .${target.export
-											.map(e => JSON.stringify(e).slice(1, -1))
+											.map((e) => JSON.stringify(e).slice(1, -1))
 											.join(".")}`
 									: ""
 							}`
@@ -165,7 +165,7 @@ class ModuleInfoHeaderPlugin {
 	 */
 	apply(compiler) {
 		const { _verbose: verbose } = this;
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const javascriptHooks =
 				JavascriptModulesPlugin.getCompilationHooks(compilation);
 			javascriptHooks.renderModulePackage.tap(

package/lib/ModuleParseError.js

@@ -43,7 +43,7 @@ class ModuleParseError extends WebpackError {
 				"\nYou may need an appropriate loader to handle this file type.";
 		} else if (loaders.length >= 1) {
 			message += `\nFile was processed with these loaders:${loaders
-				.map(loader => `\n * ${loader}`)
+				.map((loader) => `\n * ${loader}`)
 				.join("")}`;
 			message +=
 				"\nYou may need an additional loader to handle the result of these loaders.";
@@ -75,8 +75,10 @@ class ModuleParseError extends WebpackError {
 				const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
 
 				message += `${linesBefore
-					.map(l => `\n| ${l}`)
-					.join("")}\n> ${theLine}${linesAfter.map(l => `\n| ${l}`).join("")}`;
+					.map((l) => `\n| ${l}`)
+					.join(
+						""
+					)}\n> ${theLine}${linesAfter.map((l) => `\n| ${l}`).join("")}`;
 			}
 
 			loc = { start: err.loc };