@chromatic-com/cypress 0.13.0 → 0.13.1

package/embedded/node_modules/webpack/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,
@@ -58,8 +59,9 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../../declarations/WebpackOptions").Loader} Loader */
 /** @typedef {import("../../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").HashSalt} HashSalt */
-/** @typedef {import("../../declarations/WebpackOptions").HashSalt} HashDigest */
+/** @typedef {import("../../declarations/WebpackOptions").HashDigest} HashDigest */
 /** @typedef {import("../../declarations/WebpackOptions").HashDigestLength} HashDigestLength */
 /** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */
@@ -79,11 +81,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"]>,
@@ -128,6 +132,7 @@ const {
  */
 
 /**
+ * Defines the shared type used by this module.
  * @typedef {SnapshotOptions & {
  * managedPaths: NonNullable<SnapshotOptions["managedPaths"]>,
  * unmanagedPaths: NonNullable<SnapshotOptions["unmanagedPaths"]>,
@@ -140,6 +145,7 @@ const {
  */
 
 /**
+ * Defines the shared type used by this module.
  * @typedef {Optimization & {
  * runtimeChunk: NonNullable<Optimization["runtimeChunk"]>,
  * splitChunks: NonNullable<Optimization["splitChunks"]>,
@@ -168,6 +174,7 @@ const {
  */
 
 /**
+ * Defines the shared type used by this module.
  * @typedef {ExternalsPresets & {
  * web: NonNullable<ExternalsPresets["web"]>,
  * node: NonNullable<ExternalsPresets["node"]>,
@@ -180,6 +187,7 @@ const {
  */
 
 /**
+ * Defines the shared type used by this module.
  * @typedef {InfrastructureLogging & {
  * stream: NonNullable<InfrastructureLogging["stream"]>,
  * level: NonNullable<InfrastructureLogging["level"]>,
@@ -190,14 +198,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
  */
@@ -210,7 +221,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
@@ -225,7 +236,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
@@ -281,6 +292,7 @@ const A = (obj, prop, factory) => {
 };
 
 /**
+ * Apply webpack options base defaults.
  * @param {WebpackOptionsNormalized} options options to be modified
  * @returns {void}
  */
@@ -290,6 +302,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
@@ -363,6 +376,8 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		/** @type {NonNullable<ExperimentsNormalized["futureDefaults"]>} */
 		(options.experiments.futureDefaults);
 
+	F(options, "validate", () => !(futureDefaults === true && production));
+
 	F(options, "cache", () =>
 		development ? { type: /** @type {"memory"} */ ("memory") } : false
 	);
@@ -405,11 +420,8 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		hashSalt: /** @type {NonNullable<Output["hashSalt"]>} */ (
 			options.output.hashSalt
 		),
-		hashDigest: /** @type {NonNullable<Output["hashDigest"]>} */ (
-			options.output.hashDigest
-		),
-		hashDigestLength: /** @type {NonNullable<Output["hashDigestLength"]>} */ (
-			options.output.hashDigestLength
+		hashFunction: /** @type {NonNullable<Output["hashFunction"]>} */ (
+			options.output.hashFunction
 		),
 		syncWebAssembly:
 			/** @type {NonNullable<ExperimentsNormalized["syncWebAssembly"]>} */
@@ -420,9 +432,18 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		css:
 			/** @type {NonNullable<ExperimentsNormalized["css"]>} */
 			(options.experiments.css),
+		html:
+			/** @type {NonNullable<ExperimentsNormalized["html"]>} */
+			(options.experiments.html),
+		typescript:
+			/** @type {NonNullable<ExperimentsNormalized["typescript"]>} */
+			(options.experiments.typescript),
 		deferImport:
 			/** @type {NonNullable<ExperimentsNormalized["deferImport"]>} */
 			(options.experiments.deferImport),
+		sourceImport:
+			/** @type {NonNullable<ExperimentsNormalized["sourceImport"]>} */
+			(options.experiments.sourceImport),
 		futureDefaults,
 		isNode: targetProperties && targetProperties.node === true,
 		uniqueName: /** @type {string} */ (options.output.uniqueName),
@@ -430,7 +451,8 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		mode: options.mode,
 		outputModule:
 			/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
-			(options.output.module)
+			(options.output.module),
+		library: options.output.library
 	});
 
 	applyExternalsPresetsDefaults(options.externalsPresets, {
@@ -502,7 +524,10 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			mode: /** @type {Mode} */ (options.mode),
 			css:
 				/** @type {NonNullable<ExperimentsNormalized["css"]>} */
-				(options.experiments.css)
+				(options.experiments.css),
+			typescript:
+				/** @type {NonNullable<ExperimentsNormalized["typescript"]>} */
+				(options.experiments.typescript)
 		}),
 		options.resolve
 	);
@@ -528,6 +553,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 };
 
 /**
+ * Apply experiments defaults.
  * @param {ExperimentsNormalized} experiments options
  * @param {object} options options
  * @param {boolean} options.production is production
@@ -549,7 +575,12 @@ const applyExperimentsDefaults = (
 	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, "html", () => (experiments.futureDefaults ? true : undefined));
+	F(experiments, "typescript", () =>
+		experiments.futureDefaults ? true : undefined
+	);
 
 	if (typeof experiments.buildHttp === "object") {
 		D(experiments.buildHttp, "frozen", production);
@@ -558,6 +589,7 @@ const applyExperimentsDefaults = (
 };
 
 /**
+ * Apply cache defaults.
  * @param {CacheOptionsNormalized} cache options
  * @param {object} options options
  * @param {string} options.name name
@@ -640,6 +672,7 @@ const applyCacheDefaults = (
 };
 
 /**
+ * Apply snapshot defaults.
  * @param {SnapshotOptions} snapshot options
  * @param {object} options options
  * @param {boolean} options.production is production
@@ -717,17 +750,29 @@ 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
  * @param {boolean} options.deferImport is defer import enabled
+ * @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, isNode, outputModule }
+	{
+		futureDefaults,
+		deferImport,
+		sourceImport,
+		isNode,
+		outputModule,
+		library,
+		typescript
+	}
 ) => {
 	D(parserOptions, "unknownContextRequest", ".");
 	D(parserOptions, "unknownContextRegExp", false);
@@ -749,10 +794,14 @@ const applyJavascriptParserOptionsDefaults = (
 	D(parserOptions, "createRequire", isNode);
 	D(parserOptions, "dynamicUrl", true);
 	D(parserOptions, "deferImport", deferImport);
+	D(parserOptions, "sourceImport", sourceImport);
+	D(parserOptions, "typescript", typescript);
 	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
+	D(parserOptions, "anonymousDefaultExportName", !library);
 };
 
 /**
+ * Apply json generator options defaults.
  * @param {JsonGeneratorOptions} generatorOptions generator options
  * @returns {void}
  */
@@ -761,6 +810,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
@@ -779,41 +829,48 @@ 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
  * @param {boolean} options.deferImport is defer import enabled
+ * @param {boolean} options.sourceImport is import source enabled
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {Mode | undefined} options.mode mode
  * @param {HashSalt} options.hashSalt hash salt
- * @param {HashDigest} options.hashDigest hash digest
- * @param {HashDigestLength} options.hashDigestLength hash digest length
+ * @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 = (
 	module,
 	{
 		hashSalt,
-		hashDigest,
-		hashDigestLength,
+		hashFunction,
 		cache,
 		syncWebAssembly,
 		asyncWebAssembly,
 		css,
+		html,
+		typescript,
 		futureDefaults,
 		isNode,
 		uniqueName,
 		targetProperties,
 		mode,
 		deferImport,
-		outputModule
+		sourceImport,
+		outputModule,
+		library
 	}
 ) => {
 	if (cache) {
@@ -821,6 +878,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
 			 */
@@ -872,12 +930,16 @@ const applyModuleDefaults = (
 		{
 			futureDefaults,
 			deferImport,
+			sourceImport,
 			isNode,
-			outputModule
+			outputModule,
+			library,
+			typescript
 		}
 	);
 
 	F(module.generator, "json", () => ({}));
+
 	applyJsonGeneratorOptionsDefaults(
 		/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown["json"]>} */
 		(module.generator.json)
@@ -990,6 +1052,13 @@ const applyModuleDefaults = (
 				localIdentHashSalt
 			);
 
+			D(
+				/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]>} */
+				(module.generator[type]),
+				"localIdentHashFunction",
+				hashFunction
+			);
+
 			D(
 				/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]>} */
 				(module.generator[type]),
@@ -1013,6 +1082,16 @@ 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, () => ({}));
+	}
+
 	A(module, "defaultRules", () => {
 		const esm = {
 			type: JAVASCRIPT_MODULE_TYPE_ESM,
@@ -1070,6 +1149,7 @@ const applyModuleDefaults = (
 				...esm
 			}
 		];
+
 		if (asyncWebAssembly) {
 			const wasm = {
 				type: WEBASSEMBLY_MODULE_TYPE_ASYNC,
@@ -1115,6 +1195,7 @@ const applyModuleDefaults = (
 				...wasm
 			});
 		}
+
 		if (css) {
 			const resolve = {
 				fullySpecified: true,
@@ -1136,14 +1217,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
 			});
@@ -1165,6 +1252,72 @@ 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
+			});
+			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
+				});
+			}
+		}
+
+		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",
@@ -1202,6 +1355,7 @@ const applyModuleDefaults = (
 };
 
 /**
+ * Apply output defaults.
  * @param {Output} output options
  * @param {object} options options
  * @param {string} options.context context
@@ -1228,6 +1382,7 @@ const applyOutputDefaults = (
 	}
 ) => {
 	/**
+	 * Returns a readable library name.
 	 * @param {Library=} library the library option
 	 * @returns {string} a readable library name
 	 */
@@ -1279,11 +1434,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
@@ -1425,6 +1582,43 @@ 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, "assetModuleFilename", "[hash][ext][query][fragment]");
 	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
 	D(output, "compareBeforeEmit", true);
@@ -1501,7 +1695,7 @@ const applyOutputDefaults = (
 				output.module &&
 				environment.dynamicImport
 			) {
-				return "universal";
+				return "import";
 			}
 		}
 		return false;
@@ -1527,7 +1721,7 @@ const applyOutputDefaults = (
 				output.module &&
 				environment.dynamicImportInWorker
 			) {
-				return "universal";
+				return "import";
 			}
 		}
 		return false;
@@ -1601,6 +1795,7 @@ const applyOutputDefaults = (
 	}
 
 	/**
+	 * Processes the provided fn.
 	 * @param {(entryDescription: EntryDescription) => void} fn iterator
 	 * @returns {void}
 	 */
@@ -1659,6 +1854,7 @@ const applyOutputDefaults = (
 };
 
 /**
+ * Apply externals presets defaults.
  * @param {ExternalsPresets} externalsPresets options
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
@@ -1671,6 +1867,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
 	 */
@@ -1738,6 +1935,7 @@ const applyExternalsPresetsDefaults = (
 };
 
 /**
+ * Apply loader defaults.
  * @param {Loader} loader options
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
@@ -1762,6 +1960,7 @@ const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
 };
 
 /**
+ * Apply node defaults.
  * @param {WebpackNode} node options
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
@@ -1807,6 +2006,7 @@ const applyNodeDefaults = (
 };
 
 /**
+ * Apply performance defaults.
  * @param {Performance} performance options
  * @param {object} options options
  * @param {boolean} options.production is production
@@ -1820,6 +2020,7 @@ const applyPerformanceDefaults = (performance, { production }) => {
 };
 
 /**
+ * Apply optimization defaults.
  * @param {Optimization} optimization options
  * @param {object} options options
  * @param {boolean} options.production is production
@@ -1917,12 +2118,14 @@ 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.typescript is typescript enabled
  * @returns {ResolveOptions} resolve options
  */
 const getResolveDefaults = ({
@@ -1930,7 +2133,8 @@ const getResolveDefaults = ({
 	context,
 	targetProperties,
 	mode,
-	css
+	css,
+	typescript
 }) => {
 	/** @type {string[]} */
 	const conditions = ["webpack"];
@@ -1945,24 +2149,43 @@ const getResolveDefaults = ({
 		if (targetProperties.nwjs) conditions.push("nwjs");
 	}
 
-	const jsExtensions = [".js", ".json", ".wasm"];
+	const jsExtensions = typescript
+		? [".ts", ".js", ".json", ".wasm"]
+		: [".js", ".json", ".wasm"];
 
 	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", "..."],
+		conditionNames: [
+			...tsConditionPrefix,
+			"import",
+			"module-sync",
+			"module",
+			"..."
+		],
 		extensions: [...jsExtensions]
 	});
 
@@ -2043,10 +2266,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
@@ -2066,6 +2299,7 @@ const getResolveLoaderDefaults = ({ cache }) => {
 };
 
 /**
+ * Apply infrastructure logging defaults.
  * @param {InfrastructureLogging} infrastructureLogging options
  * @returns {void}
  */