webpack 5.98.0 → 5.99.0

package/lib/util/deprecation.js

@@ -7,7 +7,7 @@
 
 const util = require("util");
 
-/** @type {Map<string, Function>} */
+/** @type {Map<string, () => void>} */
 const deprecationCache = new Map();
 
 /**
@@ -23,7 +23,7 @@ const deprecationCache = new Map();
 /**
  * @param {string} message deprecation message
  * @param {string} code deprecation code
- * @returns {Function} function to trigger deprecation
+ * @returns {() => void} function to trigger deprecation
  */
 const createDeprecation = (message, code) => {
 	const cached = deprecationCache.get(message);
@@ -37,6 +37,9 @@ const createDeprecation = (message, code) => {
 	return fn;
 };
 
+/** @typedef {"concat" | "entry" | "filter" | "find" | "findIndex" | "includes" | "indexOf" | "join" | "lastIndexOf" | "map" | "reduce" | "reduceRight" | "slice" | "some"} COPY_METHODS_NAMES */
+
+/** @type {COPY_METHODS_NAMES[]} */
 const COPY_METHODS = [
 	"concat",
 	"entry",
@@ -54,6 +57,9 @@ const COPY_METHODS = [
 	"some"
 ];
 
+/** @typedef {"copyWithin" | "entries" | "fill" | "keys" | "pop" | "reverse" | "shift" | "splice" | "sort" | "unshift"} DISABLED_METHODS_NAMES */
+
+/** @type {DISABLED_METHODS_NAMES[]} */
 const DISABLED_METHODS = [
 	"copyWithin",
 	"entries",
@@ -68,7 +74,13 @@ const DISABLED_METHODS = [
 ];
 
 /**
- * @param {any} set new set
+ * @template T
+ * @typedef {Set<T> & {[Symbol.isConcatSpreadable]?: boolean} & { push?: (...items: T[]) => void } & { [P in DISABLED_METHODS_NAMES]?: () => void } & { [P in COPY_METHODS_NAMES]?: () => TODO }} SetWithDeprecatedArrayMethods
+ */
+
+/**
+ * @template T
+ * @param {SetWithDeprecatedArrayMethods<T>} set new set
  * @param {string} name property name
  * @returns {void}
  */
@@ -81,7 +93,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 		);
 		/**
 		 * @deprecated
-		 * @this {Set<any>}
+		 * @this {Set<T>}
 		 * @returns {number} count
 		 */
 		set[method] = function () {
@@ -108,7 +120,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 	);
 	/**
 	 * @deprecated
-	 * @this {Set<any>}
+	 * @this {Set<T>}
 	 * @returns {number} count
 	 */
 	set.push = function () {
@@ -121,6 +133,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 	};
 	for (const method of DISABLED_METHODS) {
 		if (set[method]) continue;
+
 		set[method] = () => {
 			throw new Error(
 				`${name} was changed from Array to Set (using Array method '${method}' is not possible)`
@@ -129,12 +142,12 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 	}
 	/**
 	 * @param {number} index index
-	 * @returns {any} value
+	 * @returns {() => T | undefined} value
 	 */
 	const createIndexGetter = index => {
 		/**
-		 * @this {Set<any>} a Set
-		 * @returns {any} the value at this location
+		 * @this {Set<T>} a Set
+		 * @returns {T | undefined} the value at this location
 		 */
 		// eslint-disable-next-line func-style
 		const fn = function () {
@@ -214,67 +227,56 @@ module.exports.createArrayToSetDeprecationSet = name => {
  * @param {string} name property name
  * @param {string} code deprecation code
  * @param {string} note additional note
- * @returns {Proxy<T>} frozen object with deprecation when modifying
+ * @returns {T} frozen object with deprecation when modifying
  */
 module.exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
 	const message = `${name} will be frozen in future, all modifications are deprecated.${
 		note && `\n${note}`
 	}`;
-	return /** @type {Proxy<T>} */ (
-		new Proxy(/** @type {object} */ (obj), {
+	return /** @type {T} */ (
+		new Proxy(obj, {
 			set: util.deprecate(
 				/**
-				 * @param {T} target target
+				 * @param {object} target target
 				 * @param {string | symbol} property property
-				 * @param {any} value value
-				 * @param {any} receiver receiver
+				 * @param {EXPECTED_ANY} value value
+				 * @param {EXPECTED_ANY} receiver receiver
 				 * @returns {boolean} result
 				 */
 				(target, property, value, receiver) =>
-					Reflect.set(
-						/** @type {object} */ (target),
-						property,
-						value,
-						receiver
-					),
+					Reflect.set(target, property, value, receiver),
 				message,
 				code
 			),
 			defineProperty: util.deprecate(
 				/**
-				 * @param {T} target target
+				 * @param {object} target target
 				 * @param {string | symbol} property property
 				 * @param {PropertyDescriptor} descriptor descriptor
 				 * @returns {boolean} result
 				 */
 				(target, property, descriptor) =>
-					Reflect.defineProperty(
-						/** @type {object} */ (target),
-						property,
-						descriptor
-					),
+					Reflect.defineProperty(target, property, descriptor),
 				message,
 				code
 			),
 			deleteProperty: util.deprecate(
 				/**
-				 * @param {T} target target
+				 * @param {object} target target
 				 * @param {string | symbol} property property
 				 * @returns {boolean} result
 				 */
-				(target, property) =>
-					Reflect.deleteProperty(/** @type {object} */ (target), property),
+				(target, property) => Reflect.deleteProperty(target, property),
 				message,
 				code
 			),
 			setPrototypeOf: util.deprecate(
 				/**
-				 * @param {T} target target
-				 * @param {object | null} proto proto
+				 * @param {object} target target
+				 * @param {EXPECTED_OBJECT | null} proto proto
 				 * @returns {boolean} result
 				 */
-				(target, proto) =>
-					Reflect.setPrototypeOf(/** @type {object} */ (target), proto),
+				(target, proto) => Reflect.setPrototypeOf(target, proto),
 				message,
 				code
 			)

package/lib/util/deterministicGrouping.js

@@ -152,15 +152,15 @@ const getTooSmallTypes = (size, minSize) => {
 };
 
 /**
- * @template T
- * @param {TODO} size size
+ * @template {object} T
+ * @param {T} size size
  * @param {Set<string>} types types
  * @returns {number} number of matching size types
  */
 const getNumberOfMatchingSizeTypes = (size, types) => {
 	let i = 0;
 	for (const key of Object.keys(size)) {
-		if (size[key] !== 0 && types.has(key)) i++;
+		if (size[/** @type {keyof T} */ (key)] !== 0 && types.has(key)) i++;
 	}
 	return i;
 };
@@ -212,7 +212,7 @@ class Group {
 	}
 
 	/**
-	 * @param {function(Node<T>): boolean} filter filter function
+	 * @param {(node: Node<T>) => boolean} filter filter function
 	 * @returns {Node<T>[] | undefined} removed nodes
 	 */
 	popNodes(filter) {
@@ -277,8 +277,8 @@ const getSimilarities = nodes => {
  * @property {Record<string, number>} maxSize maximum size of a group
  * @property {Record<string, number>} minSize minimum size of a group (preferred over maximum size)
  * @property {Iterable<T>} items a list of items
- * @property {function(T): Record<string, number>} getSize function to get size of an item
- * @property {function(T): string} getKey function to get the key of an item
+ * @property {(item: T) => Record<string, number>} getSize function to get size of an item
+ * @property {(item: T) => string} getKey function to get the key of an item
  */
 
 /**

package/lib/util/findGraphRoots.js

@@ -49,7 +49,7 @@ class Cycle {
 /**
  * @template T
  * @param {Iterable<T>} items list of items
- * @param {function(T): Iterable<T>} getDependencies function to get dependencies of an item (items that are not in list are ignored)
+ * @param {(item: T) => Iterable<T>} getDependencies function to get dependencies of an item (items that are not in list are ignored)
  * @returns {Iterable<T>} graph roots of the items
  */
 module.exports = (items, getDependencies) => {

package/lib/util/fs.js

@@ -63,22 +63,22 @@ const path = require("path");
 
 /** @typedef {string | number | boolean | null} JsonPrimitive */
 /** @typedef {JsonValue[]} JsonArray */
-/** @typedef {JsonPrimitive | JsonObject | JsonArray} JsonValue */
 /** @typedef {{[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined}} JsonObject */
+/** @typedef {JsonPrimitive | JsonObject | JsonArray} JsonValue */
 
-/** @typedef {function(NodeJS.ErrnoException | null): void} NoParamCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, string=): void} StringCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, Buffer=): void} BufferCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, (string | Buffer)=): void} StringOrBufferCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, (string[])=): void} ReaddirStringCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, (Buffer[])=): void} ReaddirBufferCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, (string[] | Buffer[])=): void} ReaddirStringOrBufferCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, (Dirent[])=): void} ReaddirDirentCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, IStats=): void} StatsCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, IBigIntStats=): void} BigIntStatsCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, (IStats | IBigIntStats)=): void} StatsOrBigIntStatsCallback */
-/** @typedef {function(NodeJS.ErrnoException | null, number=): void} NumberCallback */
-/** @typedef {function(NodeJS.ErrnoException | Error | null, JsonObject=): void} ReadJsonCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null) => void} NoParamCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: string) => void} StringCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: Buffer) => void} BufferCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: string | Buffer) => void} StringOrBufferCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: string[]) => void} ReaddirStringCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: Buffer[]) => void} ReaddirBufferCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: string[] | Buffer[]) => void} ReaddirStringOrBufferCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: Dirent[]) => void} ReaddirDirentCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: IStats) => void} StatsCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: IBigIntStats) => void} BigIntStatsCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: IStats | IBigIntStats) => void} StatsOrBigIntStatsCallback */
+/** @typedef {(err: NodeJS.ErrnoException | null, result?: number) => void} NumberCallback */
+/** @typedef {(err: NodeJS.ErrnoException | Error | null, result?: JsonObject) => void} ReadJsonCallback */
 
 /** @typedef {Map<string, FileSystemInfoEntry | "ignore">} TimeInfoEntries */
 
@@ -96,13 +96,13 @@ const path = require("path");
 // TODO webpack 6 deprecate missing getInfo
 /**
  * @typedef {object} Watcher
- * @property {function(): void} close closes the watcher and all underlying file watchers
- * @property {function(): void} pause closes the watcher, but keeps underlying file watchers alive until the next watch call
- * @property {(function(): Changes | null)=} getAggregatedChanges get current aggregated changes that have not yet send to callback
- * @property {(function(): Removals | null)=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
- * @property {function(): TimeInfoEntries} getFileTimeInfoEntries get info about files
- * @property {function(): TimeInfoEntries} getContextTimeInfoEntries get info about directories
- * @property {function(): WatcherInfo=} getInfo get info about timestamps and changes
+ * @property {() => void} close closes the watcher and all underlying file watchers
+ * @property {() => void} pause closes the watcher, but keeps underlying file watchers alive until the next watch call
+ * @property {(() => Changes | null)=} getAggregatedChanges get current aggregated changes that have not yet send to callback
+ * @property {(() => Removals | null)=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
+ * @property {() => TimeInfoEntries} getFileTimeInfoEntries get info about files
+ * @property {() => TimeInfoEntries} getContextTimeInfoEntries get info about directories
+ * @property {() => WatcherInfo=} getInfo get info about timestamps and changes
  */
 
 /**
@@ -112,8 +112,8 @@ const path = require("path");
  * @param {Iterable<string>} missing watched existence entries
  * @param {number} startTime timestamp of start time
  * @param {WatchOptions} options options object
- * @param {function(Error | null, TimeInfoEntries=, TimeInfoEntries=, Changes=, Removals=): void} callback aggregated callback
- * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
+ * @param {(err: Error | null, timeInfoEntries1?: TimeInfoEntries, timeInfoEntries2?: TimeInfoEntries, changes?: Changes, removals?: Removals) => void} callback aggregated callback
+ * @param {(value: string, num: number) => void} callbackUndelayed callback when the first change was detected
  * @returns {Watcher} a watcher
  */
 
@@ -264,15 +264,15 @@ const path = require("path");
  */
 
 /**
- * @typedef {function(PathOrFileDescriptor, ReadJsonCallback): void} ReadJson
+ * @typedef {(pathOrFileDescriptor: PathOrFileDescriptor, callback: ReadJsonCallback) => void} ReadJson
  */
 
 /**
- * @typedef {function(PathOrFileDescriptor): JsonObject} ReadJsonSync
+ * @typedef {(pathOrFileDescriptor: PathOrFileDescriptor) => JsonObject} ReadJsonSync
  */
 
 /**
- * @typedef {function((string | string[] | Set<string>)=): void} Purge
+ * @typedef {(value?: string | string[] | Set<string>) => void} Purge
  */
 
 /**
@@ -292,9 +292,9 @@ const path = require("path");
  * @property {ReadJson=} readJson
  * @property {ReadJsonSync=} readJsonSync
  * @property {Purge=} purge
- * @property {(function(string, string): string)=} join
- * @property {(function(string, string): string)=} relative
- * @property {(function(string): string)=} dirname
+ * @property {((path1: string, path2: string) => string)=} join
+ * @property {((from: string, to: string) => string)=} relative
+ * @property {((dirname: string) => string)=} dirname
  */
 
 /**
@@ -337,7 +337,7 @@ const path = require("path");
  */
 
 /**
- * @typedef {function(PathLike, NoParamCallback): void} Unlink
+ * @typedef {(pathLike: PathLike, callback: NoParamCallback) => void} Unlink
  */
 
 /**
@@ -350,9 +350,9 @@ const path = require("path");
  * @property {Stat} stat
  * @property {LStat=} lstat
  * @property {ReadFile} readFile
- * @property {(function(string, string): string)=} join
- * @property {(function(string, string): string)=} relative
- * @property {(function(string): string)=} dirname
+ * @property {((path1: string, path2: string) => string)=} join
+ * @property {((from: string, to: string) => string)=} relative
+ * @property {((dirname: string) => string)=} dirname
  */
 
 /**
@@ -395,7 +395,7 @@ const path = require("path");
  */
 
 /**
- * @typedef {function(PathLike, (BufferEncoding | WriteStreamOptions)=): NodeJS.WritableStream} CreateWriteStream
+ * @typedef {(pathLike: PathLike, result?: BufferEncoding | WriteStreamOptions) => NodeJS.WritableStream} CreateWriteStream
  */
 
 /**
@@ -431,7 +431,7 @@ const path = require("path");
  */
 
 /**
- * @template {NodeJS.ArrayBufferView} [TBuffer=Buffer]
+ * @template {NodeJS.ArrayBufferView} [TBuffer=NodeJS.ArrayBufferView]
  * @typedef {{
  * (fd: number, buffer: TBuffer, offset: number, length: number, position: ReadPosition | null, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void): void;
  * (fd: number, options: ReadAsyncOptions<TBuffer>, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void): void;
@@ -439,9 +439,9 @@ const path = require("path");
  * }} Read
  */
 
-/** @typedef {function(number, NoParamCallback): void} Close */
+/** @typedef {(df: number, callback: NoParamCallback) => void} Close */
 
-/** @typedef {function(PathLike, PathLike, NoParamCallback): void} Rename */
+/** @typedef {(a: PathLike, b: PathLike, callback: NoParamCallback) => void} Rename */
 
 /**
  * @typedef {object} IntermediateFileSystemExtras
@@ -517,7 +517,7 @@ module.exports.dirname = dirname;
 /**
  * @param {OutputFileSystem} fs a file system
  * @param {string} p an absolute path
- * @param {function(Error=): void} callback callback function for the error
+ * @param {(err?: Error) => void} callback callback function for the error
  * @returns {void}
  */
 const mkdirp = (fs, p, callback) => {
@@ -613,7 +613,7 @@ module.exports.readJson = readJson;
 /**
  * @param {InputFileSystem} fs a file system
  * @param {string} p an absolute path
- * @param {function(NodeJS.ErrnoException | Error | null, (IStats | string)=): void} callback callback
+ * @param {(err: NodeJS.ErrnoException | Error | null, stats?: IStats | string) => void} callback callback
  * @returns {void}
  */
 const lstatReadlinkAbsolute = (fs, p, callback) => {

package/lib/util/hash/wasm-hash.js

@@ -19,7 +19,7 @@ class WasmHash {
 	 * @param {number} digestSize size of digest returned by wasm
 	 */
 	constructor(instance, instancesPool, chunkSize, digestSize) {
-		const exports = /** @type {any} */ (instance.exports);
+		const exports = /** @type {EXPECTED_ANY} */ (instance.exports);
 		exports.init();
 		this.exports = exports;
 		this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
@@ -149,7 +149,7 @@ class WasmHash {
 }
 
 /**
- * @param {TODO} wasmModule wasm module
+ * @param {WebAssembly.Module} wasmModule wasm module
  * @param {WasmHash[]} instancesPool pool of instances
  * @param {number} chunkSize size of data chunks passed to wasm
  * @param {number} digestSize size of digest returned by wasm

package/lib/util/identifier.js

@@ -10,11 +10,6 @@ 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
@@ -85,24 +80,26 @@ const requestToAbsolute = (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 => {
@@ -110,11 +107,11 @@ 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 => {
@@ -156,18 +153,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>>>} */
+	/** @type {WeakMap<AssociatedObjectForCache, Map<string, Map<string, string>>>} */
 	const cache = new WeakMap();
 
 	/** @type {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} */

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
  */
 
 /**

package/lib/util/memoize.js

@@ -4,7 +4,10 @@
 
 "use strict";
 
-/** @template T @typedef {function(): T} FunctionReturning */
+/**
+ * @template T
+ * @typedef {() => T} FunctionReturning
+ */
 
 /**
  * @template T

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,8 +10,8 @@
  * @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) => {

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