webpack
Version:
Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.
2,862 lines • 91 kB
JavaScript
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
"use strict";
const fs = require("fs");
const path = require("path");
const {
CSS_TYPE,
JAVASCRIPT_TYPE,
UNKNOWN_TYPE
} = require("../ModuleSourceTypeConstants");
const {
ASSET_MODULE_TYPE,
ASSET_MODULE_TYPE_BYTES,
ASSET_MODULE_TYPE_INLINE,
ASSET_MODULE_TYPE_RESOURCE,
ASSET_MODULE_TYPE_SOURCE,
CSS_MODULE_TYPE,
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,
JSON_MODULE_TYPE,
WEBASSEMBLY_MODULE_TYPE_ASYNC,
WEBASSEMBLY_MODULE_TYPE_SYNC
} = require("../ModuleTypeConstants");
const Template = require("../Template");
const RuleSetCompiler = require("../rules/RuleSetCompiler");
const { cleverMerge } = require("../util/cleverMerge");
const {
getDefaultTarget,
getTargetProperties,
getTargetsBrowsers,
getTargetsProperties
} = require("./target");
/**
* @import {
* CacheOptionsNormalized,
* Context,
* DevTool as Devtool,
* CssGeneratorOptions,
* EntryDescription,
* EntryNormalized as Entry,
* Environment,
* Experiments,
* ExperimentsNormalized,
* ExternalsPresets,
* ExternalsType,
* FileCacheOptions,
* GeneratorOptionsByModuleTypeKnown,
* InfrastructureLogging,
* JavascriptParserOptions,
* JsonGeneratorOptions,
* Library,
* LibraryName,
* LibraryType,
* Loader,
* Mode,
* HashFunction,
* HashSalt,
* ModuleOptionsNormalized as ModuleOptions,
* Node as WebpackNode,
* OptimizationMinimizeOptions,
* OptimizationNormalized as Optimization,
* OptimizationSplitChunksOptions,
* OutputNormalized as Output,
* ParserOptionsByModuleTypeKnown,
* Performance,
* ResolveOptions,
* RuleSetRules,
* SnapshotOptions,
* WebpackOptionsNormalized
* } from "../../declarations/WebpackOptions"
*/
/** @import Module from "../Module" */
/**
* @import {
* ChunkLoadingTypes
* } from "../javascript/EnableChunkLoadingPlugin"
*/
/** @import { WasmLoadingTypes } from "../wasm/EnableWasmLoadingPlugin" */
/** @import { PlatformTargetProperties, TargetProperties } from "./target" */
/**
* 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"]>,
* cssFilename: NonNullable<Output["cssFilename"]>,
* chunkFilename: NonNullable<Output["chunkFilename"]>,
* cssChunkFilename: NonNullable<Output["cssChunkFilename"]>,
* hotUpdateChunkFilename: NonNullable<Output["hotUpdateChunkFilename"]>,
* hotUpdateGlobal: NonNullable<Output["hotUpdateGlobal"]>,
* assetModuleFilename: NonNullable<Output["assetModuleFilename"]>,
* webassemblyModuleFilename: NonNullable<Output["webassemblyModuleFilename"]>,
* sourceMapFilename: NonNullable<Output["sourceMapFilename"]>,
* hotUpdateMainFilename: NonNullable<Output["hotUpdateMainFilename"]>,
* 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"]>,
* module: NonNullable<Output["module"]>,
* asyncChunks: NonNullable<Output["asyncChunks"]>,
* charset: NonNullable<Output["charset"]>,
* iife: NonNullable<Output["iife"]>,
* globalObject: NonNullable<Output["globalObject"]>,
* scriptType: NonNullable<Output["scriptType"]>,
* path: NonNullable<Output["path"]>,
* pathinfo: NonNullable<Output["pathinfo"]>,
* hashFunction: NonNullable<Output["hashFunction"]>,
* hashDigest: NonNullable<Output["hashDigest"]>,
* hashDigestLength: NonNullable<Output["hashDigestLength"]>,
* chunkLoadTimeout: NonNullable<Output["chunkLoadTimeout"]>,
* chunkLoading: NonNullable<Output["chunkLoading"]>,
* chunkLoadingGlobal: NonNullable<Output["chunkLoadingGlobal"]>,
* 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"]>,
* crossOriginLoading: NonNullable<Output["crossOriginLoading"]>,
* wasmLoading: NonNullable<Output["wasmLoading"]>,
* }} OutputNormalizedWithDefaults
*/
/**
* Defines the shared type used by this module.
* @typedef {SnapshotOptions & {
* managedPaths: NonNullable<SnapshotOptions["managedPaths"]>,
* unmanagedPaths: NonNullable<SnapshotOptions["unmanagedPaths"]>,
* immutablePaths: NonNullable<SnapshotOptions["immutablePaths"]>,
* resolveBuildDependencies: NonNullable<SnapshotOptions["resolveBuildDependencies"]>,
* buildDependencies: NonNullable<SnapshotOptions["buildDependencies"]>,
* module: NonNullable<SnapshotOptions["module"]>,
* resolve: NonNullable<SnapshotOptions["resolve"]>,
* }} SnapshotNormalizedWithDefaults
*/
/**
* Defines the shared type used by this module.
* @typedef {Optimization & {
* runtimeChunk: NonNullable<Optimization["runtimeChunk"]>,
* splitChunks: NonNullable<Optimization["splitChunks"]>,
* mergeDuplicateChunks: NonNullable<Optimization["mergeDuplicateChunks"]>,
* removeAvailableModules: NonNullable<Optimization["removeAvailableModules"]>,
* removeEmptyChunks: NonNullable<Optimization["removeEmptyChunks"]>,
* flagIncludedChunks: NonNullable<Optimization["flagIncludedChunks"]>,
* moduleIds: NonNullable<Optimization["moduleIds"]>,
* chunkIds: NonNullable<Optimization["chunkIds"]>,
* sideEffects: NonNullable<Optimization["sideEffects"]>,
* providedExports: NonNullable<Optimization["providedExports"]>,
* 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"]>,
* checkWasmTypes: NonNullable<Optimization["checkWasmTypes"]>,
* mangleWasmImports: NonNullable<Optimization["mangleWasmImports"]>,
* portableRecords: NonNullable<Optimization["portableRecords"]>,
* realContentHash: NonNullable<Optimization["realContentHash"]>,
* minimize: NonNullable<Optimization["minimize"]>,
* minimizeOptions: NonNullable<Optimization["minimizeOptions"]>,
* minimizer: NonNullable<Exclude<Optimization["minimizer"], "...">>,
* nodeEnv: NonNullable<Optimization["nodeEnv"]>,
* }} OptimizationNormalizedWithDefaults
*/
/**
* Defines the shared type used by this module.
* @typedef {ExternalsPresets & {
* web: NonNullable<ExternalsPresets["web"]>,
* node: NonNullable<ExternalsPresets["node"]>,
* nwjs: NonNullable<ExternalsPresets["nwjs"]>,
* electron: NonNullable<ExternalsPresets["electron"]>,
* electronMain: NonNullable<ExternalsPresets["electronMain"]>,
* electronPreload: NonNullable<ExternalsPresets["electronPreload"]>,
* electronRenderer: NonNullable<ExternalsPresets["electronRenderer"]>,
* }} ExternalsPresetsNormalizedWithDefaults
*/
/**
* Defines the shared type used by this module.
* @typedef {InfrastructureLogging & {
* stream: NonNullable<InfrastructureLogging["stream"]>,
* level: NonNullable<InfrastructureLogging["level"]>,
* debug: NonNullable<InfrastructureLogging["debug"]>,
* colors: NonNullable<InfrastructureLogging["colors"]>,
* appendOnly: NonNullable<InfrastructureLogging["appendOnly"]>,
* }} InfrastructureLoggingNormalizedWithDefaults
*/
/**
* 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
*/
const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
const DEFAULT_CACHE_NAME = "default";
const DEFAULTS = {
// TODO webpack 6 - use xxhash64
HASH_FUNCTION: "md4"
};
/**
* Processes the provided obj.
* @template T
* @template {keyof T} P
* @param {T} obj an object
* @param {P} prop a property of this object
* @param {T[P]} value a default value of the property
* @returns {void}
*/
const D = (obj, prop, value) => {
if (obj[prop] === undefined) {
obj[prop] = value;
}
};
/**
* Processes the provided obj.
* @template T
* @template {keyof T} P
* @param {T} obj an object
* @param {P} prop a property of this object
* @param {() => T[P]} factory a default value factory for the property
* @returns {void}
*/
const F = (obj, prop, factory) => {
if (obj[prop] === undefined) {
obj[prop] = factory();
}
};
/**
* Sets a dynamic default value when undefined, by calling the factory function.
* factory must return an array or undefined
* When the current value is already an array an contains "..." it's replaced with
* the result of the factory function
* @template T
* @template {keyof T} P
* @param {T} obj an object
* @param {P} prop a property of this object
* @param {() => T[P]} factory a default value factory for the property
* @returns {void}
*/
const A = (obj, prop, factory) => {
const value = obj[prop];
if (value === undefined) {
obj[prop] = factory();
} else if (Array.isArray(value)) {
/** @type {EXPECTED_ANY[] | undefined} */
let newArray;
for (let i = 0; i < value.length; i++) {
const item = value[i];
if (item === "...") {
if (newArray === undefined) {
newArray = value.slice(0, i);
obj[prop] = /** @type {T[P]} */ (/** @type {unknown} */ (newArray));
}
const items =
/** @type {EXPECTED_ANY[]} */
(/** @type {unknown} */ (factory()));
if (items !== undefined) {
for (const item of items) {
newArray.push(item);
}
}
} else if (newArray !== undefined) {
newArray.push(item);
}
}
}
};
/**
* Apply webpack options base defaults.
* @param {WebpackOptionsNormalized} options options to be modified
* @returns {void}
*/
const applyWebpackOptionsBaseDefaults = (options) => {
F(options, "context", () => process.cwd());
applyInfrastructureLoggingDefaults(options.infrastructureLogging);
};
/**
* Apply webpack options defaults.
* @param {WebpackOptionsNormalized} options options to be modified
* @param {number=} compilerIndex index of compiler
* @returns {ResolvedOptions} Resolved options after apply defaults
*/
const applyWebpackOptionsDefaults = (options, compilerIndex) => {
F(options, "context", () => process.cwd());
F(options, "target", () =>
getDefaultTarget(/** @type {string} */ (options.context))
);
const { mode, name, target } = options;
const targetProperties =
target === false
? /** @type {false} */ (false)
: typeof target === "string"
? getTargetProperties(target, /** @type {Context} */ (options.context))
: getTargetsProperties(
/** @type {string[]} */ (target),
/** @type {Context} */ (options.context)
);
const development = mode === "development";
const production = mode === "production" || !mode;
if (typeof options.entry !== "function") {
for (const key of Object.keys(options.entry)) {
F(
options.entry[key],
"import",
() => /** @type {[string]} */ (["./src"])
);
}
}
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
});
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
);
applyCacheDefaults(options.cache, {
name: name || DEFAULT_CACHE_NAME,
mode: mode || "production",
development,
cacheUnaffected: options.experiments.cacheUnaffected,
futureDefaults,
compilerIndex
});
const cache = Boolean(options.cache);
applySnapshotDefaults(options.snapshot, {
production,
futureDefaults
});
applyOutputDefaults(options.output, {
context: /** @type {Context} */ (options.context),
targetProperties,
isAffectedByBrowserslist:
target === undefined ||
(typeof target === "string" && target.startsWith("browserslist")) ||
(Array.isArray(target) &&
target.some((target) => target.startsWith("browserslist"))),
outputModule:
/** @type {NonNullable<ExperimentsNormalized["outputModule"]>} */
(options.experiments.outputModule),
development,
entry: options.entry,
futureDefaults,
asyncWebAssembly:
/** @type {boolean} */
(options.experiments.asyncWebAssembly)
});
// Placed after `applyOutputDefaults`, which settles `enabledLibraryTypes`. A library
// is read by another bundler, where an eval wrapper hides `import.meta` from it.
const noDevSourceMap = /** @type {LibraryType[]} */ (
options.output.enabledLibraryTypes
).some(
(type) => futureDefaults || type === "module" || type === "modern-module"
);
F(
options,
"devtool",
() =>
/** @type {Devtool} */ (
development && !noDevSourceMap
? [
options.experiments.css
? {
type: "css",
use: "source-map"
}
: undefined,
{
type: "javascript",
use: "eval"
}
].filter(Boolean)
: false
)
);
applyModuleDefaults(options.module, {
cache,
hashSalt: /** @type {NonNullable<Output["hashSalt"]>} */ (
options.output.hashSalt
),
hashFunction: /** @type {NonNullable<Output["hashFunction"]>} */ (
options.output.hashFunction
),
syncWebAssembly:
/** @type {NonNullable<ExperimentsNormalized["syncWebAssembly"]>} */
(options.experiments.syncWebAssembly),
asyncWebAssembly:
/** @type {boolean} */
(options.experiments.asyncWebAssembly),
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),
sourceImport:
/** @type {NonNullable<ExperimentsNormalized["sourceImport"]>} */
(options.experiments.sourceImport),
futureDefaults,
isNode: targetProperties && targetProperties.node === true,
uniqueName: /** @type {string} */ (options.output.uniqueName),
targetProperties,
mode: options.mode,
outputModule:
/** @type {NonNullable<WebpackOptionsNormalized["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),
outputModule:
/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
(options.output.module)
});
applyLoaderDefaults(
/** @type {NonNullable<WebpackOptionsNormalized["loader"]>} */ (
options.loader
),
{
targetProperties,
environment: options.output.environment,
outputModule:
/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
(options.output.module)
}
);
F(options, "externalsType", () => {
const validExternalTypes = require("../../schemas/WebpackOptions.json")
.definitions.ExternalsType.enum;
return options.output.library &&
validExternalTypes.includes(options.output.library.type)
? /** @type {ExternalsType} */ (options.output.library.type)
: options.output.module
? "module-import"
: "var";
});
applyNodeDefaults(options.node, {
futureDefaults:
/** @type {NonNullable<WebpackOptionsNormalized["experiments"]["futureDefaults"]>} */
(options.experiments.futureDefaults),
outputModule:
/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
(options.output.module),
targetProperties
});
F(options, "performance", () =>
production &&
targetProperties &&
(targetProperties.browser || targetProperties.browser === null)
? {}
: false
);
applyPerformanceDefaults(
/** @type {NonNullable<WebpackOptionsNormalized["performance"]>} */
(options.performance),
{
production
}
);
applyOptimizationDefaults(options.optimization, {
development,
production,
css:
/** @type {boolean} */
(options.experiments.css),
records: Boolean(options.recordsInputPath || options.recordsOutputPath)
});
options.resolve = cleverMerge(
getResolveDefaults({
cache,
context: /** @type {Context} */ (options.context),
targetProperties,
mode: /** @type {Mode} */ (options.mode),
css:
/** @type {boolean} */
(options.experiments.css),
html:
/** @type {boolean} */
(options.experiments.html),
htmlFirst,
typescript:
/** @type {boolean} */
(options.experiments.typescript)
}),
options.resolve
);
options.resolveLoader = cleverMerge(
getResolveLoaderDefaults({ cache }),
options.resolveLoader
);
return {
platform:
targetProperties === false
? targetProperties
: {
web: targetProperties.web,
browser: targetProperties.browser,
webworker: targetProperties.webworker,
node: targetProperties.node,
deno: targetProperties.deno,
bun: targetProperties.bun,
nwjs: targetProperties.nwjs,
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, 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 ? true : "auto"
);
// the universal target (web + node, neither specific) only works as ESM —
// unless the target cannot read one, which no output format can repair, so
// leave `output.chunkFormat` to say so rather than emitting a module the
// target has already reported it will not load
const universal =
Boolean(targetProperties) &&
/** @type {TargetProperties} */ (targetProperties).node === null &&
/** @type {TargetProperties} */ (targetProperties).web === null &&
/** @type {TargetProperties} */ (targetProperties).module !== false;
// 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 : "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);
D(experiments.buildHttp, "upgrade", false);
}
};
/**
* Apply cache defaults.
* @param {CacheOptionsNormalized} cache options
* @param {object} options options
* @param {string} options.name name
* @param {Mode} options.mode mode
* @param {boolean} options.futureDefaults is future defaults enabled
* @param {boolean} options.development is development mode
* @param {number=} options.compilerIndex index of compiler
* @param {Experiments["cacheUnaffected"]} options.cacheUnaffected the cacheUnaffected experiment is enabled
* @returns {void}
*/
const applyCacheDefaults = (
cache,
{ name, mode, development, cacheUnaffected, compilerIndex, futureDefaults }
) => {
if (cache === false) return;
switch (cache.type) {
case "filesystem":
F(cache, "name", () =>
compilerIndex !== undefined
? `${`${name}-${mode}`}__compiler${compilerIndex + 1}__`
: `${name}-${mode}`
);
D(cache, "version", "");
F(cache, "cacheDirectory", () => {
const cwd = process.cwd();
/** @type {string | undefined} */
let dir = cwd;
for (;;) {
try {
if (fs.statSync(path.join(dir, "package.json")).isFile()) break;
// eslint-disable-next-line no-empty
} catch (_err) {}
const parent = path.dirname(dir);
if (dir === parent) {
dir = undefined;
break;
}
dir = parent;
}
if (!dir) {
return path.resolve(cwd, ".cache/webpack");
} else if (process.versions.pnp === "1") {
return path.resolve(dir, ".pnp/.cache/webpack");
} else if (process.versions.pnp === "3") {
return path.resolve(dir, ".yarn/.cache/webpack");
}
return path.resolve(dir, "node_modules/.cache/webpack");
});
F(cache, "cacheLocation", () =>
path.resolve(
/** @type {NonNullable<FileCacheOptions["cacheDirectory"]>} */
(cache.cacheDirectory),
/** @type {NonNullable<FileCacheOptions["name"]>} */ (cache.name)
)
);
D(cache, "hashAlgorithm", futureDefaults ? "xxhash64" : "md4");
D(cache, "store", "pack");
D(cache, "compression", false);
D(cache, "profile", false);
D(cache, "idleTimeout", 60000);
D(cache, "idleTimeoutForInitialStore", 5000);
D(cache, "idleTimeoutAfterLargeChanges", 1000);
D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
D(cache, "maxAge", 1000 * 60 * 60 * 24 * 60); // 1 month
D(cache, "allowCollectingMemory", development);
D(cache, "memoryCacheUnaffected", development && cacheUnaffected);
D(cache, "readonly", false);
D(
/** @type {NonNullable<FileCacheOptions["buildDependencies"]>} */
(cache.buildDependencies),
"defaultWebpack",
[path.resolve(__dirname, "..") + path.sep]
);
break;
case "memory":
D(cache, "maxGenerations", Infinity);
D(cache, "cacheUnaffected", development && cacheUnaffected);
break;
}
};
/**
* Apply snapshot defaults.
* @param {SnapshotOptions} snapshot options
* @param {object} options options
* @param {boolean} options.production is production
* @param {boolean} options.futureDefaults is future defaults enabled
* @returns {void}
*/
const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
if (futureDefaults) {
F(snapshot, "managedPaths", () =>
process.versions.pnp === "3"
? [
/^(.+?(?:[\\/]\.yarn[\\/]unplugged[\\/][^\\/]+)?[\\/]node_modules[\\/])/
]
: [/^(.+?[\\/]node_modules[\\/])/]
);
F(snapshot, "immutablePaths", () =>
process.versions.pnp === "3"
? [/^(.+?[\\/]cache[\\/][^\\/]+\.zip[\\/]node_modules[\\/])/]
: []
);
} else {
A(snapshot, "managedPaths", () => {
if (process.versions.pnp === "3") {
const match =
/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
require.resolve("watchpack")
);
if (match) {
return [path.resolve(match[1], "unplugged")];
}
} else {
const match = /^(.+?[\\/]node_modules[\\/])/.exec(
require.resolve("watchpack")
);
if (match) {
return [match[1]];
}
}
return [];
});
A(snapshot, "immutablePaths", () => {
if (process.versions.pnp === "1") {
const match =
/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
require.resolve("watchpack")
);
if (match) {
return [match[1]];
}
} else if (process.versions.pnp === "3") {
const match =
/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
require.resolve("watchpack")
);
if (match) {
return [match[1]];
}
}
return [];
});
}
F(snapshot, "unmanagedPaths", () => []);
F(snapshot, "resolveBuildDependencies", () => ({
timestamp: true,
hash: true
}));
F(snapshot, "buildDependencies", () => ({ timestamp: true, hash: true }));
F(snapshot, "module", () =>
production ? { timestamp: true, hash: true } : { timestamp: true }
);
F(snapshot, "contextModule", () => ({ timestamp: true }));
F(snapshot, "resolve", () =>
production ? { timestamp: true, hash: true } : { timestamp: true }
);
};
/**
* 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,
sourceImport,
isNode,
outputModule,
library,
typescript
}
) => {
D(parserOptions, "unknownContextRequest", ".");
D(parserOptions, "unknownContextRegExp", false);
D(parserOptions, "unknownContextRecursive", true);
D(parserOptions, "unknownContextCritical", true);
D(parserOptions, "exprContextRequest", ".");
D(parserOptions, "exprContextRegExp", false);
D(parserOptions, "exprContextRecursive", true);
D(parserOptions, "exprContextCritical", true);
D(parserOptions, "wrappedContextRegExp", /.*/);
D(parserOptions, "wrappedContextRecursive", true);
D(parserOptions, "wrappedContextCritical", false);
D(parserOptions, "strictThisContextOnImports", false);
D(parserOptions, "importMeta", outputModule ? "preserve-unknown" : true);
D(parserOptions, "dynamicImportMode", "lazy");
D(parserOptions, "dynamicImportPrefetch", false);
D(parserOptions, "dynamicImportPreload", false);
D(parserOptions, "dynamicImportFetchPriority", false);
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, "strictModeViolations", futureDefaults ? "error" : "warn");
D(parserOptions, "anonymousDefaultExportName", !library);
};
/**
* Apply json generator options defaults.
* @param {JsonGeneratorOptions} generatorOptions generator options
* @returns {void}
*/
const applyJsonGeneratorOptionsDefaults = (generatorOptions) => {
D(generatorOptions, "JSONParse", true);
};
/**
* Apply css generator options defaults.
* @param {CssGeneratorOptions} generatorOptions generator options
* @param {object} options options
* @param {TargetProperties | false} options.targetProperties target properties
* @returns {void}
*/
const applyCssGeneratorOptionsDefaults = (
generatorOptions,
{ targetProperties }
) => {
D(
generatorOptions,
"exportsOnly",
!targetProperties || targetProperties.document === false
);
D(generatorOptions, "esModule", true);
};
/**
* 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 {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,
hashFunction,
cache,
syncWebAssembly,
asyncWebAssembly,
css,
html,
typescript,
futureDefaults,
isNode,
uniqueName,
targetProperties,
mode,
deferImport,
sourceImport,
outputModule,
library
}
) => {
if (cache) {
D(
module,
"unsafeCache",
/**
* Handles the callback logic for this hook.
* @param {Module} module module
* @returns {boolean} true, if we want to cache the module
*/
(module) => {
const name = module.nameForCondition();
if (!name) {
return false;
}
return NODE_MODULES_REGEXP.test(name);
}
);
} else {
D(module, "unsafeCache", false);
}
F(module.parser, ASSET_MODULE_TYPE, () => ({}));
F(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[ASSET_MODULE_TYPE]>} */
(module.parser[ASSET_MODULE_TYPE]),
"dataUrlCondition",
() => ({})
);
if (
typeof (
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[ASSET_MODULE_TYPE]>} */
(module.parser[ASSET_MODULE_TYPE]).dataUrlCondition
) === "object"
) {
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[ASSET_MODULE_TYPE]>} */
(module.parser[ASSET_MODULE_TYPE]).dataUrlCondition,
"maxSize",
8096
);
}
F(module.parser, "javascript", () => ({}));
F(module.parser, JSON_MODULE_TYPE, () => ({}));
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[JSON_MODULE_TYPE]>} */
(module.parser[JSON_MODULE_TYPE]),
"exportsDepth",
mode === "development" ? 1 : Infinity
);
applyJavascriptParserOptionsDefaults(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown["javascript"]>} */
(module.parser.javascript),
{
futureDefaults,
deferImport,
sourceImport,
isNode,
outputModule,
library,
typescript
}
);
F(module.generator, "json", () => ({}));
applyJsonGeneratorOptionsDefaults(
/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown["json"]>} */
(module.generator.json)
);
if (css) {
F(module.parser, CSS_MODULE_TYPE, () => ({}));
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
(module.parser[CSS_MODULE_TYPE]),
"import",
true
);
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
(module.parser[CSS_MODULE_TYPE]),
"url",
true
);
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
(module.parser[CSS_MODULE_TYPE]),
"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,
CSS_MODULE_TYPE_MODULE,
CSS_MODULE_TYPE_GLOBAL
]) {
F(module.parser, type, () => ({}));
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
(module.parser[type]),
"animation",
true
);
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
(module.parser[type]),
"container",
true
);
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
(module.parser[type]),
"customIdents",
true
);
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
(module.parser[type]),
"dashedIdents",
true
);
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
(module.parser[type]),
"function",
true
);
D(
/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
(module.parser[type]),
"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, () => ({}));
applyCssGeneratorOptionsDefaults(
/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
(module.generator[CSS_MODULE_TYPE]),
{ targetProperties }
);
const localIdentName =
mode === "development"
? uniqueName.length > 0
? "[uniqueName]-[id]-[local]"
: "[id]-[local]"
: "[fullhash]";
const localIdentHashSalt = hashSalt;
const localIdentHashDigest = "base64url";
const localIdentHashDigestLength = 6;
const exportsConvention = "as-is";
for (const type of [
CSS_MODULE_TYPE_AUTO,
CSS_MODULE_TYPE_MODULE,
CSS_MODULE_TYPE_GLOBAL
]) {
F(module.generator, type, () => ({}));
D(
/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
(module.generator[type]),
"localIdentName",
localIdentName
);
D(
/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
(module.generator[type]),
"localIdentHashSalt",
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]),
"localIdentHashDigest",
localIdentHashDigest
);
D(
/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]>} */
(module.generator[type]),
"localIdentHashDigestLength",
localIdentHashDigestLength
);
D(
/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
(module.generator[type]),
"exportsConvention",
exportsConvention
);
}
}
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,
resolve: {
byDependency: {
esm: {
fullySpecified: true
}
}
}
};
const commonjs = {
type: JAVASCRIPT_MODULE_TYPE_DYNAMIC
};
/** @type {RuleSetRules} */
const rules = [
{
mimetype: "application/node",
type: JAVASCRIPT_MODULE_TYPE_AUTO
},
{
test: /\.json$/i,
type: JSON_MODULE_TYPE
},
{
mimetype: "application/json",
type: JSON_MODULE_TYPE
},
{
test: /\.mjs$/i,
...esm
},
{
test: /\.js$/i,
descriptionData: {
type: "module"
},
...esm
},
{
test: /\.cjs$/i,
...commonjs
},
{
test: /\.js$/i,
descriptionData: {
type: "commonjs"
},
...commonjs
},
{
mimetype: {
or: ["text/javascript", "application/javascript"]
},
...esm
}
];
if (asyncWebAssembly) {
const wasm = {
type: WEBASSEMBLY_MODULE_TYPE_ASYNC,
rules: [
{
descriptionData: {
type: "module"
},
resolve: {
fullySpecified: true
}
}
]
};
rules.push({
test: /\.wasm$/i,
...wasm
});
rules.push({
mimetype: "application/wasm",
...wasm
});
} else if (syncWebAssembly) {
const wasm = {
type: WEBASSEMBLY_MODULE_TYPE_SYNC,
rules: [
{
descriptionData: {
type: "module"
},
resolve: {
fullySpecified: true
}
}
]
};
rules.push({
test: /\.wasm$/i,
...wasm
});
rules.push({
mimetype: "application/wasm",
...wasm
});
}
if (css) {
const resolve = {
fullySpecified: true,
preferRelative: true
};
rules.push({
test: /\.css$/i,
type: CSS_MODULE_TYPE_AUTO,
resolve
});
rules.push({
mimetype: "text/css+module",
type: CSS_MODULE_TYPE_MODULE,
resolve
});
rules.push({
mimetype: "text/css",
type: CSS_MODULE_TYPE,
resolve
});
// For CSS modules, i.e. `.class { composes: className from "./style.css" }`
// 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
});
rules.push(
{
with: { type: "css" },
parser: {
exportType: "css-style-sheet"
},
resolve
},
{
assert: { type: "css" },
parser: {
exportType: "css-style-sheet"
},
resolve
}
);
}
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",
oneOf: [
{
scheme: /^data$/,
type: ASSET_MODULE_TYPE_INLINE
},
{
type: ASSET_MODULE_TYPE_RESOURCE
}
]
},
{
with: { type: JSON_MODULE_TYPE },
type: JSON_MODULE_TYPE,
parser: { namedExports: false }
},
{
assert: { type: JSON_MODULE_TYPE },
type: JSON_MODULE_TYPE,
parser: { namedExports: false }
},
{
with: { type: "text" },
type: ASSET_MODULE_TYPE_SOURCE
},
{
with: { type: "bytes" },
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
* @param {TargetProperties | false} options.targetProperties target properties
* @param {boolean} options.isAffectedByBrowserslist is affected by browserslist
* @param {boolean} options.outputModule is outputModule experiment enabled
* @param {boolean} options.development is development mode
* @param {Entry} options.entry entry option
* @param {boolean} options.futureDefaults is future defaults enabled
* @param {boolean} options.asyncWebAssembly is asyncWebAssembly enabled
* @returns {void}
*/
const applyOutputDefaults = (
output,
{
context,
targetProperties: tp,
isAffectedByBrowserslist,
outputModule,
development,
entry,
futureDefaults,
asyncWebAssembly
}
) => {
/**
* Returns a readable library name.
* @param {Library=} library the library option
* @returns {string} a readable library name
*/
const getLibraryName = (library) => {
const libraryName =
typeof library === "object" &&
library &&
!Array.isArray(library) &&
"type" in library
? library.name
: /** @type {LibraryName} */ (library);
if (Array.isArray(libraryName)) {
return libraryName.join(".");
} else if (typeof libraryName === "object") {
return getLibraryName(libraryName.root);
} else if (typeof libraryName === "string") {
return libraryName;
}
return "";
};
F(output, "uniqueName", () => {
const libraryName = getLibraryName(output.library).replace(
/^\[(\\*[\w:]+\\*)\](\.)|(\.)\[(\\*[\w:]+\\*)\](?=\.|$)|\[(\\*[\w:]+\\*)\]/g,
(m, a, d1, d2, b, c) => {
const content = a || b || c;
return content.startsWith("\\") && content.endsWith("\\")
? `${d2 || ""}[${content.slice(1, -1)}]${d1 || ""}`
: "";
}
);
if (libraryName) return libraryName;
const pkgPath = path.resolve(context, "package.json");
try {
const packageInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
return packageInfo.name || "";
} catch (err) {
if (/** @type {Error & { code: string }} */ (err).code !== "ENOENT") {
/** @type {Error & { code: string }} */
(err).message +=
`\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
throw err;
}
return "";
}
});
F(output, "module", () => Boolean(outputModule));
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
*/
const conditionallyOptimistic = (v, c) => (v === undefined && c) || v;
F(
environment,
"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",
() =>
tp && optimistic(/** @type {boolean | undefined} */ (tp.bigIntLiteral))
);
F(
environment,
"const",
() => tp && optimistic(/** @type {boolean | undefined} */ (tp.const))
);
// Only the browserslist target reports these; everywhere else they stay
// unset, which `optimistic` reads as the modern spelling being available —
// the same policy the JS features above follow.
// `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",
() =>
tp && optimistic(/** @type {boolean | undefined} */ (tp.methodShorthand))
);
F(
environment,
"arrowFunction",
() =>
tp && optimistic(/** @type {boolean | undefined} */ (tp.arrowFunction))
);
F(
environment,
"asyncFunction",
() =>
tp && optimistic(/** @type {boolean | undefined} */ (tp.asyncFunction))
);
F(
environment,
"generator",
() => tp && optimistic(/** @type {boolean | undefined} */ (tp.generator))
);
// No `topLevelAwait` here: the option is held back from the patch release,
// so nothing derives it from `tp` yet. Reapply by reverting #21881.
F(
environment,
"forOf",
() => tp && optimistic(/** @type {boolean | undefined} */ (tp.forOf))
);
// Stage 3 syntax, so these are the one pair read pessimistically: a preset that
// says nothing means unavailable, and the phase keeps webpack's own form.
F(environment, "deferImport", () =>
Boolean(tp && /** @type {boolean | undefined} */ (tp.deferImport))
);
F(environment, "sourceImport", () =>
Boolean(tp && /** @type {boolean | undefined} */ (tp.sourceImport))
);
F(
environment,
"destructuring",
() =>
tp && optimistic(/** @type {boolean | undefined} */ (tp.destructuring))
);
F(
environment,
"optionalChaining",
() =>
tp && optimistic(/** @type {boolean | undefined} */ (tp.optionalChaining))
);
F(
environment,
"spread",
() => tp && optimistic(/** @type {boolean | undefined} */ (tp.spread))
);
F(
environment,
"nodePrefixForCoreModules",
() =>
tp &&
optimistic(
/** @type {boolean | undefined} */ (tp.nodePrefixForCoreModules)
)
);
F(
environment,
"importMetaDirnameAndFilename",
() =>
// 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",
() =>
tp && optimistic(/** @type {boolean | undefined} */ (tp.templateLiteral))
);
F(environment, "dynamicImport", () =>
conditionallyOptimistic(
/** @type {boolean | undefined} */ (tp && tp.dynamicImport),
output.module
)
);
F(environment, "dynamicImportInWorker", () =>
conditionallyOptimistic(
/** @type {boolean | undefined} */ (tp && tp.dynamicImportInWorker),
output.module
)
);
F(environment, "module", () =>
conditionallyOptimistic(
/** @type {boolean | undefined} */ (tp && tp.module),
output.module
)
);
F(
environment,
"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) {
D(output.resourceHints, "dedupe", false);
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);
D(output, "importFunctionName", "import");
D(output, "importMetaName", "import.meta");
F(output, "chunkFilename", () => {
const filename =
/** @type {NonNullable<Output["chunkFilename"]>} */
(output.filename);
if (typeof filename !== "function") {
const hasName = filename.includes("[name]");
const hasId = filename.includes("[id]");
const hasChunkHash = filename.includes("[chunkhash]");
const hasContentHash = filename.includes("[contenthash]");
// Anything changing depending on chunk is fine
if (hasChunkHash || hasContentHash || hasName || hasId) return filename;
// Otherwise prefix "[id]." in front of the basename to make it changing
return filename.replace(/(^|\/)([^/]*(?:\?|$))/, "$1[id].$2");
}
return output.module ? "[id].mjs" : "[id].js";
});
F(output, "cssFilename", () => {
const filename =
/** @type {NonNullable<Output["cssFilename"]>} */
(output.filename);
if (typeof filename !== "function") {
return filename.replace(/\.[mc]?js(\?|$)/, ".css$1");
}
return "[id].css";
});
F(output, "cssChunkFilename", () => {
const chunkFilename =
/** @type {NonNullable<Output["cssChunkFilename"]>} */
(output.chunkFilename);
if (typeof chunkFilename !== "function") {
return chunkFilename.replace(/\.[mc]?js(\?|$)/, ".css$1");
}
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(
/** @type {NonNullable<Output["uniqueName"]>} */ (output.uniqueName)
);
F(output, "hotUpdateGlobal", () => `webpackHotUpdate${uniqueNameId}`);
F(output, "chunkLoadingGlobal", () => `webpackChunk${uniqueNameId}`);
F(output, "globalObject", () => {
if (tp) {
if (tp.global) return "global";
if (tp.globalThis) return "globalThis";
// Universal target (web + node): no one identifier is defined on both
// sides, so `globalThis` where the target reports nothing against it,
// and a guarded pair where it does — `self` covers window and worker
// scopes, `global` covers Node.js. Naming either alone leaves the other
// platform reading an undeclared binding.
if (tp.web === null && tp.node === null) {
return tp.globalThis === undefined
? "globalThis"
: 'typeof self !== "undefined" ? self : global';
}
}
return "self";
});
F(output, "chunkFormat", () => {
if (tp) {
const helpMessage = isAffectedByBrowserslist
? "Make sure that your 'browserslist' includes only platforms that support these features or select an appropriate 'target' to allow selecting a chunk format by default. Alternatively specify the 'output.chunkFormat' directly."
: "Select an appropriate 'target' to allow selecting one by default, or specify the 'output.chunkFormat' directly.";
if (output.module) {
if (environment.dynamicImport) return "module";
if (tp.document) return "array-push";
throw new Error(
"For the selected environment is no default ESM chunk format available:\n" +
"ESM exports can be chosen when 'import()' is available.\n" +
`JSONP Array push can be chosen when 'document' is available.\n${helpMessage}`
);
} else {
if (tp.document) return "array-push";
if (tp.require) return "commonjs";
if (tp.nodeBuiltins) return "commonjs";
if (tp.importScripts) return "array-push";
throw new Error(
"For the selected environment is no default script chunk format available:\n" +
`${
tp.module
? "Module ('module') can be chosen when ES modules are available (please set 'experiments.outputModule' and 'output.module' to `true`)"
: ""
}\n` +
"JSONP Array push ('array-push') can be chosen when 'document' or 'importScripts' is available.\n" +
`CommonJs exports ('commonjs') can be chosen when 'require' or node builtins are available.\n${helpMessage}`
);
}
}
throw new Error(
"Chunk format can't be selected by default when no target is specified"
);
});
D(output, "asyncChunks", true);
F(output, "chunkLoading", () => {
if (tp) {
switch (output.chunkFormat) {
case "array-push":
if (tp.document) return "jsonp";
if (tp.importScripts) return "import-scripts";
break;
case "commonjs":
if (tp.require) return "require";
if (tp.nodeBuiltins) return "async-node";
break;
case "module":
if (environment.dynamicImport) return "import";
break;
}
if (
(tp.require === null ||
tp.nodeBuiltins === null ||
tp.document === null ||
tp.importScripts === null) &&
output.module &&
environment.dynamicImport
) {
return "import";
}
}
return false;
});
F(
output,
"workerChunkFilename",
() =>
/** @type {NonNullable<Output["workerChunkFilename"]>} */
(output.chunkFilename)
);
F(output, "workerChunkLoading", () => {
if (tp) {
switch (output.chunkFormat) {
case "array-push":
if (tp.importScriptsInWorker) return "import-scripts";
break;
case "commonjs":
if (tp.require) return "require";
if (tp.nodeBuiltins) return "async-node";
break;
case "module":
if (environment.dynamicImportInWorker) return "import";
break;
}
if (
(tp.require === null ||
tp.nodeBuiltins === null ||
tp.importScriptsInWorker === null) &&
output.module &&
environment.dynamicImportInWorker
) {
return "import";
}
}
return false;
});
F(output, "wasmLoading", () => {
if (tp) {
if (tp.fetchWasm) return "fetch";
if (tp.nodeBuiltins) return "async-node";
if (
(tp.nodeBuiltins === null || tp.fetchWasm === null) &&
output.module &&
environment.dynamicImport
) {
return "universal";
}
}
return false;
});
F(output, "workerWasmLoading", () => output.wasmLoading);
F(output, "devtoolNamespace", () => output.uniqueName);
if (output.library) {
F(output.library, "type", () => (output.module ? "module" : "var"));
}
F(output, "path", () => path.join(process.cwd(), "dist"));
F(output, "pathinfo", () => development);
D(output, "sourceMapFilename", "[file].map[query]");
D(
output,
"hotUpdateChunkFilename",
`[id].[fullhash].hot-update.${output.module ? "mjs" : "js"}`
);
D(
output,
"hotUpdateMainFilename",
// 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));
D(
output,
"publicPath",
(tp && (tp.document || tp.importScripts)) || output.scriptType === "module"
? "auto"
: ""
);
D(output, "workerPublicPath", "");
D(output, "chunkLoadTimeout", 120000);
F(output, "hashFunction", () => {
if (futureDefaults) {
DEFAULTS.HASH_FUNCTION = "xxhash64";
return "xxhash64";
}
return "md4";
});
D(output, "hashDigest", "hex");
D(output, "hashDigestLength", futureDefaults ? 16 : 20);
D(output, "strictModuleErrorHandling", false);
D(output, "strictModuleExceptionHandling", false);
F(output, "strictModuleResolution", () => development);
const { trustedTypes } = output;
if (trustedTypes) {
F(
trustedTypes,
"policyName",
() =>
/** @type {NonNullable<Output["uniqueName"]>} */
(output.uniqueName).replace(/[^a-z0-9\-#=_/@.%]+/gi, "_") || "webpack"
);
D(trustedTypes, "onPolicyCreationFailure", "stop");
}
/**
* Processes the provided fn.
* @param {(entryDescription: EntryDescription) => void} fn iterator
* @returns {void}
*/
const forEachEntry = (fn) => {
for (const name of Object.keys(entry)) {
fn(/** @type {{ [k: string]: EntryDescription }} */ (entry)[name]);
}
};
A(output, "enabledLibraryTypes", () => {
/** @type {LibraryType[]} */
const enabledLibraryTypes = [];
if (output.library) {
enabledLibraryTypes.push(output.library.type);
}
forEachEntry((desc) => {
if (desc.library) {
enabledLibraryTypes.push(desc.library.type);
}
});
return enabledLibraryTypes;
});
A(output, "enabledChunkLoadingTypes", () => {
/** @type {ChunkLoadingTypes} */
const enabledChunkLoadingTypes = new Set();
if (output.chunkLoading) {
enabledChunkLoadingTypes.add(output.chunkLoading);
}
if (output.workerChunkLoading) {
enabledChunkLoadingTypes.add(output.workerChunkLoading);
}
forEachEntry((desc) => {
if (desc.chunkLoading) {
enabledChunkLoadingTypes.add(desc.chunkLoading);
}
});
return [...enabledChunkLoadingTypes];
});
A(output, "enabledWasmLoadingTypes", () => {
/** @type {WasmLoadingTypes} */
const enabledWasmLoadingTypes = new Set();
if (output.wasmLoading) {
enabledWasmLoadingTypes.add(output.wasmLoading);
}
if (output.workerWasmLoading) {
enabledWasmLoadingTypes.add(output.workerWasmLoading);
}
forEachEntry((desc) => {
if (desc.wasmLoading) {
enabledWasmLoadingTypes.add(desc.wasmLoading);
}
});
return [...enabledWasmLoadingTypes];
});
};
/**
* Apply externals presets defaults.
* @param {ExternalsPresets} externalsPresets options
* @param {object} options options
* @param {TargetProperties | false} options.targetProperties target properties
* @param {boolean} options.buildHttp buildHttp experiment enabled
* @param {boolean} options.outputModule is output type is module
* @returns {void}
*/
const applyExternalsPresetsDefaults = (
externalsPresets,
{ targetProperties, buildHttp, outputModule }
) => {
/**
* Checks whether this object is universal.
* @param {keyof TargetProperties} key a key
* @returns {boolean} true when target is universal, otherwise false
*/
const isUniversal = (key) =>
Boolean(outputModule && targetProperties && targetProperties[key] === null);
D(
externalsPresets,
"web",
/** @type {boolean | undefined} */
(
!buildHttp &&
targetProperties &&
(targetProperties.web || isUniversal("node"))
)
);
D(
externalsPresets,
"node",
/** @type {boolean | undefined} */
(
targetProperties &&
((targetProperties.node &&
!targetProperties.deno &&
!targetProperties.bun) ||
isUniversal("node"))
)
);
// Opt-in only: never auto-externalize installed packages, it would change existing builds.
D(externalsPresets, "nodeModules", false);
D(
externalsPresets,
"deno",
/** @type {boolean | undefined} */
(Boolean(targetProperties && targetProperties.deno))
);
D(
externalsPresets,
"bun",
/** @type {boolean | undefined} */
(Boolean(targetProperties && targetProperties.bun))
);
D(
externalsPresets,
"nwjs",
/** @type {boolean | undefined} */
(targetProperties && (targetProperties.nwjs || isUniversal("nwjs")))
);
D(
externalsPresets,
"electron",
/** @type {boolean | undefined} */
((targetProperties && targetProperties.electron) || isUniversal("electron"))
);
D(
externalsPresets,
"electronMain",
/** @type {boolean | undefined} */
(
targetProperties &&
targetProperties.electron &&
(targetProperties.electronMain || isUniversal("electronMain"))
)
);
D(
externalsPresets,
"electronPreload",
/** @type {boolean | undefined} */
(
targetProperties &&
targetProperties.electron &&
(targetProperties.electronPreload || isUniversal("electronPreload"))
)
);
D(
externalsPresets,
"electronRenderer",
/** @type {boolean | undefined} */
(
targetProperties &&
targetProperties.electron &&
(targetProperties.electronRenderer || isUniversal("electronRenderer"))
)
);
};
/**
* 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, outputModule }
) => {
F(loader, "target", () => {
if (targetProperties) {
if (targetProperties.electron) {
if (targetProperties.electronMain) return "electron-main";
if (targetProperties.electronPreload) return "electron-preload";
if (targetProperties.electronRenderer) return "electron-renderer";
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
* @param {boolean} options.futureDefaults is future defaults enabled
* @param {boolean} options.outputModule is output type is module
* @returns {void}
*/
const applyNodeDefaults = (
node,
{ futureDefaults, outputModule, targetProperties }
) => {
if (node === false) return;
F(node, "global", () => {
if (targetProperties && targetProperties.global) return false;
// We use `warm` because overriding `global` with `globalThis` (or a polyfill) is sometimes safe (global.URL), sometimes unsafe (global.process), but we need to warn about it
return futureDefaults ? "warn" : true;
});
const handlerForNames = () => {
// TODO webpack@6 remove `node-module` in favor of `eval-only`
if (targetProperties) {
if (targetProperties.node) {
return "eval-only";
}
// For the "universal" target we only evaluate these values
if (
outputModule &&
targetProperties.node === null &&
targetProperties.web === null
) {
return "eval-only";
}
}
// TODO webpack@6 should we use `warn-even-only`?
return futureDefaults ? "warn-mock" : "mock";
};
F(node, "__filename", handlerForNames);
F(node, "__dirname", handlerForNames);
};
/**
* Apply performance defaults.
* @param {Performance} performance options
* @param {object} options options
* @param {boolean} options.production is production
* @returns {void}
*/
const applyPerformanceDefaults = (performance, { production }) => {
if (performance === false) return;
D(performance, "maxAssetSize", 250000);
D(performance, "maxEntrypointSize", 250000);
// Stands in for every check left unset, so an explicit one still wins.
const all = performance.all !== undefined ? performance.all : false;
D(performance, "asyncChunkWaterfalls", all);
D(performance, "broadContexts", all);
D(performance, "cacheEffectiveness", all);
D(performance, "circularDependencies", all);
D(performance, "conflictingResourceHints", all);
D(performance, "duplicateModules", all);
D(performance, "duplicatePackages", all);
D(performance, "dynamicExports", all);
D(performance, "entrypointOverlap", all);
D(performance, "embeddedSourceMaps", all);
D(performance, "evalUsage", all);
D(performance, "hotspots", all);
D(performance, "legacyJavascript", all);
D(performance, "largeModules", all);
D(performance, "inlinedAssets", all);
D(performance, "mixedExports", all);
D(performance, "missingSideEffects", all);
D(performance, "osDependentRules", all);
D(performance, "pureAnnotations", all);
D(performance, "redundantDynamicImports", all);
D(performance, "scopeHoistingBailouts", all);
D(performance, "splitChunksCapped", all);
D(performance, "tinyChunks", all);
D(performance, "topLevelThis", all);
D(performance, "unsplitVendors", all);
D(performance, "unusedAliases", all);
D(performance, "unusedDefines", all);
D(performance, "unusedExternals", all);
D(performance, "unusedReexports", all);
D(performance, "unusedRules", all);
F(performance, "hints", () => (production ? "warning" : false));
};
/**
* Apply optimization defaults.
* @param {Optimization} optimization options
* @param {object} options options
* @param {boolean} options.production is production
* @param {boolean} options.development is development
* @param {boolean} options.css is css enabled
* @param {boolean} options.records using records
* @returns {void}
*/
const applyOptimizationDefaults = (
optimization,
{ production, development, css, records }
) => {
D(optimization, "removeAvailableModules", false);
D(optimization, "removeEmptyChunks", true);
D(optimization, "mergeDuplicateChunks", true);
D(optimization, "flagIncludedChunks", production);
F(optimization, "moduleIds", () => {
if (production) return "deterministic";
if (development) return "named";
return "natural";
});
F(optimization, "chunkIds", () => {
if (production) return "deterministic";
if (development) return "named";
return "natural";
});
F(optimization, "sideEffects", () => (production ? true : "flag"));
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);
D(optimization, "runtimeChunk", false);
D(optimization, "emitOnErrors", !production);
D(optimization, "checkWasmTypes", production);
D(optimization, "mangleWasmImports", false);
D(optimization, "portableRecords", records);
D(optimization, "realContentHash", production);
// A plugin assigning the object shorthand in `apply()` runs after
// normalization: it replaces `minimizeOptions`, keeping `minimize` boolean.
const minimizeAssignedInApply = /** @type {unknown} */ (
optimization.minimize
);
if (typeof minimizeAssignedInApply === "object") {
optimization.minimizeOptions = /** @type {OptimizationMinimizeOptions} */ (
minimizeAssignedInApply
);
optimization.minimize = true;
}
D(optimization, "minimize", production);
F(optimization, "minimizeOptions", () => ({}));
const minimizeOptions =
/** @type {NonNullable<Optimization["minimizeOptions"]>} */
(optimization.minimizeOptions);
if (optimization.minimize) {
// Canonicalize the per-asset-type options: the JS minimizer's defaults
// become visible in the resolved config rather than hidden in the wiring.
F(minimizeOptions, "javascript", () => ({ compress: { passes: 2 } }));
F(minimizeOptions, "css", () => ({}));
F(minimizeOptions, "html", () => ({}));
}
A(optimization, "minimizer", () => [
{
apply: (compiler) => {
// Lazy load the minimizer plugin
const TerserPlugin = require("minimizer-webpack-plugin");
// One minimizer instance (one worker-thread pool) handles JS and, when
// native CSS / HTML is enabled, those assets too — an array of minify
// functions each dispatched by its own `filter` (terser -> JS,
// cssMinify -> CSS, htmlMinify -> HTML). The CSS / HTML serializers stay
// worker-safe by resolving their parser with `require("webpack/…")` in
// the worker, so all three share the same pool. `test` is widened to let
// CSS / HTML assets reach the dispatcher.
// Step aside for a minimizer the user already configured for these
// types: whichever of the two ran first would mark the asset
// `minimized` and silently disable the other, so webpack only claims
// what nothing else does. Their asset matchers are read directly rather
// than resolved per asset — a coarse check, but it keeps the outcome
// independent of tap order and of the plugin version in use.
const claimedByOtherMinimizer = require("./getClaimedAssetTypes")(
compiler
);
// Per asset type: `false` disables that type, an object is its options.
const minimizeByType = /** @type {OptimizationMinimizeOptions} */ (
compiler.options.optimization.minimizeOptions
);
const terserOptions = minimizeByType.javascript || {
compress: { passes: 2 }
};
const { css, html } = compiler.options.experiments;
const minifyJs = minimizeByType.javascript !== false;
const minifyCss =
Boolean(css) &&
!claimedByOtherMinimizer.css &&
minimizeByType.css !== false;
const minifyHtml =
Boolean(html) &&
!claimedByOtherMinimizer.html &&
minimizeByType.html !== false;
if (!minifyJs && !minifyCss && !minifyHtml) return;
if (minifyJs && !minifyCss && !minifyHtml) {
new TerserPlugin({ terserOptions }).apply(
/** @type {EXPECTED_ANY} */ (compiler)
);
return;
}
/** @type {(typeof TerserPlugin.terserMinify | typeof import("../css/cssMinify") | typeof import("../html/htmlMinify"))[]} */
const minify = [];
/** @type {EXPECTED_OBJECT[]} */
const minimizerOptions = [];
/** @type {string[]} */
const extensions = [];
// `minimize.css` follows the CSS minifier wherever it runs: the HTML
// entry gets the same options, like the shared environment below.
const cssOptions =
typeof minimizeByType.css === "object"
? minimizeByType.css
: undefined;
// The browserslist selection, when the target is one. It decides both the
// prefixes and every spelling a target can read, so `vendorPrefixes`
// turns off the first alone — resolving it is what the second needs.
const { target } = compiler.options;
const browsers = target
? getTargetsBrowsers(
Array.isArray(target) ? target : [target],
/** @type {Context} */ (compiler.options.context)
)
: undefined;
const cssEnvironment = {
browsers,
vendorPrefixes:
cssOptions === undefined || cssOptions.vendorPrefixes !== false
};
const htmlOptions =
typeof minimizeByType.html === "object"
? minimizeByType.html
: undefined;
if (minifyJs) {
minify.push(TerserPlugin.terserMinify);
minimizerOptions.push(terserOptions);
extensions.push("[cm]?js");
}
if (minifyCss) {
minify.push(require("../css/cssMinify"));
minimizerOptions.push({
environment: cssEnvironment,
...cssOptions
});
extensions.push("css");
}
if (minifyHtml) {
minify.push(require("../html/htmlMinify"));
// `minimize.css` rides along under its own key rather than spread
// beside the HTML options: the two name some of the same switches
// (`quotes`, `comments`), and one flat object would hand
// each language the other's answer.
minimizerOptions.push({
environment: cssEnvironment,
css: cssOptions,
...htmlOptions
});
extensions.push("html");
}
new TerserPlugin({
test: new RegExp(`\\.(?:${extensions.join("|")})(\\?.*)?$`, "i"),
minify,
minimizerOptions
}).apply(/** @type {EXPECTED_ANY} */ (compiler));
}
}
]);
F(optimization, "nodeEnv", () => {
if (production) return "production";
if (development) return "development";
return false;
});
const { splitChunks } = optimization;
if (splitChunks) {
A(splitChunks, "defaultSizeTypes", () =>
css
? [JAVASCRIPT_TYPE, CSS_TYPE, UNKNOWN_TYPE]
: [JAVASCRIPT_TYPE, UNKNOWN_TYPE]
);
D(splitChunks, "hidePathInfo", production);
D(splitChunks, "chunks", "async");
D(splitChunks, "usedExports", optimization.usedExports === true);
D(splitChunks, "minChunks", 1);
F(splitChunks, "minSize", () => (production ? 20000 : 10000));
F(splitChunks, "minRemainingSize", () => (development ? 0 : undefined));
F(splitChunks, "enforceSizeThreshold", () => (production ? 50000 : 30000));
F(splitChunks, "maxAsyncRequests", () => (production ? 30 : Infinity));
F(splitChunks, "maxInitialRequests", () => (production ? 30 : Infinity));
D(splitChunks, "automaticNameDelimiter", "-");
const cacheGroups =
/** @type {NonNullable<OptimizationSplitChunksOptions["cacheGroups"]>} */
(splitChunks.cacheGroups);
F(cacheGroups, "default", () => ({
idHint: "",
reuseExistingChunk: true,
minChunks: 2,
priority: -20
}));
F(cacheGroups, "defaultVendors", () => ({
idHint: "vendors",
reuseExistingChunk: true,
test: NODE_MODULES_REGEXP,
priority: -10
}));
}
};
/**
* 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 = ({
cache,
context,
targetProperties,
mode,
css,
html,
htmlFirst,
typescript
}) => {
/** @type {string[]} */
const conditions = ["webpack"];
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");
if (targetProperties.electron) conditions.push("electron");
if (targetProperties.nwjs) conditions.push("nwjs");
}
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: [
...tsConditionPrefix,
"require",
"module-sync",
"module",
"..."
],
extensions: [...jsExtensions]
});
/** @type {() => ResolveOptions} */
const esmDeps = () => ({
aliasFields: browserField ? ["browser"] : [],
mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
conditionNames: [
...tsConditionPrefix,
"import",
"module-sync",
"module",
"..."
],
extensions: [...esmResolveExtensions]
});
/** @type {() => ResolveOptions} */
const workerDeps = () => {
const options = esmDeps();
const conditionNames = options.conditionNames
? ["worker", ...options.conditionNames]
: options.conditionNames;
return {
...options,
conditionNames,
preferRelative: true
};
};
/** @type {ResolveOptions} */
const resolveOptions = {
cache,
modules: ["node_modules"],
conditionNames: conditions,
mainFiles: ["index"],
extensions: [],
aliasFields: [],
exportsFields: ["exports"],
roots: [context],
mainFields: ["main"],
importsFields: ["imports"],
byDependency: {
wasm: esmDeps(),
esm: esmDeps(),
loaderImport: esmDeps(),
url: {
preferRelative: true
},
worker: workerDeps(),
commonjs: cjsDeps(),
amd: cjsDeps(),
// for backward-compat: loadModule
loader: cjsDeps(),
// for backward-compat: Custom Dependency
unknown: cjsDeps(),
// for backward-compat: getResolve without dependencyType
undefined: cjsDeps()
}
};
if (css) {
/** @type {string[]} */
const styleConditions = [];
styleConditions.push("webpack");
styleConditions.push(mode === "development" ? "development" : "production");
styleConditions.push("style");
/** @type {ResolveOptions} */
const cssResolveOptions = {
// We avoid using any main files because we have to be consistent with CSS `@import`
// and CSS `@import` does not handle `main` files in directories,
// you should always specify the full URL for styles
mainFiles: [],
mainFields: ["style", "..."],
conditionNames: styleConditions,
extensions: [".css"],
preferRelative: true
};
/** @type {NonNullable<ResolveOptions["byDependency"]>} */
(resolveOptions.byDependency)["css-import"] = cssResolveOptions;
// For CSS modules, i.e. `.class { composes: className from "./style.css" }`
// We inherit for such constructions
/** @type {NonNullable<ResolveOptions["byDependency"]>} */
(resolveOptions.byDependency)["css-import-local-module"] =
cssResolveOptions;
/** @type {NonNullable<ResolveOptions["byDependency"]>} */
(resolveOptions.byDependency)["css-import-global-module"] =
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
*/
const getResolveLoaderDefaults = ({ cache }) => {
/** @type {ResolveOptions} */
const resolveOptions = {
cache,
conditionNames: ["loader", "require", "node"],
exportsFields: ["exports"],
mainFields: ["loader", "main"],
extensions: [".js"],
mainFiles: ["index"]
};
return resolveOptions;
};
/**
* Apply infrastructure logging defaults.
* @param {InfrastructureLogging} infrastructureLogging options
* @returns {void}
*/
const applyInfrastructureLoggingDefaults = (infrastructureLogging) => {
F(infrastructureLogging, "stream", () => process.stderr);
const tty =
/** @type {NonNullable<InfrastructureLogging["stream"]>} */
(infrastructureLogging.stream).isTTY && process.env.TERM !== "dumb";
D(infrastructureLogging, "level", "info");
D(infrastructureLogging, "debug", false);
D(infrastructureLogging, "colors", tty);
D(infrastructureLogging, "appendOnly", !tty);
};
module.exports.DEFAULTS = DEFAULTS;
module.exports.applyWebpackOptionsBaseDefaults =
applyWebpackOptionsBaseDefaults;
module.exports.applyWebpackOptionsDefaults = applyWebpackOptionsDefaults;