webpack 5.97.1 → 5.104.1

package/lib/util/identifier.js

@@ -10,16 +10,11 @@ const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
 const SEGMENTS_SPLIT_REGEXP = /([|!])/;
 const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
 
-/**
- * @typedef {object} MakeRelativePathsCache
- * @property {Map<string, Map<string, string>>=} relativePaths
- */
-
 /**
  * @param {string} relativePath relative path
  * @returns {string} request
  */
-const relativePathToRequest = relativePath => {
+const relativePathToRequest = (relativePath) => {
 	if (relativePath === "") return "./.";
 	if (relativePath === "..") return "../.";
 	if (relativePath.startsWith("../")) return relativePath;
@@ -80,44 +75,47 @@ const absoluteToRequest = (context, maybeAbsolutePath) => {
  * @returns {string} absolute path
  */
 const requestToAbsolute = (context, relativePath) => {
-	if (relativePath.startsWith("./") || relativePath.startsWith("../"))
+	if (relativePath.startsWith("./") || relativePath.startsWith("../")) {
 		return path.join(context, relativePath);
+	}
 	return relativePath;
 };
 
+/** @typedef {EXPECTED_OBJECT} AssociatedObjectForCache */
+
 /**
  * @template T
- * @typedef {function(string, object=): T} MakeCacheableResult
+ * @typedef {(value: string, cache?: AssociatedObjectForCache) => T} MakeCacheableResult
  */
 
 /**
  * @template T
- * @typedef {function(string): T} BindCacheResultFn
+ * @typedef {(value: string) => T} BindCacheResultFn
  */
 
 /**
  * @template T
- * @typedef {function(object): BindCacheResultFn<T>} BindCache
+ * @typedef {(cache: AssociatedObjectForCache) => BindCacheResultFn<T>} BindCache
  */
 
 /**
  * @template T
- * @param {(function(string): T)} realFn real function
+ * @param {((value: string) => T)} realFn real function
  * @returns {MakeCacheableResult<T> & { bindCache: BindCache<T> }} cacheable function
  */
-const makeCacheable = realFn => {
+const makeCacheable = (realFn) => {
 	/**
 	 * @template T
 	 * @typedef {Map<string, T>} CacheItem
 	 */
-	/** @type {WeakMap<object, CacheItem<T>>} */
+	/** @type {WeakMap<AssociatedObjectForCache, CacheItem<T>>} */
 	const cache = new WeakMap();
 
 	/**
-	 * @param {object} associatedObjectForCache an object to which the cache will be attached
+	 * @param {AssociatedObjectForCache} associatedObjectForCache an object to which the cache will be attached
 	 * @returns {CacheItem<T>} cache item
 	 */
-	const getCache = associatedObjectForCache => {
+	const getCache = (associatedObjectForCache) => {
 		const entry = cache.get(associatedObjectForCache);
 		if (entry !== undefined) return entry;
 		/** @type {Map<string, T>} */
@@ -138,13 +136,13 @@ const makeCacheable = realFn => {
 	};
 
 	/** @type {BindCache<T>} */
-	fn.bindCache = associatedObjectForCache => {
+	fn.bindCache = (associatedObjectForCache) => {
 		const cache = getCache(associatedObjectForCache);
 		/**
 		 * @param {string} str string
 		 * @returns {T} value
 		 */
-		return str => {
+		return (str) => {
 			const entry = cache.get(str);
 			if (entry !== undefined) return entry;
 			const result = realFn(str);
@@ -156,18 +154,18 @@ const makeCacheable = realFn => {
 	return fn;
 };
 
-/** @typedef {function(string, string, object=): string} MakeCacheableWithContextResult */
-/** @typedef {function(string, string): string} BindCacheForContextResultFn */
-/** @typedef {function(string): string} BindContextCacheForContextResultFn */
-/** @typedef {function(object=): BindCacheForContextResultFn} BindCacheForContext */
-/** @typedef {function(string, object=): BindContextCacheForContextResultFn} BindContextCacheForContext */
+/** @typedef {(context: string, value: string, associatedObjectForCache?: AssociatedObjectForCache) => string} MakeCacheableWithContextResult */
+/** @typedef {(context: string, value: string) => string} BindCacheForContextResultFn */
+/** @typedef {(value: string) => string} BindContextCacheForContextResultFn */
+/** @typedef {(associatedObjectForCache?: AssociatedObjectForCache) => BindCacheForContextResultFn} BindCacheForContext */
+/** @typedef {(value: string, associatedObjectForCache?: AssociatedObjectForCache) => BindContextCacheForContextResultFn} BindContextCacheForContext */
 
 /**
- * @param {function(string, string): string} fn function
+ * @param {(context: string, identifier: string) => string} fn function
  * @returns {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} cacheable function with context
  */
-const makeCacheableWithContext = fn => {
-	/** @type {WeakMap<object, Map<string, Map<string, string>>>} */
+const makeCacheableWithContext = (fn) => {
+	/** @type {WeakMap<AssociatedObjectForCache, Map<string, Map<string, string>>>} */
 	const cache = new WeakMap();
 
 	/** @type {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} */
@@ -197,7 +195,7 @@ const makeCacheableWithContext = fn => {
 	};
 
 	/** @type {BindCacheForContext} */
-	cachedFn.bindCache = associatedObjectForCache => {
+	cachedFn.bindCache = (associatedObjectForCache) => {
 		let innerCache;
 		if (associatedObjectForCache) {
 			innerCache = cache.get(associatedObjectForCache);
@@ -256,7 +254,7 @@ const makeCacheableWithContext = fn => {
 		 * @param {string} identifier identifier used to create relative path
 		 * @returns {string} the returned relative path
 		 */
-		const boundFn = identifier => {
+		const boundFn = (identifier) => {
 			const cachedResult = innerSubCache.get(identifier);
 			if (cachedResult !== undefined) {
 				return cachedResult;
@@ -280,11 +278,9 @@ const makeCacheableWithContext = fn => {
 const _makePathsRelative = (context, identifier) =>
 	identifier
 		.split(SEGMENTS_SPLIT_REGEXP)
-		.map(str => absoluteToRequest(context, str))
+		.map((str) => absoluteToRequest(context, str))
 		.join("");
 
-module.exports.makePathsRelative = makeCacheableWithContext(_makePathsRelative);
-
 /**
  * @param {string} context context for relative path
  * @param {string} identifier identifier for path
@@ -293,11 +289,9 @@ module.exports.makePathsRelative = makeCacheableWithContext(_makePathsRelative);
 const _makePathsAbsolute = (context, identifier) =>
 	identifier
 		.split(SEGMENTS_SPLIT_REGEXP)
-		.map(str => requestToAbsolute(context, str))
+		.map((str) => requestToAbsolute(context, str))
 		.join("");
 
-module.exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
-
 /**
  * @param {string} context absolute context path
  * @param {string} request any request string may containing absolute paths, query string, etc.
@@ -306,11 +300,10 @@ module.exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
 const _contextify = (context, request) =>
 	request
 		.split("!")
-		.map(r => absoluteToRequest(context, r))
+		.map((r) => absoluteToRequest(context, r))
 		.join("!");
 
 const contextify = makeCacheableWithContext(_contextify);
-module.exports.contextify = contextify;
 
 /**
  * @param {string} context absolute context path
@@ -320,15 +313,15 @@ module.exports.contextify = contextify;
 const _absolutify = (context, request) =>
 	request
 		.split("!")
-		.map(r => requestToAbsolute(context, r))
+		.map((r) => requestToAbsolute(context, r))
 		.join("!");
 
 const absolutify = makeCacheableWithContext(_absolutify);
-module.exports.absolutify = absolutify;
 
 const PATH_QUERY_FRAGMENT_REGEXP =
 	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
+const ZERO_ESCAPE_REGEXP = /\0(.)/g;
 
 /** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
 /** @typedef {{ resource: string, path: string, query: string }} ParsedResourceWithoutFragment */
@@ -337,37 +330,97 @@ const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
  * @param {string} str the path with query and fragment
  * @returns {ParsedResource} parsed parts
  */
-const _parseResource = str => {
-	const match =
-		/** @type {[string, string, string | undefined, string | undefined]} */
-		(/** @type {unknown} */ (PATH_QUERY_FRAGMENT_REGEXP.exec(str)));
-	return {
-		resource: str,
-		path: match[1].replace(/\0(.)/g, "$1"),
-		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
-		fragment: match[3] || ""
-	};
+const _parseResource = (str) => {
+	const firstEscape = str.indexOf("\0");
+
+	// Handle `\0`
+	if (firstEscape !== -1) {
+		const match =
+			/** @type {[string, string, string | undefined, string | undefined]} */
+			(/** @type {unknown} */ (PATH_QUERY_FRAGMENT_REGEXP.exec(str)));
+
+		return {
+			resource: str,
+			path: match[1].replace(ZERO_ESCAPE_REGEXP, "$1"),
+			query: match[2] ? match[2].replace(ZERO_ESCAPE_REGEXP, "$1") : "",
+			fragment: match[3] || ""
+		};
+	}
+
+	/** @type {ParsedResource} */
+	const result = { resource: str, path: "", query: "", fragment: "" };
+	const queryStart = str.indexOf("?");
+	const fragmentStart = str.indexOf("#");
+
+	if (fragmentStart < 0) {
+		if (queryStart < 0) {
+			result.path = result.resource;
+
+			// No fragment, no query
+			return result;
+		}
+
+		result.path = str.slice(0, queryStart);
+		result.query = str.slice(queryStart);
+
+		// Query, no fragment
+		return result;
+	}
+
+	if (queryStart < 0 || fragmentStart < queryStart) {
+		result.path = str.slice(0, fragmentStart);
+		result.fragment = str.slice(fragmentStart);
+
+		// Fragment, no query
+		return result;
+	}
+
+	result.path = str.slice(0, queryStart);
+	result.query = str.slice(queryStart, fragmentStart);
+	result.fragment = str.slice(fragmentStart);
+
+	// Query and fragment
+	return result;
 };
-module.exports.parseResource = makeCacheable(_parseResource);
 
 /**
  * Parse resource, skips fragment part
  * @param {string} str the path with query and fragment
  * @returns {ParsedResourceWithoutFragment} parsed parts
  */
-const _parseResourceWithoutFragment = str => {
-	const match =
-		/** @type {[string, string, string | undefined]} */
-		(/** @type {unknown} */ (PATH_QUERY_REGEXP.exec(str)));
-	return {
-		resource: str,
-		path: match[1].replace(/\0(.)/g, "$1"),
-		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : ""
-	};
+const _parseResourceWithoutFragment = (str) => {
+	const firstEscape = str.indexOf("\0");
+
+	// Handle `\0`
+	if (firstEscape !== -1) {
+		const match =
+			/** @type {[string, string, string | undefined]} */
+			(/** @type {unknown} */ (PATH_QUERY_REGEXP.exec(str)));
+
+		return {
+			resource: str,
+			path: match[1].replace(ZERO_ESCAPE_REGEXP, "$1"),
+			query: match[2] ? match[2].replace(ZERO_ESCAPE_REGEXP, "$1") : ""
+		};
+	}
+
+	/** @type {ParsedResourceWithoutFragment} */
+	const result = { resource: str, path: "", query: "" };
+	const queryStart = str.indexOf("?");
+
+	if (queryStart < 0) {
+		result.path = result.resource;
+
+		// No query
+		return result;
+	}
+
+	result.path = str.slice(0, queryStart);
+	result.query = str.slice(queryStart);
+
+	// Query
+	return result;
 };
-module.exports.parseResourceWithoutFragment = makeCacheable(
-	_parseResourceWithoutFragment
-);
 
 /**
  * @param {string} filename the filename which should be undone
@@ -375,7 +428,7 @@ module.exports.parseResourceWithoutFragment = makeCacheable(
  * @param {boolean} enforceRelative true returns ./ for empty paths
  * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
  */
-module.exports.getUndoPath = (filename, outputPath, enforceRelative) => {
+const getUndoPath = (filename, outputPath, enforceRelative) => {
 	let depth = -1;
 	let append = "";
 	outputPath = outputPath.replace(/[\\/]$/, "");
@@ -401,3 +454,13 @@ module.exports.getUndoPath = (filename, outputPath, enforceRelative) => {
 			? `./${append}`
 			: append;
 };
+
+module.exports.absolutify = absolutify;
+module.exports.contextify = contextify;
+module.exports.getUndoPath = getUndoPath;
+module.exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
+module.exports.makePathsRelative = makeCacheableWithContext(_makePathsRelative);
+module.exports.parseResource = makeCacheable(_parseResource);
+module.exports.parseResourceWithoutFragment = makeCacheable(
+	_parseResourceWithoutFragment
+);

package/lib/util/internalSerializables.js

@@ -73,16 +73,12 @@ module.exports = {
 		require("../dependencies/CriticalDependencyWarning"),
 	"dependencies/CssImportDependency": () =>
 		require("../dependencies/CssImportDependency"),
-	"dependencies/CssLocalIdentifierDependency": () =>
-		require("../dependencies/CssLocalIdentifierDependency"),
-	"dependencies/CssSelfLocalIdentifierDependency": () =>
-		require("../dependencies/CssSelfLocalIdentifierDependency"),
+	"dependencies/CssUrlDependency": () =>
+		require("../dependencies/CssUrlDependency"),
 	"dependencies/CssIcssImportDependency": () =>
 		require("../dependencies/CssIcssImportDependency"),
 	"dependencies/CssIcssExportDependency": () =>
 		require("../dependencies/CssIcssExportDependency"),
-	"dependencies/CssUrlDependency": () =>
-		require("../dependencies/CssUrlDependency"),
 	"dependencies/CssIcssSymbolDependency": () =>
 		require("../dependencies/CssIcssSymbolDependency"),
 	"dependencies/DelegatedSourceDependency": () =>
@@ -170,6 +166,8 @@ module.exports = {
 	"dependencies/UnsupportedDependency": () =>
 		require("../dependencies/UnsupportedDependency"),
 	"dependencies/URLDependency": () => require("../dependencies/URLDependency"),
+	"dependencies/URLContextDependency": () =>
+		require("../dependencies/URLContextDependency"),
 	"dependencies/WebAssemblyExportImportedDependency": () =>
 		require("../dependencies/WebAssemblyExportImportedDependency"),
 	"dependencies/WebAssemblyImportDependency": () =>

package/lib/util/magicComment.js

@@ -5,7 +5,16 @@
 
 "use strict";
 
+const memoize = require("./memoize");
+
+const getVm = memoize(() => require("vm"));
+
 // regexp to match at least one "magic comment"
+module.exports.createMagicCommentContext = () =>
+	getVm().createContext(undefined, {
+		name: "Webpack Magic Comment Parser",
+		codeGeneration: { strings: false, wasm: false }
+	});
 module.exports.webpackCommentRegExp = new RegExp(
 	/(^|\W)webpack[A-Z]{1,}[A-Za-z]{1,}:/
 );
@@ -14,8 +23,3 @@ module.exports.webpackCommentRegExp = new RegExp(
 /**
  * @returns {import("vm").Context} magic comment context
  */
-module.exports.createMagicCommentContext = () =>
-	require("vm").createContext(undefined, {
-		name: "Webpack Magic Comment Parser",
-		codeGeneration: { strings: false, wasm: false }
-	});

package/lib/util/makeSerializable.js

@@ -13,7 +13,7 @@ const { register } = require("./serialization");
 /** @typedef {{ serialize: (context: ObjectSerializerContext) => void, deserialize: (context: ObjectDeserializerContext) => void }} SerializableClass */
 /**
  * @template {SerializableClass} T
- * @typedef {(new (...params: any[]) => T) & { deserialize?: (context: ObjectDeserializerContext) => T }} SerializableClassConstructor
+ * @typedef {(new (...params: EXPECTED_ANY[]) => T) & { deserialize?: (context: ObjectDeserializerContext) => T }} SerializableClassConstructor
  */
 
 /**
@@ -53,7 +53,7 @@ class ClassSerializer {
  * @template {Constructor} T
  * @param {T} Constructor the constructor
  * @param {string} request the request which will be required when deserializing
- * @param {string | null} [name] the name to make multiple serializer unique when sharing a request
+ * @param {string | null=} name the name to make multiple serializer unique when sharing a request
  */
 module.exports = (Constructor, request, name = null) => {
 	register(Constructor, request, name, new ClassSerializer(Constructor));

package/lib/util/memoize.js

@@ -4,14 +4,17 @@
 
 "use strict";
 
-/** @template T @typedef {function(): T} FunctionReturning */
+/**
+ * @template T
+ * @typedef {() => T} FunctionReturning
+ */
 
 /**
  * @template T
  * @param {FunctionReturning<T>} fn memorized function
  * @returns {FunctionReturning<T>} new function
  */
-const memoize = fn => {
+const memoize = (fn) => {
 	let cache = false;
 	/** @type {T | undefined} */
 	let result;

package/lib/util/objectToMap.js

@@ -6,8 +6,9 @@
 
 /**
  * Convert an object into an ES6 map
- * @param {object} obj any object type that works with Object.entries()
- * @returns {Map<string, any>} an ES6 Map of KV pairs
+ * @template {object} T
+ * @param {T} obj any object type that works with Object.entries()
+ * @returns {Map<string, T[keyof T]>} an ES6 Map of KV pairs
  */
 module.exports = function objectToMap(obj) {
 	return new Map(Object.entries(obj));

package/lib/util/processAsyncTree.js

@@ -10,12 +10,12 @@
  * @template {Error} E
  * @param {Iterable<T>} items initial items
  * @param {number} concurrency number of items running in parallel
- * @param {function(T, function(T): void, function(E=): void): void} processor worker which pushes more items
- * @param {function(E=): void} callback all items processed
+ * @param {(item: T, push: (item: T) => void, callback: (err?: E) => void) => void} processor worker which pushes more items
+ * @param {(err?: E) => void} callback all items processed
  * @returns {void}
  */
 const processAsyncTree = (items, concurrency, processor, callback) => {
-	const queue = Array.from(items);
+	const queue = [...items];
 	if (queue.length === 0) return callback();
 	let processing = 0;
 	let finished = false;
@@ -24,7 +24,7 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 	/**
 	 * @param {T} item item
 	 */
-	const push = item => {
+	const push = (item) => {
 		queue.push(item);
 		if (!processScheduled && processing < concurrency) {
 			processScheduled = true;
@@ -35,7 +35,7 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 	/**
 	 * @param {E | null | undefined} err error
 	 */
-	const processorCallback = err => {
+	const processorCallback = (err) => {
 		processing--;
 		if (err && !finished) {
 			finished = true;

package/lib/util/propertyAccess.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { SAFE_IDENTIFIER, RESERVED_IDENTIFIER } = require("./propertyName");
+const { RESERVED_IDENTIFIER, SAFE_IDENTIFIER } = require("./propertyName");
 
 /**
  * @param {ArrayLike<string>} properties properties

package/lib/util/propertyName.js

@@ -50,7 +50,6 @@ const RESERVED_IDENTIFIER = new Set([
 	"public",
 	"static",
 	"yield",
-	"yield",
 	// module code
 	"await",
 	// skip future reserved keywords defined under ES1 till ES3
@@ -67,11 +66,11 @@ const RESERVED_IDENTIFIER = new Set([
  * @param {string} prop property name to analyze
  * @returns {string} valid JS property name
  */
-const propertyName = prop => {
+const propertyName = (prop) => {
 	if (SAFE_IDENTIFIER.test(prop) && !RESERVED_IDENTIFIER.has(prop)) {
 		return prop;
 	}
 	return JSON.stringify(prop);
 };
 
-module.exports = { SAFE_IDENTIFIER, RESERVED_IDENTIFIER, propertyName };
+module.exports = { RESERVED_IDENTIFIER, SAFE_IDENTIFIER, propertyName };

package/lib/util/registerExternalSerializer.js

@@ -5,9 +5,7 @@
 
 "use strict";
 
-const { register } = require("./serialization");
-
-const Position = /** @type {TODO} */ (require("acorn")).Position;
+const Position = require("acorn").Position;
 const SourceLocation = require("acorn").SourceLocation;
 const ValidationError = require("schema-utils").ValidationError;
 const {
@@ -19,14 +17,13 @@ const {
 	ReplaceSource,
 	SourceMapSource
 } = require("webpack-sources");
+const { register } = require("./serialization");
 
 /** @typedef {import("acorn").Position} Position */
 /** @typedef {import("../Dependency").RealDependencyLocation} RealDependencyLocation */
 /** @typedef {import("../Dependency").SourcePosition} SourcePosition */
-/** @typedef {import("./serialization").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization").ObjectSerializerContext} ObjectSerializerContext */
-
-/** @typedef {ObjectSerializerContext & { writeLazy?: (value: any) => void }} WebpackObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 const CURRENT_MODULE = "webpack/lib/util/registerExternalSerializer";
 
@@ -37,7 +34,7 @@ register(
 	new (class CachedSourceSerializer {
 		/**
 		 * @param {CachedSource} source the cached source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(source, { write, writeLazy }) {
@@ -68,7 +65,7 @@ register(
 	new (class RawSourceSerializer {
 		/**
 		 * @param {RawSource} source the raw source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(source, { write }) {
@@ -95,7 +92,7 @@ register(
 	new (class ConcatSourceSerializer {
 		/**
 		 * @param {ConcatSource} source the concat source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(source, { write }) {
@@ -121,7 +118,7 @@ register(
 	new (class PrefixSourceSerializer {
 		/**
 		 * @param {PrefixSource} source the prefix source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(source, { write }) {
@@ -146,7 +143,7 @@ register(
 	new (class ReplaceSourceSerializer {
 		/**
 		 * @param {ReplaceSource} source the replace source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(source, { write }) {
@@ -196,7 +193,7 @@ register(
 	new (class OriginalSourceSerializer {
 		/**
 		 * @param {OriginalSource} source the original source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(source, { write }) {
@@ -223,7 +220,7 @@ register(
 	new (class SourceLocationSerializer {
 		/**
 		 * @param {SourceLocation} loc the location to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(loc, { write }) {
@@ -259,7 +256,7 @@ register(
 	new (class PositionSerializer {
 		/**
 		 * @param {Position} pos the position to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(pos, { write }) {
@@ -287,7 +284,7 @@ register(
 	new (class SourceMapSourceSerializer {
 		/**
 		 * @param {SourceMapSource} source the source map source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(source, { write }) {
@@ -310,10 +307,9 @@ register(
 	CURRENT_MODULE,
 	"schema-utils/ValidationError",
 	new (class ValidationErrorSerializer {
-		// TODO error should be ValidationError, but this fails the type checks
 		/**
-		 * @param {TODO} error the source map source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
+		 * @param {ValidationError} error the source map source to be serialized
+		 * @param {ObjectSerializerContext} context context
 		 * @returns {void}
 		 */
 		serialize(error, { write }) {
@@ -328,7 +324,7 @@ register(
 
 		/**
 		 * @param {ObjectDeserializerContext} context context
-		 * @returns {TODO} error
+		 * @returns {ValidationError} error
 		 */
 		deserialize({ read }) {
 			return new ValidationError(read(), read(), read());

package/lib/util/removeBOM.js

@@ -0,0 +1,25 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * @param {string | Buffer} strOrBuffer string or buffer
+ * @returns {string | Buffer} result without BOM
+ */
+module.exports = (strOrBuffer) => {
+	if (typeof strOrBuffer === "string" && strOrBuffer.charCodeAt(0) === 0xfeff) {
+		return strOrBuffer.slice(1);
+	} else if (
+		Buffer.isBuffer(strOrBuffer) &&
+		strOrBuffer[0] === 0xef &&
+		strOrBuffer[1] === 0xbb &&
+		strOrBuffer[2] === 0xbf
+	) {
+		return strOrBuffer.subarray(3);
+	}
+
+	return strOrBuffer;
+};