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

package/lib/config/defaults.js

@@ -22,6 +22,7 @@ const {
 	CSS_MODULE_TYPE_AUTO,
 	CSS_MODULE_TYPE_GLOBAL,
 	CSS_MODULE_TYPE_MODULE,
+	HTML_MODULE_TYPE,
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM,
@@ -30,6 +31,7 @@ const {
 	WEBASSEMBLY_MODULE_TYPE_SYNC
 } = require("../ModuleTypeConstants");
 const Template = require("../Template");
+const RuleSetCompiler = require("../rules/RuleSetCompiler");
 const { cleverMerge } = require("../util/cleverMerge");
 const {
 	getDefaultTarget,
@@ -70,6 +72,7 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").ParserOptionsByModuleTypeKnown} ParserOptionsByModuleTypeKnown */
 /** @typedef {import("../../declarations/WebpackOptions").Performance} Performance */
 /** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
 /** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
@@ -80,11 +83,13 @@ const {
 /** @typedef {import("./target").TargetProperties} TargetProperties */
 
 /**
+ * Defines the recursive non nullable type used by this module.
  * @template T
  * @typedef {{ [P in keyof T]-?: T[P] extends object ? RecursiveNonNullable<NonNullable<T[P]>> : NonNullable<T[P]> }} RecursiveNonNullable
  */
 
 /**
+ * Defines the shared type used by this module.
  * @typedef {Output & {
  * uniqueName: NonNullable<Output["uniqueName"]>,
  * filename: NonNullable<Output["filename"]>,
@@ -100,6 +105,7 @@ const {
  * devtoolNamespace: NonNullable<Output["devtoolNamespace"]>,
  * publicPath: NonNullable<Output["publicPath"]>,
  * workerPublicPath: NonNullable<Output["workerPublicPath"]>,
+ * workerChunkFilename: NonNullable<Output["workerChunkFilename"]>,
  * workerWasmLoading: NonNullable<Output["workerWasmLoading"]>,
  * workerChunkLoading: NonNullable<Output["workerChunkLoading"]>,
  * chunkFormat: NonNullable<Output["chunkFormat"]>,
@@ -120,6 +126,7 @@ const {
  * compareBeforeEmit: NonNullable<Output["compareBeforeEmit"]>,
  * strictModuleErrorHandling: NonNullable<Output["strictModuleErrorHandling"]>,
  * strictModuleExceptionHandling: NonNullable<Output["strictModuleExceptionHandling"]>,
+ * strictModuleResolution: NonNullable<Output["strictModuleResolution"]>,
  * importFunctionName: NonNullable<Output["importFunctionName"]>,
  * importMetaName: NonNullable<Output["importMetaName"]>,
  * environment: RecursiveNonNullable<Output["environment"]>,
@@ -129,6 +136,7 @@ const {
  */
 
 /**
+ * Defines the shared type used by this module.
  * @typedef {SnapshotOptions & {
  * managedPaths: NonNullable<SnapshotOptions["managedPaths"]>,
  * unmanagedPaths: NonNullable<SnapshotOptions["unmanagedPaths"]>,
@@ -141,6 +149,7 @@ const {
  */
 
 /**
+ * Defines the shared type used by this module.
  * @typedef {Optimization & {
  * runtimeChunk: NonNullable<Optimization["runtimeChunk"]>,
  * splitChunks: NonNullable<Optimization["splitChunks"]>,
@@ -155,6 +164,7 @@ const {
  * usedExports: NonNullable<Optimization["usedExports"]>,
  * mangleExports: NonNullable<Optimization["mangleExports"]>,
  * innerGraph: NonNullable<Optimization["innerGraph"]>,
+ * inlineExports: NonNullable<Optimization["inlineExports"]>,
  * concatenateModules: NonNullable<Optimization["concatenateModules"]>,
  * avoidEntryIife: NonNullable<Optimization["avoidEntryIife"]>,
  * emitOnErrors: NonNullable<Optimization["emitOnErrors"]>,
@@ -169,6 +179,7 @@ const {
  */
 
 /**
+ * Defines the shared type used by this module.
  * @typedef {ExternalsPresets & {
  * web: NonNullable<ExternalsPresets["web"]>,
  * node: NonNullable<ExternalsPresets["node"]>,
@@ -181,6 +192,7 @@ const {
  */
 
 /**
+ * Defines the shared type used by this module.
  * @typedef {InfrastructureLogging & {
  * stream: NonNullable<InfrastructureLogging["stream"]>,
  * level: NonNullable<InfrastructureLogging["level"]>,
@@ -191,14 +203,17 @@ const {
  */
 
 /**
+ * Defines the webpack options normalized with base defaults type used by this module.
  * @typedef {WebpackOptionsNormalized & { context: NonNullable<WebpackOptionsNormalized["context"]> } & { infrastructureLogging: InfrastructureLoggingNormalizedWithDefaults }} WebpackOptionsNormalizedWithBaseDefaults
  */
 
 /**
+ * Defines the webpack options normalized with defaults type used by this module.
  * @typedef {WebpackOptionsNormalizedWithBaseDefaults & { target: NonNullable<WebpackOptionsNormalized["target"]> } & { output: OutputNormalizedWithDefaults } & { optimization: OptimizationNormalizedWithDefaults } & { devtool: NonNullable<WebpackOptionsNormalized["devtool"]> } & { stats: NonNullable<WebpackOptionsNormalized["stats"]> } & { node: NonNullable<WebpackOptionsNormalized["node"]> } & { profile: NonNullable<WebpackOptionsNormalized["profile"]> } & { parallelism: NonNullable<WebpackOptionsNormalized["parallelism"]> } & { snapshot: SnapshotNormalizedWithDefaults } & { externalsPresets: ExternalsPresetsNormalizedWithDefaults } & { externalsType: NonNullable<WebpackOptionsNormalized["externalsType"]> } & { watch: NonNullable<WebpackOptionsNormalized["watch"]> } & { performance: NonNullable<WebpackOptionsNormalized["performance"]> } & { recordsInputPath: NonNullable<WebpackOptionsNormalized["recordsInputPath"]> } & { recordsOutputPath: NonNullable<WebpackOptionsNormalized["recordsOutputPath"]> } & { dotenv: NonNullable<WebpackOptionsNormalized["dotenv"]> }} WebpackOptionsNormalizedWithDefaults
  */
 
 /**
+ * Defines the resolved options type used by this module.
  * @typedef {object} ResolvedOptions
  * @property {PlatformTargetProperties | false} platform - platform target properties
  */
@@ -211,7 +226,7 @@ const DEFAULTS = {
 };
 
 /**
- * Sets a constant default value when undefined
+ * Processes the provided obj.
  * @template T
  * @template {keyof T} P
  * @param {T} obj an object
@@ -226,7 +241,7 @@ const D = (obj, prop, value) => {
 };
 
 /**
- * Sets a dynamic default value when undefined, by calling the factory function
+ * Processes the provided obj.
  * @template T
  * @template {keyof T} P
  * @param {T} obj an object
@@ -282,6 +297,7 @@ const A = (obj, prop, factory) => {
 };
 
 /**
+ * Apply webpack options base defaults.
  * @param {WebpackOptionsNormalized} options options to be modified
  * @returns {void}
  */
@@ -291,6 +307,7 @@ const applyWebpackOptionsBaseDefaults = (options) => {
 };
 
 /**
+ * Apply webpack options defaults.
  * @param {WebpackOptionsNormalized} options options to be modified
  * @param {number=} compilerIndex index of compiler
  * @returns {ResolvedOptions} Resolved options after apply defaults
@@ -326,6 +343,26 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		}
 	}
 
+	D(options, "watch", false);
+	D(options, "profile", false);
+	D(options, "parallelism", 100);
+	D(options, "recordsInputPath", false);
+	D(options, "recordsOutputPath", false);
+
+	// Capture the raw html intent before "auto" is resolved: only an explicit
+	// `html: true` (or futureDefaults) keeps `.html` ahead of `.js` when resolving.
+	const htmlExplicitlyEnabled = options.experiments.html === true;
+	const htmlWasUnset = options.experiments.html === undefined;
+
+	applyExperimentsDefaults(options.experiments, {
+		production,
+		development,
+		targetProperties,
+		rules: options.module.rules
+	});
+
+	// After experiments are resolved: the default dev source map depends on the
+	// (possibly "auto"-resolved) `experiments.css` value.
 	F(
 		options,
 		"devtool",
@@ -348,24 +385,20 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			)
 	);
 
-	D(options, "watch", false);
-	D(options, "profile", false);
-	D(options, "parallelism", 100);
-	D(options, "recordsInputPath", false);
-	D(options, "recordsOutputPath", false);
-
-	applyExperimentsDefaults(options.experiments, {
-		production,
-		development,
-		targetProperties
-	});
-
 	const futureDefaults =
 		/** @type {NonNullable<ExperimentsNormalized["futureDefaults"]>} */
 		(options.experiments.futureDefaults);
 
+	// `.html` outranks `.js` only for an explicit opt-in (`html: true`, or the
+	// futureDefaults-forced default), never for the auto-enabled default.
+	const htmlFirst = htmlExplicitlyEnabled || (htmlWasUnset && futureDefaults);
+
 	F(options, "validate", () => !(futureDefaults === true && production));
 
+	// Progress lives on infrastructureLogging; webpack@6 shows the interactive
+	// bar by default (`"auto"` = TTY only), webpack@5 stays opt-in.
+	D(options.infrastructureLogging, "progress", futureDefaults ? "auto" : false);
+
 	F(options, "cache", () =>
 		development ? { type: /** @type {"memory"} */ ("memory") } : false
 	);
@@ -399,7 +432,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		entry: options.entry,
 		futureDefaults,
 		asyncWebAssembly:
-			/** @type {NonNullable<ExperimentsNormalized["asyncWebAssembly"]>} */
+			/** @type {boolean} */
 			(options.experiments.asyncWebAssembly)
 	});
 
@@ -415,11 +448,17 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			/** @type {NonNullable<ExperimentsNormalized["syncWebAssembly"]>} */
 			(options.experiments.syncWebAssembly),
 		asyncWebAssembly:
-			/** @type {NonNullable<ExperimentsNormalized["asyncWebAssembly"]>} */
+			/** @type {boolean} */
 			(options.experiments.asyncWebAssembly),
 		css:
-			/** @type {NonNullable<ExperimentsNormalized["css"]>} */
+			/** @type {boolean} */
 			(options.experiments.css),
+		html:
+			/** @type {boolean} */
+			(options.experiments.html),
+		typescript:
+			/** @type {boolean} */
+			(options.experiments.typescript),
 		deferImport:
 			/** @type {NonNullable<ExperimentsNormalized["deferImport"]>} */
 			(options.experiments.deferImport),
@@ -433,9 +472,33 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		mode: options.mode,
 		outputModule:
 			/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
-			(options.output.module)
+			(options.output.module),
+		library: options.output.library
 	});
 
+	// `output.resourceHints.urlHints` shorthand: fan the project-wide rules out
+	// as the base `urlHints` of every URL-emitting parser (JS `new URL`, CSS
+	// `url()`, HTML `<img src>`). They go first so parser-scoped
+	// `parser.<type>.urlHints` rules — matched later, last-match-wins — override.
+	const outputUrlHints =
+		options.output.resourceHints && options.output.resourceHints.urlHints;
+	if (outputUrlHints && outputUrlHints.length > 0) {
+		for (const type of [
+			"javascript",
+			CSS_MODULE_TYPE,
+			CSS_MODULE_TYPE_AUTO,
+			CSS_MODULE_TYPE_MODULE,
+			CSS_MODULE_TYPE_GLOBAL,
+			HTML_MODULE_TYPE
+		]) {
+			const parser =
+				/** @type {{ urlHints?: import("../../declarations/WebpackOptions").UrlHintRule[] } | undefined} */
+				(options.module.parser[type]);
+			if (!parser) continue;
+			parser.urlHints = [...outputUrlHints, ...(parser.urlHints || [])];
+		}
+	}
+
 	applyExternalsPresetsDefaults(options.externalsPresets, {
 		targetProperties,
 		buildHttp: Boolean(options.experiments.buildHttp),
@@ -448,7 +511,13 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		/** @type {NonNullable<WebpackOptionsNormalized["loader"]>} */ (
 			options.loader
 		),
-		{ targetProperties, environment: options.output.environment }
+		{
+			targetProperties,
+			environment: options.output.environment,
+			outputModule:
+				/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
+				(options.output.module)
+		}
 	);
 
 	F(options, "externalsType", () => {
@@ -492,7 +561,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		development,
 		production,
 		css:
-			/** @type {NonNullable<ExperimentsNormalized["css"]>} */
+			/** @type {boolean} */
 			(options.experiments.css),
 		records: Boolean(options.recordsInputPath || options.recordsOutputPath)
 	});
@@ -504,8 +573,15 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			targetProperties,
 			mode: /** @type {Mode} */ (options.mode),
 			css:
-				/** @type {NonNullable<ExperimentsNormalized["css"]>} */
-				(options.experiments.css)
+				/** @type {boolean} */
+				(options.experiments.css),
+			html:
+				/** @type {boolean} */
+				(options.experiments.html),
+			htmlFirst,
+			typescript:
+				/** @type {boolean} */
+				(options.experiments.typescript)
 		}),
 		options.resolve
 	);
@@ -524,36 +600,103 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 						browser: targetProperties.browser,
 						webworker: targetProperties.webworker,
 						node: targetProperties.node,
+						deno: targetProperties.deno,
+						bun: targetProperties.bun,
 						nwjs: targetProperties.nwjs,
-						electron: targetProperties.electron
+						electron: targetProperties.electron,
+						// spans both web and node (target "universal" or ["web", "node"])
+						universal:
+							targetProperties.node === null && targetProperties.web === null
 					}
 	};
 };
 
 /**
+ * Apply experiments defaults.
  * @param {ExperimentsNormalized} experiments options
  * @param {object} options options
  * @param {boolean} options.production is production
  * @param {boolean} options.development is development mode
  * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {RuleSetRules} options.rules user `module.rules`, used to resolve the css/html/asyncWebAssembly/typescript "auto" defaults
  * @returns {void}
  */
 const applyExperimentsDefaults = (
 	experiments,
-	{ production, development, targetProperties }
+	{ production, development, targetProperties, rules }
 ) => {
 	D(experiments, "futureDefaults", false);
 	D(experiments, "backCompat", !experiments.futureDefaults);
 	// TODO do we need sync web assembly in webpack@6?
 	D(experiments, "syncWebAssembly", false);
-	D(experiments, "asyncWebAssembly", experiments.futureDefaults);
-	D(experiments, "outputModule", false);
+	D(
+		experiments,
+		"asyncWebAssembly",
+		experiments.futureDefaults ? true : "auto"
+	);
+	// the universal target (web + node, neither specific) only works as ESM
+	const universal =
+		Boolean(targetProperties) &&
+		/** @type {TargetProperties} */ (targetProperties).node === null &&
+		/** @type {TargetProperties} */ (targetProperties).web === null;
+	// the deno and bun targets only emit ECMAScript modules
+	const deno =
+		Boolean(targetProperties) &&
+		/** @type {TargetProperties} */ (targetProperties).deno === true;
+	const bun =
+		Boolean(targetProperties) &&
+		/** @type {TargetProperties} */ (targetProperties).bun === true;
+	D(experiments, "outputModule", universal || deno || bun);
 	D(experiments, "lazyCompilation", undefined);
 	D(experiments, "buildHttp", undefined);
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
 	D(experiments, "deferImport", false);
 	D(experiments, "sourceImport", false);
-	F(experiments, "css", () => (experiments.futureDefaults ? true : undefined));
+	F(experiments, "css", () => (experiments.futureDefaults ? true : "auto"));
+	F(experiments, "html", () => (experiments.futureDefaults ? true : "auto"));
+	F(experiments, "typescript", () =>
+		experiments.futureDefaults ? true : "auto"
+	);
+
+	// Resolve the "auto" default: enable the built-in css/html module type unless
+	// the user already registered a loader (or explicit type) for these files, so
+	// enabling them by default does not break existing css-loader/html-loader setups.
+	// The built-in `/\.css$/i` rule also covers `.module.css`, so a loader scoped to
+	// CSS modules must disable the built-in type too — sample both extensions.
+	// When enabled implicitly the value stays `"auto"` (truthy): Css/HtmlModulesPlugin
+	// then step aside per-module for requests that loaders were applied to
+	// (inline requests or loaders injected via hooks, e.g. html-webpack-plugin).
+	// TODO webpack 6: css/html default to `true`, drop the `"auto"` marker.
+	if (experiments.css === "auto") {
+		experiments.css =
+			!(
+				RuleSetCompiler.hasRuleForResource(rules, "/file.css") ||
+				RuleSetCompiler.hasRuleForResource(rules, "/file.module.css")
+			) && "auto";
+	}
+	if (experiments.html === "auto") {
+		experiments.html =
+			!RuleSetCompiler.hasRuleForResource(rules, "/file.html") && "auto";
+	}
+	// Auto-enable only when the built-in TypeScript support can actually run:
+	// it needs `module.stripTypeScriptTypes` (Node.js >= 22.6) and must step
+	// aside for a loader registered for `.ts`/`.mts`/`.cts` (e.g. ts-loader).
+	if (experiments.typescript === "auto") {
+		experiments.typescript =
+			// eslint-disable-next-line n/no-unsupported-features/node-builtins
+			typeof require("module").stripTypeScriptTypes === "function" &&
+			!(
+				RuleSetCompiler.hasRuleForResource(rules, "/file.ts") ||
+				RuleSetCompiler.hasRuleForResource(rules, "/file.mts") ||
+				RuleSetCompiler.hasRuleForResource(rules, "/file.cts")
+			);
+	}
+	// `syncWebAssembly` already claims `.wasm`, so don't let "auto" override it.
+	if (experiments.asyncWebAssembly === "auto") {
+		experiments.asyncWebAssembly =
+			!experiments.syncWebAssembly &&
+			!RuleSetCompiler.hasRuleForResource(rules, "/file.wasm");
+	}
 
 	if (typeof experiments.buildHttp === "object") {
 		D(experiments.buildHttp, "frozen", production);
@@ -562,6 +705,7 @@ const applyExperimentsDefaults = (
 };
 
 /**
+ * Apply cache defaults.
  * @param {CacheOptionsNormalized} cache options
  * @param {object} options options
  * @param {string} options.name name
@@ -644,6 +788,7 @@ const applyCacheDefaults = (
 };
 
 /**
+ * Apply snapshot defaults.
  * @param {SnapshotOptions} snapshot options
  * @param {object} options options
  * @param {boolean} options.production is production
@@ -721,6 +866,7 @@ const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
 };
 
 /**
+ * Apply javascript parser options defaults.
  * @param {JavascriptParserOptions} parserOptions parser options
  * @param {object} options options
  * @param {boolean} options.futureDefaults is future defaults enabled
@@ -728,11 +874,21 @@ const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
  * @param {boolean} options.sourceImport is import source enabled
  * @param {boolean} options.isNode is node target platform
  * @param {boolean} options.outputModule is output.module enabled
+ * @param {WebpackOptionsNormalized["output"]["library"]} options.library library options
+ * @param {boolean} options.typescript is typescript enabled
  * @returns {void}
  */
 const applyJavascriptParserOptionsDefaults = (
 	parserOptions,
-	{ futureDefaults, deferImport, sourceImport, isNode, outputModule }
+	{
+		futureDefaults,
+		deferImport,
+		sourceImport,
+		isNode,
+		outputModule,
+		library,
+		typescript
+	}
 ) => {
 	D(parserOptions, "unknownContextRequest", ".");
 	D(parserOptions, "unknownContextRegExp", false);
@@ -755,10 +911,14 @@ const applyJavascriptParserOptionsDefaults = (
 	D(parserOptions, "dynamicUrl", true);
 	D(parserOptions, "deferImport", deferImport);
 	D(parserOptions, "sourceImport", sourceImport);
+	D(parserOptions, "typescript", typescript);
 	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
+	D(parserOptions, "strictModeViolations", futureDefaults ? "error" : "warn");
+	D(parserOptions, "anonymousDefaultExportName", !library);
 };
 
 /**
+ * Apply json generator options defaults.
  * @param {JsonGeneratorOptions} generatorOptions generator options
  * @returns {void}
  */
@@ -767,6 +927,7 @@ const applyJsonGeneratorOptionsDefaults = (generatorOptions) => {
 };
 
 /**
+ * Apply css generator options defaults.
  * @param {CssGeneratorOptions} generatorOptions generator options
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
@@ -785,12 +946,15 @@ const applyCssGeneratorOptionsDefaults = (
 };
 
 /**
+ * Apply module defaults.
  * @param {ModuleOptions} module options
  * @param {object} options options
  * @param {boolean} options.cache is caching enabled
  * @param {boolean} options.syncWebAssembly is syncWebAssembly enabled
  * @param {boolean} options.asyncWebAssembly is asyncWebAssembly enabled
+ * @param {boolean} options.typescript is typescript enabled
  * @param {boolean} options.css is css enabled
+ * @param {boolean} options.html is html enabled
  * @param {boolean} options.futureDefaults is future defaults enabled
  * @param {string} options.uniqueName the unique name
  * @param {boolean} options.isNode is node target platform
@@ -801,6 +965,7 @@ const applyCssGeneratorOptionsDefaults = (
  * @param {HashSalt} options.hashSalt hash salt
  * @param {HashFunction} options.hashFunction hash function
  * @param {boolean} options.outputModule is output.module enabled
+ * @param {WebpackOptionsNormalized["output"]["library"]} options.library library options
  * @returns {void}
  */
 const applyModuleDefaults = (
@@ -812,6 +977,8 @@ const applyModuleDefaults = (
 		syncWebAssembly,
 		asyncWebAssembly,
 		css,
+		html,
+		typescript,
 		futureDefaults,
 		isNode,
 		uniqueName,
@@ -819,7 +986,8 @@ const applyModuleDefaults = (
 		mode,
 		deferImport,
 		sourceImport,
-		outputModule
+		outputModule,
+		library
 	}
 ) => {
 	if (cache) {
@@ -827,6 +995,7 @@ const applyModuleDefaults = (
 			module,
 			"unsafeCache",
 			/**
+			 * Handles the callback logic for this hook.
 			 * @param {Module} module module
 			 * @returns {boolean} true, if we want to cache the module
 			 */
@@ -880,11 +1049,14 @@ const applyModuleDefaults = (
 			deferImport,
 			sourceImport,
 			isNode,
-			outputModule
+			outputModule,
+			library,
+			typescript
 		}
 	);
 
 	F(module.generator, "json", () => ({}));
+
 	applyJsonGeneratorOptionsDefaults(
 		/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown["json"]>} */
 		(module.generator.json)
@@ -911,6 +1083,18 @@ const applyModuleDefaults = (
 			"namedExports",
 			true
 		);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"customMedia",
+			true
+		);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"customSelectors",
+			true
+		);
 
 		for (const type of [
 			CSS_MODULE_TYPE_AUTO,
@@ -955,6 +1139,18 @@ const applyModuleDefaults = (
 				"grid",
 				true
 			);
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"customMedia",
+				true
+			);
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"customSelectors",
+				true
+			);
 		}
 
 		F(module.generator, CSS_MODULE_TYPE, () => ({}));
@@ -1027,6 +1223,28 @@ const applyModuleDefaults = (
 		}
 	}
 
+	if (html) {
+		// `module.generator.html.extract` is intentionally left undefined by
+		// default: HtmlGenerator treats undefined as "extract iff this HTML
+		// module is a compilation entry", which is the HTML-entry-point
+		// behaviour. Setting `extract: true` forces extraction for all HTML
+		// modules (including imported ones); `extract: false` disables it
+		// everywhere.
+		F(module.generator, HTML_MODULE_TYPE, () => ({}));
+		// `module.parser.html.sources` defaults to `true` — HtmlParser uses
+		// the built-in source list to extract URL-like attributes (`<img
+		// src>`, `<link href>`, `<script src>`, …) as webpack dependencies.
+		// Users may pass `false` to disable extraction entirely or an array
+		// (with `"..."` to include the defaults) to customize it.
+		F(module.parser, HTML_MODULE_TYPE, () => ({}));
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[HTML_MODULE_TYPE]>} */
+			(module.parser[HTML_MODULE_TYPE]),
+			"sources",
+			true
+		);
+	}
+
 	A(module, "defaultRules", () => {
 		const esm = {
 			type: JAVASCRIPT_MODULE_TYPE_ESM,
@@ -1084,6 +1302,7 @@ const applyModuleDefaults = (
 				...esm
 			}
 		];
+
 		if (asyncWebAssembly) {
 			const wasm = {
 				type: WEBASSEMBLY_MODULE_TYPE_ASYNC,
@@ -1129,6 +1348,7 @@ const applyModuleDefaults = (
 				...wasm
 			});
 		}
+
 		if (css) {
 			const resolve = {
 				fullySpecified: true,
@@ -1150,14 +1370,20 @@ const applyModuleDefaults = (
 				resolve
 			});
 			// For CSS modules, i.e. `.class { composes: className from "./style.css" }`
-			// We inherit for such constructions
+			// We inherit for such constructions, but skip files that are already
+			// detected as CSS modules by extension (`.module.<ext>`) — they get
+			// the same modules-mode behavior from the auto rule, and forcing a
+			// different type stamp here would create a duplicate module instance.
+			const moduleExtension = /\.module\.\w+$/i;
 			rules.push({
 				dependency: /css-import-local-module/,
+				exclude: moduleExtension,
 				type: CSS_MODULE_TYPE_MODULE,
 				resolve
 			});
 			rules.push({
 				dependency: /css-import-global-module/,
+				exclude: moduleExtension,
 				type: CSS_MODULE_TYPE_GLOBAL,
 				resolve
 			});
@@ -1179,6 +1405,94 @@ const applyModuleDefaults = (
 				}
 			);
 		}
+		if (html) {
+			const resolve = {
+				fullySpecified: true,
+				preferRelative: true
+			};
+
+			rules.push({
+				test: /\.html$/i,
+				type: HTML_MODULE_TYPE,
+				resolve
+			});
+			rules.push({
+				mimetype: "text/html",
+				type: HTML_MODULE_TYPE,
+				resolve
+			});
+			// `<iframe srcdoc>` content is fed back through the HTML pipeline as a
+			// `data:text/html` module. `extract: "inline"` exposes the processed
+			// HTML on the `html` codegen channel that `HtmlInlineHtmlDependency.
+			// Template` reads back into the attribute, without emitting a standalone
+			// `.html` file (the module is never a page on its own).
+			rules.push({
+				dependency: "html-srcdoc",
+				generator: {
+					extract: "inline"
+				},
+				resolve
+			});
+			if (css) {
+				// Inline `<style>` content in an HTML module is fed into the
+				// CSS pipeline as a `data:text/css` virtual module. We force
+				// `exportType: "text"` so the CSS module exposes the
+				// processed CSS text on the `css-text` codegen channel that
+				// `HtmlInlineStyleDependency.Template` reads back into the
+				// `<style>` tag.
+				rules.push({
+					dependency: "html-style",
+					parser: {
+						exportType: "text"
+					},
+					resolve
+				});
+				// A `style="..."` attribute is a CSS block's contents, not a
+				// stylesheet, so parse it as one (`as: "block-contents"`).
+				rules.push({
+					dependency: "html-style-attribute",
+					parser: {
+						exportType: "text",
+						as: "block-contents"
+					},
+					resolve
+				});
+			}
+		}
+
+		if (typescript) {
+			rules.push(
+				{
+					test: /\.mts$/i,
+					...esm
+				},
+				{
+					test: /\.ts$/i,
+					descriptionData: {
+						type: "module"
+					},
+					...esm
+				},
+				{
+					test: /\.cts$/i,
+					...commonjs
+				},
+				{
+					test: /\.ts$/i,
+					descriptionData: {
+						type: "commonjs"
+					},
+					...commonjs
+				},
+				{
+					mimetype: {
+						or: ["text/typescript", "application/typescript"]
+					},
+					...esm
+				}
+			);
+		}
+
 		rules.push(
 			{
 				dependency: "url",
@@ -1211,11 +1525,52 @@ const applyModuleDefaults = (
 				type: ASSET_MODULE_TYPE_BYTES
 			}
 		);
+		if (html) {
+			// A `.webmanifest` referenced by `<link rel="manifest">` is a `url`
+			// dependency; route it to the `asset/webmanifest` type so its icon URLs
+			// are parsed. Must come after the generic `url` → asset rule so it wins.
+			rules.push({
+				dependency: "url",
+				test: /\.webmanifest$/i,
+				type: "asset/webmanifest"
+			});
+			// A generated manifest (`output.html.manifest` object) is injected as a
+			// `data:application/manifest+json` URL with no `.webmanifest` extension;
+			// route it by mimetype so its icons are parsed and hashed too.
+			rules.push({
+				dependency: "url",
+				mimetype: "application/manifest+json",
+				type: "asset/webmanifest"
+			});
+		}
+		if (futureDefaults) {
+			rules.push({
+				oneOf: [
+					{
+						resourceQuery: /(\?|&)raw(&|$)/,
+						type: ASSET_MODULE_TYPE_SOURCE
+					},
+					{
+						resourceQuery: /(\?|&)url(&|$)/,
+						type: ASSET_MODULE_TYPE_RESOURCE
+					},
+					{
+						resourceQuery: /(\?|&)no-inline(&|$)/,
+						type: ASSET_MODULE_TYPE_RESOURCE
+					},
+					{
+						resourceQuery: /(\?|&)inline(&|$)/,
+						type: ASSET_MODULE_TYPE_INLINE
+					}
+				]
+			});
+		}
 		return rules;
 	});
 };
 
 /**
+ * Apply output defaults.
  * @param {Output} output options
  * @param {object} options options
  * @param {string} options.context context
@@ -1242,6 +1597,7 @@ const applyOutputDefaults = (
 	}
 ) => {
 	/**
+	 * Returns a readable library name.
 	 * @param {Library=} library the library option
 	 * @returns {string} a readable library name
 	 */
@@ -1293,11 +1649,13 @@ const applyOutputDefaults = (
 
 	const environment = /** @type {Environment} */ (output.environment);
 	/**
+	 * Returns true, when v is truthy or undefined.
 	 * @param {boolean | undefined} v value
 	 * @returns {boolean} true, when v is truthy or undefined
 	 */
 	const optimistic = (v) => v || v === undefined;
 	/**
+	 * Conditionally optimistic.
 	 * @param {boolean | undefined} v value
 	 * @param {boolean | undefined} c condition
 	 * @returns {boolean | undefined} true, when v is truthy or undefined, or c is truthy
@@ -1309,6 +1667,17 @@ const applyOutputDefaults = (
 		"globalThis",
 		() => /** @type {boolean | undefined} */ (tp && tp.globalThis)
 	);
+	F(
+		environment,
+		"symbol",
+		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.symbol))
+	);
+	F(
+		environment,
+		"hasOwn",
+		// No optimistic, because it is new
+		() => tp && /** @type {boolean | undefined} */ (tp.hasOwn)
+	);
 	F(
 		environment,
 		"bigIntLiteral",
@@ -1320,6 +1689,22 @@ const applyOutputDefaults = (
 		"const",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.const))
 	);
+	// `let` was added after `const`; targets predating it report only `const`,
+	// so fall back to `const` when `let` is unreported (undefined). Targets that
+	// do report `let` (browserslist, built-ins) keep their own accurate value.
+	F(environment, "let", () =>
+		conditionallyOptimistic(
+			/** @type {boolean | undefined} */ (tp && tp.let),
+			environment.const
+		)
+	);
+	F(
+		environment,
+		"logicalAssignment",
+		() =>
+			// No optimistic, because it is new
+			tp && /** @type {boolean | undefined} */ (tp.logicalAssignment)
+	);
 	F(
 		environment,
 		"methodShorthand",
@@ -1338,6 +1723,11 @@ const applyOutputDefaults = (
 		() =>
 			tp && optimistic(/** @type {boolean | undefined} */ (tp.asyncFunction))
 	);
+	F(
+		environment,
+		"generator",
+		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.generator))
+	);
 	F(
 		environment,
 		"forOf",
@@ -1355,6 +1745,11 @@ const applyOutputDefaults = (
 		() =>
 			tp && optimistic(/** @type {boolean | undefined} */ (tp.optionalChaining))
 	);
+	F(
+		environment,
+		"spread",
+		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.spread))
+	);
 	F(
 		environment,
 		"nodePrefixForCoreModules",
@@ -1371,6 +1766,13 @@ const applyOutputDefaults = (
 			// No optimistic, because it is new
 			tp && /** @type {boolean | undefined} */ (tp.importMetaDirnameAndFilename)
 	);
+	F(
+		environment,
+		"nodeBuiltinModuleGetter",
+		() =>
+			// No optimistic, because it is new
+			tp && /** @type {boolean | undefined} */ (tp.nodeBuiltinModuleGetter)
+	);
 	F(
 		environment,
 		"templateLiteral",
@@ -1400,6 +1802,30 @@ const applyOutputDefaults = (
 		"document",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.document))
 	);
+	F(
+		environment,
+		"modulePreload",
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.modulePreload))
+	);
+
+	// Vite-style default for ESM output (`output.module`): preload the entry's
+	// initial dependency graph, which native `import()` would otherwise fetch in
+	// a waterfall. Classic output loads initial chunks via parallel `<script>`
+	// tags (no waterfall), so it stays opt-in.
+	if (output.module && output.resourceHints === undefined) {
+		output.resourceHints = {};
+	}
+	if (output.resourceHints) {
+		if (output.module) D(output.resourceHints, "initial", true);
+		// `modulePreloadPolyfill` defaults from the target's modulepreload
+		// support: inject the polyfill iff the environment lacks it.
+		D(
+			output.resourceHints,
+			"modulePreloadPolyfill",
+			!environment.modulePreload
+		);
+	}
 
 	D(output, "filename", output.module ? "[name].mjs" : "[name].js");
 	F(output, "iife", () => !output.module);
@@ -1439,8 +1865,48 @@ const applyOutputDefaults = (
 		}
 		return "[id].css";
 	});
+	// Derive html filename defaults from `output.filename` / `output.chunkFilename`
+	// (the same shape the CSS pipeline uses), but if the derived template lacks
+	// any per-module differentiator, fall back to `[name].html` so multiple
+	// extracted HTML modules in one compilation don't collide on the same
+	// emitted file. For example: `output.filename: "bundle.js"` would derive
+	// `bundle.html` — two `.html` modules extracted in the same build would
+	// both want that name and conflict at emit time.
+	const HAS_PATH_PLACEHOLDER_REGEXP =
+		/\[(name|id|chunkhash|contenthash|fullhash|hash)/;
+	/**
+	 * @param {string} template html filename template derived from `output.filename`
+	 * @returns {string} same template, or `[name].html` if it has no per-module placeholder
+	 */
+	const ensureUniqueHtmlTemplate = (template) =>
+		HAS_PATH_PLACEHOLDER_REGEXP.test(template) ? template : "[name].html";
+	F(output, "htmlFilename", () => {
+		const filename =
+			/** @type {NonNullable<Output["htmlFilename"]>} */
+			(output.filename);
+		if (typeof filename !== "function") {
+			return ensureUniqueHtmlTemplate(
+				filename.replace(/\.[mc]?js(\?|$)/, ".html$1")
+			);
+		}
+		return "[name].html";
+	});
+	F(output, "htmlChunkFilename", () => {
+		const chunkFilename =
+			/** @type {NonNullable<Output["htmlChunkFilename"]>} */
+			(output.chunkFilename);
+		if (typeof chunkFilename !== "function") {
+			return ensureUniqueHtmlTemplate(
+				chunkFilename.replace(/\.[mc]?js(\?|$)/, ".html$1")
+			);
+		}
+		return "[name].html";
+	});
+	D(output, "html", false);
 	D(output, "assetModuleFilename", "[hash][ext][query][fragment]");
 	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
+	// On by default like other wasm toolchains; set false to drop the fallback runtime code.
+	D(output, "wasmStreamingFallback", true);
 	D(output, "compareBeforeEmit", true);
 	D(output, "charset", !futureDefaults);
 	const uniqueNameId = Template.toIdentifier(
@@ -1452,8 +1918,11 @@ const applyOutputDefaults = (
 		if (tp) {
 			if (tp.global) return "global";
 			if (tp.globalThis) return "globalThis";
-			// For universal target (i.e. code can be run in browser/node/worker etc.)
-			if (tp.web === null && tp.node === null && tp.module) return "globalThis";
+			// Universal target (web + node) with no reported accessor: `globalThis`
+			// is the only one defined everywhere (`null` = mixed support → `self`).
+			if (tp.web === null && tp.node === null && tp.globalThis === undefined) {
+				return "globalThis";
+			}
 		}
 		return "self";
 	});
@@ -1520,6 +1989,13 @@ const applyOutputDefaults = (
 		}
 		return false;
 	});
+	F(
+		output,
+		"workerChunkFilename",
+		() =>
+			/** @type {NonNullable<Output["workerChunkFilename"]>} */
+			(output.chunkFilename)
+	);
 	F(output, "workerChunkLoading", () => {
 		if (tp) {
 			switch (output.chunkFormat) {
@@ -1576,7 +2052,9 @@ const applyOutputDefaults = (
 	D(
 		output,
 		"hotUpdateMainFilename",
-		`[runtime].[fullhash].hot-update.${output.module ? "json.mjs" : "json"}`
+		// Only `chunkLoading: "import"` loads the manifest via `import()` (needs an
+		// `export default` ES module); every other loader fetches it as raw JSON.
+		`[runtime].[fullhash].hot-update.${output.chunkLoading === "import" ? "json.mjs" : "json"}`
 	);
 	D(output, "crossOriginLoading", false);
 	F(output, "scriptType", () => (output.module ? "module" : false));
@@ -1601,6 +2079,7 @@ const applyOutputDefaults = (
 	D(output, "hashDigestLength", futureDefaults ? 16 : 20);
 	D(output, "strictModuleErrorHandling", false);
 	D(output, "strictModuleExceptionHandling", false);
+	F(output, "strictModuleResolution", () => development);
 
 	const { trustedTypes } = output;
 	if (trustedTypes) {
@@ -1615,6 +2094,7 @@ const applyOutputDefaults = (
 	}
 
 	/**
+	 * Processes the provided fn.
 	 * @param {(entryDescription: EntryDescription) => void} fn iterator
 	 * @returns {void}
 	 */
@@ -1673,6 +2153,7 @@ const applyOutputDefaults = (
 };
 
 /**
+ * Apply externals presets defaults.
  * @param {ExternalsPresets} externalsPresets options
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
@@ -1685,6 +2166,7 @@ const applyExternalsPresetsDefaults = (
 	{ targetProperties, buildHttp, outputModule }
 ) => {
 	/**
+	 * Checks whether this object is universal.
 	 * @param {keyof TargetProperties} key a key
 	 * @returns {boolean} true when target is universal, otherwise false
 	 */
@@ -1705,7 +2187,25 @@ const applyExternalsPresetsDefaults = (
 		externalsPresets,
 		"node",
 		/** @type {boolean | undefined} */
-		(targetProperties && (targetProperties.node || isUniversal("node")))
+		(
+			targetProperties &&
+				((targetProperties.node &&
+					!targetProperties.deno &&
+					!targetProperties.bun) ||
+					isUniversal("node"))
+		)
+	);
+	D(
+		externalsPresets,
+		"deno",
+		/** @type {boolean | undefined} */
+		(Boolean(targetProperties && targetProperties.deno))
+	);
+	D(
+		externalsPresets,
+		"bun",
+		/** @type {boolean | undefined} */
+		(Boolean(targetProperties && targetProperties.bun))
 	);
 	D(
 		externalsPresets,
@@ -1752,13 +2252,18 @@ const applyExternalsPresetsDefaults = (
 };
 
 /**
+ * Apply loader defaults.
  * @param {Loader} loader options
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {Environment} options.environment environment
+ * @param {boolean} options.outputModule is output type is module
  * @returns {void}
  */
-const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
+const applyLoaderDefaults = (
+	loader,
+	{ targetProperties, environment, outputModule }
+) => {
 	F(loader, "target", () => {
 		if (targetProperties) {
 			if (targetProperties.electron) {
@@ -1768,14 +2273,26 @@ const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
 				return "electron";
 			}
 			if (targetProperties.nwjs) return "nwjs";
+			if (targetProperties.deno) return "deno";
+			if (targetProperties.bun) return "bun";
 			if (targetProperties.node) return "node";
 			if (targetProperties.web) return "web";
+			// no single platform to report: the bundle runs on both (target
+			// `"universal"` / `["web", "node"]`), so loaders get `"universal"`
+			if (
+				outputModule &&
+				targetProperties.node === null &&
+				targetProperties.web === null
+			) {
+				return "universal";
+			}
 		}
 	});
 	D(loader, "environment", environment);
 };
 
 /**
+ * Apply node defaults.
  * @param {WebpackNode} node options
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
@@ -1821,6 +2338,7 @@ const applyNodeDefaults = (
 };
 
 /**
+ * Apply performance defaults.
  * @param {Performance} performance options
  * @param {object} options options
  * @param {boolean} options.production is production
@@ -1834,6 +2352,7 @@ const applyPerformanceDefaults = (performance, { production }) => {
 };
 
 /**
+ * Apply optimization defaults.
  * @param {Optimization} optimization options
  * @param {object} options options
  * @param {boolean} options.production is production
@@ -1864,6 +2383,7 @@ const applyOptimizationDefaults = (
 	D(optimization, "providedExports", true);
 	D(optimization, "usedExports", production);
 	D(optimization, "innerGraph", production);
+	D(optimization, "inlineExports", production);
 	D(optimization, "mangleExports", production);
 	D(optimization, "concatenateModules", production);
 	D(optimization, "avoidEntryIife", production);
@@ -1877,8 +2397,8 @@ const applyOptimizationDefaults = (
 	A(optimization, "minimizer", () => [
 		{
 			apply: (compiler) => {
-				// Lazy load the Terser plugin
-				const TerserPlugin = require("terser-webpack-plugin");
+				// Lazy load the minimizer plugin
+				const TerserPlugin = require("minimizer-webpack-plugin");
 
 				new TerserPlugin({
 					terserOptions: {
@@ -1931,12 +2451,16 @@ const applyOptimizationDefaults = (
 };
 
 /**
+ * Gets resolve defaults.
  * @param {object} options options
  * @param {boolean} options.cache is cache enable
  * @param {string} options.context build context
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {Mode} options.mode mode
  * @param {boolean} options.css is css enabled
+ * @param {boolean} options.html is html enabled
+ * @param {boolean} options.htmlFirst whether `.html` should outrank `.js` when resolving (only when html was explicitly enabled)
+ * @param {boolean} options.typescript is typescript enabled
  * @returns {ResolveOptions} resolve options
  */
 const getResolveDefaults = ({
@@ -1944,7 +2468,10 @@ const getResolveDefaults = ({
 	context,
 	targetProperties,
 	mode,
-	css
+	css,
+	html,
+	htmlFirst,
+	typescript
 }) => {
 	/** @type {string[]} */
 	const conditions = ["webpack"];
@@ -1952,6 +2479,8 @@ const getResolveDefaults = ({
 	conditions.push(mode === "development" ? "development" : "production");
 
 	if (targetProperties) {
+		if (targetProperties.deno) conditions.push("deno");
+		if (targetProperties.bun) conditions.push("bun");
 		if (targetProperties.webworker) conditions.push("worker");
 		if (targetProperties.node) conditions.push("node");
 		if (targetProperties.web) conditions.push("browser");
@@ -1959,25 +2488,54 @@ const getResolveDefaults = ({
 		if (targetProperties.nwjs) conditions.push("nwjs");
 	}
 
-	const jsExtensions = [".js", ".json", ".wasm"];
+	const jsExtensions = typescript
+		? [".ts", ".js", ".json", ".wasm"]
+		: [".js", ".json", ".wasm"];
+
+	// Explicitly enabling html keeps `.html` ahead of `.js` (html-as-entry feature).
+	// Auto-enabled html/css are lower-priority fallbacks after `.js`, so enabling
+	// them by default never makes `x.html`/`x.css` shadow `x.js`.
+	const esmResolveExtensions = [
+		...(html && htmlFirst ? [".html"] : []),
+		...jsExtensions,
+		...(html && !htmlFirst ? [".html"] : []),
+		...(css ? [".css"] : [])
+	];
 
 	const tp = targetProperties;
 	const browserField =
 		tp && tp.web && (!tp.node || (tp.electron && tp.electronRenderer));
 
+	// When `experiments.typescript` is on, also honor the `typescript`
+	// conditional-exports key so monorepo packages can ship .ts sources via
+	// `package.json#exports` — same convention Node.js's amaro uses.
+	const tsConditionPrefix = typescript ? ["typescript"] : [];
+
 	/** @type {() => ResolveOptions} */
 	const cjsDeps = () => ({
 		aliasFields: browserField ? ["browser"] : [],
 		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
-		conditionNames: ["require", "module", "..."],
+		conditionNames: [
+			...tsConditionPrefix,
+			"require",
+			"module-sync",
+			"module",
+			"..."
+		],
 		extensions: [...jsExtensions]
 	});
 	/** @type {() => ResolveOptions} */
 	const esmDeps = () => ({
 		aliasFields: browserField ? ["browser"] : [],
 		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
-		conditionNames: ["import", "module", "..."],
-		extensions: [...jsExtensions]
+		conditionNames: [
+			...tsConditionPrefix,
+			"import",
+			"module-sync",
+			"module",
+			"..."
+		],
+		extensions: [...esmResolveExtensions]
 	});
 
 	/** @type {() => ResolveOptions} */
@@ -2057,10 +2615,20 @@ const getResolveDefaults = ({
 			cssResolveOptions;
 	}
 
+	if (typescript) {
+		resolveOptions.tsconfig = true;
+		resolveOptions.extensionAlias = {
+			".js": [".js", ".ts"],
+			".cjs": [".cjs", ".cts"],
+			".mjs": [".mjs", ".mts"]
+		};
+	}
+
 	return resolveOptions;
 };
 
 /**
+ * Gets resolve loader defaults.
  * @param {object} options options
  * @param {boolean} options.cache is cache enable
  * @returns {ResolveOptions} resolve options
@@ -2080,6 +2648,7 @@ const getResolveLoaderDefaults = ({ cache }) => {
 };
 
 /**
+ * Apply infrastructure logging defaults.
  * @param {InfrastructureLogging} infrastructureLogging options
  * @returns {void}
  */