webpack 5.99.8 → 5.100.0

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -11,8 +11,12 @@ const HelperRuntimeModule = require("./HelperRuntimeModule");
 /** @typedef {import("../Compilation")} Compilation */
 
 class AsyncModuleRuntimeModule extends HelperRuntimeModule {
-	constructor() {
+	/**
+	 * @param {boolean=} deferInterop if defer import is used.
+	 */
+	constructor(deferInterop = false) {
 		super("async module");
+		this._deferInterop = deferInterop;
 	}
 
 	/**
@@ -22,10 +26,20 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
+		const defer = this._deferInterop;
 		return Template.asString([
-			'var webpackQueues = typeof Symbol === "function" ? Symbol("webpack queues") : "__webpack_queues__";',
-			`var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
-			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
+			'var hasSymbol = typeof Symbol === "function";',
+			'var webpackQueues = hasSymbol ? Symbol("webpack queues") : "__webpack_queues__";',
+			`var webpackExports = ${
+				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
+			}hasSymbol ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
+			'var webpackError = hasSymbol ? Symbol("webpack error") : "__webpack_error__";',
+			defer
+				? `var webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = hasSymbol ? Symbol("webpack done") : "__webpack_done__";`
+				: "",
+			defer
+				? `var webpackDefer = ${RuntimeGlobals.makeDeferredNamespaceObjectSymbol} = hasSymbol ? Symbol("webpack defer") : "__webpack_defer__";`
+				: "",
 			`var resolveQueue = ${runtimeTemplate.basicFunction("queue", [
 				"if(queue && queue.d < 1) {",
 				Template.indent([
@@ -45,6 +59,39 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				`deps.map(${runtimeTemplate.basicFunction("dep", [
 					'if(dep !== null && typeof dep === "object") {',
 					Template.indent([
+						defer
+							? Template.asString([
+									"if(!dep[webpackQueues] && dep[webpackDefer]) {",
+									Template.indent([
+										"var asyncDeps = dep[webpackDefer];",
+										`var hasUnresolvedAsyncSubgraph = asyncDeps.some(${runtimeTemplate.basicFunction(
+											"id",
+											[
+												"var cache = __webpack_module_cache__[id];",
+												"return !cache || cache[webpackDone] === false;"
+											]
+										)});`,
+										"if (hasUnresolvedAsyncSubgraph) {",
+										Template.indent([
+											"var d = dep;",
+											"dep = {",
+											Template.indent([
+												"then(callback) {",
+												Template.indent([
+													"Promise.all(asyncDeps.map(__webpack_require__))",
+													`.then(${runtimeTemplate.returningFunction(
+														"callback(d)"
+													)});`
+												]),
+												"}"
+											]),
+											"};"
+										]),
+										"} else return dep;"
+									]),
+									"}"
+								])
+							: "",
 						"if(dep[webpackQueues]) return dep;",
 						"if(dep.then) {",
 						Template.indent([
@@ -58,6 +105,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"resolveQueue(queue);"
 							])});`,
 							"var obj = {};",
+							defer ? "obj[webpackDefer] = false;" : "",
 							`obj[webpackQueues] = ${runtimeTemplate.expressionFunction(
 								"fn(queue)",
 								"fn"
@@ -92,11 +140,12 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 					"fn"
 				)};`,
 				"module.exports = promise;",
-				`body(${runtimeTemplate.basicFunction("deps", [
+				`var handle = ${runtimeTemplate.basicFunction("deps", [
 					"currentDeps = wrapDeps(deps);",
 					"var fn;",
 					`var getResult = ${runtimeTemplate.returningFunction(
 						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
+							defer ? "if(d[webpackDefer]) return d;" : "",
 							"if(d[webpackError]) throw d[webpackError];",
 							"return d[webpackExports];"
 						])})`
@@ -114,16 +163,22 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"q"
 							)};`,
 							`currentDeps.map(${runtimeTemplate.expressionFunction(
-								"dep[webpackQueues](fnQueue)",
+								`${
+									defer ? "dep[webpackDefer]||" : ""
+								}dep[webpackQueues](fnQueue)`,
 								"dep"
 							)});`
 						]
 					)});`,
 					"return fn.r ? promise : getResult();"
-				])}, ${runtimeTemplate.expressionFunction(
-					"(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)",
+				])}`,
+				`var done = ${runtimeTemplate.expressionFunction(
+					`(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)${
+						defer ? ", promise[webpackDone] = true" : ""
+					}`,
 					"err"
-				)});`,
+				)}`,
+				"body(handle, done);",
 				"queue && queue.d < 0 && (queue.d = 0);"
 			])};`
 		]);

package/lib/runtime/CreateFakeNamespaceObjectRuntimeModule.js

@@ -49,7 +49,7 @@ class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				`${RuntimeGlobals.makeNamespaceObject}(ns);`,
 				"var def = {};",
 				"leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];",
-				"for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
+				"for(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
 				Template.indent([
 					`Object.getOwnPropertyNames(current).forEach(${runtimeTemplate.expressionFunction(
 						`def[key] = ${runtimeTemplate.returningFunction("value[key]", "")}`,

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -0,0 +1,214 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/**
+ * @param {import("../Module").ExportsType} exportsType exports type
+ * @returns {string} mode
+ */
+function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
+	if (exportsType === "namespace") return `/* ${exportsType} */ 0`;
+	if (exportsType === "default-only") return `/* ${exportsType} */ 1`;
+	if (exportsType === "default-with-named") return `/* ${exportsType} */ 2`;
+	if (exportsType === "dynamic") return `/* ${exportsType} */ 3`;
+	return "";
+}
+/**
+ * @param {import("../ModuleTemplate").RuntimeTemplate} _runtimeTemplate runtimeTemplate
+ * @param {import("../Module").ExportsType} exportsType exportsType
+ * @param {string} moduleId moduleId
+ * @param {(import("../ChunkGraph").ModuleId | null)[]} asyncDepsIds asyncDepsIds
+ * @returns {string} function
+ */
+function getOptimizedDeferredModule(
+	_runtimeTemplate,
+	exportsType,
+	moduleId,
+	asyncDepsIds
+) {
+	const isAsync = asyncDepsIds && asyncDepsIds.length;
+	const init = `${RuntimeGlobals.require}(${moduleId})${
+		isAsync ? `[${RuntimeGlobals.asyncModuleExportSymbol}]` : ""
+	}`;
+	const props = [
+		`/* ${exportsType} */ get a() {`,
+		// if exportsType is "namespace" we can generate the most optimized code,
+		// on the second access, we can avoid trigger the getter.
+		// we can also do this if exportsType is "dynamic" and there is a "__esModule" property on it.
+		exportsType === "namespace" || exportsType === "dynamic"
+			? Template.indent([
+					`var exports = ${init};`,
+					`${
+						exportsType === "dynamic" ? "if (exports.__esModule) " : ""
+					}Object.defineProperty(this, "a", { value: exports });`,
+					"return exports;"
+				])
+			: Template.indent([`return ${init};`]),
+		isAsync ? "}," : "}",
+		isAsync
+			? `[${
+					RuntimeGlobals.makeDeferredNamespaceObjectSymbol
+				}]: ${JSON.stringify(asyncDepsIds.filter(x => x !== null))}`
+			: ""
+	];
+	return Template.asString(["{", Template.indent(props), "}"]);
+}
+
+const strictModuleCache = [
+	"if (cachedModule && cachedModule.error === undefined) {",
+	Template.indent([
+		"var exports = cachedModule.exports;",
+		"if (mode == 0) return exports;",
+		`if (mode == 1) return ${RuntimeGlobals.createFakeNamespaceObject}(exports);`,
+		`if (mode == 2) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 2);`,
+		`if (mode == 3) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 6);` // 2 | 4
+	]),
+	"}"
+];
+const nonStrictModuleCache = [
+	"// optimization not applied when output.strictModuleErrorHandling is off"
+];
+
+class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {boolean} hasAsyncRuntime if async module is used.
+	 */
+	constructor(hasAsyncRuntime) {
+		super("make deferred namespace object");
+		this.hasAsyncRuntime = hasAsyncRuntime;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		if (!this.compilation) return null;
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.makeDeferredNamespaceObject;
+		const hasAsync = this.hasAsyncRuntime;
+		const strictError =
+			this.compilation.options.output.strictModuleErrorHandling;
+		const init = runtimeTemplate.supportsOptionalChaining()
+			? "init?.();"
+			: "if (init) init();";
+		return `${fn} = ${runtimeTemplate.basicFunction("moduleId, mode", [
+			"// mode: 0 => namespace (esm)",
+			"// mode: 1 => default-only (esm strict cjs)",
+			"// mode: 2 => default-with-named (esm-cjs compat)",
+			"// mode: 3 => dynamic (if exports has __esModule, then esm, otherwise default-with-named)",
+			"",
+			"var cachedModule = __webpack_module_cache__[moduleId];",
+			...(strictError ? strictModuleCache : nonStrictModuleCache),
+			"",
+			`var init = ${runtimeTemplate.basicFunction("", [
+				`ns = ${RuntimeGlobals.require}(moduleId);`,
+				hasAsync
+					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in ns) ns = ns[${RuntimeGlobals.asyncModuleExportSymbol}];`
+					: "",
+				"init = null;",
+				"if (mode == 0 || mode == 3 && ns.__esModule && typeof ns === 'object') {",
+				Template.indent([
+					"delete handler.defineProperty;",
+					"delete handler.deleteProperty;",
+					"delete handler.set;",
+					"delete handler.get;",
+					"delete handler.has;",
+					"delete handler.ownKeys;",
+					"delete handler.getOwnPropertyDescriptor;"
+				]),
+				"} else if (mode == 1) {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns);`
+				]),
+				"} else if (mode == 2) {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, 2);`
+				]),
+				"} else if (mode == 3) {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, 6);`
+				]),
+				"}"
+			])};`,
+			"",
+			`var ns = ${
+				strictError ? "" : "cachedModule && cachedModule.exports || "
+			}__webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });`,
+			"var handler = {",
+			Template.indent([
+				"__proto__: null,",
+				`get: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent([
+						'case "__esModule": return true;',
+						'case Symbol.toStringTag: return "Deferred Module";',
+						'case "then": return undefined;'
+					]),
+					"}",
+					init,
+					"return ns[name];"
+				])},`,
+				`has: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent(
+						[
+							'case "__esModule":',
+							"case Symbol.toStringTag:",
+							hasAsync
+								? `case ${RuntimeGlobals.makeDeferredNamespaceObjectSymbol}:`
+								: "",
+							Template.indent("return true;"),
+							'case "then":',
+							Template.indent("return false;")
+						].filter(Boolean)
+					),
+					"}",
+					init,
+					"return name in ns;"
+				])},`,
+				`ownKeys: ${runtimeTemplate.basicFunction("", [
+					init,
+					`var keys = Reflect.ownKeys(ns).filter(${runtimeTemplate.expressionFunction('x !== "then"', "x")}).concat([Symbol.toStringTag]);`,
+					"return keys;"
+				])},`,
+				`getOwnPropertyDescriptor: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent([
+						'case "__esModule": return { value: true, configurable: !!mode };',
+						'case Symbol.toStringTag: return { value: "Deferred Module", configurable: !!mode };',
+						'case "then": return undefined;'
+					]),
+					"}",
+					init,
+					"var desc = Reflect.getOwnPropertyDescriptor(ns, name);",
+					'if (mode == 2 && name == "default" && !desc) {',
+					Template.indent("desc = { value: ns, configurable: true };"),
+					"}",
+					"return desc;"
+				])},`,
+				`defineProperty: ${runtimeTemplate.basicFunction("_, name", [
+					init,
+					// Note: This behavior does not match the spec one, but since webpack does not do it either
+					// for a normal Module Namespace object (in MakeNamespaceObjectRuntimeModule), let's keep it simple.
+					"return false;"
+				])},`,
+				`deleteProperty: ${runtimeTemplate.returningFunction("false")},`,
+				`set: ${runtimeTemplate.returningFunction("false")},`
+			]),
+			"}",
+			// we don't fully emulate ES Module semantics in this Proxy to align with normal webpack esm namespace object.
+			"return new Proxy(ns, handler);"
+		])};`;
+	}
+}
+
+module.exports = MakeDeferredNamespaceObjectRuntimeModule;
+module.exports.getMakeDeferredNamespaceModeFromExportsType =
+	getMakeDeferredNamespaceModeFromExportsType;
+module.exports.getOptimizedDeferredModule = getOptimizedDeferredModule;

package/lib/runtime/RuntimeIdRuntimeModule.js

@@ -22,8 +22,9 @@ class RuntimeIdRuntimeModule extends RuntimeModule {
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const runtime = chunk.runtime;
-		if (typeof runtime !== "string")
+		if (typeof runtime !== "string") {
 			throw new Error("RuntimeIdRuntimeModule must be in a single runtime");
+		}
 		const id = chunkGraph.getRuntimeId(runtime);
 		return `${RuntimeGlobals.runtimeId} = ${JSON.stringify(id)};`;
 	}

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -28,9 +28,9 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 	generate() {
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
-		const chunkIds = Array.from(
-			chunkGraph.getChunkEntryDependentChunksIterable(chunk)
-		).map(chunk => chunk.id);
+		const chunkIds = [
+			...chunkGraph.getChunkEntryDependentChunksIterable(chunk)
+		].map(chunk => chunk.id);
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		return Template.asString([
@@ -38,11 +38,12 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 			`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
 				"",
 				!this.asyncChunkLoading
-					? chunkIds
-							.map(
+					? [
+							...chunkIds.map(
 								id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)});`
-							)
-							.concat("return next();")
+							),
+							"return next();"
+						]
 					: chunkIds.length === 1
 						? `return ${RuntimeGlobals.ensureChunk}(${JSON.stringify(
 								chunkIds[0]

package/lib/schemes/DataUriPlugin.js

@@ -56,7 +56,9 @@ class DataUriPlugin {
 						if (match) {
 							resourceData.data.mimetype = match[1] || "";
 							resourceData.data.parameters = match[2] || "";
-							resourceData.data.encoding = match[3] || false;
+							resourceData.data.encoding = /** @type {"base64" | false} */ (
+								match[3] || false
+							);
 							resourceData.data.encodedContent = match[4] || "";
 						}
 					});

package/lib/schemes/FileUriPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { URL, fileURLToPath } = require("url");
+const { fileURLToPath } = require("url");
 const { NormalModule } = require("..");
 
 /** @typedef {import("../Compiler")} Compiler */

package/lib/schemes/HttpUriPlugin.js

@@ -6,13 +6,17 @@
 "use strict";
 
 const EventEmitter = require("events");
-const { extname, basename } = require("path");
-const { URL } = require("url");
-const { createGunzip, createBrotliDecompress, createInflate } = require("zlib");
+const { basename, extname } = require("path");
+const {
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
+	createBrotliDecompress,
+	createGunzip,
+	createInflate
+} = require("zlib");
 const NormalModule = require("../NormalModule");
 const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
-const { mkdirp, dirname, join } = require("../util/fs");
+const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("http").IncomingMessage} IncomingMessage */
@@ -32,7 +36,7 @@ const getHttps = memoize(() => require("https"));
 
 /**
  * @param {typeof import("http") | typeof import("https")} request request
- * @param {string | { toString: () => string } | undefined} proxy proxy
+ * @param {string | URL | undefined} proxy proxy
  * @returns {(url: URL, requestOptions: RequestOptions, callback: (incomingMessage: IncomingMessage) => void) => EventEmitter} fn
  */
 const proxyFetch = (request, proxy) => (url, options, callback) => {
@@ -85,7 +89,7 @@ const proxyFetch = (request, proxy) => (url, options, callback) => {
 let inProgressWrite;
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/schemes/HttpUriPlugin.check.js"),
+	require("../../schemas/plugins/schemes/HttpUriPlugin.check"),
 	() => require("../../schemas/plugins/schemes/HttpUriPlugin.json"),
 	{
 		name: "Http Uri Plugin",
@@ -210,8 +214,9 @@ class Lockfile {
 	static parse(content) {
 		// TODO handle merge conflicts
 		const data = JSON.parse(content);
-		if (data.version !== 1)
+		if (data.version !== 1) {
 			throw new Error(`Unsupported lockfile version ${data.version}`);
+		}
 		const lockfile = new Lockfile();
 		for (const key of Object.keys(data)) {
 			if (key === "version") continue;
@@ -234,16 +239,15 @@ class Lockfile {
 	 */
 	toString() {
 		let str = "{\n";
-		const entries = Array.from(this.entries).sort(([a], [b]) =>
-			a < b ? -1 : 1
-		);
+		const entries = [...this.entries].sort(([a], [b]) => (a < b ? -1 : 1));
 		for (const [key, entry] of entries) {
 			if (typeof entry === "string") {
 				str += `  ${JSON.stringify(key)}: ${JSON.stringify(entry)},\n`;
 			} else {
 				str += `  ${JSON.stringify(key)}: { `;
-				if (entry.resolved !== key)
+				if (entry.resolved !== key) {
 					str += `"resolved": ${JSON.stringify(entry.resolved)}, `;
+				}
 				str += `"integrity": ${JSON.stringify(
 					entry.integrity
 				)}, "contentType": ${JSON.stringify(entry.contentType)} },\n`;
@@ -330,8 +334,9 @@ const cachedWithKey = (fn, forceFn = fn) => {
 	const resultFn = (arg, callback) => {
 		const cacheEntry = cache.get(arg);
 		if (cacheEntry !== undefined) {
-			if (cacheEntry.result !== undefined)
+			if (cacheEntry.result !== undefined) {
 				return callback(null, cacheEntry.result);
+			}
 			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
 			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
 			else cacheEntry.callbacks.push(callback);
@@ -361,8 +366,9 @@ const cachedWithKey = (fn, forceFn = fn) => {
 	resultFn.force = (arg, callback) => {
 		const cacheEntry = cache.get(arg);
 		if (cacheEntry !== undefined && cacheEntry.force) {
-			if (cacheEntry.result !== undefined)
+			if (cacheEntry.result !== undefined) {
 				return callback(null, cacheEntry.result);
+			}
 			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
 			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
 			else cacheEntry.callbacks.push(callback);
@@ -531,7 +537,7 @@ class HttpUriPlugin {
 									(err, s) => {
 										if (err) return callback(err);
 										const lockfile = buffer
-											? Lockfile.parse(buffer.toString("utf-8"))
+											? Lockfile.parse(buffer.toString("utf8"))
 											: new Lockfile();
 										lockfileCache = {
 											lockfile,
@@ -611,8 +617,9 @@ class HttpUriPlugin {
 				const storeResult = (lockfile, url, result, callback) => {
 					if (result.storeLock) {
 						storeLockEntry(lockfile, url, result.entry);
-						if (!cacheLocation || !result.content)
+						if (!cacheLocation || !result.content) {
 							return callback(null, result);
+						}
 						const key = getCacheKey(result.entry.resolved);
 						const filePath = join(intermediateFs, cacheLocation, key);
 						mkdirp(intermediateFs, dirname(intermediateFs, filePath), err => {
@@ -831,7 +838,7 @@ class HttpUriPlugin {
 										new Error(
 											`${url} request status code = ${
 												res.statusCode
-											}\n${content.toString("utf-8")}`
+											}\n${content.toString("utf8")}`
 										)
 									);
 								}
@@ -938,8 +945,9 @@ class HttpUriPlugin {
 										const result =
 											/** @type {ResolveContentResult} */
 											(_result);
-										if (!result.storeLock || entryTag === "ignore")
+										if (!result.storeLock || entryTag === "ignore") {
 											return callback(null, result);
+										}
 										if (frozen) {
 											return callback(
 												new Error(
@@ -1058,7 +1066,7 @@ Remove this line from the lockfile to force upgrading.`
 											let isEolChanged = false;
 											try {
 												contentWithChangedEol = Buffer.from(
-													content.toString("utf-8").replace(/\r\n/g, "\n")
+													content.toString("utf8").replace(/\r\n/g, "\n")
 												);
 												isEolChanged = verifyIntegrity(
 													contentWithChangedEol,
@@ -1245,7 +1253,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 									return callback(err);
 								}
 								const lockfile = buffer
-									? Lockfile.parse(buffer.toString("utf-8"))
+									? Lockfile.parse(buffer.toString("utf8"))
 									: new Lockfile();
 								for (const [key, value] of /** @type {LockfileUpdates} */ (
 									lockfileUpdates