@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/{DllReferencePlugin.js → dll/DllReferencePlugin.js}

@@ -5,20 +5,20 @@
 
 "use strict";
 
-const parseJson = require("json-parse-even-better-errors");
+const ExternalModuleFactoryPlugin = require("../ExternalModuleFactoryPlugin");
+const DelegatedSourceDependency = require("../dependencies/DelegatedSourceDependency");
+const WebpackError = require("../errors/WebpackError");
+const { makePathsRelative } = require("../util/identifier");
+const parseJson = require("../util/parseJson");
 const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
-const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
-const WebpackError = require("./WebpackError");
-const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
-const makePathsRelative = require("./util/identifier").makePathsRelative;
 
-/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
-/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsContent} DllReferencePluginOptionsContent */
-/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Compiler").CompilationParams} CompilationParams */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("../../declarations/plugins/dll/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
+/** @typedef {import("../../declarations/plugins/dll/DllReferencePlugin").DllReferencePluginOptionsContent} DllReferencePluginOptionsContent */
+/** @typedef {import("../../declarations/plugins/dll/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Compiler").CompilationParams} CompilationParams */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 /** @typedef {{ path: string, data: DllReferencePluginOptionsManifest | undefined, error: Error | undefined }} CompilationDataItem */
 
@@ -26,28 +26,30 @@ const PLUGIN_NAME = "DllReferencePlugin";
 
 class DllReferencePlugin {
 	/**
+	 * Creates an instance of DllReferencePlugin.
 	 * @param {DllReferencePluginOptions} options options object
 	 */
 	constructor(options) {
+		/** @type {DllReferencePluginOptions} */
 		this.options = options;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
-				() => require("../schemas/plugins/DllReferencePlugin.json"),
+				() => require("../../schemas/plugins/dll/DllReferencePlugin.json"),
 				this.options,
 				{
 					name: "Dll Reference Plugin",
 					baseDataPath: "options"
 				},
 				(options) =>
-					require("../schemas/plugins/DllReferencePlugin.check")(options)
+					require("../../schemas/plugins/dll/DllReferencePlugin.check")(options)
 			);
 		});
 		compiler.hooks.compilation.tap(
@@ -79,9 +81,12 @@ class DllReferencePlugin {
 						// Catch errors parsing the manifest so that blank
 						// or malformed manifest files don't kill the process.
 						try {
-							data.data = parseJson(
-								/** @type {Buffer} */ (result).toString("utf8")
-							);
+							data.data =
+								/** @type {DllReferencePluginOptionsManifest} */
+								(
+									/** @type {unknown} */
+									(parseJson(/** @type {Buffer} */ (result).toString("utf8")))
+								);
 						} catch (parseErr) {
 							// Store the error in the params so that it can
 							// be added as a compilation error later on.
@@ -177,13 +182,16 @@ class DllReferencePlugin {
 
 class DllManifestError extends WebpackError {
 	/**
+	 * Creates an instance of DllManifestError.
 	 * @param {string} filename filename of the manifest
 	 * @param {string} message error message
 	 */
 	constructor(filename, message) {
 		super();
 
+		/** @type {string} */
 		this.name = "DllManifestError";
+		/** @type {string} */
 		this.message = `Dll manifest ${filename}\n${message}`;
 	}
 }

package/lib/{LibManifestPlugin.js → dll/LibManifestPlugin.js}

@@ -6,18 +6,19 @@
 "use strict";
 
 const asyncLib = require("neo-async");
-const EntryDependency = require("./dependencies/EntryDependency");
-const { someInIterable } = require("./util/IterableHelpers");
-const { compareModulesById } = require("./util/comparators");
-const { dirname, mkdirp } = require("./util/fs");
+const EntryDependency = require("../dependencies/EntryDependency");
+const { someInIterable } = require("../util/IterableHelpers");
+const { compareModulesById } = require("../util/comparators");
+const { dirname, mkdirp } = require("../util/fs");
 
-/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Compiler").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./Module").BuildMeta} BuildMeta */
-/** @typedef {import("./ExportsInfo").ExportInfoName} ExportInfoName */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Compiler").IntermediateFileSystem} IntermediateFileSystem */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 
 /**
+ * Defines the manifest module data type used by this module.
  * @typedef {object} ManifestModuleData
  * @property {ModuleId} id
  * @property {BuildMeta=} buildMeta
@@ -25,6 +26,7 @@ const { dirname, mkdirp } = require("./util/fs");
  */
 
 /**
+ * Defines the lib manifest plugin options type used by this module.
  * @typedef {object} LibManifestPluginOptions
  * @property {string=} context Context of requests in the manifest file (defaults to the webpack context).
  * @property {boolean=} entryOnly If true, only entry points will be exposed (default: true).
@@ -38,14 +40,16 @@ const PLUGIN_NAME = "LibManifestPlugin";
 
 class LibManifestPlugin {
 	/**
+	 * Creates an instance of LibManifestPlugin.
 	 * @param {LibManifestPluginOptions} options the options
 	 */
 	constructor(options) {
+		/** @type {LibManifestPluginOptions} */
 		this.options = options;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/electron/ElectronTargetPlugin.js

@@ -7,25 +7,44 @@
 
 const ExternalsPlugin = require("../ExternalsPlugin");
 
+/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {"main" | "preload" | "renderer"} ElectronContext */
 
 class ElectronTargetPlugin {
 	/**
+	 * Creates an instance of ElectronTargetPlugin.
 	 * @param {ElectronContext=} context in main, preload or renderer context?
+	 * @param {ExternalsType=} type default external type
 	 */
-	constructor(context) {
+	constructor(context, type = "node-commonjs") {
 		/** @type {ElectronContext | undefined} */
 		this._context = context;
+		/** @type {ExternalsType} */
+		this.type = type;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		new ExternalsPlugin("node-commonjs", [
+		/**
+		 * @param {Dependency} dependency the dependency
+		 * @returns {ExternalsType} the external type
+		 */
+		const externalType = (dependency) => {
+			// When `require` electron built-in modules with module output
+			// we should still emit `node-commonjs` for compatibility
+			if (dependency.category === "commonjs") {
+				return "node-commonjs";
+			}
+
+			return this.type;
+		};
+		new ExternalsPlugin(externalType, [
 			"clipboard",
 			"crash-reporter",
 			"electron",
@@ -37,7 +56,7 @@ class ElectronTargetPlugin {
 		]).apply(compiler);
 		switch (this._context) {
 			case "main":
-				new ExternalsPlugin("node-commonjs", [
+				new ExternalsPlugin(externalType, [
 					"app",
 					"auto-updater",
 					"browser-window",
@@ -57,7 +76,7 @@ class ElectronTargetPlugin {
 				break;
 			case "preload":
 			case "renderer":
-				new ExternalsPlugin("node-commonjs", [
+				new ExternalsPlugin(externalType, [
 					"desktop-capturer",
 					"ipc-renderer",
 					"remote",

package/lib/{AbstractMethodError.js → errors/AbstractMethodError.js}

@@ -10,6 +10,8 @@ const WebpackError = require("./WebpackError");
 const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
 
 /**
+ * Creates the error message shown when an abstract API is called without
+ * being implemented by a subclass.
  * @param {string=} method method name
  * @returns {string} message
  */
@@ -18,6 +20,8 @@ function createMessage(method) {
 }
 
 /**
+ * Captures a stack trace so the calling method name can be folded into the
+ * final abstract-method error message.
  * @constructor
  */
 function Message() {
@@ -35,7 +39,8 @@ function Message() {
 }
 
 /**
- * Error for abstract method
+ * Error thrown when code reaches a method that is intended to be overridden by
+ * a subclass.
  * @example
  * ```js
  * class FooClass {
@@ -46,6 +51,10 @@ function Message() {
  * ```
  */
 class AbstractMethodError extends WebpackError {
+	/**
+	 * Creates an error whose message points at the abstract method that was
+	 * invoked.
+	 */
 	constructor() {
 		super(new Message().message);
 		/** @type {string} */

package/lib/{AsyncDependencyToInitialChunkError.js → errors/AsyncDependencyToInitialChunkError.js}

@@ -7,12 +7,17 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
 
+/**
+ * Error raised when webpack detects an attempt to lazy-load a chunk name that
+ * is already claimed by an entrypoint's initial chunk.
+ */
 class AsyncDependencyToInitialChunkError extends WebpackError {
 	/**
-	 * Creates an instance of AsyncDependencyToInitialChunkError.
+	 * Captures the chunk name, originating module, and source location for an
+	 * invalid async dependency targeting an initial chunk.
 	 * @param {string} chunkName Name of Chunk
 	 * @param {Module} module module tied to dependency
 	 * @param {DependencyLocation} loc location of dependency

package/lib/errors/BuildCycleError.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const WebpackError = require("../WebpackError");
+const WebpackError = require("./WebpackError");
 
 /** @typedef {import("../Module")} Module */
 

package/lib/{ChunkRenderError.js → errors/ChunkRenderError.js}

@@ -7,7 +7,7 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("../Chunk")} Chunk */
 
 class ChunkRenderError extends WebpackError {
 	/**

package/lib/{CodeGenerationError.js → errors/CodeGenerationError.js}

@@ -7,7 +7,7 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("../Module")} Module */
 
 class CodeGenerationError extends WebpackError {
 	/**

package/lib/{CommentCompilationWarning.js → errors/CommentCompilationWarning.js}

@@ -5,13 +5,19 @@
 
 "use strict";
 
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 
+/**
+ * Warning used for comment-related compilation issues, such as malformed magic
+ * comments that webpack can parse but wants to report.
+ */
 class CommentCompilationWarning extends WebpackError {
 	/**
+	 * Captures a warning message together with the dependency location that
+	 * triggered it.
 	 * @param {string} message warning message
 	 * @param {DependencyLocation} loc affected lines of code
 	 */
@@ -27,7 +33,7 @@ class CommentCompilationWarning extends WebpackError {
 
 makeSerializable(
 	CommentCompilationWarning,
-	"webpack/lib/CommentCompilationWarning"
+	"webpack/lib/errors/CommentCompilationWarning"
 );
 
 module.exports = CommentCompilationWarning;

package/lib/{ConcurrentCompilationError.js → errors/ConcurrentCompilationError.js}

@@ -7,12 +7,15 @@
 
 const WebpackError = require("./WebpackError");
 
-module.exports = class ConcurrentCompilationError extends WebpackError {
+class ConcurrentCompilationError extends WebpackError {
 	constructor() {
 		super(
 			"You ran Webpack twice. Each instance only supports a single concurrent compilation at a time."
 		);
 
+		/** @type {string} */
 		this.name = "ConcurrentCompilationError";
 	}
-};
+}
+
+module.exports = ConcurrentCompilationError;

package/lib/{EnvironmentNotSupportAsyncWarning.js → errors/EnvironmentNotSupportAsyncWarning.js}

@@ -5,12 +5,12 @@
 
 "use strict";
 
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {"asyncWebAssembly" | "topLevelAwait" | "external promise" | "external script" | "external import" | "external module"} Feature */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {"asyncWebAssembly" | "topLevelAwait" | "external promise" | "external script" | "external import" | "external module" | "external amd-async"} Feature */
 
 class EnvironmentNotSupportAsyncWarning extends WebpackError {
 	/**
@@ -45,7 +45,7 @@ As a result, the code may not run as expected or may cause runtime errors.`;
 
 makeSerializable(
 	EnvironmentNotSupportAsyncWarning,
-	"webpack/lib/EnvironmentNotSupportAsyncWarning"
+	"webpack/lib/errors/EnvironmentNotSupportAsyncWarning"
 );
 
 module.exports = EnvironmentNotSupportAsyncWarning;

package/lib/{HookWebpackError.js → errors/HookWebpackError.js}

@@ -5,13 +5,14 @@
 
 "use strict";
 
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error, string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Error, string]>} ObjectSerializerContext */
 
 /**
+ * Defines the callback callback.
  * @template T
  * @callback Callback
  * @param {Error | null} err
@@ -28,45 +29,46 @@ class HookWebpackError extends WebpackError {
 	constructor(error, hook) {
 		super(error ? error.message : undefined, error ? { cause: error } : {});
 
+		/** @type {string} */
 		this.hook = hook;
+		/** @type {Error} */
 		this.error = error;
 		/** @type {string} */
 		this.name = "HookWebpackError";
+		/** @type {boolean} */
 		this.hideStack = true;
 		this.stack += `\n-- inner error --\n${error ? error.stack : ""}`;
+		/** @type {string} */
 		this.details = `caused by plugins in ${hook}\n${error ? error.stack : ""}`;
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.error);
-		write(this.hook);
-
+		context.write(this.error).write(this.hook);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.error = read();
-		this.hook = read();
-
-		super.deserialize(context);
+		this.error = context.read();
+		const c1 = context.rest;
+		this.hook = c1.read();
+		super.deserialize(c1.rest);
 	}
 }
 
-makeSerializable(HookWebpackError, "webpack/lib/HookWebpackError");
+makeSerializable(HookWebpackError, "webpack/lib/errors/HookWebpackError");
 
 module.exports = HookWebpackError;
 
 /**
+ * Creates webpack error.
  * @param {Error} error an error
  * @param {string} hook name of the hook
  * @returns {WebpackError} a webpack error
@@ -79,8 +81,9 @@ const makeWebpackError = (error, hook) => {
 module.exports.makeWebpackError = makeWebpackError;
 
 /**
+ * Creates webpack error callback.
  * @template T
- * @param {(err: WebpackError | null, result?: T) => void} callback webpack error callback
+ * @param {(err: Error | null, result?: T) => void} callback webpack error callback
  * @param {string} hook name of hook
  * @returns {Callback<T>} generic callback
  */
@@ -99,6 +102,7 @@ const makeWebpackErrorCallback = (callback, hook) => (err, result) => {
 module.exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
 
 /**
+ * Try run or webpack error.
  * @template T
  * @param {() => T} fn function which will be wrapping in try catch
  * @param {string} hook name of hook

package/lib/{IgnoreErrorModuleFactory.js → errors/IgnoreErrorModuleFactory.js}

@@ -5,26 +5,29 @@
 
 "use strict";
 
-const ModuleFactory = require("./ModuleFactory");
+const ModuleFactory = require("../ModuleFactory");
 
-/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../NormalModuleFactory")} NormalModuleFactory */
 
 /**
  * Ignores error when module is unresolved
  */
 class IgnoreErrorModuleFactory extends ModuleFactory {
 	/**
+	 * Creates an instance of IgnoreErrorModuleFactory.
 	 * @param {NormalModuleFactory} normalModuleFactory normalModuleFactory instance
 	 */
 	constructor(normalModuleFactory) {
 		super();
 
+		/** @type {NormalModuleFactory} */
 		this.normalModuleFactory = normalModuleFactory;
 	}
 
 	/**
+	 * Processes the provided data.
 	 * @param {ModuleFactoryCreateData} data data object
 	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}

package/lib/{InvalidDependenciesModuleWarning.js → errors/InvalidDependenciesModuleWarning.js}

@@ -5,13 +5,14 @@
 
 "use strict";
 
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("../Module")} Module */
 
 class InvalidDependenciesModuleWarning extends WebpackError {
 	/**
+	 * Creates an instance of InvalidDependenciesModuleWarning.
 	 * @param {Module} module module tied to dependency
 	 * @param {Iterable<string>} deps invalid dependencies
 	 */
@@ -31,14 +32,16 @@ ${depsList.slice(0, 3).join("\n")}${
 
 		/** @type {string} */
 		this.name = "InvalidDependenciesModuleWarning";
+		/** @type {string} */
 		this.details = depsList.slice(3).join("\n");
+		/** @type {Module} */
 		this.module = module;
 	}
 }
 
 makeSerializable(
 	InvalidDependenciesModuleWarning,
-	"webpack/lib/InvalidDependenciesModuleWarning"
+	"webpack/lib/errors/InvalidDependenciesModuleWarning"
 );
 
 module.exports = InvalidDependenciesModuleWarning;

package/lib/errors/JSONParseError.js

@@ -0,0 +1,115 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error, EXPECTED_ANY, string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Error, EXPECTED_ANY, string]>} ObjectSerializerContext */
+
+const makeSerializable = require("../util/makeSerializable");
+
+const CONTEXT = 20;
+
+class JSONParseError extends SyntaxError {
+	/**
+	 * @param {Error} err err
+	 * @param {EXPECTED_ANY} raw raw
+	 * @param {string} txt text
+	 */
+	constructor(err, raw, txt) {
+		let originalMessage = err.message;
+		/** @type {string} */
+		let message;
+		/** @type {number} */
+		let position;
+
+		if (typeof raw !== "string") {
+			message = `Cannot parse ${Array.isArray(raw) && raw.length === 0 ? "an empty array" : String(raw)}`;
+			position = 0;
+		} else if (!txt) {
+			message = `${originalMessage} while parsing empty string`;
+			position = 0;
+		} else {
+			// Node 20 puts single quotes around the token and a comma after it
+			const UNEXPECTED_TOKEN = /^Unexpected token '?(.)'?(,)? /i;
+			const badTokenMatch = originalMessage.match(UNEXPECTED_TOKEN);
+			const badIndexMatch = originalMessage.match(/ position\s+(\d+)/i);
+
+			if (badTokenMatch) {
+				const h = badTokenMatch[1].charCodeAt(0).toString(16).toUpperCase();
+				const hex = `0x${h.length % 2 ? "0" : ""}${h}`;
+
+				originalMessage = originalMessage.replace(
+					UNEXPECTED_TOKEN,
+					`Unexpected token ${JSON.stringify(badTokenMatch[1])} (${hex})$2 `
+				);
+			}
+
+			/** @type {number | undefined} */
+			let errIdx;
+
+			if (badIndexMatch) {
+				errIdx = Number(badIndexMatch[1]);
+			} else if (
+				// doesn't happen in Node 22+
+				/^Unexpected end of JSON.*/i.test(originalMessage)
+			) {
+				errIdx = txt.length - 1;
+			}
+
+			if (errIdx === undefined) {
+				message = `${originalMessage} while parsing '${txt.slice(0, CONTEXT * 2)}'`;
+				position = 0;
+			} else {
+				const start = errIdx <= CONTEXT ? 0 : errIdx - CONTEXT;
+				const end =
+					errIdx + CONTEXT >= txt.length ? txt.length : errIdx + CONTEXT;
+				const slice = `${start ? "..." : ""}${txt.slice(start, end)}${end === txt.length ? "" : "..."}`;
+
+				message = `${originalMessage} while parsing ${txt === slice ? "" : "near "}${JSON.stringify(slice)}`;
+				position = errIdx;
+			}
+		}
+
+		super(message);
+
+		/** @type {string} */
+		this.name = "JSONParseError";
+		/** @type {string | undefined} */
+		this.stack = undefined;
+		/** @type {Error} */
+		this.systemError = err;
+		/** @type {EXPECTED_ANY} */
+		this.raw = raw;
+		/** @type {string} */
+		this.txt = txt;
+		/** @type {number} */
+		this.position = position;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.systemError).write(this.raw).write(this.txt);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {JSONParseError} DelegatedModule
+	 */
+	static deserialize(context) {
+		const systemError = context.read();
+		const c1 = context.rest;
+		const raw = c1.read();
+		const c2 = c1.rest;
+		return new JSONParseError(systemError, raw, c2.read());
+	}
+}
+
+makeSerializable(JSONParseError, "webpack/lib/errors/JSONParseError");
+
+module.exports = JSONParseError;