webpack 5.107.1 → 5.108.0

package/lib/buildChunkGraph.js

@@ -16,6 +16,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Entrypoint")} Entrypoint */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
@@ -241,6 +242,44 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 	}
 };
 
+/**
+ * Derives block modules for another runtime from an already extracted result.
+ * Only the merged active state of each connection group can differ per
+ * runtime; modules and connection groups are reused. When all states turn
+ * out equal, the tuple array is shared instead of copied.
+ * @param {Module} module the root module
+ * @param {BlockModulesMap} source map containing the extracted result for all blocks of the module
+ * @param {RuntimeSpec} runtime runtime to derive for
+ * @param {BlockModulesMap} blockModulesMap block modules map to fill
+ */
+const deriveBlockModules = (module, source, runtime, blockModulesMap) => {
+	/** @type {DependenciesBlock[]} */
+	const queue = [module];
+	while (queue.length > 0) {
+		const block = /** @type {DependenciesBlock} */ (queue.pop());
+		const sourceModules =
+			/** @type {BlockModulesInFlattenTuples} */
+			(source.get(block));
+		let target = sourceModules;
+		for (let i = 0, len = sourceModules.length; i < len; i += 3) {
+			const state = getActiveStateOfConnections(
+				/** @type {ModuleGraphConnection[]} */ (sourceModules[i + 2]),
+				runtime
+			);
+			if (target === sourceModules) {
+				if (state === sourceModules[i + 1]) continue;
+				// states diverged, copy (states before i are identical)
+				target = [...sourceModules];
+			}
+			target[i + 1] = state;
+		}
+		blockModulesMap.set(block, target);
+		for (const b of block.blocks) {
+			queue.push(b);
+		}
+	}
+};
+
 /**
  * Processes the provided logger.
  * @param {Logger} logger a logger
@@ -267,8 +306,10 @@ const visitModules = (
 	/** @type {Map<RuntimeSpec, BlockModulesMap>} */
 	const blockModulesRuntimeMap = new Map();
 
-	/** @type {BlockModulesMap | undefined} */
-	let blockModulesMap;
+	// map containing the first extraction per root module,
+	// other runtimes derive their result from it
+	/** @type {Map<Module, BlockModulesMap>} */
+	const firstBlockModulesMapByModule = new Map();
 
 	/** @type {Map<Module, number>} */
 	const ordinalByModule = new Map();
@@ -302,7 +343,7 @@ const visitModules = (
 	 * @returns {BlockModulesInFlattenTuples | undefined} block modules in flatten tuples
 	 */
 	const getBlockModules = (block, runtime) => {
-		blockModulesMap = blockModulesRuntimeMap.get(runtime);
+		let blockModulesMap = blockModulesRuntimeMap.get(runtime);
 		if (blockModulesMap === undefined) {
 			/** @type {BlockModulesMap} */
 			blockModulesMap = new Map();
@@ -320,18 +361,33 @@ const visitModules = (
 				() => {
 					logger.time("visitModules: prepare");
 					const map = new Map();
-					extractBlockModules(module, moduleGraph, runtime, map);
+					const source = firstBlockModulesMapByModule.get(module);
+					if (source !== undefined) {
+						deriveBlockModules(module, source, runtime, map);
+					} else {
+						extractBlockModules(module, moduleGraph, runtime, map);
+					}
 					logger.timeAggregate("visitModules: prepare");
 					return map;
 				}
 			);
+			// allow other runtimes to derive from a memCache hit too
+			if (!firstBlockModulesMapByModule.has(module)) {
+				firstBlockModulesMapByModule.set(module, map);
+			}
 			for (const [block, blockModules] of map) {
 				blockModulesMap.set(block, blockModules);
 			}
 			return map.get(block);
 		}
 		logger.time("visitModules: prepare");
-		extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+		const source = firstBlockModulesMapByModule.get(module);
+		if (source !== undefined) {
+			deriveBlockModules(module, source, runtime, blockModulesMap);
+		} else {
+			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+			firstBlockModulesMapByModule.set(module, blockModulesMap);
+		}
 		blockModules =
 			/** @type {BlockModulesInFlattenTuples} */
 			(blockModulesMap.get(block));
@@ -581,7 +637,27 @@ const visitModules = (
 					}
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
-					// TODO merge entryOptions
+					// Fill in options the existing entrypoint hasn't set yet. We never
+					// overwrite: blocks that dedupe to one entrypoint (e.g. several
+					// workers pointing at the same module) legitimately carry distinct
+					// values such as `runtime`, so the first block to create the
+					// entrypoint wins and later ones only contribute missing keys.
+					// `name` is excluded: it is the entrypoint's identity, fixed at
+					// creation (and used to key namedChunkGroups), so back-filling it
+					// from a block that deduped in via its module would leave
+					// `entrypoint.name` out of sync and make module codegen
+					// order-dependent, which breaks persistent caching.
+					const existingOptions = entrypoint.options;
+					for (const key_ of Object.keys(entryOptions)) {
+						const key =
+							/** @type {keyof EntryOptions} */
+							(key_);
+						if (key === "name") continue;
+						if (entryOptions[key] === undefined) continue;
+						if (existingOptions[key] !== undefined) continue;
+						/** @type {EntryOptions[keyof EntryOptions]} */
+						(existingOptions[key]) = entryOptions[key];
+					}
 					entrypoint.addOrigin(
 						module,
 						/** @type {DependencyLocation} */ (b.loc),
@@ -733,7 +809,6 @@ const visitModules = (
 					continue;
 				}
 
-				const refOrdinal = /** @type {number} */ getModuleOrdinal(refModule);
 				const activeState = /** @type {ConnectionState} */ (
 					blockModules[i + 1]
 				);
@@ -744,7 +819,10 @@ const visitModules = (
 					skipConnectionBuffer.push([refModule, connections]);
 					// We skip inactive connections
 					if (activeState === false) continue;
-				} else if (isOrdinalSetInMask(minAvailableModules, refOrdinal)) {
+				} else if (
+					// assigning ordinals lazily here keeps masks small
+					isOrdinalSetInMask(minAvailableModules, getModuleOrdinal(refModule))
+				) {
 					// already in parent chunks, skip it for now
 					skipBuffer.push(refModule);
 					continue;
@@ -1290,7 +1368,8 @@ const connectChunkGroups = (
 		// connections and modules can only create one version
 		// TODO maybe decide this per runtime
 		if (
-			// TODO is this needed?
+			// Blocks with nested blocks must stay connected — skipping orphans the
+			// nested block's chunk group from this block's chunk group parent.
 			!blocksWithNestedBlocks.has(block) &&
 			connections.every(({ chunkGroup, originChunkGroupInfo }) =>
 				areModulesAvailable(

package/lib/bun/BunTargetPlugin.js

@@ -0,0 +1,48 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q @sheo13666q
+*/
+
+"use strict";
+
+const ExternalsPlugin = require("../ExternalsPlugin");
+const NodeTargetPlugin = require("../node/NodeTargetPlugin");
+
+/** @typedef {import("../Compiler")} Compiler */
+
+// Bun exposes the node.js core modules; externalize them with the `node:`
+// specifier (Bun resolves both forms) like the deno target.
+// cspell:word pnpapi
+const coreModules = new Set(
+	NodeTargetPlugin.builtins.filter(
+		(builtin) => typeof builtin === "string" && builtin !== "pnpapi"
+	)
+);
+
+// Bun's own built-in modules (`bun`, `bun:sqlite`, ...) are provided by the
+// runtime, never bundled.
+const BUN_BUILTINS = /^bun(?::|$)/;
+
+class BunTargetPlugin {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new ExternalsPlugin(
+			(dependency) =>
+				dependency.category === "commonjs" ? "node-commonjs" : "module-import",
+			({ request }, callback) => {
+				if (!request) return callback();
+				if (request.startsWith("node:") || BUN_BUILTINS.test(request)) {
+					return callback(null, request);
+				}
+				if (coreModules.has(request)) return callback(null, `node:${request}`);
+				callback();
+			}
+		).apply(compiler);
+	}
+}
+
+module.exports = BunTargetPlugin;

package/lib/cache/AddBuildDependenciesPlugin.js

@@ -15,6 +15,7 @@ class AddBuildDependenciesPlugin {
 	 * @param {Iterable<string>} buildDependencies list of build dependencies
 	 */
 	constructor(buildDependencies) {
+		/** @type {Set<string>} */
 		this.buildDependencies = new Set(buildDependencies);
 	}
 

package/lib/cache/AddManagedPathsPlugin.js

@@ -15,8 +15,11 @@ class AddManagedPathsPlugin {
 	 * @param {Iterable<string | RegExp>} unmanagedPaths list of unmanaged paths
 	 */
 	constructor(managedPaths, immutablePaths, unmanagedPaths) {
+		/** @type {Set<string | RegExp>} */
 		this.managedPaths = new Set(managedPaths);
+		/** @type {Set<string | RegExp>} */
 		this.immutablePaths = new Set(immutablePaths);
+		/** @type {Set<string | RegExp>} */
 		this.unmanagedPaths = new Set(unmanagedPaths);
 	}
 

package/lib/cache/IdleFileCachePlugin.js

@@ -28,9 +28,13 @@ class IdleFileCachePlugin {
 		idleTimeoutForInitialStore,
 		idleTimeoutAfterLargeChanges
 	) {
+		/** @type {PackFileCacheStrategy} */
 		this.strategy = strategy;
+		/** @type {number} */
 		this.idleTimeout = idleTimeout;
+		/** @type {number} */
 		this.idleTimeoutForInitialStore = idleTimeoutForInitialStore;
+		/** @type {number} */
 		this.idleTimeoutAfterLargeChanges = idleTimeoutAfterLargeChanges;
 	}
 

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -25,6 +25,7 @@ class MemoryWithGcCachePlugin {
 	 * @param {MemoryWithGcCachePluginOptions} options options
 	 */
 	constructor({ maxGenerations }) {
+		/** @type {number} */
 		this._maxGenerations = maxGenerations;
 	}
 

package/lib/cache/PackFileCacheStrategy.js

@@ -710,6 +710,7 @@ class PackContentItems {
 	 * @param {Content} map items
 	 */
 	constructor(map) {
+		/** @type {Content} */
 		this.map = map;
 	}
 

package/lib/cache/ResolverCachePlugin.js

@@ -36,7 +36,9 @@ class CacheEntry {
 	 * @param {Snapshot} snapshot snapshot
 	 */
 	constructor(result, snapshot) {
+		/** @type {ResolveRequest} */
 		this.result = result;
+		/** @type {Snapshot} */
 		this.snapshot = snapshot;
 	}
 

package/lib/cache/getLazyHashedEtag.js

@@ -25,7 +25,7 @@ class LazyHashedEtag {
 	 * @param {HashFunction} hashFunction the hash function to use
 	 */
 	constructor(obj, hashFunction = DEFAULTS.HASH_FUNCTION) {
-		/** @type {HashableObject} */
+		/** @type {HashableObject | undefined} */
 		this._obj = obj;
 		/** @type {undefined | string} */
 		this._hash = undefined;
@@ -40,8 +40,15 @@ class LazyHashedEtag {
 	toString() {
 		if (this._hash === undefined) {
 			const hash = createHash(this._hashFunction);
-			this._obj.updateHash(hash);
+			/** @type {HashableObject} */
+			(this._obj).updateHash(hash);
 			this._hash = hash.digest("base64");
+			// Drop the captured object once the hash is memoized. The hash is
+			// never reset, so we never need `_obj` again — and many callers
+			// (e.g. `SourceMapDevToolPlugin`, `RealContentHashPlugin`) capture
+			// a heavy `CachedSource` here that would otherwise stay reachable
+			// through this etag for the lifetime of the compilation cache.
+			this._obj = undefined;
 		}
 		return this._hash;
 	}

package/lib/cache/mergeEtags.js

@@ -14,7 +14,9 @@ class MergedEtag {
 	 * @param {Etag} b second
 	 */
 	constructor(a, b) {
+		/** @type {Etag} */
 		this.a = a;
+		/** @type {Etag} */
 		this.b = b;
 	}
 

package/lib/cli.js

@@ -17,15 +17,15 @@ const webpackSchema =
 /** @typedef {JSONSchema4 | JSONSchema6 | JSONSchema7} JSONSchema */
 /** @typedef {JSONSchema & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
 
-// TODO add originPath to PathItem for better errors
 /**
  * Defines the path item type used by this module.
  * @typedef {object} PathItem
  * @property {Schema} schema the part of the schema
  * @property {string} path the path in the config
+ * @property {string} segment the JSON pointer segment of this schema part (absolute when starting with "#")
  */
 
-/** @typedef {"unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"} ProblemType */
+/** @typedef {"unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "prototype-pollution-in-path" | "multiple-values-unexpected" | "invalid-value"} ProblemType */
 
 /** @typedef {string | number | boolean | RegExp} Value */
 
@@ -181,6 +181,12 @@ const getArguments = (schema = webpackSchema) => {
 				values: schemaPart.enum
 			};
 		}
+		if (schemaPart.const !== undefined) {
+			return {
+				type: "enum",
+				values: [schemaPart.const]
+			};
+		}
 		switch (schemaPart.type) {
 			case "number":
 				return {
@@ -233,6 +239,20 @@ const getArguments = (schema = webpackSchema) => {
 		};
 	};
 
+	/**
+	 * Joins the per-item segments into a JSON pointer (built only when needed).
+	 * @param {PathItem[]} path full path in schema (deepest item first)
+	 * @returns {string} JSON pointer to the deepest schema part
+	 */
+	const getOriginPath = (path) => {
+		let origin = "";
+		for (let i = path.length - 1; i >= 0; i--) {
+			const { segment } = path[i];
+			origin = segment[0] === "#" ? segment : origin + segment;
+		}
+		return origin;
+	};
+
 	/**
 	 * Adds the provided path to this object.
 	 * @param {PathItem[]} path full path in schema
@@ -283,7 +303,11 @@ const getArguments = (schema = webpackSchema) => {
 		) {
 			if (multiple) {
 				throw new Error(
-					`Conflicting schema for ${path[0].path} with ${argConfig.type} type (array type must be before single item type)`
+					`Conflicting schema for ${path[0].path} (${getOriginPath(
+						path
+					)}) with ${
+						argConfig.type
+					} type (array type must be before single item type)`
 				);
 			}
 			return 0;
@@ -294,18 +318,25 @@ const getArguments = (schema = webpackSchema) => {
 		return 1;
 	};
 
-	// TODO support `not` and `if/then/else`
-	// TODO support `const`, but we don't use it on our schema
+	// TODO support `not`
 	/**
 	 * Returns added arguments.
 	 * @param {Schema} schemaPart the current schema
-	 * @param {string} schemaPath the current path in the schema
+	 * @param {string} schemaPath the current path in the config
 	 * @param {PathItem[]} path all previous visited schemaParts
 	 * @param {string | null} inArray if inside of an array, the path to the array
+	 * @param {string} segment the JSON pointer segment of the current schema
 	 * @returns {number} added arguments
 	 */
-	const traverse = (schemaPart, schemaPath = "", path = [], inArray = null) => {
+	const traverse = (
+		schemaPart,
+		schemaPath = "",
+		path = [],
+		inArray = null,
+		segment = "#"
+	) => {
 		while (schemaPart.$ref) {
+			segment = schemaPart.$ref;
 			schemaPart = getSchemaPart(schemaPart.$ref);
 		}
 
@@ -320,12 +351,33 @@ const getArguments = (schema = webpackSchema) => {
 		if (schemaPart.cli && schemaPart.cli.exclude) return 0;
 
 		/** @type {PathItem[]} */
-		const fullPath = [{ schema: schemaPart, path: schemaPath }, ...path];
+		const fullPath = [
+			{ schema: schemaPart, path: schemaPath, segment },
+			...path
+		];
 
 		let addedArguments = 0;
 
 		addedArguments += addFlag(fullPath, Boolean(inArray));
 
+		// Collect flags from both branches of a conditional schema.
+		const conditional = /** @type {JSONSchema7} */ (schemaPart);
+		if (conditional.if) {
+			for (const key of /** @type {const} */ (["if", "then", "else"])) {
+				const subSchema = conditional[key];
+				if (subSchema && typeof subSchema === "object") {
+					addedArguments += traverse(
+						/** @type {Schema} */
+						(subSchema),
+						schemaPath,
+						fullPath,
+						inArray,
+						`/${key}`
+					);
+				}
+			}
+		}
+
 		if (schemaPart.type === "object") {
 			if (schemaPart.properties) {
 				for (const property of Object.keys(schemaPart.properties)) {
@@ -334,7 +386,8 @@ const getArguments = (schema = webpackSchema) => {
 						(schemaPart.properties[property]),
 						schemaPath ? `${schemaPath}.${property}` : property,
 						fullPath,
-						inArray
+						inArray,
+						`/properties/${property}`
 					);
 				}
 			}
@@ -354,7 +407,8 @@ const getArguments = (schema = webpackSchema) => {
 						(item),
 						`${schemaPath}.${i}`,
 						fullPath,
-						schemaPath
+						schemaPath,
+						`/items/${i}`
 					);
 				}
 
@@ -366,7 +420,8 @@ const getArguments = (schema = webpackSchema) => {
 				(schemaPart.items),
 				`${schemaPath}[]`,
 				fullPath,
-				schemaPath
+				schemaPath,
+				"/items"
 			);
 
 			if (addedArguments > 0) {
@@ -377,10 +432,16 @@ const getArguments = (schema = webpackSchema) => {
 			return addedArguments;
 		}
 
-		const maybeOf = schemaPart.oneOf || schemaPart.anyOf || schemaPart.allOf;
+		const ofKey = schemaPart.oneOf
+			? "oneOf"
+			: schemaPart.anyOf
+				? "anyOf"
+				: schemaPart.allOf
+					? "allOf"
+					: undefined;
 
-		if (maybeOf) {
-			const items = maybeOf;
+		if (ofKey) {
+			const items = /** @type {Schema[]} */ (schemaPart[ofKey]);
 
 			for (let i = 0; i < items.length; i++) {
 				addedArguments += traverse(
@@ -388,7 +449,8 @@ const getArguments = (schema = webpackSchema) => {
 					(items[i]),
 					schemaPath,
 					fullPath,
-					inArray
+					inArray,
+					`/${ofKey}/${i}`
 				);
 			}
 
@@ -449,6 +511,14 @@ const cliAddedItems = new WeakMap();
 
 /** @typedef {string | number} Property */
 
+/**
+ * Whether a path segment would walk into the prototype chain.
+ * @param {string} name path segment
+ * @returns {boolean} true when the segment is unsafe to write through
+ */
+const isUnsafeKey = (name) =>
+	name === "__proto__" || name === "constructor" || name === "prototype";
+
 /**
  * Gets object and property.
  * @param {ObjectConfiguration} config configuration
@@ -465,6 +535,14 @@ const getObjectAndProperty = (config, schemaPath, index = 0) => {
 	for (const part of parts) {
 		const isArray = part.endsWith("[]");
 		const name = isArray ? part.slice(0, -2) : part;
+		if (isUnsafeKey(name)) {
+			return {
+				problem: {
+					type: "prototype-pollution-in-path",
+					path: parts.slice(0, i).join(".")
+				}
+			};
+		}
 		let value = current[name];
 		if (isArray) {
 			if (value === undefined) {
@@ -511,6 +589,14 @@ const getObjectAndProperty = (config, schemaPath, index = 0) => {
 		current = value;
 		i++;
 	}
+	if (isUnsafeKey(property.endsWith("[]") ? property.slice(0, -2) : property)) {
+		return {
+			problem: {
+				type: "prototype-pollution-in-path",
+				path: parts.join(".")
+			}
+		};
+	}
 	const value = current[property];
 	if (property.endsWith("[]")) {
 		const name = property.slice(0, -2);
@@ -748,16 +834,20 @@ const processArguments = (args, config, values) => {
 const isColorSupported = () => {
 	const { env = {}, argv = [], platform = "" } = process;
 
-	const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
-	const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+	// Read values instead of using `in`: Deno's and Bun's `process.env` honor
+	// property access but not the `in`/`has` trap, so `"X" in env` is unreliable.
+	const isDisabled = env.NO_COLOR !== undefined || argv.includes("--no-color");
+	const isForced = env.FORCE_COLOR !== undefined || argv.includes("--color");
 	const isWindows = platform === "win32";
 	const isDumbTerminal = env.TERM === "dumb";
 
 	const isCompatibleTerminal = tty.isatty(1) && env.TERM && !isDumbTerminal;
 
 	const isCI =
-		"CI" in env &&
-		("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+		env.CI !== undefined &&
+		(env.GITHUB_ACTIONS !== undefined ||
+			env.GITLAB_CI !== undefined ||
+			env.CIRCLECI !== undefined);
 
 	return (
 		!isDisabled &&

package/lib/config/browserslistTargetHandler.js

@@ -120,6 +120,44 @@ const resolve = (browsers) => {
 			kaios: [2, 5],
 			node: [6, 0]
 		}),
+		let: rawChecker({
+			chrome: 49,
+			and_chr: 49,
+			edge: 12,
+			firefox: 44,
+			and_ff: 44,
+			// ie: Not supported
+			opera: 36,
+			op_mob: 36,
+			safari: [10, 0],
+			ios_saf: [10, 0],
+			samsung: [5, 0],
+			android: 49,
+			and_qq: [10, 4],
+			baidu: [13, 18],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		logicalAssignment: rawChecker({
+			chrome: 85,
+			and_chr: 85,
+			edge: 85,
+			firefox: 79,
+			and_ff: 79,
+			// ie: Not supported,
+			opera: 71,
+			op_mob: 60,
+			safari: 14,
+			ios_saf: 14,
+			samsung: [14, 0],
+			android: 85,
+			and_qq: [14, 9],
+			baidu: [13, 52],
+			and_uc: [15, 5],
+			kaios: [3, 0],
+			node: [15, 0]
+		}),
 		methodShorthand: rawChecker({
 			chrome: 47,
 			and_chr: 47,
@@ -317,6 +355,62 @@ const resolve = (browsers) => {
 			kaios: [3, 0],
 			node: 14
 		}),
+		symbol: rawChecker({
+			chrome: 38,
+			and_chr: 38,
+			edge: 12,
+			firefox: 36,
+			and_ff: 36,
+			// ie: Not supported,
+			opera: 25,
+			op_mob: 25,
+			safari: 9,
+			ios_saf: 9,
+			samsung: [3, 0],
+			android: 38,
+			and_qq: [10, 4],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [0, 12]
+		}),
+		hasOwn: rawChecker({
+			chrome: 93,
+			and_chr: 93,
+			edge: 93,
+			firefox: 92,
+			and_ff: 92,
+			// ie: Not supported,
+			opera: 79,
+			op_mob: 66,
+			safari: [15, 4],
+			ios_saf: [15, 4],
+			samsung: 17,
+			android: 93,
+			// and_qq: Not supported
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			node: [16, 9]
+		}),
+		spread: rawChecker({
+			chrome: 60,
+			and_chr: 60,
+			edge: 79,
+			firefox: 55,
+			and_ff: 55,
+			// ie: Not supported,
+			opera: 47,
+			op_mob: 44,
+			safari: [11, 1],
+			ios_saf: [11, 3],
+			samsung: [8, 2],
+			android: 60,
+			and_qq: [13, 1],
+			// baidu: Not supported
+			and_uc: [15, 5],
+			kaios: [3, 0],
+			node: [8, 3]
+		}),
 		templateLiteral: rawChecker({
 			chrome: 41,
 			and_chr: 41,
@@ -380,6 +474,11 @@ const resolve = (browsers) => {
 			rawChecker({
 				node: [22, 16]
 			}),
+		nodeBuiltinModuleGetter:
+			nodeProperty &&
+			rawChecker({
+				node: [22, 3]
+			}),
 		require: nodeProperty
 	};
 };